refactor(studio): remove unreachable expanded-child timeline code

packages/studio/src/components/nle/TimelinePane.tsx

@@ -1,77 +1,10 @@
-import { useCallback, type ReactNode } from "react";
+import type { ReactNode } from "react";
 import { Timeline } from "../../player";
 import type { TimelineElement, TimelineTimeRange } from "../../player";
 import type { BlockedTimelineEditIntent } from "../../player/components/timelineEditing";
 import { AudioMeterStrip } from "./AudioMeterStrip";
 import { useTimelineEditContext } from "../../contexts/TimelineEditContext";
-import { trackStudioExpandedClipEdit } from "../../telemetry/events";
 import { useNLEContext } from "./NLEContext";
-import type { TimelineMoveOperation } from "../../hooks/timelineMoveAdapter";
-
-type TimelineMoveEdit = {
-  element: TimelineElement;
-  updates: Pick<TimelineElement, "start" | "track">;
-};
-
-export function forwardRebasedTimelineMoveElements(
-  edits: TimelineMoveEdit[],
-  coalesceKey: string | undefined,
-  operation: TimelineMoveOperation | undefined,
-  onMoveElements: (
-    edits: TimelineMoveEdit[],
-    coalesceKey?: string,
-    operation?: TimelineMoveOperation,
-    coalesceMs?: number,
-  ) => Promise<void> | void,
-  coalesceMs?: number,
-) {
-  return onMoveElements(
-    edits.map(({ element, updates }) => {
-      const basis = element.expandedParentStart;
-      if (basis === undefined) return { element, updates };
-      return {
-        element: { ...element, id: element.domId ?? element.id, start: element.start - basis },
-        updates: { ...updates, start: Math.max(0, updates.start - basis) },
-      };
-    }),
-    coalesceKey,
-    operation,
-    coalesceMs,
-  );
-}
-
-type TimelineResizeChange = {
-  element: TimelineElement;
-  start: number;
-  duration: number;
-  playbackStart?: number;
-};
-
-export function forwardRebasedTimelineResizeElements(
-  changes: TimelineResizeChange[],
-  options: { coalesceKey?: string } | undefined,
-  onResizeElements: (
-    changes: TimelineResizeChange[],
-    options?: { coalesceKey?: string },
-  ) => Promise<void> | void,
-) {
-  return onResizeElements(
-    changes.map((change) => {
-      const basis = change.element.expandedParentStart;
-      if (basis === undefined) return change;
-      return {
-        ...change,
-        element: {
-          ...change.element,
-          id: change.element.domId ?? change.element.id,
-          start: change.element.start - basis,
-        },
-        start: Math.max(0, change.start - basis),
-      };
-    }),
-    options,
-  );
-}
 
 export interface TimelinePaneProps {
   /** Slot rendered above the timeline tracks (toolbar with split, delete, zoom) */
@@ -114,7 +47,6 @@ export interface TimelinePaneProps {
   canPasteClip?: () => boolean;
 }
 
-// fallow-ignore-next-line complexity
 export function TimelinePane({
   timelineToolbar,
   timelineFooter,
@@ -142,119 +74,10 @@ export function TimelinePane({
     timelineSessionEpoch,
   } = useNLEContext();
 
-  // Move/resize/split come from the timeline edit context, not props — the
-  // wrappers below intercept expanded clips and must call the *real* handlers.
-  // (Delete is a direct prop; it stays that way.)
+  // Move/resize/split come from the timeline edit context, not props.
   const { onMoveElement, onMoveElements, onResizeElement, onResizeElements, onSplitElement } =
     useTimelineEditContext();
 
-  // An expanded sub-comp child reaches the normal edit handlers in its own
-  // local coordinates: addressed by its real DOM id, with timeline time rebased
-  // onto the sub-comp it lives in. The handlers then save + reloadPreview exactly
-  // as they do for top-level clips — no separate live-DOM path.
-  const toLocalElement = useCallback(
-    (element: TimelineElement, basis: number): TimelineElement => ({
-      ...element,
-      id: element.domId ?? element.id,
-      start: element.start - basis,
-    }),
-    [],
-  );
-
-  const handleMoveElement = useCallback(
-    (element: TimelineElement, updates: Pick<TimelineElement, "start" | "track">) => {
-      const basis = element.expandedParentStart;
-      if (basis === undefined) return onMoveElement?.(element, updates);
-      trackStudioExpandedClipEdit({ action: "move" });
-      onMoveElement?.(toLocalElement(element, basis), {
-        ...updates,
-        start: Math.max(0, updates.start - basis),
-      });
-    },
-    [onMoveElement, toLocalElement],
-  );
-
-  // Batched move (ripple / insert): rebase each expanded sub-comp child to its
-  // local coords, exactly as handleMoveElement does for a single clip.
-  const handleMoveElements = useCallback(
-    (
-      edits: Array<{ element: TimelineElement; updates: Pick<TimelineElement, "start" | "track"> }>,
-      coalesceKey?: string,
-      operation?: TimelineMoveOperation,
-      coalesceMs?: number,
-    ) => {
-      // Match the sibling handlers: report the telemetry when the batch touches at
-      // least one expanded sub-comp child (the clips being rebased to local coords).
-      if (edits.some(({ element }) => element.expandedParentStart !== undefined)) {
-        trackStudioExpandedClipEdit({ action: "move" });
-      }
-      if (!onMoveElements) return;
-      return forwardRebasedTimelineMoveElements(
-        edits,
-        coalesceKey,
-        operation,
-        onMoveElements,
-        coalesceMs,
-      );
-    },
-    [onMoveElements],
-  );
-
-  const handleResizeElement = useCallback(
-    (
-      element: TimelineElement,
-      updates: Pick<TimelineElement, "start" | "duration" | "playbackStart">,
-    ) => {
-      const basis = element.expandedParentStart;
-      if (basis === undefined) return onResizeElement?.(element, updates);
-      trackStudioExpandedClipEdit({ action: "resize" });
-      onResizeElement?.(toLocalElement(element, basis), {
-        ...updates,
-        start: Math.max(0, updates.start - basis),
-      });
-    },
-    [onResizeElement, toLocalElement],
-  );
-
-  const handleResizeElements = useCallback(
-    (
-      changes: Array<{
-        element: TimelineElement;
-        start: number;
-        duration: number;
-        playbackStart?: number;
-      }>,
-      options?: { coalesceKey?: string },
-    ) => {
-      if (!onResizeElements) return;
-      if (changes.some(({ element }) => element.expandedParentStart !== undefined)) {
-        trackStudioExpandedClipEdit({ action: "resize" });
-      }
-      return forwardRebasedTimelineResizeElements(changes, options, onResizeElements);
-    },
-    [onResizeElements],
-  );
-
-  const handleDeleteElement = useCallback(
-    (element: TimelineElement) => {
-      const basis = element.expandedParentStart;
-      if (basis === undefined) return onDeleteElement?.(element);
-      trackStudioExpandedClipEdit({ action: "delete" });
-      return onDeleteElement?.(toLocalElement(element, basis));
-    },
-    [onDeleteElement, toLocalElement],
-  );
-
-  const handleSplitElement = useCallback(
-    (element: TimelineElement, splitTime: number) => {
-      const basis = element.expandedParentStart;
-      if (basis === undefined) return onSplitElement?.(element, splitTime);
-      trackStudioExpandedClipEdit({ action: "split" });
-      return onSplitElement?.(toLocalElement(element, basis), Math.max(0, splitTime - basis));
-    },
-    [onSplitElement, toLocalElement],
-  );
-
   return (
     <div
       className="relative flex h-full flex-col"
@@ -280,16 +103,16 @@ export function TimelinePane({
               onDrillDown={handleDrillDown}
               renderClipContent={renderClipContent}
               onFileDrop={onFileDrop}
-              onDeleteElement={handleDeleteElement}
+              onDeleteElement={onDeleteElement}
               onAssetDrop={onAssetDrop}
               onBlockDrop={onBlockDrop}
               onCompositionDrop={onCompositionDrop}
-              onMoveElement={handleMoveElement}
-              onMoveElements={handleMoveElements}
-              onResizeElement={handleResizeElement}
-              onResizeElements={handleResizeElements}
+              onMoveElement={onMoveElement}
+              onMoveElements={onMoveElements}
+              onResizeElement={onResizeElement}
+              onResizeElements={onResizeElements}
               onBlockedEditAttempt={onBlockedEditAttempt}
-              onSplitElement={handleSplitElement}
+              onSplitElement={onSplitElement}
               onSelectElement={onSelectTimelineElement}
               onRangeSelect={onRangeSelect}
               onCopyClip={onCopyClip}

packages/studio/src/components/nle/useCanvasZOrderTimelineMirror.test.tsx

@@ -321,55 +321,6 @@ describe("useCanvasZOrderTimelineMirror", () => {
     expect(history.moveCoalesceKeys).toEqual([]);
   });
 
-  it("maps the crossed neighbor to its timeline key and rebases expanded sub-comp children", async () => {
-    // t is an expanded sub-comp child (expandedParentStart 5, absolute start 5):
-    // the mirror must forward its persist in LOCAL time (start 0), the same
-    // rebase a timeline lane drag applies (forwardRebasedTimelineMoveElements).
-    setStoreElements([
-      {
-        ...storeEl("a", 0, 25, 5),
-        sourceFile: "sub.html",
-        key: "sub.html#a",
-        expandedParentStart: 5,
-      },
-      {
-        ...storeEl("b", 1, 5, 10),
-        sourceFile: "sub.html",
-        key: "sub.html#b",
-        expandedParentStart: 5,
-      },
-      {
-        ...storeEl("t", 2, 5, 10),
-        sourceFile: "sub.html",
-        key: "sub.html#t",
-        expandedParentStart: 5,
-      },
-    ]);
-    const edits: Array<{ element: TimelineElement; updates: { start: number; track: number } }> =
-      [];
-    const onMoveElements: TimelineEditCallbacks["onMoveElements"] = (batch) => {
-      edits.push(...batch);
-    };
-    const { mirror } = mountMirrorOnlyHarness(onMoveElements);
-
-    const mirrored = await act(async () =>
-      mirror({
-        selectionKey: "sub.html#t",
-        action: "bring-forward",
-        // The crossed sibling maps to sub.html#b via its DOM id + sourceFile —
-        // the same derivation reorder entries use (deriveTimelineStoreKey).
-        crossed: domTarget("b"),
-        sourceFile: "sub.html",
-        coalesceKey: "z-reorder:bring-forward:t",
-      }),
-    );
-    expect(mirrored).toBe(true);
-    expect(edits).toHaveLength(1);
-    // Rebased to sub-comp local coords: absolute 5 − parent start 5 = 0.
-    expect(edits[0].element.start).toBe(0);
-    expect(edits[0].updates).toMatchObject({ start: 0, track: 0 });
-  });
-
   it("maps a cross-file duplicate selector to the source-scoped crossed occurrence", async () => {
     setStoreElements([
       {

packages/studio/src/components/nle/useCanvasZOrderTimelineMirror.ts

@@ -13,7 +13,6 @@ import { commitZMirrorLaneMove } from "../../player/components/timelineClipDragC
 import { deriveTimelineStoreKey } from "../../player/lib/timelineElementHelpers";
 import { buildStableSelector, getSelectorIndex } from "../editor/domEditingDom";
 import { useStudioShellContextOptional } from "../../contexts/StudioContext";
-import { forwardRebasedTimelineMoveElements } from "./TimelinePane";
 
 export interface MirrorZOrderInput {
   /** Timeline store key of the element the menu acted on (entry.key), if any. */
@@ -44,10 +43,9 @@ export interface MirrorZOrderInput {
  * renders and the resolver expects. No alternate row expansion is built here.
  *
  * The mirror persists through the SAME machinery as a timeline lane drag
- * (commitZMirrorLaneMove → persistMoveEdits → onMoveElements, with expanded
- * children rebased to local coords via forwardRebasedTimelineMoveElements) —
- * optimistic store update + rollback included, so the timeline reflects the
- * lane change without a reload. The deps below deliberately OMIT
+ * (commitZMirrorLaneMove → persistMoveEdits → onMoveElements) — optimistic
+ * store update + rollback included, so the timeline reflects the lane change
+ * without a reload. The deps below deliberately OMIT
  * `readZIndex`/`onStackingPatches`: the lane→z stacking sync
  * (syncStackingForEdit) must not fire and recompute the z values the user just
  * set — commitZMirrorLaneMove never calls it, and without these deps it would
@@ -160,16 +158,7 @@ function useMirrorLaneMoveCommit(): (
           elements: els,
           trackOrder: displayTrackOrder(els),
           updateElement: (key, updates) => usePlayerStore.getState().updateElement(key, updates),
-          onMoveElements: onMoveElements
-            ? (edits, coalesceKey2, operation, coalesceMs) =>
-                forwardRebasedTimelineMoveElements(
-                  edits,
-                  coalesceKey2,
-                  operation,
-                  onMoveElements,
-                  coalesceMs,
-                )
-            : undefined,
+          onMoveElements,
           // NO readZIndex / onStackingPatches: see the hook doc — the lane→z
           // stacking sync must not re-trigger and fight the just-set z values.
         },