fuck malware, fuck you

apps/web/src/components/editor/assets-panel/views/settings.tsx

@@ -60,15 +60,15 @@ function ProjectSettingsTabs() {
               <div className="flex-1 p-5">
                 <BackgroundView />
               </div>
-              <div className="bg-panel/85 sticky -bottom-0 flex flex-col backdrop-blur-lg">
+              {/* <div className="bg-panel/85 sticky -bottom-0 flex flex-col backdrop-blur-lg">
                 <Separator />
                 <Button className="text-muted-foreground hover:text-foreground/85 h-auto w-fit !bg-transparent p-5 py-4 text-xs shadow-none">
                   Custom background
                   <PlusIcon />
                 </Button>
-              </div>
+              </div> */}
 
-              {/* another ui, looks so beautiful I don't wanna remove it */}
+              {/* another ui */}
               {/* <div className="flex flex-col justify-center items-center pb-5 sticky bottom-0">
                 <Button className="w-fit h-auto gap-1.5 px-3.5 py-1.5 bg-foreground hover:bg-foreground/85 text-background rounded-full">
                   <span className="text-sm">Custom</span>

apps/web/src/components/editor/properties-panel/index.tsx

@@ -1,17 +1,16 @@
 "use client";
 
-import { useTimelineStore } from "@/stores/timeline-store";
 import { ScrollArea } from "../../ui/scroll-area";
 import { AudioProperties } from "./audio-properties";
 import { VideoProperties } from "./video-properties";
 import { TextProperties } from "./text-properties";
 import { SquareSlashIcon } from "lucide-react";
 import { useEditor } from "@/hooks/use-editor";
+import { useElementSelection } from "@/hooks/timeline/element/use-element-selection";
 
 export function PropertiesPanel() {
-  const { selectedElements } = useTimelineStore();
-
-  const editor = useEditor();
+    const editor = useEditor();
+  const { selectedElements } = useElementSelection();
 
   const elementsWithTracks = editor.timeline.getElementsWithTracks({
     elements: selectedElements,

apps/web/src/components/editor/timeline/bookmarks.tsx

@@ -9,6 +9,7 @@ interface TimelineBookmarksRowProps {
   bookmarksScrollRef: React.RefObject<HTMLDivElement>;
   handleWheel: (e: React.WheelEvent) => void;
   handleTimelineContentClick: (e: React.MouseEvent) => void;
+  handleRulerTrackingMouseDown: (e: React.MouseEvent) => void;
   handleRulerMouseDown: (e: React.MouseEvent) => void;
 }
 
@@ -18,6 +19,7 @@ export function TimelineBookmarksRow({
   bookmarksScrollRef,
   handleWheel,
   handleTimelineContentClick,
+  handleRulerTrackingMouseDown,
   handleRulerMouseDown,
 }: TimelineBookmarksRowProps) {
   const editor = useEditor();
@@ -28,6 +30,7 @@ export function TimelineBookmarksRow({
       className="relative mt-0.5 h-4 flex-1 overflow-hidden"
       onWheel={handleWheel}
       onClick={handleTimelineContentClick}
+      onMouseDown={handleRulerTrackingMouseDown}
       data-bookmarks-area
     >
       <ScrollArea className="scrollbar-hidden w-full" ref={bookmarksScrollRef}>

apps/web/src/components/editor/timeline/drag-line.tsx

@@ -0,0 +1,21 @@
+import { getDropLineY } from "@/lib/timeline/drop-utils";
+import type { TimelineTrack, DropTarget } from "@/types/timeline";
+
+interface DragLineProps {
+  dropTarget: DropTarget | null;
+  tracks: TimelineTrack[];
+  isVisible: boolean;
+}
+
+export function DragLine({ dropTarget, tracks, isVisible }: DragLineProps) {
+  if (!isVisible || !dropTarget) return null;
+
+  const y = getDropLineY({ dropTarget, tracks });
+
+  return (
+    <div
+      className="bg-primary pointer-events-none absolute left-0 right-0 z-50 h-0.5"
+      style={{ top: `${y}px` }}
+    />
+  );
+}

apps/web/src/components/editor/timeline/index.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { ScrollArea } from "@/components/ui/scroll-area";
-import { Eye, VolumeOff, Volume2 } from "lucide-react";
+import { Eye, EyeOff, VolumeOff, Volume2, LucideIcon, EyeIcon, Trash2 } from "lucide-react";
 import {
   ContextMenu,
   ContextMenuContent,
@@ -13,7 +13,7 @@ import { useState, useRef, useCallback } from "react";
 import { TimelineTrackContent } from "./timeline-track";
 import { TimelinePlayhead } from "./timeline-playhead";
 import { SelectionBox } from "../selection-box";
-import { useSelectionBox } from "@/hooks/use-selection-box";
+import { useSelectionBox } from "@/hooks/timeline/use-selection-box";
 import { SnapIndicator } from "./snap-indicator";
 import { SnapPoint } from "@/hooks/timeline/use-timeline-snapping";
 import type { TimelineTrack } from "@/types/timeline";
@@ -21,17 +21,18 @@ import {
   TIMELINE_CONSTANTS,
   TRACK_ICONS,
 } from "@/constants/timeline-constants";
-import { useElementInteraction } from "@/hooks/timeline/use-element-interaction";
+import { useElementInteraction } from "@/hooks/timeline/element/use-element-interaction";
 import {
   getTrackHeight,
   getCumulativeHeightBefore,
   getTotalTracksHeight,
   canTracktHaveAudio,
   canTrackBeHidden,
+  isMainTrack,
 } from "@/lib/timeline";
 import { TimelineToolbar } from "./timeline-toolbar";
-import { useScrollSync } from "@/hooks/use-scroll-sync";
-import { useElementSelection } from "@/hooks/use-element-selection";
+import { useScrollSync } from "@/hooks/timeline/use-scroll-sync";
+import { useElementSelection } from "@/hooks/timeline/element/use-element-selection";
 import { useTimelineInteractions } from "@/hooks/timeline/use-timeline-interactions";
 import { useTimelineDragDrop } from "@/hooks/timeline/use-timeline-drag-drop";
 import { TimelineRuler } from "./timeline-ruler";
@@ -39,17 +40,18 @@ import { TimelineBookmarksRow } from "./bookmarks";
 import { useTimelineStore } from "@/stores/timeline-store";
 import { useEditor } from "@/hooks/use-editor";
 import { useTimelinePlayhead } from "@/hooks/timeline/use-timeline-playhead";
+import { DragLine } from "./drag-line";
 
 export function Timeline() {
   const tracksContainerHeight = { min: 200, max: 800 };
   const { snappingEnabled } = useTimelineStore();
-  const { clearSelection, setSelection } = useElementSelection();
+  const { clearElementSelection, setElementSelection } = useElementSelection();
   const editor = useEditor();
   const timeline = editor.timeline;
   const tracks = timeline.getTracks();
   const seek = (time: number) => editor.playback.seek({ time });
 
-  // Refs
+  // refs
   const timelineRef = useRef<HTMLDivElement>(null);
   const rulerRef = useRef<HTMLDivElement>(null);
   const tracksContainerRef = useRef<HTMLDivElement>(null);
@@ -60,7 +62,7 @@ export function Timeline() {
   const trackLabelsScrollRef = useRef<HTMLDivElement>(null);
   const bookmarksScrollRef = useRef<HTMLDivElement>(null);
 
-  // State
+  // state
   const [isInTimeline, setIsInTimeline] = useState(false);
   const [currentSnapPoint, setCurrentSnapPoint] = useState<SnapPoint | null>(
     null,
@@ -84,26 +86,20 @@ export function Timeline() {
     zoomLevel,
     timelineRef,
     tracksContainerRef,
+    tracksScrollRef,
     onSnapPointChange: handleSnapPointChange,
   });
 
-  const timelineDuration = timeline.getTotalDuration() || 0;
-  const paddedDuration =
-    timelineDuration + TIMELINE_CONSTANTS.PLAYHEAD_LOOKAHEAD_SECONDS;
-  const dynamicTimelineWidth = Math.max(
-    paddedDuration * TIMELINE_CONSTANTS.PIXELS_PER_SECOND * zoomLevel,
-    timelineRef.current?.clientWidth || 1000,
-  );
+  const { handleRulerMouseDown: handlePlayheadRulerMouseDown } =
+    useTimelinePlayhead({
+      zoomLevel,
+      rulerRef,
+      rulerScrollRef,
+      tracksScrollRef,
+      playheadRef,
+    });
 
-  const { handleRulerMouseDown } = useTimelinePlayhead({
-    zoomLevel,
-    rulerRef,
-    rulerScrollRef,
-    tracksScrollRef,
-    playheadRef,
-  });
-
-  const { dragProps } = useTimelineDragDrop({
+  const { isDragOver, dropTarget, dragProps } = useTimelineDragDrop({
     containerRef: tracksContainerRef,
     zoomLevel,
   });
@@ -115,26 +111,39 @@ export function Timeline() {
   } = useSelectionBox({
     containerRef: tracksContainerRef,
     onSelectionComplete: (elements) => {
-      setSelection(elements);
+      setElementSelection({ elements });
     },
     tracksScrollRef,
     zoomLevel,
   });
 
+  const timelineDuration = timeline.getTotalDuration() || 0;
+  const paddedDuration =
+    timelineDuration + TIMELINE_CONSTANTS.PLAYHEAD_LOOKAHEAD_SECONDS;
+  const dynamicTimelineWidth = Math.max(
+    paddedDuration * TIMELINE_CONSTANTS.PIXELS_PER_SECOND * zoomLevel,
+    timelineRef.current?.clientWidth || 1000,
+  );
+
   const showSnapIndicator =
     dragState.isDragging && snappingEnabled && currentSnapPoint !== null;
 
-  const { handleTimelineMouseDown, handleTimelineContentClick } =
-    useTimelineInteractions({
-      playheadRef,
-      rulerScrollRef,
-      tracksScrollRef,
-      zoomLevel,
-      duration: timeline.getTotalDuration(),
-      isSelecting,
-      clearSelectedElements: clearSelection,
-      seek,
-    });
+  const {
+    handleTracksMouseDown,
+    handleTracksClick,
+    handleRulerMouseDown,
+    handleRulerClick,
+  } = useTimelineInteractions({
+    playheadRef,
+    trackLabelsRef,
+    rulerScrollRef,
+    tracksScrollRef,
+    zoomLevel,
+    duration: timeline.getTotalDuration(),
+    isSelecting,
+    clearSelectedElements: clearElementSelection,
+    seek,
+  });
 
   useScrollSync({
     rulerScrollRef,
@@ -194,8 +203,9 @@ export function Timeline() {
               rulerRef={rulerRef}
               rulerScrollRef={rulerScrollRef}
               handleWheel={handleWheel}
-              handleTimelineContentClick={handleTimelineContentClick}
-              handleRulerMouseDown={handleRulerMouseDown}
+              handleTimelineContentClick={handleRulerClick}
+              handleRulerTrackingMouseDown={handleRulerMouseDown}
+              handleRulerMouseDown={handlePlayheadRulerMouseDown}
             />
           </div>
           <div className="flex">
@@ -207,8 +217,9 @@ export function Timeline() {
               dynamicTimelineWidth={dynamicTimelineWidth}
               bookmarksScrollRef={bookmarksScrollRef}
               handleWheel={handleWheel}
-              handleTimelineContentClick={handleTimelineContentClick}
-              handleRulerMouseDown={handleRulerMouseDown}
+              handleTimelineContentClick={handleRulerClick}
+              handleRulerTrackingMouseDown={handleRulerMouseDown}
+              handleRulerMouseDown={handlePlayheadRulerMouseDown}
             />
           </div>
         </div>
@@ -231,39 +242,41 @@ export function Timeline() {
                       }}
                     >
                       <div className="flex min-w-0 flex-1 items-center justify-end gap-2">
-                        {canTracktHaveAudio(track) && (
-                          <>
-                            {track.muted ? (
-                              <VolumeOff
-                                className="text-destructive h-4 w-4 cursor-pointer"
-                                onClick={() =>
-                                  timeline.toggleTrackMute({
-                                    trackId: track.id,
-                                  })
-                                }
-                              />
-                            ) : (
-                              <Volume2
-                                className="text-muted-foreground h-4 w-4 cursor-pointer"
-                                onClick={() =>
-                                  timeline.toggleTrackMute({
-                                    trackId: track.id,
-                                  })
-                                }
-                              />
-                            )}
-                          </>
+                        {/* Debug main track */}
+                        {isMainTrack(track) && (
+                          <div className="size-2 rounded-full bg-red-500" />
                         )}
-                        {canTrackBeHidden(track) && (
-                          <Eye
-                            className="text-muted-foreground h-4 w-4 cursor-pointer"
+
+                        {canTracktHaveAudio(track) && (
+                          <TrackToggleIcon
+                            isOff={track.muted}
+                            icons={{
+                              on: Volume2,
+                              off: VolumeOff,
+                            }}
                             onClick={() =>
-                              timeline.toggleTrackHidden({
+                              editor.timeline.toggleTrackMute({
                                 trackId: track.id,
                               })
                             }
                           />
                         )}
+
+                        {canTrackBeHidden(track) && (
+                          <TrackToggleIcon
+                            isOff={track.hidden}
+                            icons={{
+                              on: Eye,
+                              off: EyeOff,
+                            }}
+                            onClick={() =>
+                              editor.timeline.toggleTrackVisibility({
+                                trackId: track.id,
+                              })
+                            }
+                          />
+                        )}
+
                         <TrackIcon track={track} />
                       </div>
                     </div>
@@ -282,10 +295,10 @@ export function Timeline() {
               handleWheel(e);
             }}
             onMouseDown={(e) => {
-              handleTimelineMouseDown(e);
+              handleTracksMouseDown(e);
               handleSelectionMouseDown(e);
             }}
-            onClick={handleTimelineContentClick}
+            onClick={handleTracksClick}
             ref={tracksContainerRef}
           >
             <SelectionBox
@@ -294,6 +307,12 @@ export function Timeline() {
               containerRef={tracksContainerRef}
               isActive={selectionBox?.isActive || false}
             />
+            <DragLine
+              dropTarget={dropTarget}
+              tracks={timeline.getTracks()}
+              isVisible={isDragOver}
+            />
+
             <ScrollArea className="h-full w-full" ref={tracksScrollRef}>
               <div
                 className="relative flex-1"
@@ -337,7 +356,7 @@ export function Timeline() {
                             />
                           </div>
                         </ContextMenuTrigger>
-                        <ContextMenuContent className="z-200">
+                        <ContextMenuContent className="z-200 w-40">
                           <ContextMenuItem
                             onClick={(e) => {
                               e.stopPropagation();
@@ -346,12 +365,42 @@ export function Timeline() {
                               });
                             }}
                           >
-                            {canTracktHaveAudio(track) && track.muted
-                              ? "Unmute track"
-                              : "Mute track"}
+                            <Volume2 />
+                            <span>
+
+                              {canTracktHaveAudio(track) && track.muted
+                                ? "Unmute track"
+                                : "Mute track"}
+                            </span>
                           </ContextMenuItem>
-                          <ContextMenuItem onClick={(e) => e.stopPropagation()}>
-                            Track settings (soon)
+                          <ContextMenuItem
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              timeline.toggleTrackVisibility({
+                                trackId: track.id,
+                              });
+                            }}
+                          >
+                            <>
+                              <EyeIcon />
+                              <span>
+                                {canTrackBeHidden(track) && track.hidden
+                                  ? "Show track"
+                                  : "Hide track"}
+                              </span>
+                            </>
+                          </ContextMenuItem>
+                          <ContextMenuItem
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              timeline.removeTrack({
+                                trackId: track.id,
+                              });
+                            }}
+                            variant="destructive"
+                          >
+                            <Trash2 />
+                            Delete track
                           </ContextMenuItem>
                         </ContextMenuContent>
                       </ContextMenu>
@@ -370,3 +419,32 @@ export function Timeline() {
 function TrackIcon({ track }: { track: TimelineTrack }) {
   return <>{TRACK_ICONS[track.type]}</>;
 }
+
+function TrackToggleIcon({
+  isOff,
+  icons,
+  onClick,
+}: {
+  isOff: boolean;
+  icons: {
+    on: LucideIcon;
+    off: LucideIcon;
+  };
+  onClick: () => void;
+}) {
+  return (
+    <>
+      {isOff ? (
+        <icons.off
+          className="text-destructive size-4 cursor-pointer"
+          onClick={onClick}
+        />
+      ) : (
+        <icons.on
+          className="text-muted-foreground size-4 cursor-pointer"
+          onClick={onClick}
+        />
+      )}
+    </>
+  );
+}

apps/web/src/components/editor/timeline/timeline-element.tsx

@@ -12,11 +12,11 @@ import {
   VolumeX,
   ArrowUpDown,
 } from "lucide-react";
+import { useEffect, useRef } from "react";
 import { useEditor } from "@/hooks/use-editor";
-import { useTimelineStore } from "@/stores/timeline-store";
 import { useAssetsPanelStore } from "@/stores/assets-panel-store";
 import AudioWaveform from "./audio-waveform";
-import { useTimelineElementResize } from "@/hooks/timeline/use-element-resize";
+import { useTimelineElementResize } from "@/hooks/timeline/element/use-element-resize";
 import { TIMELINE_CONSTANTS } from "@/constants/timeline-constants";
 import {
   getTrackClasses,
@@ -40,6 +40,7 @@ import type {
 import { MediaAsset } from "@/types/assets";
 import { mediaSupportsAudio } from "@/lib/media-utils";
 import { type TAction, invokeAction } from "@/lib/actions";
+import { useElementSelection } from "@/hooks/timeline/element/use-element-selection";
 
 interface TimelineElementProps {
   element: TimelineElementType;
@@ -64,7 +65,8 @@ export function TimelineElement({
   dragState,
 }: TimelineElementProps) {
   const editor = useEditor();
-  const { selectedElements } = useTimelineStore();
+  const lastDragStateRef = useRef(false);
+  const { selectedElements } = useElementSelection();
   const { requestRevealMedia } = useAssetsPanelStore();
 
   const mediaAssets = editor.media.getAssets();
@@ -77,7 +79,12 @@ export function TimelineElement({
 
   const hasAudio = mediaSupportsAudio({ media: mediaAsset });
 
-  const { handleResizeStart } = useTimelineElementResize({
+  const {
+    handleResizeStart,
+    isResizing,
+    currentStartTime,
+    currentDuration,
+  } = useTimelineElementResize({
     element,
     track,
     zoomLevel,
@@ -88,15 +95,16 @@ export function TimelineElement({
       selected.elementId === element.id && selected.trackId === track.id,
   );
 
-  const elementWidth =
-    element.duration * TIMELINE_CONSTANTS.PIXELS_PER_SECOND * zoomLevel;
-
   const isBeingDragged = dragState.elementId === element.id;
   const elementStartTime =
     isBeingDragged && dragState.isDragging
       ? dragState.currentTime
       : element.startTime;
-  const elementLeft = elementStartTime * 50 * zoomLevel;
+  const displayedStartTime = isResizing ? currentStartTime : elementStartTime;
+  const displayedDuration = isResizing ? currentDuration : element.duration;
+  const elementWidth =
+    displayedDuration * TIMELINE_CONSTANTS.PIXELS_PER_SECOND * zoomLevel;
+  const elementLeft = displayedStartTime * 50 * zoomLevel;
 
   const handleAction = ({
     action,
@@ -122,9 +130,8 @@ export function TimelineElement({
     <ContextMenu>
       <ContextMenuTrigger asChild>
         <div
-          className={`timeline-element absolute top-0 h-full select-none ${
-            isBeingDragged ? "z-50" : "z-10"
-          }`}
+          className={`timeline-element absolute top-0 h-full select-none ${isBeingDragged ? "z-30" : "z-10"
+            }`}
           style={{ left: `${elementLeft}px`, width: `${elementWidth}px` }}
           data-element-id={element.id}
           data-track-id={track.id}
@@ -166,7 +173,7 @@ export function TimelineElement({
             isMuted={isMuted}
             selectedCount={selectedElements.length}
             onClick={(event) =>
-              handleAction({ action: "toggle-mute-selected", event })
+              handleAction({ action: "toggle-elements-muted-selected", event })
             }
           />
         )}
@@ -177,7 +184,10 @@ export function TimelineElement({
             isCurrentElementSelected={isCurrentElementSelected}
             selectedCount={selectedElements.length}
             onClick={(event) =>
-              handleAction({ action: "toggle-visibility-selected", event })
+              handleAction({
+                action: "toggle-elements-visibility-selected",
+                event,
+              })
             }
           />
         )}
@@ -260,7 +270,7 @@ function ElementInner({
         {
           type: track.type,
         },
-      )} ${isBeingDragged ? "z-50" : "z-10"} ${canElementBeHidden(element) && element.hidden ? "opacity-50" : ""}`}
+      )} ${isBeingDragged ? "z-30" : "z-10"} ${canElementBeHidden(element) && element.hidden ? "opacity-50" : ""}`}
       onClick={(e) => onElementClick(e, element)}
       onMouseDown={(e) => onElementMouseDown(e, element)}
       onContextMenu={(e) => onElementMouseDown(e, element)}

apps/web/src/components/editor/timeline/timeline-playhead.tsx

@@ -87,7 +87,7 @@ export function TimelinePlayhead({
   return (
     <div
       ref={playheadRef}
-      className="pointer-events-auto absolute z-40"
+      className="pointer-events-auto absolute z-60"
       style={{
         left: `${leftPosition}px`,
         top: 0,

apps/web/src/components/editor/timeline/timeline-ruler.tsx

@@ -11,6 +11,7 @@ interface TimelineRulerProps {
   rulerScrollRef: React.RefObject<HTMLDivElement>;
   handleWheel: (e: React.WheelEvent) => void;
   handleTimelineContentClick: (e: React.MouseEvent) => void;
+  handleRulerTrackingMouseDown: (e: React.MouseEvent) => void;
   handleRulerMouseDown: (e: React.MouseEvent) => void;
 }
 
@@ -21,6 +22,7 @@ export function TimelineRuler({
   rulerScrollRef,
   handleWheel,
   handleTimelineContentClick,
+  handleRulerTrackingMouseDown,
   handleRulerMouseDown,
 }: TimelineRulerProps) {
   const editor = useEditor();
@@ -50,6 +52,7 @@ export function TimelineRuler({
       className="relative h-4 flex-1 overflow-hidden"
       onWheel={handleWheel}
       onClick={handleTimelineContentClick}
+      onMouseDown={handleRulerTrackingMouseDown}
       data-ruler-area
     >
       <ScrollArea className="scrollbar-hidden w-full" ref={rulerScrollRef}>

apps/web/src/components/editor/timeline/timeline-toolbar.tsx

@@ -1,5 +1,4 @@
 import { useEditor } from "@/hooks/use-editor";
-import { useElementSelection } from "@/hooks/use-element-selection";
 import {
   TooltipProvider,
   Tooltip,
@@ -37,6 +36,8 @@ import { TIMELINE_CONSTANTS } from "@/constants/timeline-constants";
 import { EditableTimecode } from "@/components/ui/editable-timecode";
 import { ScenesView } from "../scenes-view";
 import { type TAction, invokeAction } from "@/lib/actions";
+import { cn } from "@/lib/utils";
+import { useTimelineStore } from "@/stores/timeline-store";
 
 export function TimelineToolbar({
   zoomLevel,
@@ -49,13 +50,13 @@ export function TimelineToolbar({
     const newZoomLevel =
       direction === "in"
         ? Math.min(
-            TIMELINE_CONSTANTS.ZOOM_MAX,
-            zoomLevel + TIMELINE_CONSTANTS.ZOOM_STEP,
-          )
+          TIMELINE_CONSTANTS.ZOOM_MAX,
+          zoomLevel + TIMELINE_CONSTANTS.ZOOM_STEP,
+        )
         : Math.max(
-            TIMELINE_CONSTANTS.ZOOM_MIN,
-            zoomLevel - TIMELINE_CONSTANTS.ZOOM_STEP,
-          );
+          TIMELINE_CONSTANTS.ZOOM_MIN,
+          zoomLevel - TIMELINE_CONSTANTS.ZOOM_STEP,
+        );
     setZoomLevel({ zoom: newZoomLevel });
   };
 
@@ -75,13 +76,9 @@ export function TimelineToolbar({
 }
 
 function ToolbarLeftSection() {
-  const { selectedElements } = useElementSelection();
-
   const editor = useEditor();
   const currentTime = editor.playback.getCurrentTime();
-  const duration = editor.timeline.getTotalDuration();
   const isPlaying = editor.playback.getIsPlaying();
-  const activeProject = editor.project.getActive();
   const currentBookmarked = editor.scenes.isBookmarked({ time: currentTime });
 
   const handleAction = ({
@@ -114,11 +111,7 @@ function ToolbarLeftSection() {
 
         <div className="bg-border mx-2 h-10 w-px" />
 
-        <TimeDisplay
-          currentTime={currentTime}
-          duration={duration}
-          fps={activeProject.settings.fps}
-        />
+        <TimeDisplay />
 
         <div className="bg-border mx-1 h-10 w-px" />
 
@@ -148,9 +141,9 @@ function ToolbarLeftSection() {
 
         <ToolbarButton
           icon={<SplitSquareHorizontal />}
-          tooltip="Coming soon" /* Separate audio */
+          tooltip="Coming soon" /* separate audio */
           disabled={true}
-          onClick={({ event }) => {}}
+          onClick={({ event }) => { }}
         />
 
         <ToolbarButton
@@ -163,9 +156,9 @@ function ToolbarLeftSection() {
 
         <ToolbarButton
           icon={<Snowflake />}
-          tooltip="Coming soon" /* Freeze frame */
+          tooltip="Coming soon" /* freeze frame */
           disabled={true}
-          onClick={({ event }) => {}}
+          onClick={({ event }) => { }}
         />
 
         <ToolbarButton
@@ -196,31 +189,26 @@ function ToolbarLeftSection() {
   );
 }
 
-function TimeDisplay({
-  currentTime,
-  duration,
-  fps,
-}: {
-  currentTime: number;
-  duration: number;
-  fps: number;
-}) {
+function TimeDisplay() {
   const editor = useEditor();
+  const currentTime = editor.playback.getCurrentTime();
+  const totalDuration = editor.timeline.getTotalDuration();
+  const fps = editor.project.getActive().settings.fps;
 
   return (
     <div className="flex flex-row items-center justify-center px-2">
       <EditableTimecode
         time={currentTime}
-        duration={duration}
+        duration={totalDuration}
         format="HH:MM:SS:FF"
         fps={fps}
-        onTimeChange={(time) => editor.playback.seek({ time })}
+        onTimeChange={({ time }) => editor.playback.seek({ time })}
         className="text-center"
       />
       <div className="text-muted-foreground px-2 font-mono text-xs">/</div>
       <div className="text-muted-foreground text-center font-mono text-xs">
         {formatTimeCode({
-          timeInSeconds: duration,
+          timeInSeconds: totalDuration,
           format: "HH:MM:SS:FF",
           fps,
         })}
@@ -242,7 +230,7 @@ function SceneSelector() {
         <ScenesView>
           <SplitButtonRight
             disabled={scenesCount === 1}
-            onClick={() => {}}
+            onClick={() => { }}
             type="button"
           >
             <LayersIcon className="size-4" />
@@ -262,19 +250,21 @@ function ToolbarRightSection({
   onZoomChange: (zoom: number) => void;
   onZoom: (options: { direction: "in" | "out" }) => void;
 }) {
+  const { snappingEnabled, rippleEditingEnabled, toggleSnapping, toggleRippleEditing } = useTimelineStore();
+
   return (
     <div className="flex items-center gap-1">
       <TooltipProvider delayDuration={500}>
         <ToolbarButton
-          icon={<Magnet />}
+          icon={<Magnet className={cn(snappingEnabled ? "text-primary" : "")} />}
           tooltip="Auto snapping"
-          onClick={() => {}}
+          onClick={() => toggleSnapping()}
         />
 
         <ToolbarButton
-          icon={<Link />}
+          icon={<Link className={cn(rippleEditingEnabled ? "text-primary" : "")} />}
           tooltip="Ripple editing"
-          onClick={() => {}}
+          onClick={() => toggleRippleEditing()}
         />
       </TooltipProvider>
 

apps/web/src/components/editor/timeline/timeline-track.tsx

@@ -1,11 +1,11 @@
 "use client";
 
-import { useElementSelection } from "@/hooks/use-element-selection";
+import { useElementSelection } from "@/hooks/timeline/element/use-element-selection";
 import { TimelineElement } from "./timeline-element";
 import { TimelineTrack } from "@/types/timeline";
 import type { TimelineElement as TimelineElementType } from "@/types/timeline";
 import { TIMELINE_CONSTANTS } from "@/constants/timeline-constants";
-import { useEdgeAutoScroll } from "@/hooks/use-edge-auto-scroll";
+import { useEdgeAutoScroll } from "@/hooks/timeline/use-edge-auto-scroll";
 import { ElementDragState } from "@/types/timeline";
 import { useEditor } from "@/hooks/use-editor";
 
@@ -39,7 +39,7 @@ export function TimelineTrackContent({
   onElementClick,
 }: TimelineTrackContentProps) {
   const editor = useEditor();
-  const { isSelected, clearSelection } = useElementSelection();
+  const { isElementSelected, clearElementSelection } = useElementSelection();
 
   const duration = editor.timeline.getTotalDuration();
 
@@ -52,14 +52,17 @@ export function TimelineTrackContent({
   });
 
   return (
-    <div className="hover:bg-muted/20 size-full" onClick={clearSelection}>
+    <div
+      className="hover:bg-muted/20 size-full"
+      onClick={clearElementSelection}
+    >
       <div className="track-elements-container relative h-full min-w-full">
         {track.elements.length === 0 ? (
           <div className="text-muted-foreground border-muted/30 flex size-full items-center justify-center rounded-sm border-2 border-dashed text-xs" />
         ) : (
           <>
             {track.elements.map((element) => {
-              const isElementSelected = isSelected({
+              const isSelected = isElementSelected({
                 trackId: track.id,
                 elementId: element.id,
               });
@@ -70,7 +73,7 @@ export function TimelineTrackContent({
                   element={element}
                   track={track}
                   zoomLevel={zoomLevel}
-                  isSelected={isElementSelected}
+                  isSelected={isSelected}
                   onElementMouseDown={(event, element) =>
                     onElementMouseDown({ event, element, track })
                   }

apps/web/src/components/providers/editor-provider.tsx

@@ -8,7 +8,7 @@ import {
   useKeybindingsListener,
   useKeybindingDisabler,
 } from "@/hooks/use-keybindings";
-import { useEditorActions } from "@/hooks/use-editor-actions";
+import { useEditorActions } from "@/hooks/actions/use-editor-actions";
 
 interface EditorProviderProps {
   projectId: string;

apps/web/src/components/ui/editable-timecode.tsx

@@ -10,7 +10,7 @@ interface EditableTimecodeProps {
   duration: number;
   format?: TTimeCode;
   fps: number;
-  onTimeChange?: (time: number) => void;
+  onTimeChange?: ({ time }: { time: number }) => void;
   className?: string;
   disabled?: boolean;
 }
@@ -54,43 +54,57 @@ export function EditableTimecode({
       return;
     }
 
-    // Clamp time to valid range
     const clampedTime = Math.max(
       0,
       duration ? Math.min(duration, parsedTime) : parsedTime,
     );
 
-    onTimeChange?.(clampedTime);
+    onTimeChange?.({ time: clampedTime });
     setIsEditing(false);
     setInputValue("");
     setHasError(false);
     enterPressedRef.current = false;
   };
 
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === "Enter") {
-      e.preventDefault();
+  const handleKeyDown = ({
+    key,
+    preventDefault,
+  }: React.KeyboardEvent<HTMLInputElement>) => {
+    if (key === "Enter") {
+      preventDefault();
       enterPressedRef.current = true;
       applyEdit();
-    } else if (e.key === "Escape") {
-      e.preventDefault();
+    } else if (key === "Escape") {
+      preventDefault();
       cancelEditing();
     }
   };
 
-  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    setInputValue(e.target.value);
+  const handleInputChange = ({
+    target,
+  }: React.ChangeEvent<HTMLInputElement>) => {
+    setInputValue(target.value);
     setHasError(false);
   };
 
   const handleBlur = () => {
-    // Only apply edit if Enter wasn't pressed (to avoid double processing)
     if (!enterPressedRef.current && isEditing) {
       applyEdit();
     }
   };
 
-  // Focus input when entering edit mode
+  const handleDisplayKeyDown = ({
+    key,
+    preventDefault,
+  }: React.KeyboardEvent<HTMLSpanElement>) => {
+    if (disabled) return;
+
+    if (key === "Enter" || key === " ") {
+      preventDefault();
+      startEditing();
+    }
+  };
+
   useEffect(() => {
     if (isEditing && inputRef.current) {
       inputRef.current.focus();
@@ -123,6 +137,9 @@ export function EditableTimecode({
   return (
     <span
       onClick={startEditing}
+      onKeyDown={handleDisplayKeyDown}
+      role="button"
+      tabIndex={disabled ? -1 : 0}
       className={cn(
         "text-primary cursor-pointer font-mono text-xs tabular-nums",
         "hover:bg-muted/50 -mx-1 px-1 transition-colors hover:rounded",

apps/web/src/components/ui/sidebar.tsx

@@ -1,763 +0,0 @@
-"use client";
-
-import * as React from "react";
-import { Slot as SlotPrimitive } from "radix-ui";
-import { VariantProps, cva } from "class-variance-authority";
-import { PanelLeft } from "lucide-react";
-
-import { useIsMobile } from "../../hooks/use-mobile";
-import { cn } from "../../lib/utils";
-import { Button } from "./button";
-import { Input } from "./input";
-import { Separator } from "./separator";
-import { Sheet, SheetContent, SheetTitle } from "./sheet";
-import { Skeleton } from "./skeleton";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from "./tooltip";
-
-const SIDEBAR_COOKIE_NAME = "sidebar:state";
-const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7;
-const SIDEBAR_WIDTH = "16rem";
-const SIDEBAR_WIDTH_MOBILE = "18rem";
-const SIDEBAR_WIDTH_ICON = "3rem";
-const SIDEBAR_KEYBOARD_SHORTCUT = "b";
-
-type SidebarContext = {
-  state: "expanded" | "collapsed";
-  open: boolean;
-  setOpen: (open: boolean) => void;
-  openMobile: boolean;
-  setOpenMobile: (open: boolean) => void;
-  isMobile: boolean;
-  toggleSidebar: () => void;
-};
-
-const SidebarContext = React.createContext<SidebarContext | null>(null);
-
-function useSidebar() {
-  const context = React.useContext(SidebarContext);
-  if (!context) {
-    throw new Error("useSidebar must be used within a SidebarProvider.");
-  }
-
-  return context;
-}
-
-const SidebarProvider = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div"> & {
-    defaultOpen?: boolean;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-  }
->(
-  (
-    {
-      defaultOpen = true,
-      open: openProp,
-      onOpenChange: setOpenProp,
-      className,
-      style,
-      children,
-      ...props
-    },
-    ref
-  ) => {
-    const isMobile = useIsMobile();
-    const [openMobile, setOpenMobile] = React.useState(false);
-
-    // This is the internal state of the sidebar.
-    // We use openProp and setOpenProp for control from outside the component.
-    const [_open, _setOpen] = React.useState(defaultOpen);
-    const open = openProp ?? _open;
-    const setOpen = React.useCallback(
-      (value: boolean | ((value: boolean) => boolean)) => {
-        const openState = typeof value === "function" ? value(open) : value;
-        if (setOpenProp) {
-          setOpenProp(openState);
-        } else {
-          _setOpen(openState);
-        }
-
-        // This sets the cookie to keep the sidebar state.
-        document.cookie = `${SIDEBAR_COOKIE_NAME}=${openState}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`;
-      },
-      [setOpenProp, open]
-    );
-
-    // Helper to toggle the sidebar.
-    const toggleSidebar = React.useCallback(() => {
-      return isMobile
-        ? setOpenMobile((open) => !open)
-        : setOpen((open) => !open);
-    }, [isMobile, setOpen, setOpenMobile]);
-
-    // Adds a keyboard shortcut to toggle the sidebar.
-    React.useEffect(() => {
-      const handleKeyDown = (event: KeyboardEvent) => {
-        if (
-          event.key === SIDEBAR_KEYBOARD_SHORTCUT &&
-          (event.metaKey || event.ctrlKey)
-        ) {
-          event.preventDefault();
-          toggleSidebar();
-        }
-      };
-
-      window.addEventListener("keydown", handleKeyDown);
-      return () => window.removeEventListener("keydown", handleKeyDown);
-    }, [toggleSidebar]);
-
-    // We add a state so that we can do data-state="expanded" or "collapsed".
-    // This makes it easier to style the sidebar with Tailwind classes.
-    const state = open ? "expanded" : "collapsed";
-
-    const contextValue = React.useMemo<SidebarContext>(
-      () => ({
-        state,
-        open,
-        setOpen,
-        isMobile,
-        openMobile,
-        setOpenMobile,
-        toggleSidebar,
-      }),
-      [state, open, setOpen, isMobile, openMobile, setOpenMobile, toggleSidebar]
-    );
-
-    return (
-      <SidebarContext.Provider value={contextValue}>
-        <TooltipProvider delayDuration={0}>
-          <div
-            style={
-              {
-                "--sidebar-width": SIDEBAR_WIDTH,
-                "--sidebar-width-icon": SIDEBAR_WIDTH_ICON,
-                ...style,
-              } as React.CSSProperties
-            }
-            className={cn(
-              "group/sidebar-wrapper flex min-h-svh w-full has-data-[variant=inset]:bg-sidebar",
-              className
-            )}
-            ref={ref}
-            {...props}
-          >
-            {children}
-          </div>
-        </TooltipProvider>
-      </SidebarContext.Provider>
-    );
-  }
-);
-SidebarProvider.displayName = "SidebarProvider";
-
-const Sidebar = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div"> & {
-    side?: "left" | "right";
-    variant?: "sidebar" | "floating" | "inset";
-    collapsible?: "offcanvas" | "icon" | "none";
-  }
->(
-  (
-    {
-      side = "left",
-      variant = "sidebar",
-      collapsible = "offcanvas",
-      className,
-      children,
-      ...props
-    },
-    ref
-  ) => {
-    const { isMobile, state, openMobile, setOpenMobile } = useSidebar();
-
-    if (collapsible === "none") {
-      return (
-        <div
-          className={cn(
-            "flex h-full w-(--sidebar-width) flex-col bg-sidebar text-sidebar-foreground",
-            className
-          )}
-          ref={ref}
-          {...props}
-        >
-          {children}
-        </div>
-      );
-    }
-
-    if (isMobile) {
-      return (
-        <Sheet open={openMobile} onOpenChange={setOpenMobile} {...props}>
-          <SheetContent
-            data-sidebar="sidebar"
-            data-mobile="true"
-            className="w-(--sidebar-width) bg-sidebar p-0 text-sidebar-foreground [&>button]:hidden"
-            style={
-              {
-                "--sidebar-width": SIDEBAR_WIDTH_MOBILE,
-              } as React.CSSProperties
-            }
-            side={side}
-          >
-            <SheetTitle className="sr-only">Navigation Menu</SheetTitle>
-            <div className="flex h-full w-full flex-col">{children}</div>
-          </SheetContent>
-        </Sheet>
-      );
-    }
-
-    return (
-      <div
-        ref={ref}
-        className="group peer hidden md:block text-sidebar-foreground"
-        data-state={state}
-        data-collapsible={state === "collapsed" ? collapsible : ""}
-        data-variant={variant}
-        data-side={side}
-      >
-        {/* This is what handles the sidebar gap on desktop */}
-        <div
-          className={cn(
-            "duration-200 relative h-full w-(--sidebar-width) bg-transparent transition-[width] ease-linear",
-            "group-data-[collapsible=offcanvas]:w-0",
-            "group-data-[side=right]:rotate-180",
-            variant === "floating" || variant === "inset"
-              ? "group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4)))]"
-              : "group-data-[collapsible=icon]:w-(--sidebar-width-icon)"
-          )}
-        />
-        <div
-          className={cn(
-            "duration-200 fixed h-[calc(100vh-4rem)] top-16 z-10 hidden w-(--sidebar-width) transition-[left,right,width] ease-linear md:flex",
-            side === "left"
-              ? "left-0 border-r group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]"
-              : "right-0 border-l group-data-[collapsible=offcanvas]:right-[calc(var(--sidebar-width)*-1)]",
-            variant === "floating" || variant === "inset"
-              ? "p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4))+2px)]"
-              : "group-data-[collapsible=icon]:w-(--sidebar-width-icon)",
-            className
-          )}
-          {...props}
-        >
-          <div
-            data-sidebar="sidebar"
-            className="flex h-full w-full flex-col bg-sidebar group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:border group-data-[variant=floating]:border-sidebar-border group-data-[variant=floating]:shadow-sm"
-          >
-            {children}
-          </div>
-        </div>
-      </div>
-    );
-  }
-);
-Sidebar.displayName = "Sidebar";
-
-const SidebarTrigger = React.forwardRef<
-  React.ElementRef<typeof Button>,
-  React.ComponentProps<typeof Button>
->(({ className, onClick, ...props }, ref) => {
-  const { toggleSidebar } = useSidebar();
-
-  return (
-    <Button
-      ref={ref}
-      data-sidebar="trigger"
-      variant="text"
-      size="icon"
-      className={cn("h-8 w-8", className)}
-      onClick={(event) => {
-        onClick?.(event);
-        toggleSidebar();
-      }}
-      {...props}
-    >
-      <PanelLeft />
-      <span className="sr-only">Toggle Sidebar</span>
-    </Button>
-  );
-});
-SidebarTrigger.displayName = "SidebarTrigger";
-
-const SidebarRail = React.forwardRef<
-  HTMLButtonElement,
-  React.ComponentProps<"button">
->(({ className, ...props }, ref) => {
-  const { toggleSidebar } = useSidebar();
-
-  return (
-    <button
-      ref={ref}
-      data-sidebar="rail"
-      aria-label="Toggle Sidebar"
-      tabIndex={-1}
-      onClick={toggleSidebar}
-      title="Toggle Sidebar"
-      className={cn(
-        "absolute inset-y-0 z-20 hidden w-4 -translate-x-1/2 transition-all ease-linear after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] hover:after:bg-sidebar-border group-data-[side=left]:-right-4 group-data-[side=right]:left-0 sm:flex",
-        "in-data-[side=left]:cursor-w-resize in-data-[side=right]:cursor-e-resize",
-        "[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize",
-        "group-data-[collapsible=offcanvas]:translate-x-0 group-data-[collapsible=offcanvas]:after:left-full hover:group-data-[collapsible=offcanvas]:bg-sidebar",
-        "[[data-side=left][data-collapsible=offcanvas]_&]:-right-2",
-        "[[data-side=right][data-collapsible=offcanvas]_&]:-left-2",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarRail.displayName = "SidebarRail";
-
-const SidebarInset = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"main">
->(({ className, ...props }, ref) => {
-  return (
-    <main
-      ref={ref}
-      className={cn(
-        "relative flex min-h-svh flex-1 flex-col bg-background",
-        "peer-data-[variant=inset]:min-h-[calc(100svh-(--spacing(4)))] md:peer-data-[variant=inset]:m-2 md:peer-data-[variant=inset]:peer-data-[state=collapsed]:ml-2 md:peer-data-[variant=inset]:ml-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow-sm",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarInset.displayName = "SidebarInset";
-
-const SidebarInput = React.forwardRef<
-  React.ElementRef<typeof Input>,
-  React.ComponentProps<typeof Input>
->(({ className, ...props }, ref) => {
-  return (
-    <Input
-      ref={ref}
-      data-sidebar="input"
-      className={cn(
-        "h-8 w-full bg-background shadow-none focus-visible:ring-2 focus-visible:ring-sidebar-ring",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarInput.displayName = "SidebarInput";
-
-const SidebarHeader = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div">
->(({ className, ...props }, ref) => {
-  return (
-    <div
-      ref={ref}
-      data-sidebar="header"
-      className={cn("flex flex-col gap-2 p-2", className)}
-      {...props}
-    />
-  );
-});
-SidebarHeader.displayName = "SidebarHeader";
-
-const SidebarFooter = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div">
->(({ className, ...props }, ref) => {
-  return (
-    <div
-      ref={ref}
-      data-sidebar="footer"
-      className={cn("flex flex-col gap-2 p-2", className)}
-      {...props}
-    />
-  );
-});
-SidebarFooter.displayName = "SidebarFooter";
-
-const SidebarSeparator = React.forwardRef<
-  React.ElementRef<typeof Separator>,
-  React.ComponentProps<typeof Separator>
->(({ className, ...props }, ref) => {
-  return (
-    <Separator
-      ref={ref}
-      data-sidebar="separator"
-      className={cn("mx-2 w-auto bg-sidebar-border", className)}
-      {...props}
-    />
-  );
-});
-SidebarSeparator.displayName = "SidebarSeparator";
-
-const SidebarContent = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div">
->(({ className, ...props }, ref) => {
-  return (
-    <div
-      ref={ref}
-      data-sidebar="content"
-      className={cn(
-        "flex min-h-0 flex-1 flex-col gap-2 overflow-auto group-data-[collapsible=icon]:overflow-hidden",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarContent.displayName = "SidebarContent";
-
-const SidebarGroup = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div">
->(({ className, ...props }, ref) => {
-  return (
-    <div
-      ref={ref}
-      data-sidebar="group"
-      className={cn("relative flex w-full min-w-0 flex-col p-2", className)}
-      {...props}
-    />
-  );
-});
-SidebarGroup.displayName = "SidebarGroup";
-
-const SidebarGroupLabel = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div"> & { asChild?: boolean }
->(({ className, asChild = false, ...props }, ref) => {
-  const Comp = asChild ? SlotPrimitive.Slot : "div";
-
-  return (
-    <Comp
-      ref={ref as any}
-      data-sidebar="group-label"
-      className={cn(
-        "duration-200 flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium text-sidebar-foreground/70 outline-hidden ring-sidebar-ring transition-[margin,opa] ease-linear focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
-        "group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarGroupLabel.displayName = "SidebarGroupLabel";
-
-const SidebarGroupAction = React.forwardRef<
-  HTMLButtonElement,
-  React.ComponentProps<"button"> & { asChild?: boolean }
->(({ className, asChild = false, ...props }, ref) => {
-  const Comp = asChild ? SlotPrimitive.Slot : "button";
-
-  return (
-    <Comp
-      ref={ref as any}
-      data-sidebar="group-action"
-      className={cn(
-        "absolute right-3 top-3.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-hidden ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
-        // Increases the hit area of the button on mobile.
-        "after:absolute after:-inset-2 md:after:hidden",
-        "group-data-[collapsible=icon]:hidden",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarGroupAction.displayName = "SidebarGroupAction";
-
-const SidebarGroupContent = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div">
->(({ className, ...props }, ref) => (
-  <div
-    ref={ref}
-    data-sidebar="group-content"
-    className={cn("w-full text-sm", className)}
-    {...props}
-  />
-));
-SidebarGroupContent.displayName = "SidebarGroupContent";
-
-const SidebarMenu = React.forwardRef<
-  HTMLUListElement,
-  React.ComponentProps<"ul">
->(({ className, ...props }, ref) => (
-  <ul
-    ref={ref}
-    data-sidebar="menu"
-    className={cn("flex w-full min-w-0 flex-col gap-1", className)}
-    {...props}
-  />
-));
-SidebarMenu.displayName = "SidebarMenu";
-
-const SidebarMenuItem = React.forwardRef<
-  HTMLLIElement,
-  React.ComponentProps<"li">
->(({ className, ...props }, ref) => (
-  <li
-    ref={ref}
-    data-sidebar="menu-item"
-    className={cn("group/menu-item relative", className)}
-    {...props}
-  />
-));
-SidebarMenuItem.displayName = "SidebarMenuItem";
-
-const sidebarMenuButtonVariants = cva(
-  "peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-hidden ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-data-[sidebar=menu-action]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:size-8! group-data-[collapsible=icon]:p-2! [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
-  {
-    variants: {
-      variant: {
-        default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
-        outline:
-          "bg-background shadow-[0_0_0_1px_var(--sidebar-border)] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_var(--sidebar-accent)]",
-      },
-      size: {
-        default: "h-8 text-sm",
-        sm: "h-7 text-xs",
-        lg: "h-12 text-sm group-data-[collapsible=icon]:p-0!",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-);
-
-const SidebarMenuButton = React.forwardRef<
-  HTMLButtonElement,
-  React.ComponentProps<"button"> & {
-    asChild?: boolean;
-    isActive?: boolean;
-    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
-  } & VariantProps<typeof sidebarMenuButtonVariants>
->(
-  (
-    {
-      asChild = false,
-      isActive = false,
-      variant = "default",
-      size = "default",
-      tooltip,
-      className,
-      ...props
-    },
-    ref
-  ) => {
-    const Comp = asChild ? SlotPrimitive.Slot : "button";
-    const { isMobile, state } = useSidebar();
-
-    const button = (
-      <Comp
-        ref={ref as any}
-        data-sidebar="menu-button"
-        data-size={size}
-        data-active={isActive}
-        className={cn(sidebarMenuButtonVariants({ variant, size }), className)}
-        {...props}
-      />
-    );
-
-    if (!tooltip) {
-      return button;
-    }
-
-    if (typeof tooltip === "string") {
-      tooltip = {
-        children: tooltip,
-      };
-    }
-
-    return (
-      <Tooltip>
-        <TooltipTrigger asChild>{button}</TooltipTrigger>
-        <TooltipContent
-          side="right"
-          align="center"
-          hidden={state !== "collapsed" || isMobile}
-          {...tooltip}
-        />
-      </Tooltip>
-    );
-  }
-);
-SidebarMenuButton.displayName = "SidebarMenuButton";
-
-const SidebarMenuAction = React.forwardRef<
-  HTMLButtonElement,
-  React.ComponentProps<"button"> & {
-    asChild?: boolean;
-    showOnHover?: boolean;
-  }
->(({ className, asChild = false, showOnHover = false, ...props }, ref) => {
-  const Comp = asChild ? SlotPrimitive.Slot : "button";
-
-  return (
-    <Comp
-      ref={ref as any}
-      data-sidebar="menu-action"
-      className={cn(
-        "absolute right-1 top-1.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-hidden ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 peer-hover/menu-button:text-sidebar-accent-foreground [&>svg]:size-4 [&>svg]:shrink-0",
-        // Increases the hit area of the button on mobile.
-        "after:absolute after:-inset-2 md:after:hidden",
-        "peer-data-[size=sm]/menu-button:top-1",
-        "peer-data-[size=default]/menu-button:top-1.5",
-        "peer-data-[size=lg]/menu-button:top-2.5",
-        "group-data-[collapsible=icon]:hidden",
-        showOnHover &&
-          "group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 peer-data-[active=true]/menu-button:text-sidebar-accent-foreground md:opacity-0",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarMenuAction.displayName = "SidebarMenuAction";
-
-const SidebarMenuBadge = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div">
->(({ className, ...props }, ref) => (
-  <div
-    ref={ref}
-    data-sidebar="menu-badge"
-    className={cn(
-      "absolute right-1 flex h-5 min-w-5 items-center justify-center rounded-md px-1 text-xs font-medium tabular-nums text-sidebar-foreground select-none pointer-events-none",
-      "peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[active=true]/menu-button:text-sidebar-accent-foreground",
-      "peer-data-[size=sm]/menu-button:top-1",
-      "peer-data-[size=default]/menu-button:top-1.5",
-      "peer-data-[size=lg]/menu-button:top-2.5",
-      "group-data-[collapsible=icon]:hidden",
-      className
-    )}
-    {...props}
-  />
-));
-SidebarMenuBadge.displayName = "SidebarMenuBadge";
-
-const SidebarMenuSkeleton = React.forwardRef<
-  HTMLDivElement,
-  React.ComponentProps<"div"> & {
-    showIcon?: boolean;
-  }
->(({ className, showIcon = false, ...props }, ref) => {
-  // Random width between 50 to 90%.
-  const width = React.useMemo(() => {
-    return `${Math.floor(Math.random() * 40) + 50}%`;
-  }, []);
-
-  return (
-    <div
-      ref={ref}
-      data-sidebar="menu-skeleton"
-      className={cn("rounded-md h-8 flex gap-2 px-2 items-center", className)}
-      {...props}
-    >
-      {showIcon && (
-        <Skeleton
-          className="size-4 rounded-md"
-          data-sidebar="menu-skeleton-icon"
-        />
-      )}
-      <Skeleton
-        className="h-4 flex-1 max-w-(--skeleton-width)"
-        data-sidebar="menu-skeleton-text"
-        style={
-          {
-            "--skeleton-width": width,
-          } as React.CSSProperties
-        }
-      />
-    </div>
-  );
-});
-SidebarMenuSkeleton.displayName = "SidebarMenuSkeleton";
-
-const SidebarMenuSub = React.forwardRef<
-  HTMLUListElement,
-  React.ComponentProps<"ul">
->(({ className, ...props }, ref) => (
-  <ul
-    ref={ref}
-    data-sidebar="menu-sub"
-    className={cn(
-      "mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l border-sidebar-border px-2.5 py-0.5",
-      "group-data-[collapsible=icon]:hidden",
-      className
-    )}
-    {...props}
-  />
-));
-SidebarMenuSub.displayName = "SidebarMenuSub";
-
-const SidebarMenuSubItem = React.forwardRef<
-  HTMLLIElement,
-  React.ComponentProps<"li">
->(({ ...props }, ref) => <li ref={ref} {...props} />);
-SidebarMenuSubItem.displayName = "SidebarMenuSubItem";
-
-const SidebarMenuSubButton = React.forwardRef<
-  HTMLAnchorElement,
-  React.ComponentProps<"a"> & {
-    asChild?: boolean;
-    size?: "sm" | "md";
-    isActive?: boolean;
-  }
->(({ asChild = false, size = "md", isActive, className, ...props }, ref) => {
-  const Comp = asChild ? SlotPrimitive.Slot : "a";
-
-  return (
-    <Comp
-      ref={ref as any}
-      data-sidebar="menu-sub-button"
-      data-size={size}
-      data-active={isActive}
-      className={cn(
-        "flex h-7 min-w-0 -translate-x-px items-center gap-2 overflow-hidden rounded-md px-2 text-sidebar-foreground outline-hidden ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0 [&>svg]:text-sidebar-accent-foreground",
-        "data-[active=true]:bg-sidebar-accent data-[active=true]:text-sidebar-accent-foreground",
-        size === "sm" && "text-xs",
-        size === "md" && "text-sm",
-        "group-data-[collapsible=icon]:hidden",
-        className
-      )}
-      {...props}
-    />
-  );
-});
-SidebarMenuSubButton.displayName = "SidebarMenuSubButton";
-
-export {
-  Sidebar,
-  SidebarContent,
-  SidebarFooter,
-  SidebarGroup,
-  SidebarGroupAction,
-  SidebarGroupContent,
-  SidebarGroupLabel,
-  SidebarHeader,
-  SidebarInput,
-  SidebarInset,
-  SidebarMenu,
-  SidebarMenuAction,
-  SidebarMenuBadge,
-  SidebarMenuButton,
-  SidebarMenuItem,
-  SidebarMenuSkeleton,
-  SidebarMenuSub,
-  SidebarMenuSubButton,
-  SidebarMenuSubItem,
-  SidebarProvider,
-  SidebarRail,
-  SidebarSeparator,
-  SidebarTrigger,
-  useSidebar,
-};

apps/web/src/components/ui/toaster.tsx

@@ -1,31 +0,0 @@
-"use client";
-
-import { useToast } from "../../hooks/use-toast";
-import {
-  Toast,
-  ToastClose,
-  ToastDescription,
-  ToastProvider,
-  ToastTitle,
-  ToastViewport,
-} from "./toast";
-
-export function Toaster() {
-  const { toasts } = useToast();
-
-  return (
-    <ToastProvider>
-      {toasts.map(({ id, title, description, action, ...props }) => (
-        <Toast key={id} {...props}>
-          <div className="grid gap-1">
-            {title && <ToastTitle>{title}</ToastTitle>}
-            {description && <ToastDescription>{description}</ToastDescription>}
-          </div>
-          {action}
-          <ToastClose />
-        </Toast>
-      ))}
-      <ToastViewport />
-    </ToastProvider>
-  );
-}