@hyperframes/studio 0.8.90 → 0.8.92

package/src/player/components/timelineCollision.test.ts

@@ -5,12 +5,10 @@ import {
   isInsertAllowedForZone,
   isLaneFree,
   resolveInsertRow,
-  resolveMainTrackDropStart,
-  resolvePlacement,
+  resolveNearestFreeStart,
   resolveZoneDropPlacement,
   timeRangesOverlap,
 } from "./timelineCollision";
-import { INSERT_BOUNDARY_BAND } from "./timelineLayout";
 
 function el(id: string, track: number, start: number, duration: number): TimelineElement {
   return { id, tag: "video", start, duration, track };
@@ -41,196 +39,84 @@ describe("isLaneFree", () => {
   });
 });
 
-describe("resolvePlacement", () => {
-  const trackOrder = [0, 1, 2, 3];
+describe("resolveNearestFreeStart", () => {
+  const row = [el("a", 0, 2, 3), el("b", 0, 8, 2)]; // busy [2,5) and [8,10)
 
-  it("keeps the desired lane when it is free", () => {
-    const els = [el("a", 2, 0, 4)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 1,
-        start: 0,
-        duration: 4,
-        trackOrder,
-        excludeKey: null,
-      }),
-    ).toEqual({
-      track: 1,
-      needsInsert: false,
-    });
+  it("keeps a start whose span is already free", () => {
+    expect(resolveNearestFreeStart(row, 0, 5, 3, null)).toBe(5);
+    expect(resolveNearestFreeStart(row, 1, 3, 4, null)).toBe(3); // another row
   });
 
-  it("pushes up to the nearest free lane above when the target is occupied", () => {
-    // desired = 2 occupied; 1 free above → land on 1
-    const els = [el("blocker", 2, 0, 4)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 2,
-        start: 1,
-        duration: 2,
-        trackOrder,
-        excludeKey: null,
-      }),
-    ).toEqual({ track: 1, needsInsert: false });
+  it("keeps the clip's own start between edges no centisecond start fits", () => {
+    const tight = [el("a", 0, 0, 3.333), el("b", 0, 6.666, 4)];
+    expect(resolveNearestFreeStart(tight, 0, 3.333, 3.333, null)).toBe(10.67);
+    expect(resolveNearestFreeStart(tight, 0, 3.333, 3.333, null, 0, 3.333)).toBe(3.333);
+    expect(resolveNearestFreeStart(tight, 0, 3.4, 3.333, null, 0, 3.333)).toBe(3.333);
   });
 
-  it("prefers up even when a lane below is also free", () => {
-    // desired 2 occupied; both 1 (up) and 3 (down) free → up wins
-    const els = [el("blocker", 2, 0, 5)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 2,
-        start: 0,
-        duration: 3,
-        trackOrder,
-        excludeKey: null,
-      }),
-    ).toEqual({ track: 1, needsInsert: false });
+  it("keeps the clip's own start when float sums land a hair past a neighbour's edge", () => {
+    const after = [el("a", 0, 0, 0.333), el("b", 0, 2.066, 1)]; // 0.333 + 1.733 = 2.0660000000000003
+    expect(resolveNearestFreeStart(after, 0, 0.333, 1.733, null, 0, 0.333)).toBe(0.333);
+    const before = [el("a", 0, 0.1, 0.2), el("b", 0, 1.3, 1)]; // a ends at 0.30000000000000004
+    expect(resolveNearestFreeStart(before, 0, 0.3, 1, null, 0, 0.3)).toBe(0.3);
   });
 
-  it("falls to a lane below when every lane above is occupied", () => {
-    // desired 1 occupied; 0 occupied above; 2 free below → land on 2
-    const els = [el("x", 0, 0, 5), el("y", 1, 0, 5)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 1,
-        start: 1,
-        duration: 2,
-        trackOrder,
-        excludeKey: null,
-      }),
-    ).toEqual({ track: 2, needsInsert: false });
+  it("takes the clip's own start only when it is free, not below minStart, and nearest", () => {
+    expect(resolveNearestFreeStart(row, 0, 4, 2, null, 0, 3.5)).toBe(5); // nearer, but its own spot overlaps a
+    expect(resolveNearestFreeStart(row, 0, 0, 1, null, 1, 0.5)).toBe(1); // below the floor
+    expect(resolveNearestFreeStart(row, 0, 6, 1, null, 0, 5.5)).toBe(6); // the release time is nearer
+    expect(resolveNearestFreeStart(row, 0, 6.5, 1, null, 0, 6)).toBe(6.5); // nearer again, not the origin
   });
 
-  it("signals needsInsert when no lane is free", () => {
-    const els = [el("a", 0, 0, 9), el("b", 1, 0, 9), el("c", 2, 0, 9), el("d", 3, 0, 9)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 2,
-        start: 1,
-        duration: 2,
-        trackOrder,
-        excludeKey: null,
-      }),
-    ).toEqual({ track: 2, needsInsert: true });
+  it("moves an overlapping span to the nearest time it fits", () => {
+    expect(resolveNearestFreeStart(row, 0, 4, 2, null)).toBe(5); // 1 s later beats 2 s earlier
+    expect(resolveNearestFreeStart(row, 0, 2.2, 1.5, null)).toBe(0.5); // 1.7 s earlier beats 2.8 s later
   });
 
-  it("signals needsInsert when the desired track is occupied but absent from the zone's lanes (#2195)", () => {
-    // desiredTrack 5 is occupied yet not in trackOrder (its kind-zone has no lane
-    // here). Landing on it would overlap, so the empty-zone branch must insert —
-    // not silently land on the occupied track (the placement hole).
-    const els = [el("blocker", 5, 0, 5)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 5,
-        start: 1,
-        duration: 2,
-        trackOrder: [],
-        excludeKey: null,
-      }),
-    ).toEqual({ track: 5, needsInsert: true });
+  it("sends a tie to the later time", () => {
+    expect(resolveNearestFreeStart([el("a", 0, 2, 2)], 0, 2, 2, null)).toBe(4); // 0 and 4 both 2 s away
   });
 
-  it("signals needsInsert when the desired track is FREE but absent from the zone's lanes (#2195 free-span hole)", () => {
-    // desiredTrack 5 is FREE (no overlap) yet not in trackOrder — its kind-zone has
-    // no lane here. The old code short-circuited on isLaneFree and landed on the
-    // foreign-zone lane; the zone check must win and signal an insert.
-    const els = [el("elsewhere", 9, 0, 5)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 5,
-        start: 1,
-        duration: 2,
-        trackOrder: [],
-        excludeKey: null,
-      }),
-    ).toEqual({ track: 5, needsInsert: true });
+  it("skips a gap too short for the clip and lands after the row's last clip", () => {
+    expect(resolveNearestFreeStart(row, 0, 5, 4, null)).toBe(10); // the [5,8) gap is 3 s
+    expect(resolveNearestFreeStart([el("a", 0, 0, 30)], 0, 12, 5, null)).toBe(30);
   });
 
-  it("placeholder-scenario excludes the dragged clip so it does not collide with itself", () => {
-    const els = [el("self", 1, 0, 5)];
-    expect(
-      resolvePlacement({
-        elements: els,
-        desiredTrack: 1,
-        start: 0,
-        duration: 5,
-        trackOrder,
-        excludeKey: "self",
-      }),
-    ).toEqual({ track: 1, needsInsert: false });
-  });
-});
-
-describe("resolveInsertRow", () => {
-  const n = 3; // three lanes: rows 0,1,2
-
-  it("targets the lane (null) when over its middle band", () => {
-    expect(resolveInsertRow(1.5, n, 0.22)).toBe(null); // dead center of lane 1
-  });
-
-  it("inserts at the top boundary of a lane when near its top edge", () => {
-    expect(resolveInsertRow(1.1, n, 0.22)).toBe(1); // just into lane 1 → boundary above it
-  });
-
-  it("inserts at the bottom boundary of a lane when near its bottom edge", () => {
-    expect(resolveInsertRow(1.9, n, 0.22)).toBe(2); // near bottom of lane 1 → boundary below
+  it("ignores the excluded (dragged) clip", () => {
+    expect(resolveNearestFreeStart(row, 0, 2, 3, "a")).toBe(2);
   });
 
-  it("inserts above the top lane when the pointer is above everything", () => {
-    expect(resolveInsertRow(-0.5, n, 0.22)).toBe(0);
+  it("never goes below the lowest allowed start", () => {
+    const blocked = [el("c", 0, 6.4, 3.6)]; // busy [6.4,10)
+    expect(resolveNearestFreeStart(blocked, 0, 6.5, 2, null)).toBe(4.4);
+    expect(resolveNearestFreeStart(blocked, 0, 6.5, 2, null, 6.5)).toBe(10);
+    expect(resolveNearestFreeStart([], 0, 6.667, 2, null, 6.667)).toBe(6.667); // not rounded up
   });
 
-  it("inserts below the bottom lane when the pointer is past the last lane", () => {
-    expect(resolveInsertRow(3.4, n, 0.22)).toBe(3);
+  it("keeps a gap-bound start on centiseconds so a written start cannot overlap", () => {
+    const start = resolveNearestFreeStart([el("a", 0, 7.1, 2)], 0, 3, 5.045333, null);
+    expect(start).toBe(2.05);
+    expect(start + 5.045333).toBeLessThanOrEqual(7.1);
   });
 });
 
-describe("resolveInsertRow — production band only arms in the inter-clip gutter (UX rule 1)", () => {
-  // The production band equals the clip inset (CLIP_Y / TRACK_H): a clip body fills
-  // [band, 1 − band] of its row, so an insert must ONLY arm in the thin gutter that
-  // straddles a boundary — never while the pointer is over a clip body. This is the
-  // regression for the plain-horizontal-drag misfire (the old 0.32 band armed an
-  // insert across ~64% of every row).
-  const n = 3;
-  const b = INSERT_BOUNDARY_BAND;
-
-  it("the band is the clip inset (3/48), not the old feel-tuned 0.32", () => {
-    expect(b).toBeCloseTo(3 / 48, 10);
-    expect(b).toBeLessThan(0.1);
-  });
-
-  it("returns null across the WHOLE clip body of every lane (no insert = move-to-lane)", () => {
-    // Sweep each lane's body [band+ε, 1−band−ε] in fine steps → always a move.
-    for (let lane = 0; lane < n; lane++) {
-      for (let frac = b + 0.01; frac <= 1 - b - 0.01 + 1e-9; frac += 0.02) {
-        expect(resolveInsertRow(lane + frac, n, b)).toBeNull();
-      }
+describe("resolveInsertRow (only empty space outside the rows opens a track)", () => {
+  const n = 3; // three rows: 0, 1, 2
+
+  it("stays on the row everywhere over it, edges included", () => {
+    for (let rowFloat = 0; rowFloat < n; rowFloat += 0.01) {
+      expect(resolveInsertRow(rowFloat, n)).toBeNull();
     }
   });
 
-  it("arms an insert in the gutter straddling every internal boundary (dead-zone-free)", () => {
-    // Just under a boundary → insert BELOW the upper lane; just over → ABOVE the
-    // lower lane. Both resolve to the same boundary row, so the gutter has no dead
-    // spot that neither moves nor inserts.
-    expect(resolveInsertRow(1 - b / 2, n, b)).toBe(1); // bottom gutter of lane 0
-    expect(resolveInsertRow(1 + b / 2, n, b)).toBe(1); // top gutter of lane 1
-    expect(resolveInsertRow(2 - b / 2, n, b)).toBe(2);
-    expect(resolveInsertRow(2 + b / 2, n, b)).toBe(2);
+  it("opens a track above the first row and below the last", () => {
+    expect(resolveInsertRow(-0.4, n)).toBe(0);
+    expect(resolveInsertRow(n, n)).toBe(n);
+    expect(resolveInsertRow(n + 0.4, n)).toBe(n);
   });
 
-  it("still arms a top / bottom insert above the first / below the last lane", () => {
-    expect(resolveInsertRow(b / 2, n, b)).toBe(0); // top gutter of lane 0 → insert above top
-    expect(resolveInsertRow(-0.4, n, b)).toBe(0); // in the top breathing pad
-    expect(resolveInsertRow(n - b / 2, n, b)).toBe(n); // bottom gutter of last lane
-    expect(resolveInsertRow(n + 0.4, n, b)).toBe(n); // in the bottom breathing pad
+  it("opens the first track on an empty timeline", () => {
+    expect(resolveInsertRow(0.5, 0)).toBe(0);
   });
 });
 
@@ -273,7 +159,7 @@ describe("isInsertAllowedForZone", () => {
   });
 });
 
-describe("resolveZoneDropPlacement (the whole drop decision, no same-track overlap)", () => {
+describe("resolveZoneDropPlacement (a drop on a row stays on that row, no overlap)", () => {
   // order [0,1,2] visual + [3] audio. audioRow = 3.
   const order = [0, 1, 2, 3];
   const audioTracks = new Set([3]);
@@ -286,90 +172,49 @@ describe("resolveZoneDropPlacement (the whole drop decision, no same-track overl
     dragKey: "x",
     isAudio: false,
   };
+  const allVisualOccupied = () => [el("a", 0, 0, 10), el("b", 1, 0, 10), el("c", 2, 0, 10)];
 
   it("lands on the aimed track when it is free at that time", () => {
     expect(
       resolveZoneDropPlacement({ ...base, elements: [el("a", 1, 10, 3)], desiredTrack: 1 }),
-    ).toEqual({ track: 1, insertRow: null });
+    ).toEqual({ track: 1, insertRow: null, start: 2 });
   });
 
-  it("relocates UP to the nearest free track when the aimed spot overlaps a clip", () => {
+  it("stays on the aimed row at its nearest free time when the aimed span is occupied", () => {
     expect(
       resolveZoneDropPlacement({ ...base, elements: [el("a", 1, 0, 5)], desiredTrack: 1 }),
-    ).toEqual({ track: 0, insertRow: null });
+    ).toEqual({ track: 1, insertRow: null, start: 5 });
   });
 
-  it("relocates DOWN when the tracks above are also occupied", () => {
+  it("never hops to another row or opens a track when every row is occupied", () => {
     expect(
-      resolveZoneDropPlacement({
-        ...base,
-        elements: [el("a", 0, 0, 5), el("b", 1, 0, 5)],
-        desiredTrack: 1,
-      }),
-    ).toEqual({ track: 2, insertRow: null });
+      resolveZoneDropPlacement({ ...base, elements: allVisualOccupied(), desiredTrack: 1 }),
+    ).toEqual({ track: 1, insertRow: null, start: 10 });
   });
 
-  it("crosses an occupied aim instead of snapping the dragged clip back to its origin", () => {
+  it("does not fall back to the dragged clip's origin row", () => {
     expect(
       resolveZoneDropPlacement({
         ...base,
         elements: [el("a", 0, 0, 5), el("b", 1, 0, 5), el("x", 2, 0, 5)],
         desiredTrack: 1,
       }),
-    ).toEqual({ track: 1, insertRow: 1 });
-
-    expect(
-      resolveZoneDropPlacement({
-        ...base,
-        elements: [el("x", 0, 0, 5), el("b", 1, 0, 5), el("a", 2, 0, 5)],
-        desiredTrack: 1,
-      }),
-    ).toEqual({ track: 1, insertRow: 2 });
-  });
-
-  it("auto-creates a new track when EVERY lane in the zone is occupied at that time", () => {
-    expect(
-      resolveZoneDropPlacement({
-        ...base,
-        elements: [el("a", 0, 0, 5), el("b", 1, 0, 5), el("c", 2, 0, 5)],
-        desiredTrack: 1,
-      }),
-    ).toEqual({ track: 1, insertRow: 2 });
+    ).toEqual({ track: 1, insertRow: null, start: 5 });
   });
 
-  // Every visual lane (0,1,2) occupied across the drop span → no free lane exists.
-  const allVisualOccupied = () => [el("a", 0, 0, 10), el("b", 1, 0, 10), el("c", 2, 0, 10)];
-
-  it("occupied aim with NO free lane creates an adjacent track — never snaps back (UX rule 3)", () => {
-    // The clip must NOT return to its origin; it gets a fresh track adjacent to the
-    // aim. Default bias = below the aimed row.
-    const result = resolveZoneDropPlacement({
-      ...base,
-      elements: allVisualOccupied(),
-      desiredTrack: 1,
+  it("Tag (2 s, 5 s long) onto the Subtitle row (0-6 s) lands at 6 s on that row", () => {
+    const elements = [el("title", 0, 0, 10), el("subtitle", 1, 0, 6), el("tag", 2, 2, 5)];
+    const drop = { ...base, elements, start: 2, duration: 5, dragKey: "tag" };
+    expect(resolveZoneDropPlacement({ ...drop, desiredTrack: 1 })).toEqual({
+      track: 1,
+      insertRow: null,
+      start: 6,
+    });
+    expect(resolveZoneDropPlacement({ ...drop, desiredTrack: 0 })).toEqual({
+      track: 0,
+      insertRow: null,
+      start: 10,
     });
-    expect(result.insertRow).not.toBeNull(); // a track is created, not an origin snap-back
-    expect(result).toEqual({ track: 1, insertRow: 2 }); // adjacent, below the aimed row
-  });
-
-  it("opens the new adjacent track ABOVE the aimed row when the pointer is in its upper half (UX rule 3)", () => {
-    expect(
-      resolveZoneDropPlacement({
-        ...base,
-        elements: allVisualOccupied(),
-        desiredTrack: 1,
-        preferInsertAbove: true,
-      }),
-    ).toEqual({ track: 1, insertRow: 1 }); // boundary ABOVE lane 1
-    // Same aim, pointer in the lower half → the track opens BELOW the aimed row.
-    expect(
-      resolveZoneDropPlacement({
-        ...base,
-        elements: allVisualOccupied(),
-        desiredTrack: 1,
-        preferInsertAbove: false,
-      }),
-    ).toEqual({ track: 1, insertRow: 2 });
   });
 
   it("shares a track for sequential (non-overlapping) clips", () => {
@@ -380,45 +225,37 @@ describe("resolveZoneDropPlacement (the whole drop decision, no same-track overl
         desiredTrack: 1,
         start: 2,
       }),
-    ).toEqual({ track: 1, insertRow: null });
+    ).toEqual({ track: 1, insertRow: null, start: 2 });
   });
 
   it("clamps a visual clip OUT of the audio zone before placing", () => {
     expect(resolveZoneDropPlacement({ ...base, elements: [], desiredTrack: 3 })).toEqual({
       track: 2,
       insertRow: null,
+      start: 2,
     });
   });
 
   it("clamps an audio clip INTO the audio zone before placing", () => {
     expect(
       resolveZoneDropPlacement({ ...base, elements: [], desiredTrack: 0, isAudio: true }),
-    ).toEqual({ track: 3, insertRow: null });
+    ).toEqual({ track: 3, insertRow: null, start: 2 });
   });
 
   it("upward create-drag off the top lane inserts at the TOP of the visual zone, never below audio (reviewer repro)", () => {
-    // 3-visual + 1-audio timeline. Dragging a top-lane visual clip up past the
-    // create threshold emits the sentinel desiredTrack = minTrack-1 = -1. The
-    // old hoist did order.indexOf(-1) = -1 and fell to below = order.length = 4,
-    // creating the new track BELOW the audio zone — repro {track:-1, insertRow:4}.
-    // It must now anchor to the top boundary of the visual zone.
+    // The sentinel desiredTrack = minTrack-1 = -1 must anchor to the visual zone's top boundary.
     expect(
       resolveZoneDropPlacement({ ...base, elements: allVisualOccupied(), desiredTrack: -1 }),
-    ).toEqual({ track: -1, insertRow: 0 });
+    ).toEqual({ track: -1, insertRow: 0, start: 2 });
   });
 
   it("downward create-drag off the bottom visual lane inserts at the audio boundary, never below it", () => {
-    // Sentinel desiredTrack = maxTrack+1 = 4 for a downward create-drag. A visual
-    // clip must land at the bottom of the visual zone (row 3 = just above audio),
-    // not past the audio lanes.
     expect(
       resolveZoneDropPlacement({ ...base, elements: allVisualOccupied(), desiredTrack: 4 }),
-    ).toEqual({ track: 4, insertRow: 3 });
+    ).toEqual({ track: 4, insertRow: 3, start: 2 });
   });
 
   it("audio create-drag with an out-of-range aim inserts inside the audio zone", () => {
-    // An audio clip aimed above its zone (sentinel below its own min lane) anchors
-    // to the audio zone's top boundary (row 3), not into the visual zone.
     expect(
       resolveZoneDropPlacement({
         ...base,
@@ -426,22 +263,22 @@ describe("resolveZoneDropPlacement (the whole drop decision, no same-track overl
         desiredTrack: -1,
         isAudio: true,
       }),
-    ).toEqual({ track: -1, insertRow: 3 });
+    ).toEqual({ track: -1, insertRow: 3, start: 2 });
   });
 
-  it("honors a deliberate boundary insert in the clip's own zone", () => {
+  it("honors an insert aimed at the space outside the rows in the clip's own zone", () => {
     expect(
-      resolveZoneDropPlacement({ ...base, elements: [], desiredTrack: 1, deliberateInsertRow: 1 }),
-    ).toEqual({ track: 1, insertRow: 1 });
+      resolveZoneDropPlacement({ ...base, elements: [], desiredTrack: 0, deliberateInsertRow: 0 }),
+    ).toEqual({ track: 0, insertRow: 0, start: 2 });
   });
 
-  it("ignores a deliberate insert that lands in the WRONG zone (visual into audio)", () => {
+  it("ignores an insert that lands in the WRONG zone (visual into audio)", () => {
     expect(
       resolveZoneDropPlacement({ ...base, elements: [], desiredTrack: 1, deliberateInsertRow: 4 }),
-    ).toEqual({ track: 1, insertRow: null });
+    ).toEqual({ track: 1, insertRow: null, start: 2 });
   });
 
-  it("lets an AUDIO clip create a new audio track via a boundary insert", () => {
+  it("lets an AUDIO clip open a new audio track below the last row", () => {
     expect(
       resolveZoneDropPlacement({
         ...base,
@@ -450,69 +287,30 @@ describe("resolveZoneDropPlacement (the whole drop decision, no same-track overl
         isAudio: true,
         deliberateInsertRow: 4,
       }),
-    ).toEqual({ track: 3, insertRow: 4 });
+    ).toEqual({ track: 3, insertRow: 4, start: 2 });
   });
 
-  it("Abhai repro: audio dropped on a visual-only timeline over an occupied span → insert, no overlap (#2195)", () => {
-    // No audio zone exists yet (audioTracks empty). The audio clip is aimed at the
-    // sole visual lane, which is occupied at the drop time. The zone-drop must
-    // create the audio zone's first lane (insertRow set) rather than stacking the
-    // audio clip onto the occupied visual track — the no-overlap invariant.
-    const result = resolveZoneDropPlacement({
+  it("audio dropped on a visual-only timeline opens its zone's first row, no overlap (#2195)", () => {
+    const drop = {
       order: [0],
       audioTracks: new Set<number>(),
       elements: [el("v", 0, 0, 5)],
       desiredTrack: 0,
       deliberateInsertRow: null,
-      start: 1,
       duration: 2,
       dragKey: "audio",
       isAudio: true,
+    };
+    // Occupied and free spans alike: the visual row is not a row an audio clip may land on.
+    expect(resolveZoneDropPlacement({ ...drop, start: 1 })).toEqual({
+      track: 0,
+      insertRow: 1,
+      start: 1,
     });
-    expect(result.insertRow).not.toBeNull();
-    expect(result).toEqual({ track: 0, insertRow: 1 });
-  });
-
-  it("free-span repro: audio dropped on a FREE stretch of a visual-only timeline → insert, not a visual lane (#2195)", () => {
-    // Same visual-only timeline, but the audio clip is aimed at a stretch the sole
-    // visual lane is FREE at. The zone check must still fire an insert (create the
-    // audio zone) rather than short-circuiting on isLaneFree and dropping the audio
-    // clip onto the visual lane — the kind-zone hole where the free-lane fast path
-    // beat the wrong-zone check.
-    const result = resolveZoneDropPlacement({
-      order: [0],
-      audioTracks: new Set<number>(),
-      elements: [el("v", 0, 0, 5)],
-      desiredTrack: 0,
-      deliberateInsertRow: null,
-      start: 10, // past the visual clip's end → the visual lane is FREE here
-      duration: 2,
-      dragKey: "audio",
-      isAudio: true,
+    expect(resolveZoneDropPlacement({ ...drop, start: 10 })).toEqual({
+      track: 0,
+      insertRow: 1,
+      start: 10,
     });
-    expect(result.insertRow).not.toBeNull();
-    expect(result).toEqual({ track: 0, insertRow: 1 });
-  });
-});
-
-describe("resolveMainTrackDropStart (magnetic first clip on an empty main track)", () => {
-  it("snaps to 0 when landing on an empty main track", () => {
-    expect(resolveMainTrackDropStart([], 1, 0, false, 7)).toBe(0);
-  });
-
-  it("leaves the drop start alone once the main track already holds another clip", () => {
-    expect(resolveMainTrackDropStart([el("other", 0, 0, 3)], 1, 0, false, 7)).toBe(7);
-  });
-
-  it("leaves the drop start alone when landing off the main track", () => {
-    expect(resolveMainTrackDropStart([], 1, 2, false, 7)).toBe(7);
-  });
-
-  it("a clip already resident on the main track doing a horizontal move is a no-op", () => {
-    expect(resolveMainTrackDropStart([], 0, 0, false, 7)).toBe(7);
-  });
-
-  it("an audio clip landing on track 0 is not the main track (visual zone only)", () => {
-    expect(resolveMainTrackDropStart([], 1, 0, true, 7)).toBe(7);
   });
 });