@bycrux/editor 1.0.1 → 1.1.0

package/src/video/timeline/__tests__/timeline-model.test.ts

@@ -6,11 +6,14 @@ import {
   resolveAudioWindow,
   computeAutoCrossfade,
   computeDerivedTiming,
+  computeVisualCrossfade,
   groupAudioLanes,
   mapTrackItems,
+  normalizeAudioTracks,
   normalizeTrackOrder,
   normalizeTracks,
   trackItems,
+  updateAudioTrack,
 } from '../timeline-model'
 
 function track(overrides: Partial<AudioTrack> = {}): AudioTrack {
@@ -165,6 +168,36 @@ describe('computeAutoCrossfade', () => {
     expect(next!.audio!.tracks.map(t => t.id)).toEqual(['solo', 'a', 'b'])
     expect(next!.audio!.tracks.find(t => t.id === 'solo')!.fadeOut).toBeUndefined()
   })
+
+  // Regression test for the sharpest edge of the id-less-audio-track defect.
+  // `trackMap = new Map(updated.map(t => [t.id, t]))` keys on `t.id`; with two
+  // id-less tracks, both keys are the same `undefined`, so the map collapses
+  // to ONE entry (the last one processed) and `audioTracks.map(t =>
+  // trackMap.get(t.id) ?? t)` hands that SAME entry back for every original
+  // track — every track in the project becomes a byte-identical copy of it,
+  // `src` included. This runs unconditionally on any project with two
+  // overlapping audio tracks, no user edit required, which is why it's the
+  // sharpest edge: it doesn't wait for a gesture like `updateAudioTrack` does.
+  it('does not collapse two overlapping id-less audio tracks into copies of each other', () => {
+    const p = project({
+      audio: {
+        tracks: [
+          { src: 'music-a.mp3', start: 0, end: 3 } as AudioTrack,
+          { src: 'music-b.mp3', start: 2, end: 5 } as AudioTrack,
+        ],
+      },
+    })
+    const next = computeAutoCrossfade(p)
+    expect(next).not.toBeNull()
+    const tracks = next!.audio!.tracks
+    expect(tracks).toHaveLength(2)
+    expect(new Set(tracks.map(t => t.id)).size).toBe(2)
+    // Each track keeps its OWN src — neither becomes a copy of the other.
+    expect(tracks.find(t => t.start === 0)!.src).toBe('music-a.mp3')
+    expect(tracks.find(t => t.start === 2)!.src).toBe('music-b.mp3')
+    expect(tracks.find(t => t.start === 0)!.fadeOut).toBe(1)
+    expect(tracks.find(t => t.start === 2)!.fadeIn).toBe(1)
+  })
 })
 
 describe('groupAudioLanes', () => {
@@ -574,3 +607,277 @@ describe('mapTrackItems', () => {
     expect(mapTrackItems({ id: 'p1', tracks: 'nope' } as Proj, items => items)).toEqual([])
   })
 })
+
+// ── Audio track id policy ────────────────────────────────────────────────
+//
+// Same load-bearing properties as `normalizeTracks` above: normalization
+// never mutates its input, is idempotent, and returns the SAME OBJECT when
+// every audio track already has a usable id (the lazy on-open migration
+// reads that identity as "no write needed").
+
+describe('normalizeAudioTracks', () => {
+  /** Deliberately loose, like the function itself. */
+  type Proj = { id: string; audio?: unknown }
+  interface NormTrack { id: string; src: string; [k: string]: unknown }
+
+  const raw = (id: unknown, src: string, extra: Record<string, unknown> = {}) =>
+    (id === undefined ? { src, ...extra } : { id, src, ...extra })
+
+  /** The normalized audio tracks, typed. */
+  const tracksOf = (p: Proj): NormTrack[] => (normalizeAudioTracks(p).audio as { tracks: NormTrack[] }).tracks
+
+  it('fills in distinct ids for tracks with no id at all', () => {
+    const out = tracksOf({ id: 'p1', audio: { tracks: [raw(undefined, 'a.mp3'), raw(undefined, 'b.mp3')] } })
+    expect(out.map(t => t.id)).toEqual(['aud-0', 'aud-1'])
+    expect(new Set(out.map(t => t.id)).size).toBe(2)
+  })
+
+  it('fills in a missing, empty, or non-string id', () => {
+    const out = tracksOf({
+      id: 'p1',
+      audio: { tracks: [raw(undefined, 'a.mp3'), raw('', 'b.mp3'), raw(7, 'c.mp3')] },
+    })
+    expect(out.map(t => t.id)).toEqual(['aud-0', 'aud-1', 'aud-2'])
+  })
+
+  it('lets the first holder of a duplicate id keep it', () => {
+    const out = tracksOf({
+      id: 'p1',
+      audio: { tracks: [raw('dup', 'a.mp3'), raw('dup', 'b.mp3')] },
+    })
+    expect(out.map(t => t.id)).toEqual(['dup', 'aud-1'])
+    // The first holder keeps ITS OWN src, not the second track's.
+    expect(out[0].src).toBe('a.mp3')
+    expect(out[1].src).toBe('b.mp3')
+  })
+
+  it('steps a generated id aside when an explicit id already claims the name', () => {
+    const out = tracksOf({
+      id: 'p1',
+      audio: { tracks: [raw(undefined, 'a.mp3'), raw('aud-0', 'b.mp3')] },
+    })
+    expect(out.map(t => t.id)).toEqual(['aud-0-2', 'aud-0'])
+  })
+
+  it('keeps generated ids unique under repeated collision', () => {
+    const out = tracksOf({
+      id: 'p1',
+      audio: { tracks: [raw(undefined, 'a.mp3'), raw('aud-0', 'b.mp3'), raw('aud-0-2', 'c.mp3')] },
+    })
+    expect(out.map(t => t.id)).toEqual(['aud-0-3', 'aud-0', 'aud-0-2'])
+    expect(new Set(out.map(t => t.id)).size).toBe(3)
+  })
+
+  it('preserves existing valid ids (e.g. init.py-style `vo-01`) untouched', () => {
+    const p: Proj = { id: 'p1', audio: { tracks: [raw('vo-01', 'voice.wav'), raw('music-bed', 'bed.mp3')] } }
+    expect(normalizeAudioTracks(p)).toBe(p)
+  })
+
+  it('returns the SAME OBJECT when every track already has a usable id', () => {
+    const p: Proj = { id: 'p1', audio: { tracks: [raw('aud-0', 'a.mp3'), raw('aud-1', 'b.mp3')] } }
+    expect(normalizeAudioTracks(p)).toBe(p)
+  })
+
+  it('is idempotent and converges, so a second pass needs no write', () => {
+    const once = normalizeAudioTracks({ id: 'p1', audio: { tracks: [raw(undefined, 'a.mp3'), raw(undefined, 'b.mp3')] } })
+    const twice = normalizeAudioTracks(once)
+    expect(twice).toBe(once)
+  })
+
+  it('carries volume / muted / fadeIn / ducking and unknown keys through untouched', () => {
+    const out = tracksOf({
+      id: 'p1',
+      audio: {
+        tracks: [raw(undefined, 'a.mp3', {
+          volume: 0.15, muted: true, fadeIn: 1.5, ducking: { enabled: true, depth: -12 }, somethingNew: { a: 1 },
+        })],
+      },
+    })
+    expect(out[0]).toEqual({
+      id: 'aud-0', src: 'a.mp3', volume: 0.15, muted: true, fadeIn: 1.5,
+      ducking: { enabled: true, depth: -12 }, somethingNew: { a: 1 },
+    })
+  })
+
+  it('does not mutate its input', () => {
+    const p: Proj = { id: 'p1', audio: { tracks: [raw(undefined, 'a.mp3')] } }
+    const before = structuredClone(p)
+    tracksOf(p)
+    expect(p).toEqual(before)
+  })
+
+  it('is tolerant of a project with no audio, or a malformed audio/tracks, and never throws', () => {
+    const missing: Proj = { id: 'p1' }
+    expect(normalizeAudioTracks(missing)).toBe(missing)
+    expect('audio' in normalizeAudioTracks(missing)).toBe(false)
+
+    for (const audio of [null, 'nope', 7, []]) {
+      const p: Proj = { id: 'p1', audio }
+      expect(() => normalizeAudioTracks(p)).not.toThrow()
+      expect(normalizeAudioTracks(p)).toBe(p)
+    }
+
+    for (const tracks of [undefined, null, 'nope', {}]) {
+      const p: Proj = { id: 'p1', audio: { tracks } }
+      expect(() => normalizeAudioTracks(p)).not.toThrow()
+      expect(normalizeAudioTracks(p)).toBe(p)
+    }
+
+    const empty: Proj = { id: 'p1', audio: { tracks: [] } }
+    expect(normalizeAudioTracks(empty)).toBe(empty)
+  })
+})
+
+describe('updateAudioTrack', () => {
+  it('patches only the matching track when ids are already real', () => {
+    const p = project({
+      audio: { tracks: [track({ id: 'a', src: 'a.mp3', volume: 1 }), track({ id: 'b', src: 'b.mp3', volume: 1 })] },
+    })
+    const out = updateAudioTrack(p, 'a', { volume: 0.4 })
+    expect(out.audio?.tracks.find(t => t.id === 'a')?.volume).toBe(0.4)
+    expect(out.audio?.tracks.find(t => t.id === 'b')).toEqual(track({ id: 'b', src: 'b.mp3', volume: 1 }))
+  })
+
+  // Regression test for the actual defect: `docs/schemas/project.md` never
+  // required `id` on an audio track, but every editor mutation (this
+  // function included) used to key a track by `id` with `===`. Two id-less
+  // tracks both read `id` as the same `undefined`, so `t.id === trackId`
+  // matched BOTH of them at once — dragging one fade handle on a 2-track
+  // music bed fanned the edit out and clobbered the sibling. Reproduced here
+  // exactly as the live app hits it: the ids passed in are the ones
+  // `normalizeAudioTracks` (VideoEditor's on-open backfill) would hand out —
+  // `aud-0`/`aud-1` — but `updateAudioTrack` itself is called with the
+  // ORIGINAL, still id-less project, proving it is safe even when a caller
+  // hasn't normalized first.
+  it('edits exactly one id-less audio track, leaving its sibling byte-for-byte untouched', () => {
+    const original: Project = project({
+      audio: {
+        tracks: [
+          { src: 'music-a.mp3', start: 0, end: 10, volume: 1 } as AudioTrack,
+          { src: 'music-b.mp3', start: 10, end: 20, volume: 1 } as AudioTrack,
+        ],
+      },
+    })
+    const untouchedSibling = original.audio!.tracks[1]
+    const targetId = normalizeAudioTracks(original).audio!.tracks[0].id
+
+    const out = updateAudioTrack(original, targetId, { volume: 0.4 })
+
+    expect(out.audio?.tracks).toHaveLength(2)
+    expect(out.audio?.tracks[0].volume).toBe(0.4)
+    expect(out.audio?.tracks[0].src).toBe('music-a.mp3')
+    // The defect this guards against: the sibling's `src` (and every other
+    // field) must be exactly what it started as — not silently fanned into
+    // the edited track's values.
+    expect(out.audio?.tracks[1]).toEqual({ ...untouchedSibling, id: out.audio?.tracks[1].id })
+    expect(out.audio?.tracks[1].src).toBe('music-b.mp3')
+    expect(out.audio?.tracks[1].volume).toBe(1)
+  })
+})
+
+// ── Visual crossfade (overlays) ──────────────────────────────────────────
+
+/** An overlay item. `extra` carries whatever the case under test needs —
+ *  `opaque`, a hand-authored `keyframes` array — without a helper per shape. */
+const ov = (id: string, start: number, end: number, extra: Record<string, unknown> = {}) =>
+  ({ id, type: 'overlay' as const, src: 'Card.jsx', start, end, ...extra })
+
+/** Two-track project in the OBJECT form: `tracks[0]` is the (empty) primary
+ *  footage row `computeVisualCrossfade` skips wholesale, `tracks[1]` is the
+ *  overlay row under test. */
+const proj = (items: unknown[]) => ({
+  version: '0.2',
+  tracks: [{ id: 'trk-0', items: [] }, { id: 'trk-1', items }],
+}) as never
+
+const opacityTrack = (p: Project, trackIdx: number, itemIdx: number) =>
+  (p as unknown as { tracks: { items: { keyframes?: { prop: string; points: unknown[] }[] }[] }[] })
+    .tracks[trackIdx].items[itemIdx].keyframes?.find(k => k.prop === 'opacity')
+
+describe('computeVisualCrossfade', () => {
+  it('writes complementary opacity curves onto a transparent overlapping pair', () => {
+    const out = computeVisualCrossfade(proj([ov('a', 0, 4), ov('b', 3, 8)]))!
+    expect(out).not.toBeNull()
+    // 'a' fades 1 -> 0 over its LAST second (item-relative t = 3 .. 4)
+    expect(opacityTrack(out, 1, 0)!.points).toEqual([
+      { t: 3, value: 1 }, { t: 4, value: 0 },
+    ])
+    // 'b' fades 0 -> 1 over its FIRST second (item-relative t = 0 .. 1)
+    expect(opacityTrack(out, 1, 1)!.points).toEqual([
+      { t: 0, value: 0 }, { t: 1, value: 1 },
+    ])
+  })
+
+  it('holds the outgoing side when it is opaque', () => {
+    const out = computeVisualCrossfade(
+      proj([ov('a', 0, 4, { opaque: true }), ov('b', 3, 8, { opaque: true })]),
+    )!
+    expect(opacityTrack(out, 1, 0)).toBeUndefined()          // 'a' holds — no track written
+    expect(opacityTrack(out, 1, 1)!.points).toEqual([
+      { t: 0, value: 0 }, { t: 1, value: 1 },
+    ])
+  })
+
+  it('is idempotent — a converged project reports no change', () => {
+    const once = computeVisualCrossfade(proj([ov('a', 0, 4), ov('b', 3, 8)]))!
+    expect(computeVisualCrossfade(once as never)).toBeNull()
+  })
+
+  it('returns null when nothing overlaps', () => {
+    expect(computeVisualCrossfade(proj([ov('a', 0, 4), ov('b', 4, 8)]))).toBeNull()
+  })
+
+  it('never touches an item whose opacity was keyframed by hand', () => {
+    const authored = ov('b', 3, 8, {
+      keyframes: [{ prop: 'opacity', points: [{ t: 0, value: 0.5 }] }],
+    })
+    expect(computeVisualCrossfade(proj([ov('a', 0, 4), authored]))).toBeNull()
+  })
+
+  it('leaves clips alone — a video pair gets no keyframes', () => {
+    const clip = (id: string, s: number, e: number) =>
+      ({ id, type: 'video' as const, src: 'a.mov', start: s, end: e, inPoint: 0, outPoint: e - s })
+    expect(computeVisualCrossfade(proj([clip('a', 0, 4), clip('b', 3, 8)]))).toBeNull()
+  })
+
+  it('preserves a non-opacity keyframe track already on the item', () => {
+    const moving = ov('b', 3, 8, {
+      keyframes: [{ prop: 'offsetX', points: [{ t: 0, value: -20 }, { t: 1, value: 0 }] }],
+    })
+    const out = computeVisualCrossfade(proj([ov('a', 0, 4), moving]))!
+    const kf = (out as unknown as { tracks: { items: { keyframes: { prop: string }[] }[] }[] })
+      .tracks[1].items[1].keyframes
+    expect(kf.map(k => k.prop).sort()).toEqual(['offsetX', 'opacity'])
+  })
+
+  it('scales the derived curve by each side\'s own base opacity', () => {
+    // Both sides authored at 0.5 opacity (not via a keyframe track — that
+    // would be "hand-authored" and skip derivation entirely per the test
+    // above). The derived fade must ride on top of that base level, not
+    // silently replace it with a full 1<->0 fade for the pair's whole
+    // pre/post-overlap life.
+    const out = computeVisualCrossfade(
+      proj([ov('a', 0, 4, { opacity: 0.5 }), ov('b', 3, 8, { opacity: 0.5 })]),
+    )!
+    expect(out).not.toBeNull()
+    // 'a' fades 0.5 -> 0 over its LAST second
+    expect(opacityTrack(out, 1, 0)!.points).toEqual([
+      { t: 3, value: 0.5 }, { t: 4, value: 0 },
+    ])
+    // 'b' fades 0 -> 0.5 over its FIRST second
+    expect(opacityTrack(out, 1, 1)!.points).toEqual([
+      { t: 0, value: 0 }, { t: 1, value: 0.5 },
+    ])
+  })
+
+  it('removes a derived curve when the overlap is removed', () => {
+    const faded = computeVisualCrossfade(proj([ov('a', 0, 4), ov('b', 3, 8)]))!
+    const pulled = structuredClone(faded) as unknown as
+      { tracks: { items: { start: number; end: number }[] }[] }
+    pulled.tracks[1].items[1].start = 4
+    const out = computeVisualCrossfade(pulled as never)!
+    expect(out).not.toBeNull()
+    expect(opacityTrack(out, 1, 0)).toBeUndefined()
+    expect(opacityTrack(out, 1, 1)).toBeUndefined()
+  })
+})

package/src/video/timeline/canvas/__tests__/pointer-machine.test.ts

@@ -245,6 +245,14 @@ const BASE_Y = rowMidY(0)      // track 0, the tall base row
 const OVERLAY_Y = rowMidY(1)   // track 1, stacked above it
 const LANE_Y = Math.round(LAYOUT.lanes[0].y + LAYOUT.lanes[0].height / 2)
 
+/** `rowMidY`'s twin for a one-off project whose layout isn't the shared
+ *  `LAYOUT` above — the overlay-trim containment tests below each build
+ *  their own small fixture. */
+function rowMidYFor(ctx: PointerContext, trackIdx: number): number {
+  const row = ctx.layout.rows.find(r => r.trackIdx === trackIdx)!
+  return Math.round(row.y + row.height / 2)
+}
+
 const C0_BODY = { x: 250, y: BASE_Y }
 const C0_OUT_EDGE = { x: 495, y: BASE_Y }
 const C1_BODY = { x: 750, y: BASE_Y }
@@ -940,6 +948,114 @@ describe('edge trim — ripple mode', () => {
   })
 })
 
+// Two butt-joined overlays on trk-1: a 0s–4s, b 4s–8s. trk-0 carries one
+// plain video clip spanning both, just so the fixture is a valid project —
+// no test below touches it.
+function overlapProject(): Project {
+  return {
+    id: 'p',
+    tracks: [
+      { id: 'trk-0', items: [{ id: 'c0', type: 'video', src: 'a.mp4', start: 0, end: 8, inPoint: 0, outPoint: 8, sourceDuration: 20 }] },
+      {
+        id: 'trk-1',
+        items: [
+          { id: 'a', type: 'overlay', start: 0, end: 4 },
+          { id: 'b', type: 'overlay', start: 4, end: 8 },
+        ],
+      },
+    ],
+  } as unknown as Project
+}
+
+describe('edge trim on an overlay track — bounded overlap (transitions)', () => {
+  it("trimming an overlay's right edge past its neighbour's start creates an overlap", () => {
+    const ctx = makeContext({ project: overlapProject() })
+    const row1Y = rowMidYFor(ctx, 1)
+    const d = new Driver(ctx)
+    // a's out edge sits at t=4 (x=400); offset 5px toward `a` so the hit
+    // resolves to ITS edge rather than b's in edge at the same x — the same
+    // disambiguation `C0_OUT_EDGE`/`C1_IN_EDGE` use above.
+    d.down(395, row1Y)
+    // +1s worth of pixels (100px/s): the edge lands at t=5, one second into b.
+    const next = lastProjectChange(d.move(495, row1Y))
+    expect(visual(next, 'a')).toMatchObject({ start: 0, end: 5 })
+    expect(visual(next, 'b')).toMatchObject({ start: 4, end: 8 })
+  })
+
+  it('trimming still refuses to swallow the neighbour entirely', () => {
+    const ctx = makeContext({ project: overlapProject() })
+    const row1Y = rowMidYFor(ctx, 1)
+    const d = new Driver(ctx)
+    d.down(395, row1Y)
+    // +5s worth of pixels would land a's edge at t=9, past b's own end (8) —
+    // full containment, which is not a transition.
+    const next = lastProjectChange(d.move(895, row1Y))
+    expect(visual(next, 'a').end).toBeLessThan(visual(next, 'b').end)
+    expect(visual(next, 'b')).toMatchObject({ start: 4, end: 8 })
+  })
+
+  it('stops short of a three-way overlap when the next neighbour already overlaps ITS next', () => {
+    // a 0-4, b 4-8, c 7-10: b and c already overlap at [7, 8) before this
+    // drag even starts. The single-neighbour clamp (against b.end alone)
+    // would let a's edge travel anywhere up to b.end (8), including into
+    // b∩c — landing a, b, and c all live at the same instant, a shape the
+    // editor would accept but `validate_project` rejects.
+    const threeWayProject: Project = {
+      id: 'p',
+      tracks: [
+        { id: 'trk-0', items: [{ id: 'c0', type: 'video', src: 'a.mp4', start: 0, end: 10, inPoint: 0, outPoint: 10, sourceDuration: 20 }] },
+        {
+          id: 'trk-1',
+          items: [
+            { id: 'a', type: 'overlay', start: 0, end: 4 },
+            { id: 'b', type: 'overlay', start: 4, end: 8 },
+            { id: 'c', type: 'overlay', start: 7, end: 10 },
+          ],
+        },
+      ],
+    } as unknown as Project
+    const ctx = makeContext({ project: threeWayProject })
+    const row1Y = rowMidYFor(ctx, 1)
+    const d = new Driver(ctx)
+    // a's out edge sits at t=4 (x=400); offset 5px toward `a` for the same
+    // disambiguation the tests above use.
+    d.down(395, row1Y)
+    // +4s worth of pixels targets a's edge at t=8 — inside b (4-8) and past
+    // c's start (7). The new guard must clamp short of c.start, not just
+    // short of b.end.
+    const next = lastProjectChange(d.move(795, row1Y))
+    expect(visual(next, 'a').end).toBeLessThan(7)
+    expect(visual(next, 'a').end).toBeGreaterThan(6.9)
+    expect(visual(next, 'b')).toMatchObject({ start: 4, end: 8 })
+    expect(visual(next, 'c')).toMatchObject({ start: 7, end: 10 })
+  })
+
+  it("still stops a tracks[0] trim at nothing — overlap there was never checked", () => {
+    // Same shape, but the pair sits on tracks[0] instead: no containment
+    // guard applies there (see the comment in `applyTrim`), so the edge
+    // travels exactly as far as the drag and the magnet/floor logic alone
+    // would already take it — this only guards against the new clamp
+    // accidentally leaking onto trackIdx 0.
+    const project: Project = {
+      id: 'p',
+      tracks: [{
+        id: 'trk-0',
+        items: [
+          { id: 'a', type: 'video', src: 'a.mp4', start: 0, end: 4, inPoint: 0, outPoint: 4, sourceDuration: 20 },
+          { id: 'b', type: 'video', src: 'b.mp4', start: 4, end: 8, inPoint: 0, outPoint: 4, sourceDuration: 20 },
+        ],
+      }],
+    } as unknown as Project
+    const ctx = makeContext({ project })
+    const row0Y = rowMidYFor(ctx, 0)
+    const d = new Driver(ctx)
+    d.down(395, row0Y)
+    const next = lastProjectChange(d.move(895, row0Y))
+    expect(visual(next, 'a').end).toBeCloseTo(9)
+    expect(visual(next, 'b')).toMatchObject({ start: 4, end: 8 })
+  })
+})
+
 // ── Alt / Cmd trim ops ───────────────────────────────────────────────────
 
 describe('Alt + edge-drag — roll', () => {

package/src/video/timeline/canvas/pointer-machine.ts

@@ -637,6 +637,23 @@ function adjacentOnTrack(project: Project, item: VisualItem): { prev?: VisualIte
   }
 }
 
+/** `adjacentOnTrack`'s twin for trim's containment guard — the nearest item
+ *  in either direction on `item`'s own track, WHETHER OR NOT it touches.
+ *  Roll needs a shared boundary to move (that's what it's rolling); a trim's
+ *  containment guard needs the nearest neighbour regardless, because the
+ *  overlap it is bounding is exactly the case where the two are no longer
+ *  touching. */
+function neighboursOnTrack(project: Project, item: VisualItem): { prev?: VisualItem; next?: VisualItem } {
+  const track = trackItems(project).find(t => t.some(other => other.id === item.id))
+  if (!track) return {}
+  const sorted = [...track].sort((a, b) => a.start - b.start)
+  const pos = sorted.findIndex(other => other.id === item.id)
+  return {
+    prev: pos > 0 ? sorted[pos - 1] : undefined,
+    next: pos >= 0 && pos < sorted.length - 1 ? sorted[pos + 1] : undefined,
+  }
+}
+
 /** Where a guide line goes, and how hard the magnet holding it pulls. */
 export interface SnapGuide {
   time: number
@@ -854,7 +871,48 @@ function applyTrim(ctx: PointerContext, press: Press, point: Point, snap: SnapSt
     itemSnapPoints(ctx, press, [fixedEdge, ...originGuard(escaped, [initTime])]),
     ctx.viewport, snap, ctx.snapConfig,
   )
-  const resized = computeResizedItem(item as Draggable, edge, snapped.time)
+
+  // Overlay tracks (anything but tracks[0]) may trim an edge PAST a
+  // neighbour's near boundary — see transitions.js's header: a partial
+  // overlap is a transition, containment is not — but not far enough to
+  // contain the neighbour outright, which `engine/validate.py` rejects.
+  // tracks[0] gets none of this: its own overlap is never checked at all
+  // (primary clips render in `itsoffset` order), so its trim stays exactly
+  // as it was — bounded only by `computeResizedItem`'s own floor below.
+  // Clamped on the TARGET time, before `computeResizedItem` runs, so a
+  // clamp that lands short of the drag still produces a consistent
+  // inPoint/outPoint for video items via `resizeWindowedItem`, rather than
+  // trimming the span after the fact and leaving the source window stale.
+  let targetTime = snapped.time
+  if ((press.hit.trackIdx ?? 0) !== 0) {
+    const { prev, next } = neighboursOnTrack(press.baseProject, item)
+    if (edge === 'end' && next) {
+      targetTime = Math.min(targetTime, next.end - EPSILON)
+      // `next` may ALREADY overlap its own next neighbour (a transition that
+      // predates this drag). The clamp above only keeps this item from
+      // containing `next` outright — it says nothing about that second
+      // overlap, so extending into `next` can still land inside next∩afterNext
+      // and put three items live at the same instant, a shape the two-item
+      // containment guard allows but `engine/validate.py` rejects. Clamp
+      // short of that second neighbour's start whenever the overlap exists.
+      const { next: afterNext } = neighboursOnTrack(press.baseProject, next)
+      if (afterNext && afterNext.start < next.end) {
+        targetTime = Math.min(targetTime, afterNext.start - EPSILON)
+      }
+    }
+    if (edge === 'start' && prev) {
+      targetTime = Math.max(targetTime, prev.start + EPSILON)
+      // Mirror of the `end`-edge guard above: `prev` may already overlap ITS
+      // own previous neighbour, and shrinking this item's start into `prev`
+      // can land inside beforePrev∩prev, making three items live at once.
+      const { prev: beforePrev } = neighboursOnTrack(press.baseProject, prev)
+      if (beforePrev && beforePrev.end > prev.start) {
+        targetTime = Math.max(targetTime, beforePrev.end + EPSILON)
+      }
+    }
+  }
+
+  const resized = computeResizedItem(item as Draggable, edge, targetTime)
 
   // Trims always rebuild from the pressed-at project, never from the running
   // preview — otherwise ripple's gap collapse would compound move by move.