Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
172 changes: 172 additions & 0 deletions src/lib/ai-edition/store/useTimeline.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -501,6 +501,178 @@ 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);
});

// 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();
});

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({
Expand Down
43 changes: 36 additions & 7 deletions src/lib/ai-edition/store/useTimeline.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -257,10 +264,11 @@ 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<Set<string>>(new Set());
const dimsProbeAttemptsRef = useRef<Map<string, number>>(new Map());
useEffect(() => {
if (!document) return;
const usedAssetIds = new Set(document.timeline.clips.map((c) => c.assetId));
Expand All @@ -278,7 +286,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,
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
);
if (missing.length === 0) return;
// No cleanup cancels this. The effect re-runs on EVERY document change, and a fresh
Expand All @@ -291,20 +300,40 @@ export function useTimeline() {
void (async () => {
type Dims = { width: number; height: number };
const probed: Record<string, { video?: Dims; camera?: Dims }> = {};
// 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);
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
// 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
Expand Down
Loading