peachsim 0.1.1635 → 0.1.1641

package/cli/commands/record.ts

@@ -76,18 +76,41 @@ const STORE_RECORD_START_TIMEOUT_MS = 90_000
 // (bitmap-capture.ts), so recovery is simply to retry.
 const CAPTURE_STEP_ENCODE_BUDGET_MS = 30_000
 
+// waits out a recording's duration as an in-flight bridge command. the host
+// closes a cli socket that sends nothing for 60s, but never one with a command
+// awaiting its sim, so a client-side sleep through a long capture dropped the
+// connection before the encode/flush step could use it.
+async function holdCapture(bridge: WsBridge, durationMs: number) {
+  await bridge.send(
+    { type: 'evaluate', code: `new Promise((r) => setTimeout(r, ${durationMs}))` },
+    { timeoutMs: durationMs + CAPTURE_STEP_ENCODE_BUDGET_MS },
+  )
+}
+
+// an explicit --timeout is the step's budget. a step that records for the
+// whole duration (a gif) gets that duration on top of it.
+function captureStepTimeoutMs(
+  parsed: ParsedBridgeCliArgs,
+  durationMs: number,
+  spansCapture: boolean,
+): number {
+  if (!parsed.explicitTimeout)
+    return Math.max(20_000, durationMs + CAPTURE_STEP_ENCODE_BUDGET_MS)
+  return spansCapture ? durationMs + parsed.commandTimeoutMs : parsed.commandTimeoutMs
+}
+
 async function evalCaptureStep<T>(
   bridge: WsBridge,
   code: string,
   step: string,
   durationMs: number,
+  timeoutMs: number,
 ): Promise<T> {
-  const timeoutMs = Math.max(20_000, durationMs + CAPTURE_STEP_ENCODE_BUDGET_MS)
   try {
     return (await bridge.send({ type: 'evaluate', code }, { timeoutMs })) as T
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err)
-    if (/^command timed out after \d+s$/.test(msg)) {
+    if (/^command timed out after \d+(?:\.\d+)?s$/.test(msg)) {
       console.error(
         `  ${step} stalled — the render host did not finish within ` +
           `${Math.round(timeoutMs / 1000)}s; it is likely contended or wedged.\n` +
@@ -145,6 +168,7 @@ const RECORD_VALUE_FLAGS = new Set([
   '--repo',
   '--scene',
   '--shell-url',
+  '--timeout',
 ])
 const RECORD_SUBCOMMANDS = new Set([
   'start',
@@ -242,6 +266,8 @@ export async function runRecord(args: string[], opts: RecordOptions) {
 
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
+    // an explicit --timeout wins over the default
+    commandTimeoutMs: 60_000,
     stripBooleanFlags: ['--no-shell', '--shell-only', '--open', '--lockstep'],
     stripValueFlags: [
       '--mode',
@@ -356,7 +382,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
       originOverride,
       allowGitHubAuth: true,
     })
-    const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 60_000 })
+    const bridge = createBridgeFromParsed(parsed)
     try {
       await assertStoreBridgesAvailable(bridge)
       await assertGuestBundleLoaded(bridge, mode)
@@ -376,7 +402,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         peachExit(1)
       }
       console.log(`  recording ${mode} for ${durationSec}s`)
-      await new Promise((r) => setTimeout(r, durationMs))
+      await holdCapture(bridge, durationMs)
       await evalStoreStop(bridge)
       const result = await pollStoreUpload(bridge)
       handleStoreUploadResult(result, openAfter, mode)
@@ -398,7 +424,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
     )
   }
 
-  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 60_000 })
+  const bridge = createBridgeFromParsed(parsed)
   try {
     await assertRecorderAvailable(bridge)
     await assertTabVisibleForCapture(bridge)
@@ -434,7 +460,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         console.error(`  frame capture start failed: ${start.error ?? 'unknown error'}`)
         peachExit(1)
       }
-      await new Promise((r) => setTimeout(r, durationMs))
+      await holdCapture(bridge, durationMs)
       const deadline = Date.now() + Math.max(5_000, durationMs)
       // frames come back a few at a time: one message holding every base64 png
       // exceeds the bridge socket's message cap and closes it.
@@ -490,6 +516,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         }${layers ? `, layers: ${JSON.stringify(layers)}` : ''} })`,
         'gif encode',
         durationMs,
+        captureStepTimeoutMs(parsed, durationMs, true),
       )
       if (!result) {
         console.error('  gif capture returned no frames')
@@ -523,6 +550,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         `window.__sootsimRecorder.start(${JSON.stringify(startOpts)})`,
         `${format} start`,
         durationMs,
+        captureStepTimeoutMs(parsed, durationMs, false),
       )
     if (!startResult.ok) {
       console.error(`  start failed: ${startResult.error ?? 'unknown error'}`)
@@ -543,7 +571,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
     }
 
     console.log(`  recording ${format} for ${durationSec}s → ${out}`)
-    await new Promise((r) => setTimeout(r, durationMs))
+    await holdCapture(bridge, durationMs)
 
     const stopResult: {
       ok: boolean
@@ -557,6 +585,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
       `window.__sootsimRecorder.stop()`,
       `${format} encode/flush`,
       durationMs,
+      captureStepTimeoutMs(parsed, durationMs, false),
     )
     if (!stopResult.ok) {
       console.error(`  stop failed: ${stopResult.error ?? 'unknown error'}`)
@@ -590,11 +619,11 @@ async function probeSim(bridge: WsBridge, code: string): Promise<boolean> {
   try {
     return await bridge.send(
       { type: 'evaluate', code },
-      { timeoutMs: SIM_PROBE_TIMEOUT_MS },
+      { defaultTimeoutMs: SIM_PROBE_TIMEOUT_MS },
     )
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err)
-    if (/^command timed out after \d+s$/.test(msg)) {
+    if (/^command timed out after \d+(?:\.\d+)?s$/.test(msg)) {
       console.error(
         '  sim did not respond — it is connected to the bridge but has not\n' +
           '  loaded an app (or its page is unresponsive). run `peach list`\n' +
@@ -786,7 +815,7 @@ async function refuseLiveRecording(parsed: ParsedBridgeCliArgs) {
     ...parsed,
     simId: existing.simId ?? parsed.simId,
     simIdSource: existing.simId ? 'saved' : parsed.simIdSource,
-    commandTimeoutMs: 8_000,
+    commandTimeoutMs: parsed.explicitTimeout ? parsed.commandTimeoutMs : 8_000,
   })
   try {
     const sims = await bridge.listSims()
@@ -808,8 +837,12 @@ async function refuseLiveRecording(parsed: ParsedBridgeCliArgs) {
 }
 
 async function recordStart(args: string[], opts: RecordOptions) {
+  const mode = parseMode(valueOf(args, '--mode'))
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
+    // an explicit --timeout wins over the per-mode default
+    commandTimeoutMs:
+      mode === 'live' || mode === 'combined' ? STORE_RECORD_START_TIMEOUT_MS : 15_000,
     stripBooleanFlags: ['--no-shell', '--shell-only', '--lockstep'],
     stripValueFlags: [
       '--mode',
@@ -823,7 +856,6 @@ async function recordStart(args: string[], opts: RecordOptions) {
     ],
   })
   await refuseLiveRecording(parsed)
-  const mode = parseMode(valueOf(args, '--mode'))
   const layers: 'tenant' | 'shell' | undefined = args.includes('--shell-only')
     ? 'shell'
     : args.includes('--no-shell')
@@ -840,11 +872,19 @@ async function recordStart(args: string[], opts: RecordOptions) {
   const fps = Number(valueOf(args, '--fps') ?? '30')
   const repoScope = readRepoScope(args)
 
-  const bridge = createBridgeFromParsed({
-    ...parsed,
-    commandTimeoutMs:
-      mode === 'live' || mode === 'combined' ? STORE_RECORD_START_TIMEOUT_MS : 15_000,
-  })
+  // the session is recorded before the engine is asked to start, so a start
+  // that times out on this side while the engine records stays stoppable. a
+  // refusal clears it.
+  const session: RecordingState = {
+    simId: parsed.simId ?? null,
+    mode,
+    format,
+    fps,
+    layers,
+    startedAt: new Date().toISOString(),
+  }
+
+  const bridge = createBridgeFromParsed(parsed)
   try {
     if (mode === 'live' || mode === 'combined') {
       // live mode captures events only — --no-shell / --shell-only have no
@@ -869,6 +909,7 @@ async function recordStart(args: string[], opts: RecordOptions) {
       await assertGuestBundleLoaded(bridge, mode)
       if (mode === 'combined') await assertTabVisibleForCapture(bridge)
       await injectPreviewSessionAuth(bridge, valueOf(args, '--origin'), repoScope)
+      writeRecordingState(session)
       const started = await evalStoreStart(
         bridge,
         mode,
@@ -876,6 +917,7 @@ async function recordStart(args: string[], opts: RecordOptions) {
         mode === 'combined' ? layers : undefined,
       )
       if (!started.ok) {
+        clearRecordingState()
         console.error(
           `  start failed: recording store refused to start (${mode})` +
             (started.error ? `: ${started.error}` : ''),
@@ -883,8 +925,6 @@ async function recordStart(args: string[], opts: RecordOptions) {
         peachExit(1)
       }
     } else {
-      await assertRecorderAvailable(bridge)
-      await assertTabVisibleForCapture(bridge)
       const lockstep = args.includes('--lockstep')
       if (lockstep && format !== 'mp4') {
         console.error('  --lockstep requires --format mp4 (webm is realtime-clocked)')
@@ -898,23 +938,21 @@ async function recordStart(args: string[], opts: RecordOptions) {
       } = { format, fps }
       if (layers) startOpts.layers = layers
       if (lockstep) startOpts.lockstep = true
+      writeRecordingState(session)
       const result: { ok: boolean; error?: string } = await bridge.send({
         type: 'evaluate',
-        code: `window.__sootsimRecorder.start(${JSON.stringify(startOpts)})`,
+        code: `(() => {
+          if (!window.__sootsimRecorder) return { ok: false, error: 'recorder unavailable in this sim' };
+          if (document.hidden) return { ok: false, error: 'the peach tab is hidden; bring it to the foreground before recording' };
+          return window.__sootsimRecorder.start(${JSON.stringify(startOpts)});
+        })()`,
       })
       if (!result.ok) {
+        clearRecordingState()
         console.error(`  start failed: ${result.error ?? 'unknown error'}`)
         peachExit(1)
       }
     }
-    writeRecordingState({
-      simId: parsed.simId ?? null,
-      mode,
-      format,
-      fps,
-      layers,
-      startedAt: new Date().toISOString(),
-    })
     if (mode === 'video') {
       console.log(
         `  recording ${format} @ ${fps}fps${layers ? ` (${layers})` : ''} — run \`peach record stop --output <path>\` when done`,
@@ -936,7 +974,7 @@ async function recordPreludeStart(args: string[], opts: RecordOptions) {
     stripValueFlags: ['--origin'],
   })
   await refuseLiveRecording(parsed)
-  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 15_000 })
+  const bridge = createBridgeFromParsed(parsed)
   try {
     await assertStoreBridgesAvailable(bridge)
     await assertTabVisibleForCapture(bridge)
@@ -987,7 +1025,13 @@ async function recordPreludeStart(args: string[], opts: RecordOptions) {
 //   - the event recorder alone drives hidden PR-preview preludes before a
 //     visible live/combined segment exists
 // returns null when the engine can't be reached.
-type EngineRecordingState = 'idle' | 'recording' | 'processing' | 'prelude'
+type EngineRecordingState =
+  | 'idle'
+  | 'starting'
+  | 'recording'
+  | 'processing'
+  | 'ready'
+  | 'prelude'
 
 async function probeEngineRecordingState(
   bridge: WsBridge,
@@ -1008,8 +1052,10 @@ async function probeEngineRecordingState(
       })()`,
       })
     if (!snap) return null
+    if (snap.headless === 'starting') return 'starting'
     if (snap.store === 'recording' || snap.headless === 'recording') return 'recording'
-    if (snap.store === 'processing') return 'processing'
+    if (snap.store === 'processing' || snap.headless === 'processing') return 'processing'
+    if (snap.headless === 'ready') return 'ready'
     if (snap.eventRecording) return 'prelude'
     if (snap.store === 'idle' || snap.headless === 'idle') return 'idle'
     return null
@@ -1054,26 +1100,36 @@ async function cancelEngineRecording(bridge: WsBridge): Promise<{
 
 async function recordStatus(args: string[], opts: RecordOptions) {
   const state = readRecordingState()
-  if (state) {
-    noteSimMismatch(parseBridgeCliArgs(args, { port: opts.port }).simId, state)
-    if (state.mode === 'video') {
-      console.log(
-        `  recording ${state.mode} (${state.format} @ ${state.fps}fps) on sim ${state.simId ?? '?'} since ${state.startedAt}`,
-      )
-    } else {
-      console.log(
-        `  recording ${state.mode} on sim ${state.simId ?? '?'} since ${state.startedAt}`,
-      )
-    }
-    return
-  }
-  // no `record start` session — but an atomic run or the rail button may
-  // still be recording. ask the engine before claiming nothing is happening.
-  const parsed = parseBridgeCliArgs(args, { port: opts.port })
-  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 8_000 })
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    commandTimeoutMs: 8_000,
+  })
+  if (state) noteSimMismatch(parsed.simId, state)
+  const bridge = createBridgeFromParsed({
+    ...parsed,
+    simId: state?.simId ?? parsed.simId,
+  })
   try {
     const engineState = await probeEngineRecordingState(bridge)
+    if (state) {
+      if (engineState === 'idle') {
+        clearRecordingState()
+        console.log('  no recording in progress')
+      } else if (engineState === 'ready') {
+        console.log('  recording ready to save — run `peach record stop --output <path>`')
+      } else if (engineState === null) {
+        console.log(
+          '  recording state unavailable — the sim did not respond; the tracked session is preserved',
+        )
+      } else {
+        console.log(
+          `  ${engineState} ${state.mode}${state.mode === 'video' ? ` (${state.format} @ ${state.fps}fps)` : ''} on sim ${state.simId ?? '?'} since ${state.startedAt}`,
+        )
+      }
+      return
+    }
     if (
+      engineState === 'starting' ||
       engineState === 'recording' ||
       engineState === 'processing' ||
       engineState === 'prelude'
@@ -1111,16 +1167,18 @@ async function recordCancel(args: string[], opts: RecordOptions) {
   if (!state) {
     // no `record start` session to cancel — but check the engine so we
     // don't falsely claim nothing is happening while an atomic run records.
-    const probeParsed = parseBridgeCliArgs(args, { port: opts.port })
-    const probeBridge = createBridgeFromParsed({
-      ...probeParsed,
+    const probeParsed = parseBridgeCliArgs(args, {
+      port: opts.port,
       commandTimeoutMs: 8_000,
     })
+    const probeBridge = createBridgeFromParsed(probeParsed)
     try {
       const engineState = await probeEngineRecordingState(probeBridge)
       if (
+        engineState === 'starting' ||
         engineState === 'recording' ||
         engineState === 'processing' ||
+        engineState === 'ready' ||
         engineState === 'prelude'
       ) {
         // `record cancel` is explicit intent: the caller wants whatever is
@@ -1152,18 +1210,14 @@ async function recordCancel(args: string[], opts: RecordOptions) {
     }
     return
   }
-  const parsed = parseBridgeCliArgs(args, { port: opts.port })
+  const parsed = parseBridgeCliArgs(args, { port: opts.port, commandTimeoutMs: 15_000 })
   noteSimMismatch(parsed.simId, state)
   // the recorder (and its buffered blob) lives in the page of the sim the
   // recording was *started* on — `state.simId` wins over the requested
   // --sim, otherwise cancel would stop an idle recorder on the wrong sim
   // and leave the real recording running (F11-1).
   const simId = state.simId ?? parsed.simId ?? undefined
-  const bridge = createBridgeFromParsed({
-    ...parsed,
-    simId,
-    commandTimeoutMs: 15_000,
-  })
+  const bridge = createBridgeFromParsed({ ...parsed, simId })
   try {
     if (state.mode === 'live' || state.mode === 'combined') {
       await bridge.send({
@@ -1173,7 +1227,11 @@ async function recordCancel(args: string[], opts: RecordOptions) {
     } else {
       await bridge.send({
         type: 'evaluate',
-        code: `window.__sootsimRecorder.stop()`,
+        code: `(async () => {
+          const recorder = window.__sootsimRecorder;
+          await recorder.stop();
+          return recorder.forceRelease();
+        })()`,
       })
     }
   } catch {
@@ -1194,6 +1252,9 @@ async function recordStop(args: string[], opts: RecordOptions) {
 
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
+    // an explicit --timeout wins over the per-mode default
+    commandTimeoutMs:
+      state.mode === 'live' || state.mode === 'combined' ? UPLOAD_TIMEOUT_MS : 60_000,
     stripBooleanFlags: ['--open'],
     stripValueFlags: ['--output'],
   })
@@ -1204,15 +1265,25 @@ async function recordStop(args: string[], opts: RecordOptions) {
   const simId = state.simId ?? parsed.simId ?? undefined
   const openAfter = args.includes('--open')
 
-  const bridge = createBridgeFromParsed({
-    ...parsed,
-    simId,
-    commandTimeoutMs:
-      state.mode === 'live' || state.mode === 'combined' ? UPLOAD_TIMEOUT_MS : 60_000,
-  })
+  const bridge = createBridgeFromParsed({ ...parsed, simId })
   try {
     if (state.mode === 'live' || state.mode === 'combined') {
-      await evalStoreStop(bridge)
+      const stopped = await evalStoreStop(bridge)
+      if (stopped === 'pending') {
+        console.error(
+          `  stop failed: the ${state.mode} start is still in flight and has not begun a take yet.\n` +
+            '  run `peach record stop` again once it begins.',
+        )
+        peachExit(1)
+      }
+      if (!stopped) {
+        clearRecordingState()
+        console.error(
+          `  stop failed: the ${state.mode} start still in flight never began a take, so there is nothing to upload.\n` +
+            '  run `peach record start` again.',
+        )
+        peachExit(1)
+      }
       const result = await pollStoreUpload(bridge)
       clearRecordingState()
       handleStoreUploadResult(result, openAfter, state.mode)
@@ -1235,7 +1306,17 @@ async function recordStop(args: string[], opts: RecordOptions) {
     })
     if (!stopResult.ok) {
       console.error(`  stop failed: ${stopResult.error ?? 'unknown error'}`)
-      clearRecordingState()
+      // a start that timed out on the client can still be on its way to the
+      // engine. keep the state so a later stop finds the recording instead of
+      // leaving it running with nothing to stop it.
+      if (stopResult.error === 'not recording') {
+        console.error(
+          '  the start may not have reached the engine yet. retry `peach record stop`,\n' +
+            '  or run `peach record cancel` to give up on it.',
+        )
+      } else {
+        clearRecordingState()
+      }
       peachExit(1)
     }
     if (!stopResult.size) {
@@ -1396,11 +1477,16 @@ async function evalStoreStart(
   return { ok: false, error: error ?? null }
 }
 
-async function evalStoreStop(bridge: WsBridge): Promise<void> {
-  await bridge.send({
+// the engine stop waits for a start still in flight. false means that start
+// never began a take, so no upload will come and the store's last one belongs
+// to an earlier take. 'pending' means the start was still pending when the
+// engine stopped waiting, so it may yet begin one.
+async function evalStoreStop(bridge: WsBridge): Promise<boolean | 'pending'> {
+  const stopped: boolean | 'pending' | null = await bridge.send({
     type: 'evaluate',
-    code: `void window.SootSim.bridges.stopRecording()`,
+    code: `window.SootSim.bridges.stopRecording()`,
   })
+  return stopped === 'pending' ? stopped : stopped !== false
 }
 
 interface StoreUploadResult {

package/cli/commands/swift.ts

@@ -5,6 +5,7 @@ import { WebSocket, WebSocketServer } from 'ws'
 import { resolveContrastBackendOrigin } from '../../src/backend-origin'
 import { produceConfiguredBundle } from '../../src/configured-bundle-producer'
 import { swiftGuestBundle } from '../../src/guest-bundle'
+import { insertNativeAppIdentityFooter } from '../../src/native-app-identity'
 import {
   resolveSwiftModule,
   SWIFT_ENDPOINT_ENV,
@@ -164,11 +165,21 @@ export async function runSwift(
   const appProject = resolveAppProject(packagePath)
   host.configureSwiftStandinBehavior(packagePath, await loadRNXAppConfig(appProject))
   // collection preflights every input path before any source bytes are read.
-  host.swiftPackageWatchFiles(packagePath, undefined)
+  try {
+    host.swiftPackageWatchFiles(packagePath, undefined)
+  } catch (error) {
+    const { SwiftObjCCompilationError } = await import('../../src/swift-objc-compile')
+    if (!(error instanceof SwiftObjCCompilationError)) throw error
+    console.error(error.message)
+    host.disposeSwiftProject(packagePath)
+    return 1
+  }
   const packageName = path.basename(packagePath)
   const appInfo = host.swiftProjectAppInfo(packagePath)
   const guestSource = swiftGuestBundle(packageName)
-  let guest = guestSource
+  const withIdentity = (source: string) =>
+    appInfo.identity ? insertNativeAppIdentityFooter(source, appInfo.identity) : source
+  let guest = withIdentity(guestSource)
   const controller = new AbortController()
   const resources: OpenCommandResources = {}
   let metadata: (SwiftEntryModuleArgs & { hmrPath: string }) | null = null
@@ -192,7 +203,9 @@ export async function runSwift(
         try {
           const config = await loadRNXAppConfig(appProject)
           host.configureSwiftStandinBehavior(packagePath, config)
-          guest = await produceConfiguredBundle(guestSource, config, new Set())
+          guest = withIdentity(
+            await produceConfiguredBundle(guestSource, config, new Set()),
+          )
           const next = await host.swiftPackageMetadata(
             packagePath,
             packageName,
@@ -348,7 +361,8 @@ export async function runSwift(
     console.log(`  Swift preview host: ${origin}`)
     await refresh()
     controller.signal.throwIfAborted()
-    if (!metadata || compileError) throw new Error(compileError)
+    // refresh already printed the error
+    if (!metadata || compileError) return 1
     if (opts.device) openArgs.push('--device', opts.device)
     if (opts.driver) openArgs.push('--driver', opts.driver)
     if (opts.headless) openArgs.push('--headless')

package/cli/commands/three-mode.ts

@@ -6,6 +6,10 @@
 import { createHash } from 'node:crypto'
 import { mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs'
 import { dirname, extname, resolve } from 'node:path'
+import {
+  collectTimelineAssetRefs,
+  timelineAssetRefOf,
+} from 'peach-engine/screenshots/timeline-assets'
 import {
   isThreeModeSetting,
   THREE_MODE_SETTING_IDS,
@@ -353,44 +357,6 @@ function mimeTypeForAsset(path: string, contentType: unknown) {
 // timeline as blob: URLs.
 const TIMELINE_ASSET_CHUNK_BYTES = 1_048_576
 
-type TimelineAssetRef = {
-  src: string
-  recording: boolean
-}
-
-function timelineAssetRefOf(value: Record<string, unknown>): TimelineAssetRef | null {
-  if (
-    (value.type === 'recording' ||
-      value.type === 'screenshot' ||
-      value.kind === 'screen') &&
-    typeof value.src === 'string' &&
-    !/^(?:blob:|data:|https?:)/i.test(value.src)
-  ) {
-    return { src: value.src, recording: value.type === 'recording' }
-  }
-  return null
-}
-
-function collectTimelineAssetRefs(value: unknown): TimelineAssetRef[] {
-  const refs: TimelineAssetRef[] = []
-  const seen = new Set<string>()
-  const visit = (node: unknown): void => {
-    if (Array.isArray(node)) {
-      for (const entry of node) visit(entry)
-      return
-    }
-    if (!isRecord(node)) return
-    for (const entry of Object.values(node)) visit(entry)
-    const ref = timelineAssetRefOf(node)
-    if (ref && !seen.has(ref.src)) {
-      seen.add(ref.src)
-      refs.push(ref)
-    }
-  }
-  visit(value)
-  return refs
-}
-
 type DistinctTimelineAsset = {
   hash: string
   mime: string