diff --git a/src/lib/ai-edition/store/useTimeline.test.ts b/src/lib/ai-edition/store/useTimeline.test.ts index 3a8433ce9..229b8f8f4 100644 --- a/src/lib/ai-edition/store/useTimeline.test.ts +++ b/src/lib/ai-edition/store/useTimeline.test.ts @@ -501,6 +501,296 @@ describe("useTimeline backfills missing source dimensions on load", () => { expect(bridgeMocks.save).not.toHaveBeenCalled(); }); + // #1610: a long fragmented-MP4 take outlasted the 5 s probe, and that one failure was final + // for the session, so the editor stretched the picture. The backfill waits longer and + // tries again on a later document change. + it("waits longer than an insert probe and retries a failed probe on a later change", async () => { + probeVideoDimensionsMock.mockResolvedValueOnce(null); + const unprobed = { ...sampleDoc, assets: [{ ...sampleDoc.assets[0], video: undefined }] }; + useProjectStore.setState({ + projectId: "proj_test", + document: unprobed, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + await waitFor(() => expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(1)); + expect(probeVideoDimensionsMock.mock.calls[0][1]).toBeGreaterThanOrEqual(60_000); + await act(async () => { + await new Promise((r) => setTimeout(r, 0)); + }); + expect(bridgeMocks.save).not.toHaveBeenCalled(); + + act(() => { + useProjectStore.setState({ document: { ...unprobed, zoomRanges: [] }, revision: 2 }); + }); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(1)); + expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(2); + const saved = useProjectStore.getState().document?.assets.find((a) => a.id === "asset_1"); + expect(saved?.video).toMatchObject({ width: 1920, height: 1080 }); + }); + + it("stops probing an unreadable file after a bounded number of attempts", async () => { + probeVideoDimensionsMock.mockResolvedValue(null); + const unprobed = { ...sampleDoc, assets: [{ ...sampleDoc.assets[0], video: undefined }] }; + useProjectStore.setState({ + projectId: "proj_test", + document: unprobed, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + for (let revision = 2; revision < 8; revision++) { + await act(async () => { + await new Promise((r) => setTimeout(r, 0)); + }); + act(() => { + useProjectStore.setState({ document: { ...unprobed, zoomRanges: [] }, revision }); + }); + } + await act(async () => { + await new Promise((r) => setTimeout(r, 0)); + }); + expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(3); + expect(bridgeMocks.save).not.toHaveBeenCalled(); + }); + + // A successful probe whose save was deferred is not a failure: it must not use up the + // attempts, or a busy save queue would end the backfill for the session. + it("keeps retrying a successful probe whose save keeps timing out", async () => { + for (let i = 0; i < 3; i++) waitForDocumentSavesMock.mockResolvedValueOnce("timeout"); + const unprobed = { ...sampleDoc, assets: [{ ...sampleDoc.assets[0], video: undefined }] }; + useProjectStore.setState({ + projectId: "proj_test", + document: unprobed, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + for (let revision = 2; revision < 5; revision++) { + await waitFor(() => expect(waitForDocumentSavesMock).toHaveBeenCalledTimes(revision - 1)); + await act(async () => { + await new Promise((r) => setTimeout(r, 0)); + }); + act(() => { + useProjectStore.setState({ document: { ...unprobed, zoomRanges: [] }, revision }); + }); + } + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(1)); + expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(4); + }); + + it("retries a successful probe whose save failed on a later change", async () => { + bridgeMocks.save.mockResolvedValueOnce({ success: false, error: "disk full" }); + const unprobed = { ...sampleDoc, assets: [{ ...sampleDoc.assets[0], video: undefined }] }; + useProjectStore.setState({ + projectId: "proj_test", + document: unprobed, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(1)); + await act(async () => { + await new Promise((r) => setTimeout(r, 0)); + }); + act(() => { + useProjectStore.setState({ document: { ...unprobed, zoomRanges: [] }, revision: 2 }); + }); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(2)); + const saved = useProjectStore.getState().document?.assets.find((a) => a.id === "asset_1"); + expect(saved?.video).toMatchObject({ width: 1920, height: 1080 }); + }); + + // A save that never settles must not hold the batch chain, or the asset stays reserved and + // no later change ever probes it again. + it("releases a batch whose save never settles once the deadline passes", async () => { + vi.useFakeTimers({ shouldAdvanceTime: true }); + let settleHungSave!: () => void; + try { + bridgeMocks.save.mockImplementationOnce( + () => + new Promise((resolve) => { + settleHungSave = () => resolve({ success: false, error: "hung" }); + }), + ); + const unprobed = { ...sampleDoc, assets: [{ ...sampleDoc.assets[0], video: undefined }] }; + useProjectStore.setState({ + projectId: "proj_test", + document: unprobed, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(1)); + await act(async () => { + await vi.advanceTimersByTimeAsync(10_000); + }); + act(() => { + useProjectStore.setState({ document: { ...unprobed, zoomRanges: [] }, revision: 2 }); + }); + await waitFor(() => expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(2)); + // Settle it so the store's in-flight count does not leak into the next test. + await act(async () => { + settleHungSave(); + await vi.advanceTimersByTimeAsync(0); + }); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(2)); + } finally { + vi.useRealTimers(); + } + }); + + // A run started while an earlier asset is still probing must not take a later asset of + // the first batch: it would be probed twice. + it("does not probe a queued asset again from a run started while the batch is out", async () => { + let resolveFirst!: (dims: { width: number; height: number }) => void; + probeVideoDimensionsMock.mockImplementation((url: string) => + url.includes("first") + ? new Promise((resolve) => { + resolveFirst = resolve; + }) + : Promise.resolve({ width: 1280, height: 720 }), + ); + const first = { ...sampleDoc.assets[0], originalPath: "/tmp/first.webm", video: undefined }; + const second = { + ...sampleDoc.assets[0], + id: "asset_2", + originalPath: "/tmp/second.webm", + video: undefined, + }; + const twoAssets: AxcutDocument = { + ...sampleDoc, + assets: [first, second], + timeline: { + ...sampleDoc.timeline, + clips: [ + ...sampleDoc.timeline.clips, + { ...sampleDoc.timeline.clips[0], id: "clip_b", assetId: "asset_2" }, + ], + }, + }; + useProjectStore.setState({ + projectId: "proj_test", + document: twoAssets, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + await waitFor(() => expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(1)); + act(() => { + useProjectStore.setState({ document: { ...twoAssets, zoomRanges: [] }, revision: 2 }); + }); + await act(async () => { + resolveFirst({ width: 1920, height: 1080 }); + await new Promise((r) => setTimeout(r, 0)); + }); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(1)); + const secondCalls = probeVideoDimensionsMock.mock.calls.filter(([url]) => + String(url).includes("second"), + ); + expect(secondCalls).toHaveLength(1); + }); + + // toFileUrl throws on a path it cannot encode. That must count as one failed probe, not + // strand the batch: the readable asset after it still gets its dims saved. + it("still saves the rest of the batch when one path cannot be turned into a URL", async () => { + const broken = { + ...sampleDoc.assets[0], + originalPath: "/tmp/bad\uD800.webm", + video: undefined, + }; + const readable = { + ...sampleDoc.assets[0], + id: "asset_2", + originalPath: "/tmp/readable.webm", + video: undefined, + }; + useProjectStore.setState({ + projectId: "proj_test", + document: { + ...sampleDoc, + assets: [broken, readable], + timeline: { + ...sampleDoc.timeline, + clips: [ + ...sampleDoc.timeline.clips, + { ...sampleDoc.timeline.clips[0], id: "clip_b", assetId: "asset_2" }, + ], + }, + }, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(1)); + const assets = useProjectStore.getState().document?.assets; + expect(assets?.find((a) => a.id === "asset_2")?.video).toMatchObject({ width: 1920 }); + expect(assets?.find((a) => a.id === "asset_1")?.video).toBeUndefined(); + }); + + // Two batches that wait on the same save must not both build on the same document: the + // second save would drop the first one's dimensions while that asset stays marked probed. + it("keeps both batches' dimensions when their saves would overlap", async () => { + let releaseSaves!: () => void; + const saves = new Promise<"drained">((resolve) => { + releaseSaves = () => resolve("drained"); + }); + waitForDocumentSavesMock.mockImplementationOnce(() => saves); + waitForDocumentSavesMock.mockImplementationOnce(() => saves); + const second = { + ...sampleDoc.assets[0], + id: "asset_2", + originalPath: "/tmp/second.webm", + video: undefined, + }; + const doc: AxcutDocument = { + ...sampleDoc, + assets: [{ ...sampleDoc.assets[0], video: undefined }, second], + }; + useProjectStore.setState({ + projectId: "proj_test", + document: doc, + revision: 1, + status: "ready", + error: null, + }); + renderTimeline(); + await waitFor(() => expect(waitForDocumentSavesMock).toHaveBeenCalledTimes(1)); + // asset_2 enters the timeline while the first batch waits: a second batch probes it. + act(() => { + useProjectStore.setState({ + document: { + ...doc, + timeline: { + ...doc.timeline, + clips: [ + ...doc.timeline.clips, + { ...doc.timeline.clips[0], id: "clip_b", assetId: "asset_2" }, + ], + }, + }, + revision: 2, + }); + }); + await waitFor(() => expect(probeVideoDimensionsMock).toHaveBeenCalledTimes(2)); + await act(async () => { + await new Promise((r) => setTimeout(r, 0)); + releaseSaves(); + }); + await waitFor(() => expect(bridgeMocks.save).toHaveBeenCalledTimes(2)); + const assets = useProjectStore.getState().document?.assets; + expect(assets?.find((a) => a.id === "asset_1")?.video).toMatchObject({ width: 1920 }); + expect(assets?.find((a) => a.id === "asset_2")?.video).toMatchObject({ width: 1920 }); + }); + it("does not re-probe a used asset with no reachable file more than once", async () => { probeVideoDimensionsMock.mockResolvedValue(null); // probe fails (unreadable file) useProjectStore.setState({ diff --git a/src/lib/ai-edition/store/useTimeline.ts b/src/lib/ai-edition/store/useTimeline.ts index 32408cdb3..3171ac416 100644 --- a/src/lib/ai-edition/store/useTimeline.ts +++ b/src/lib/ai-edition/store/useTimeline.ts @@ -89,6 +89,13 @@ import { useSequentialTimelineOps } from "./useSequentialTimelineOps"; // these 2 s, which is what all five add* used to hardcode. const DEFAULT_NEW_REGION_SEC = 2; +// The on-load dimension backfill runs in the background, so it can wait far longer than an +// insert's 5 s probe. It has to: the Linux recorder writes fragmented MP4 with no index, and +// Chromium walks every fragment before `loadedmetadata`, which takes well past 5 s on a long +// take (#1610). A failure is retried on a later document change, a bounded number of times. +const DIMS_PROBE_TIMEOUT_MS = 60_000; +const DIMS_PROBE_ATTEMPTS = 3; + // NaN-guarded floors. Timeline inputs arrive from drag deltas and persisted // documents, both of which can carry NaN; every action needs the same guard. const finiteSec = (n: number) => (Number.isFinite(n) ? Math.max(0, n) : 0); @@ -257,10 +264,14 @@ export function useTimeline() { // cropped clip could show under ORIGINAL while an un-probed 16:9 sibling was missing entirely. // Probe once on load and persist via saveDocument with `history: false` (a write the user // never made must not be what the next Ctrl+Z reverses), so the fix sticks and every consumer - // agrees without each re-probing on its own (what the export dialog used to do). Attempt each - // asset at most once per session, even on failure, so a file that can't be probed doesn't - // spin the effect on every document change. + // agrees without each re-probing on its own (what the export dialog used to do). A failed + // probe is tried again on a later document change, up to DIMS_PROBE_ATTEMPTS per session, so + // one slow open is not final (#1610) and an unreadable file still doesn't spin the effect. const probedAssetIdsRef = useRef>(new Set()); + const dimsProbeAttemptsRef = useRef>(new Map()); + // Batches write one after another: two that waited on the same save would each re-read the + // same document, and the second save would drop the first one's dimensions. + const dimsWriteRef = useRef>(Promise.resolve()); useEffect(() => { if (!document) return; const usedAssetIds = new Set(document.timeline.clips.map((c) => c.assetId)); @@ -278,7 +289,8 @@ export function useTimeline() { (a) => usedAssetIds.has(a.id) && (needsScreen(a) || needsCamera(a)) && - !probedAssetIdsRef.current.has(a.id), + !probedAssetIdsRef.current.has(a.id) && + (dimsProbeAttemptsRef.current.get(a.id) ?? 0) < DIMS_PROBE_ATTEMPTS, ); if (missing.length === 0) return; // No cleanup cancels this. The effect re-runs on EVERY document change, and a fresh @@ -291,54 +303,86 @@ export function useTimeline() { void (async () => { type Dims = { width: number; height: number }; const probed: Record = {}; + // Reserve the whole batch before the first await: a run triggered while an earlier + // asset is still probing must not pick up a later one and probe it twice. + for (const a of missing) probedAssetIdsRef.current.add(a.id); + // A path toFileUrl cannot encode (a lone surrogate throws) is a failed probe, not a + // throw that skips the cleanup below and strands the whole reserved batch. + const probe = async (path: string) => { + try { + return await probeVideoDimensions(toFileUrl(path), DIMS_PROBE_TIMEOUT_MS); + } catch { + return null; + } + }; for (const a of missing) { - probedAssetIdsRef.current.add(a.id); const entry: { video?: Dims; camera?: Dims } = {}; + let failed = false; if (needsScreen(a)) { - const dims = await probeVideoDimensions(toFileUrl(a.originalPath)); + const dims = await probe(a.originalPath); if (dims) entry.video = dims; + else failed = true; } // Probed independently of the screen: one file being unreadable must not cost // the other its dimensions, and a camera-less asset simply skips this. if (a.cameraTrack && needsCamera(a)) { - const dims = await probeVideoDimensions(toFileUrl(a.cameraTrack.sourcePath)); + const dims = await probe(a.cameraTrack.sourcePath); if (dims) entry.camera = dims; + else failed = true; } if (entry.video || entry.camera) probed[a.id] = entry; + // Unmarked so a later document change retries what is still missing. Only a failed + // probe counts toward the limit: a save deferred below must stay retryable. + if (failed) { + probedAssetIdsRef.current.delete(a.id); + dimsProbeAttemptsRef.current.set(a.id, (dimsProbeAttemptsRef.current.get(a.id) ?? 0) + 1); + } } if (Object.keys(probed).length === 0) return; - // The store only takes a document once its save returns, so a write still in flight - // (the fresh-recording auto-zooms, typically) is invisible here. Building on the store - // before it lands and saving after it would erase it. Wait it out; on a timeout, - // write nothing and let a later run probe again. - if ((await waitForDocumentSaves()) === "timeout") { - for (const id of Object.keys(probed)) probedAssetIdsRef.current.delete(id); - return; - } - // Re-read fresh state so a concurrent edit made while probing isn't stomped. - const current = useProjectStore.getState().document; - if (!current || current.project.id !== originatingProjectId) return; - // `history: false` — see the comment above: a backfill nobody asked for must - // not become the thing the next Ctrl+Z reverses. - await useProjectStore.getState().saveDocument( - { - ...current, - assets: current.assets.map((a) => { - const found = probed[a.id]; - if (!found) return a; - return { - ...a, - ...(found.video - ? { video: { codec: "unknown", fps: 0, ...a.video, ...found.video } } - : {}), - ...(found.camera && a.cameraTrack - ? { cameraTrack: { ...a.cameraTrack, ...found.camera } } - : {}), - }; - }), - }, - { history: false }, - ); + dimsWriteRef.current = dimsWriteRef.current + .then(async () => { + // The store only takes a document once its save returns, so a write still in flight + // (the fresh-recording auto-zooms, typically) is invisible here. Building on the store + // before it lands and saving after it would erase it. Wait it out; on a timeout, + // write nothing and let a later run probe again. + if ((await waitForDocumentSaves()) === "timeout") { + for (const id of Object.keys(probed)) probedAssetIdsRef.current.delete(id); + return; + } + // Re-read fresh state so a concurrent edit made while probing isn't stomped. + const current = useProjectStore.getState().document; + if (!current || current.project.id !== originatingProjectId) return; + // `history: false` — see the comment above: a backfill nobody asked for must + // not become the thing the next Ctrl+Z reverses. + const saved = await saveWithDeadline( + useProjectStore.getState().saveDocument( + { + ...current, + assets: current.assets.map((a) => { + const found = probed[a.id]; + if (!found) return a; + return { + ...a, + ...(found.video + ? { video: { codec: "unknown", fps: 0, ...a.video, ...found.video } } + : {}), + ...(found.camera && a.cameraTrack + ? { cameraTrack: { ...a.cameraTrack, ...found.camera } } + : {}), + }; + }), + }, + { history: false }, + ), + ); + // A failed save (disk full, say), or one that never settles, leaves the dims unwritten: + // a later change retries them without counting a failed probe. The deadline keeps a + // hung save from stalling every batch queued behind it. + if (saved !== true) + for (const id of Object.keys(probed)) probedAssetIdsRef.current.delete(id); + }) + // A failed write must not stall the next batch. + .catch(() => undefined); })(); }, [document]);