@bycrux/editor 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bycrux/editor",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "lint": "eslint src"
   },
   "dependencies": {
-    "@bycrux/timeline-core": "^0.2.0",
+    "@bycrux/timeline-core": "^0.2.1",
     "class-variance-authority": "^0.7",
     "clsx": "^2",
     "lucide-react": "^0.400",

package/src/ControlsInfoModal.tsx

@@ -309,6 +309,7 @@ export const VIDEO_CONTROLS: ControlSection[] = [
     heading: 'Keyboard',
     entries: [
       { keys: ['S'], label: 'Split at the playhead' },
+      { keys: ['M'], label: 'Drop a marker at the playhead (or the preview axis)' },
       { keys: ['⌘/Ctrl', 'A'], label: 'Toggle the preview axis' },
       { keys: ['⇧', 'Delete'], label: 'Ripple-delete the selection' },
       { keys: ['⌘/Ctrl', 'Z'], label: 'Undo' },

package/src/engine/__tests__/scheduler.test.ts

@@ -483,7 +483,27 @@ describe('transportEndFor', () => {
     expect(transportEndFor(p)).toBe(8)
   })
 
-  it('uses max(overlayEnd, captionEnd) for a canvas project — audio EXCLUDED', () => {
+  it('counts track 0 in a canvas project — an overlay-only single track is not a zero-length transport', () => {
+    // The shape an animations-workflow project actually has: ONE track, holding
+    // nothing but overlays, and no captions. Reading the ceiling off
+    // `tracks.slice(1)` made this 0, so play/space started the transport and
+    // stopped it in the same tick — the picture never moved.
+    const p = project([overlay('o1', 0, 5), overlay('o2', 5, 12)])
+    expect(p.tracks).toHaveLength(1)
+    expect(transportEndFor(p)).toBe(12)
+  })
+
+  it('counts track 0 images in a canvas project, even past the overlay tracks', () => {
+    // Same defect, other content kind: a background image outlasting every
+    // overlay used to be invisible to the ceiling.
+    const p = project(
+      [{ id: 'img', type: 'image', src: '/a.png', start: 0, end: 9 }],
+      [overlay('o', 0, 4)],
+    )
+    expect(transportEndFor(p)).toBe(9)
+  })
+
+  it('uses max(visualEnd, captionEnd) for a canvas project — audio EXCLUDED', () => {
     // The legacy canvas rAF's ceiling is `canvasMaxEndRef`, which really does
     // leave audio out. Faithful, not unified.
     const p = project([{ id: 'img', type: 'image', src: '/a.png', start: 0, end: 3 }], [

package/src/engine/scheduler.ts

@@ -517,9 +517,9 @@ function withTrackAudio(track: VisualTrack | undefined, item: VisualItem): Visua
  * Two formulas, because the legacy hook has two and they legitimately differ:
  *
  *   - **Canvas projects** (no track-0 video) run the `isCanvasProject` rAF,
- *     whose ceiling is `canvasMaxEndRef` = `max(overlayEnd, captionEnd)`. Note
+ *     whose ceiling is `canvasMaxEndRef` = `max(visualEnd, captionEnd)`. Note
  *     what is NOT in it: audio. A canvas project whose music outlasts its
- *     overlays stops at the overlays today.
+ *     visuals stops at the visuals today.
  *   - **Video projects** use `projectEnd` = `max(videoEnd, overlayEnd,
  *     audioEnd)` — captions excluded, audio included — which timeline-core
  *     already ports verbatim (including its two documented faithfulness warts:
@@ -527,18 +527,28 @@ function withTrackAudio(track: VisualTrack | undefined, item: VisualItem): Visua
  *
  * Unifying them would be a behavior change in one mode or the other, so both
  * are kept and the divergence is named here rather than smoothed over.
+ *
+ * `visualEnd` spans EVERY enabled track, track 0 included — it is deliberately
+ * not the video path's `overlayEnd` (`tracks.slice(1)`). In canvas mode track 0
+ * is a content track like any other: it carries the background images, and an
+ * agent-authored project can put its overlays there too (an animations-workflow
+ * project is frequently ONE track holding nothing but overlays). Skipping it
+ * made the ceiling collapse to 0 for exactly those projects, so play/space
+ * started the transport and stopped it in the same tick. `OverlayItemsLayer`
+ * has always drawn track 0 in canvas mode (`isCanvasProject ? enabledTrackItems
+ * : overlayTracks`); this is the transport agreeing with what is on screen.
  */
 export function transportEndFor(project: Project): number {
   const clips = track0VideoItems(project)
   if (clips.length > 0) return timelineProjectEnd(withEnabledItemTracks(project))
-  const overlayEnd = enabledTrackItems(project).slice(1)
+  const visualEnd = enabledTrackItems(project)
     .flat()
     .reduce((m, i) => Math.max(m, i?.end ?? 0), 0)
   const captionEnd = (project.captions?.segments ?? []).reduce(
     (m: number, s) => Math.max(m, s.end ?? 0),
     0,
   )
-  return Math.max(overlayEnd, captionEnd)
+  return Math.max(visualEnd, captionEnd)
 }
 
 /**

package/src/index.ts

@@ -19,6 +19,7 @@ export type {
   CarouselElement,
   Slide,
   EditorProject,
+  Marker,
 } from './schema'
 
 // ── Contracts (adapter, theme, render, media, component props) ────────────────
@@ -103,6 +104,9 @@ export {
 // "land where you dropped it, without stomping existing footage".
 export { placeDroppedClip, resolveDropTrackIndex } from './video/timeline/placement'
 export type { DroppedClipPlacement, PlacedClipResult } from './video/timeline/placement'
+// Marker model — pure mutations over `project.markers` (see markers.ts's file
+// header for the "same reference when unchanged" contract they all share).
+export { addMarker, moveMarker, renameMarker, removeMarkers, nextMarkerLabel } from './video/timeline/markers'
 
 // ── Image tone (HDR image color mapping) ─────────────────────────────────────
 // The picker component is exported so hosts using `onProvideImageTone` can

package/src/schema.ts

@@ -290,6 +290,23 @@ export interface Asset {
   name?: string
 }
 
+/**
+ * An operator's flag on the timeline — a moment worth coming back to.
+ *
+ * Markers are an EDITING and COMMUNICATION aid: they are drawn in the editor's
+ * marker strip and handed to the agent through the context endpoint, and the
+ * renderer ignores them completely. Nothing about a marker reaches the export.
+ *
+ * `label` is always present. A new marker gets an auto-number so dropping one
+ * never interrupts the edit to type; renaming it is a separate, deliberate act.
+ */
+export interface Marker {
+  id: string
+  /** Timeline position in seconds. Never negative. */
+  t: number
+  label: string
+}
+
 // ── Carousel types ─────────────────────────────────────────────────────────
 export interface ImageElement {
   id: string
@@ -385,6 +402,10 @@ export interface EditorProject {
   captions?: Captions
   audio?: { tracks: AudioTrack[] }
   assets?: Asset[]
+  /** Operator markers, kept sorted by `t`. Absent — not `[]` — when the
+   *  project has none, so a marker-less project is byte-identical to one from
+   *  before the feature existed (the same discipline `captions` follows). */
+  markers?: Marker[]
   carousel?: { aspect: string }
   profile?: string
   derivedFrom?: string  // ID of the source project this was derived from (e.g. clips workflow)

package/src/video/VideoEditor.tsx

@@ -11,10 +11,12 @@ import { getOverlayDesignCanvas } from './design-canvas'
 import { availableResolutionTiers, availableFpsTiers, currentResolutionTier, maxExportFps } from './export-limits'
 import { applyTheme, defaultMontajTheme, isLightTheme } from '../theme'
 import { collapseGaps, rippleDelete, splitAtTime } from './cuts'
+import { addMarker } from './timeline/markers'
 import { repairCaptionWords } from './captionRepair'
 import { maxCaptionLane, normalizeCaptionLanes } from './captionLanes'
 import Timeline, { type TimelineActions, type TimelineMode } from './timeline/Timeline'
-import { computeAutoCrossfade, computeDerivedTiming, computeVisualCrossfade, enabledTrackItems, mapTrackItems, normalizeAudioTracks, trackItems } from './timeline/timeline-model'
+import { visualDuration } from '@bycrux/timeline-core'
+import { computeAutoCrossfade, computeDerivedTiming, computeVisualCrossfade, enabledTrackItems, mapTrackItems, normalizeAudioTracks, trackItems, withEnabledItemTracks } from './timeline/timeline-model'
 import { makeCaptionEdit, type CaptionEditPatch } from './timeline/makeCaptionEdit'
 import PreviewPlayer, { type TransportHandle, type ScrubHandle } from './preview/PreviewPlayer'
 import SocialPreviewMenu, { PlatformGlyph, platformOption } from './preview/SocialPreviewMenu'
@@ -144,6 +146,56 @@ export function backfillCaptionIds<P extends Project>(project: P): P {
   }
 }
 
+/**
+ * Where a marker lands.
+ *
+ * With the preview axis ON, the yellow line is what the operator is looking at,
+ * so that is where the marker goes; with it OFF — or ON but with the pointer
+ * off the timeline, where `hoverScrub` reads null — the playhead is.
+ *
+ * `??`, never `||`: a hovered 0 is the start of the timeline, a perfectly
+ * ordinary place to mark, and `||` would silently reroute it to the playhead.
+ *
+ * Exported and tested on its own because `hoverScrub` is a private ref with no
+ * test seam. `handleSplit` carries the same rule inline
+ * (`previewAxis ? (hoverScrub.get() ?? undefined) : undefined`) and is
+ * deliberately NOT refactored onto this helper here: that is existing,
+ * currently-untested behavior and changing it is outside this plan. If you
+ * touch Split's rule later, unify it with this one.
+ */
+export function markerDropTime(previewAxis: boolean, hovered: number | null, playhead: number): number {
+  return previewAxis ? (hovered ?? playhead) : playhead
+}
+
+/**
+ * How long the export dialog thinks the finished video is.
+ *
+ * This is what bounds the cover-frame picker, so it has to be the duration the
+ * RENDER produces — hence `visualDuration`, timeline-core's port of render.js's
+ * own `getTotalDurationSeconds`: the furthest `end` over every item on every
+ * track, audio excluded. Anything narrower offers the operator a grid that
+ * stops before their video does.
+ *
+ * It used to be `max(end)` over the track-0 VIDEO items alone (the same list
+ * that feeds `keeps`). That reads track 0 as "the footage track", which is only
+ * true when there IS footage: an overlay-only project — one track of nothing
+ * but overlays, which the animations workflow emits routinely — measured 0, so
+ * the picker reported "No frames to pick from" for a project made entirely of
+ * pickable frames. The milder version of the same bug cut the grid short
+ * whenever an outro overlay outlived the last clip.
+ *
+ * `keeps` is deliberately NOT widened to match. It answers a different
+ * question — which windows contain real footage the SDR curve thumbnails can
+ * sample — and an overlay-only project genuinely has none.
+ *
+ * Enabled tracks only, and via `withEnabledItemTracks` because `visualDuration`
+ * wants the flat array-of-arrays shape: a track the operator has switched off
+ * is skipped by the render too, so it must not stretch the picker.
+ */
+export function exportDurationSec(project: { tracks?: unknown }): number {
+  return visualDuration(withEnabledItemTracks(project))
+}
+
 /**
  * `<VideoEditor>` — the assembled, host-agnostic video editor.
  *
@@ -1178,7 +1230,10 @@ function ReviewSurface<P extends Project>({
     keeps: renderKeeps,
     imageTone: { value: currentImageTone ?? 'vivid', set: handleImageToneChange },
     name: project.name?.trim() || undefined,
-    durationSec: renderKeeps.reduce((m, k) => Math.max(m, k.end), 0),
+    // NOT derived from `renderKeeps` — see `exportDurationSec`. Keeps covers
+    // the footage windows the curve thumbnails can sample; the cover picker
+    // has to span the whole rendered video, overlay-only projects included.
+    durationSec: exportDurationSec(project),
     aspectRatio: (() => {
       const r = project.settings?.resolution
       return r && r[0] > 0 && r[1] > 0 ? r[0] / r[1] : undefined
@@ -1194,7 +1249,13 @@ function ReviewSurface<P extends Project>({
       set: handleExportFpsChange,
     },
   }), [
-    isHdrProject, renderKeeps, currentImageTone, handleImageToneChange,
+    // `project.tracks` is listed for `exportDurationSec`, which reads every
+    // track rather than just the footage keeps. `renderKeeps` already changes
+    // identity with it, so this is belt-and-braces — but relying on that would
+    // leave the duration silently stale the day keeps stops being memoized on
+    // tracks. Deliberately NOT the whole `project`: this memo is kept off
+    // unrelated project mutations on purpose (see `availableRes` above).
+    isHdrProject, renderKeeps, project.tracks, currentImageTone, handleImageToneChange,
     project.name, project.settings?.resolution, project.settings?.fps,
     availableRes, availableFpsList, handleExportResolutionChange, handleExportFpsChange,
   ])
@@ -1621,6 +1682,13 @@ function ReviewSurface<P extends Project>({
     void sync.mutate(() => updated as P)
   }
 
+  function handleAddMarker(at?: number) {
+    const base = syncProjectRef.current
+    const updated = addMarker(base, at ?? clock.get())
+    if (updated === base) return   // key repeat inside the half-frame window
+    void sync.mutate(() => updated as P)
+  }
+
   function handleRippleToggle() {
     const next = !rippleMode
     setRippleMode(next)
@@ -1757,6 +1825,13 @@ function ReviewSurface<P extends Project>({
       // is selected (a no-op if the axis isn't over the item).
       action: () => handleSplit(previewAxis ? (hoverScrub.get() ?? undefined) : undefined),
     },
+    {
+      id: 'video.add-marker',
+      description: 'Drop a marker',
+      keyHint: ['M'],
+      matches: matchesPlainKey('m'),
+      action: () => handleAddMarker(markerDropTime(previewAxis, hoverScrub.get(), clock.get())),
+    },
     {
       id: 'video.undo',
       description: 'Undo',
@@ -1897,6 +1972,7 @@ function ReviewSurface<P extends Project>({
   const paletteCommands: PaletteCommand[] = [
     { id: 'play-pause', label: 'Play/Pause', keyHint: ['Space'], run: () => transportRef.current?.togglePlay() },
     { id: 'split', label: 'Split at playhead', keyHint: ['S'], run: () => handleSplit() },
+    { id: 'add-marker', label: 'Drop a marker', keyHint: ['M'], run: () => handleAddMarker() },
   ]
   if (primarySelectedId) {
     paletteCommands.push({ id: 'ripple-delete', label: 'Ripple-delete selection', keyHint: ['⇧', 'Delete'], run: () => handleRippleDelete() })

package/src/video/__tests__/VideoEditor.keymap.test.tsx

@@ -386,6 +386,70 @@ describe('VideoEditor — preview axis toggle', () => {
   })
 })
 
+describe('VideoEditor — M drops a marker', () => {
+  it('drops one at the playhead with an auto-number label', async () => {
+    const adapter = makeFakeAdapter()
+    const onProjectChange = vi.fn()
+    render(<VideoEditor project={makeVideoProject()} adapter={adapter} onProjectChange={onProjectChange} slots={{ exportActions: <div /> }} />)
+    await screen.findByLabelText('Preview axis')
+
+    await act(async () => {
+      document.dispatchEvent(new KeyboardEvent('keydown', { key: 'm' }))
+    })
+    const next = onProjectChange.mock.calls[onProjectChange.mock.calls.length - 1][0]
+    expect(next.markers).toHaveLength(1)
+    expect(next.markers[0]).toMatchObject({ t: 0, label: '1' })   // playhead starts at 0
+  })
+
+  it('does not fire while typing in a text surface', async () => {
+    const adapter = makeFakeAdapter()
+    const onProjectChange = vi.fn()
+    render(<VideoEditor project={makeVideoProject()} adapter={adapter} onProjectChange={onProjectChange} slots={{ exportActions: <div /> }} />)
+    await screen.findByLabelText('Preview axis')
+    onProjectChange.mockClear()   // drop the mount-time "notify host" call — see the Space test above
+
+    const input = document.createElement('input')
+    document.body.appendChild(input)
+    await act(async () => {
+      input.dispatchEvent(new KeyboardEvent('keydown', { key: 'm', bubbles: true }))
+    })
+    expect(onProjectChange).not.toHaveBeenCalled()
+    input.remove()
+  })
+
+  it('Cmd+M is left alone — the shortcut is the bare letter', async () => {
+    // Cmd+M minimises the window on macOS; swallowing it would be hostile.
+    const adapter = makeFakeAdapter()
+    const onProjectChange = vi.fn()
+    render(<VideoEditor project={makeVideoProject()} adapter={adapter} onProjectChange={onProjectChange} slots={{ exportActions: <div /> }} />)
+    await screen.findByLabelText('Preview axis')
+    onProjectChange.mockClear()   // drop the mount-time "notify host" call — see the Space test above
+
+    await act(async () => {
+      document.dispatchEvent(new KeyboardEvent('keydown', { key: 'm', metaKey: true }))
+    })
+    expect(onProjectChange).not.toHaveBeenCalled()
+  })
+
+  it('holding M does not spray markers', async () => {
+    // Key repeat fires keydown over and over at the same playhead; the
+    // half-frame guard in addMarker must make every repeat after the first a
+    // no-op that never reaches onProjectChange.
+    const adapter = makeFakeAdapter()
+    const onProjectChange = vi.fn()
+    render(<VideoEditor project={makeVideoProject()} adapter={adapter} onProjectChange={onProjectChange} slots={{ exportActions: <div /> }} />)
+    await screen.findByLabelText('Preview axis')
+
+    for (let i = 0; i < 5; i++) {
+      await act(async () => {
+        document.dispatchEvent(new KeyboardEvent('keydown', { key: 'm' }))
+      })
+    }
+    const last = onProjectChange.mock.calls[onProjectChange.mock.calls.length - 1][0]
+    expect(last.markers).toHaveLength(1)
+  })
+})
+
 // ── T2 — copy / paste / duplicate / paste-attributes ────────────────────
 //
 // Persistence assertions read `adapter.saveProject`'s SECOND argument (the

package/src/video/__tests__/cuts.test.ts

@@ -310,6 +310,90 @@ describe('splitAtTime', () => {
     expect(lw.duration + rw.duration).toBeCloseTo(10)
   })
 
+  // A fade belongs to an EDGE. Both halves used to inherit BOTH fades from the
+  // spread, so every cut manufactured a fade-out into the razor and a fade-in
+  // out of it — on a voiceover with the usual trailing fade, each cut left a
+  // fragment ramping to silence at the cut that the operator had to zero by
+  // hand.
+  it('does not manufacture a fade-out at the cut on the left half', () => {
+    const p = makeProject({
+      tracks: vtracks([]),
+      audio: { tracks: [{ id: 'au', src: 'a.mp3', start: 0, end: 100, fadeOut: 0.4 }] },
+    })
+    const [left, right] = splitAtTime(p, 40, null).audio!.tracks
+    expect(left.fadeOut).toBeUndefined()   // the cut edge — no fade was asked for
+    expect(right.fadeOut).toBe(0.4)        // still the original END, keeps its fade
+  })
+
+  it('does not manufacture a fade-in at the cut on the right half', () => {
+    const p = makeProject({
+      tracks: vtracks([]),
+      audio: { tracks: [{ id: 'au', src: 'a.mp3', start: 0, end: 100, fadeIn: 0.3 }] },
+    })
+    const [left, right] = splitAtTime(p, 40, null).audio!.tracks
+    expect(left.fadeIn).toBe(0.3)          // still the original START, keeps its fade
+    expect(right.fadeIn).toBeUndefined()   // the cut edge
+  })
+
+  it('drops the curve along with the fade it described', () => {
+    // A `fadeOutCurve` on a half with no fade-out is dead data, and the next
+    // hand-drawn fade there should start from the default shape.
+    const p = makeProject({
+      tracks: vtracks([]),
+      audio: { tracks: [{
+        id: 'au', src: 'a.mp3', start: 0, end: 100,
+        fadeIn: 0.3, fadeInCurve: 'linear', fadeOut: 0.4, fadeOutCurve: 'log',
+      }] },
+    })
+    const [left, right] = splitAtTime(p, 40, null).audio!.tracks
+    expect(left.fadeInCurve).toBe('linear')
+    expect(left.fadeOutCurve).toBeUndefined()
+    expect(right.fadeOutCurve).toBe('log')
+    expect(right.fadeInCurve).toBeUndefined()
+  })
+
+  it('splitting twice never reintroduces a fade at either cut', () => {
+    // The shape that surfaced this: successive razors down one voiceover. The
+    // middle fragment owns neither original edge, so it must carry no fade at
+    // all — before the fix it carried both.
+    const p = makeProject({
+      tracks: vtracks([]),
+      audio: { tracks: [{ id: 'au', src: 'a.mp3', start: 0, end: 100, fadeIn: 0.3, fadeOut: 0.4 }] },
+    })
+    const once = splitAtTime(p, 40, null)
+    const twice = splitAtTime(once, 70, once.audio!.tracks[1].id)
+    const [a, b, c] = twice.audio!.tracks
+    expect([a.fadeIn, a.fadeOut]).toEqual([0.3, undefined])
+    expect([b.fadeIn, b.fadeOut]).toEqual([undefined, undefined])
+    expect([c.fadeIn, c.fadeOut]).toEqual([undefined, 0.4])
+  })
+
+  it('clamps a kept fade that no longer fits its own fragment', () => {
+    // A 3s fade-out is fine on the whole 20s track; the fragment it lands on is
+    // 1s long. Nothing downstream re-clamps — the renderer just anchors
+    // `st = end - fadeOut`, which would start the fade before this fragment's
+    // audio begins.
+    const p = makeProject({
+      tracks: vtracks([]),
+      audio: { tracks: [{ id: 'au', src: 'a.mp3', start: 0, end: 20, fadeIn: 3, fadeOut: 3 }] },
+    })
+    const [left, right] = splitAtTime(p, 19, null).audio!.tracks
+    expect(right.fadeOut).toBe(1)   // clamped to the 1s fragment
+    expect(left.fadeIn).toBe(3)     // still fits the 19s fragment, untouched
+  })
+
+  it('leaves a track with no fades alone', () => {
+    const p = makeProject({
+      tracks: vtracks([]),
+      audio: { tracks: [{ id: 'au', src: 'a.mp3', start: 0, end: 10 }] },
+    })
+    const [left, right] = splitAtTime(p, 4, null).audio!.tracks
+    for (const half of [left, right]) {
+      expect(half).not.toHaveProperty('fadeIn')
+      expect(half).not.toHaveProperty('fadeOut')
+    }
+  })
+
   it('carries an existing trim window across a split (both halves stay within source)', () => {
     // A pre-trimmed track: source window [2,12] mapped onto timeline [0,10].
     const p = makeProject({

package/src/video/__tests__/exportDurationSec.test.ts

@@ -0,0 +1,60 @@
+/**
+ * The export dialog's duration — what the cover-frame picker samples across.
+ *
+ * This used to be derived from the track-0 VIDEO items alone, which is a safe
+ * reading only when track 0 holds footage. An overlay-only project (the
+ * animations workflow emits exactly that: one track of nothing but overlays)
+ * therefore reported 0, and the picker had no frames to offer — on a project
+ * that renders perfectly well and is entirely made of pickable frames.
+ */
+import { describe, it, expect } from 'vitest'
+import { exportDurationSec } from '../VideoEditor'
+import type { EditorProject, VisualItem } from '../../schema'
+
+const video = (id: string, start: number, end: number): VisualItem =>
+  ({ id, type: 'video', src: `/${id}.mp4`, start, end }) as VisualItem
+const overlay = (id: string, start: number, end: number): VisualItem =>
+  ({ id, type: 'overlay', src: `/${id}.jsx`, start, end }) as VisualItem
+
+function proj(tracks: { items: VisualItem[]; enabled?: boolean }[]): EditorProject {
+  return {
+    id: 'p', status: 'draft', settings: { resolution: [1920, 1080], fps: 30 },
+    tracks: tracks.map((t, i) => ({ id: `trk-${i}`, ...t })),
+  } as EditorProject
+}
+
+describe('exportDurationSec', () => {
+  it('spans an overlay-only project, which used to report 0', () => {
+    // The Daubert-demo shape: one track, overlays only, no video anywhere.
+    expect(exportDurationSec(proj([{ items: [overlay('o1', 0, 5), overlay('o2', 5, 12)] }]))).toBe(12)
+  })
+
+  it('reaches an overlay that outlives the last video clip', () => {
+    // An outro card after the final clip is ordinary, and its frames are just
+    // as pickable as the footage before it — the render encodes to 14, so the
+    // picker has to offer the whole 14.
+    expect(exportDurationSec(proj([
+      { items: [video('v', 0, 8)] },
+      { items: [overlay('outro', 8, 14)] },
+    ]))).toBe(14)
+  })
+
+  it('still matches the video end when video is the longest thing', () => {
+    // The common case must not move.
+    expect(exportDurationSec(proj([
+      { items: [video('a', 0, 4), video('b', 4, 9)] },
+      { items: [overlay('o', 0, 3)] },
+    ]))).toBe(9)
+  })
+
+  it('ignores a disabled track, which the render also skips', () => {
+    expect(exportDurationSec(proj([
+      { items: [video('v', 0, 6)] },
+      { items: [overlay('o', 0, 30)], enabled: false },
+    ]))).toBe(6)
+  })
+
+  it('is 0 for a project with nothing on any track', () => {
+    expect(exportDurationSec(proj([{ items: [] }]))).toBe(0)
+  })
+})

package/src/video/__tests__/markerDropTime.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest'
+import { markerDropTime } from '../VideoEditor'
+
+describe('markerDropTime', () => {
+  it('uses the playhead when the preview axis is off', () => {
+    expect(markerDropTime(false, 12, 4)).toBe(4)
+  })
+
+  it('uses the hovered time when the axis is on', () => {
+    // The yellow line is what the operator is looking at, so that is where the
+    // marker goes.
+    expect(markerDropTime(true, 12, 4)).toBe(12)
+  })
+
+  it('falls back to the playhead when the axis is on but nothing is hovered', () => {
+    // Axis on with the pointer off the timeline: hoverScrub reads null.
+    expect(markerDropTime(true, null, 4)).toBe(4)
+  })
+
+  it('treats a hovered 0 as a real position, not as absent', () => {
+    // The bug a `||` instead of `??` would introduce: the very start of the
+    // timeline is a perfectly ordinary place to mark.
+    expect(markerDropTime(true, 0, 4)).toBe(0)
+  })
+})

package/src/video/cuts.ts

@@ -481,19 +481,47 @@ function splitAudioTrack(track: AudioTrack, at: number): [AudioTrack, AudioTrack
   const outPoint = track.outPoint ?? track.sourceDuration ?? (track.end - track.start)
   const splitPoint = inPoint + (at - track.start)
 
+  // A FADE BELONGS TO AN EDGE, NOT TO THE CLIP. Spreading `...track` into both
+  // halves gave both fragments both fades, which is wrong on the two edges the
+  // split just created: the left half fades OUT into the cut and the right half
+  // fades IN out of it, neither of which anyone asked for. On a voiceover
+  // carrying the usual trailing fade-out that is very visible — every cut
+  // produced a fragment that ramps to silence at the razor, and the operator
+  // has to zero it by hand each time. Fades are added deliberately; a cut is
+  // not a request for one.
+  //
+  // So each half keeps only the fade whose EDGE it still owns:
+  //   • the left half keeps the original START, so it keeps `fadeIn`;
+  //   • the right half keeps the original END, so it keeps `fadeOut`;
+  //   • the two new edges at the cut carry no fade at all.
+  // The paired curve goes with its fade — a `fadeOutCurve` describing a
+  // fade-out that no longer exists is dead data, and the operator's next
+  // hand-drawn fade should start from the default shape like any other new one.
+  //
+  // The kept fade is then clamped to its own fragment's span. A 3s fade-out on
+  // a 20s track is fine; split that track 1s from its end and the 3s fade no
+  // longer fits inside the 1s fragment it lands on. Nothing downstream
+  // re-clamps for us — the pointer-machine and the properties panel each clamp
+  // their OWN edits, and the renderer just anchors `st = end - fadeOut`, which
+  // for an oversized fade starts before the fragment's audio does.
+  const { fadeOut: _outAmt, fadeOutCurve: _outCurve, ...leftBase } = track
+  const { fadeIn: _inAmt, fadeInCurve: _inCurve, ...rightBase } = track
+
   const left: AudioTrack = {
-    ...track,
+    ...leftBase,
     end: at,
     inPoint,
     outPoint: splitPoint,
   }
   const right: AudioTrack = {
-    ...track,
+    ...rightBase,
     id: uniqueId(track.id),
     start: at,
     inPoint: splitPoint,
     outPoint,
   }
+  if (left.fadeIn !== undefined)  left.fadeIn  = Math.min(left.fadeIn, at - track.start)
+  if (right.fadeOut !== undefined) right.fadeOut = Math.min(right.fadeOut, track.end - at)
   return [left, right]
 }