videobook 0.0.0-stage → 0.2.0

package/dist/jobs/render-project.js

@@ -0,0 +1,380 @@
+import { findVideoFile } from "videobook-engine";
+import { copyFile, mkdir, stat, unlink } from "node:fs/promises";
+import { join, resolve, basename } from "node:path";
+import { renderMedia, selectComposition } from "@remotion/renderer";
+import { logger } from "../logger.js";
+import { registerJobHandler } from "../queue.js";
+import { probeVideo, runFfmpeg } from "../ffmpeg.js";
+import { withRemotionCancellation } from "../remotion-cancellation.js";
+import { renderBrowserExecutable } from "../remotion/browser.js";
+import { formatTimestamp, generateTimestamps } from "../frame-utils.js";
+import { parseSegments } from "../remotion/subtitles/segments.js";
+import { chunkSegments } from "../remotion/subtitles/chunker.js";
+import { requireApiKey } from "../api-key.js";
+import { buildIntelligenceResponses } from "../openai-intelligence.js";
+import { resolveOsgImagePath } from "../osg-assets.js";
+import { claimLockedLease } from "./_lease.js";
+import { ensureElevenLabsTranscript } from "./_transcribe.js";
+import { ingestWorkspaceOutputs } from "./_persist-output.js";
+import { iso1FromIso3, readLanguageCode, sidecarMatchesSource, translatedTranscriptFilename, translateTranscript, } from "./_translate-transcript.js";
+import { LANDSCAPE_WIDTH, LANDSCAPE_HEIGHT, PORTRAIT_WIDTH, PORTRAIT_HEIGHT, SQUARE_WIDTH, SQUARE_HEIGHT, } from "../remotion/constants.js";
+import { getSharedBundleLocation } from "../remotion/shared-bundle.js";
+import { DEFAULT_KEYWORD_GRAPHICS_LINGER_SECONDS, DEFAULT_KEYWORD_GRAPHICS_MAX_COUNT, parseKeywordTranscript, selectKeywordGraphics, selectRequestedKeywordGraphics, } from "../remotion/keyword-graphics.js";
+import { isKeywordPlacementCacheValid, keywordPlacementFingerprint, readKeywordPlacementAnalysis, } from "../keyword-placement-cache.js";
+import { resolveKeywordPlacements } from "../remotion/keyword-placement.js";
+import { aliveRenderTrack } from "../alive-captions/track.js";
+const LOCK_DURATION_MS = 1_800_000; // 30 min for renders
+const CLAIM_WAIT_MS = 30_000;
+// Lazy subtitle-language resolution: serve the cached translated sidecar when
+// it matches the current transcript, translate-and-cache when it doesn't, and
+// fall back to the original-language transcript on any translation failure —
+// a render must never fail because translation did.
+async function resolveSubtitleSegments(engine, assetId, raw, subtitleLanguage, signal) {
+    const sourceSegments = parseSegments(raw);
+    const sourceIso1 = iso1FromIso3(readLanguageCode(raw));
+    if (subtitleLanguage === "original" || subtitleLanguage === sourceIso1) {
+        return sourceSegments;
+    }
+    const sidecarFilename = translatedTranscriptFilename(subtitleLanguage);
+    const existing = await engine.files.read(assetId, sidecarFilename);
+    if (existing.ok) {
+        try {
+            const sidecar = JSON.parse(existing.value.toString());
+            if (sidecarMatchesSource(sidecar, sourceSegments)) {
+                return parseSegments(sidecar);
+            }
+        }
+        catch {
+            // unreadable sidecar — re-translate below
+        }
+    }
+    try {
+        const responses = buildIntelligenceResponses(requireApiKey("OPENAI_API_KEY"));
+        const sidecar = await translateTranscript(raw, subtitleLanguage, responses, signal);
+        const writeResult = await engine.files.write(assetId, sidecarFilename, JSON.stringify(sidecar, null, 2));
+        if (!writeResult.ok) {
+            logger.warn("subtitle-cache-failed", { assetId, error: writeResult.error });
+        }
+        return parseSegments(sidecar);
+    }
+    catch (err) {
+        logger.warn("subtitle-translation-failed", { assetId, error: err });
+        return sourceSegments;
+    }
+}
+function abortRace(signal) {
+    return new Promise((_, reject) => {
+        const fail = () => {
+            reject(signal.reason instanceof Error ? signal.reason : new Error("aborted"));
+        };
+        if (signal.aborted) {
+            fail();
+            return;
+        }
+        signal.addEventListener("abort", fail, { once: true });
+    });
+}
+export function registerRenderProjectJob(engine) {
+    registerJobHandler("render_project", async (payload, ctx) => {
+        ctx.signal.throwIfAborted();
+        const { orientation, assets, subtitlesEnabled, subtitleLanguage = "original", highlightStyle, position, fontSize, textColor, highlightColor, audioFadeIn, audioFadeOut, audioVolume, osgImagePath: payloadOsgImagePath, osgAssetId, osgPosition, osgSize, osgScale, osgOpacity, osgStartSeconds, osgEndSeconds, osgTailSeconds, keywordGraphicsEnabled = false, keywordGraphicsMaxCount = DEFAULT_KEYWORD_GRAPHICS_MAX_COUNT, keywordGraphicsLingerSeconds = DEFAULT_KEYWORD_GRAPHICS_LINGER_SECONDS, keywordGraphicsKeywords = null, backgroundMode, strokeWidth, strokeColor, shadowBlur, shadowOpacity, } = payload;
+        const bundleDir = await Promise.race([
+            getSharedBundleLocation(),
+            abortRace(ctx.signal),
+        ]);
+        ctx.signal.throwIfAborted();
+        const targetWidth = orientation === "portrait" ? PORTRAIT_WIDTH : orientation === "square" ? SQUARE_WIDTH : LANDSCAPE_WIDTH;
+        const targetHeight = orientation === "portrait" ? PORTRAIT_HEIGHT : orientation === "square" ? SQUARE_HEIGHT : LANDSCAPE_HEIGHT;
+        const outputFilename = orientation === "portrait"
+            ? "portrait.mp4"
+            : orientation === "square"
+                ? "square.mp4"
+                : "landscape.mp4";
+        // The stored-settings path (set_video_overlay → lazy render) carries only
+        // osgAssetId; resolve it to a file at run time so the overlay actually
+        // renders — and so the path survives file moves between enqueue and run.
+        let osgImagePath = payloadOsgImagePath;
+        if (!osgImagePath && osgAssetId) {
+            const resolved = await resolveOsgImagePath(engine, osgAssetId);
+            if (resolved.ok) {
+                osgImagePath = resolved.path;
+            }
+            else {
+                logger.warn("overlay-skipped", { assetId: osgAssetId, error: resolved.error });
+            }
+        }
+        // Copy OSG image into bundle dir once if provided
+        let osgCopyName = null;
+        let osgCopyPath = null;
+        if (osgImagePath) {
+            osgCopyName = `osg-project-${Date.now()}${basename(osgImagePath).replace(/^[^.]*/, "")}`;
+            osgCopyPath = join(bundleDir, osgCopyName);
+            await copyFile(resolve(osgImagePath), osgCopyPath);
+        }
+        const rendered = [];
+        const failed = [];
+        try {
+            for (const asset of assets) {
+                try {
+                    ctx.signal.throwIfAborted();
+                    const claim = await claimLockedLease(engine, asset.assetId, asset.assetDir, "render", { durationMs: LOCK_DURATION_MS, data: { state: `rendering-${orientation}` } }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: CLAIM_WAIT_MS, meta: { orientation } });
+                    if (!claim.ok) {
+                        failed.push({ assetId: asset.assetId, error: claim.reason });
+                        continue;
+                    }
+                    const lease = { ownerId: claim.ownerId };
+                    const heartbeat = setInterval(() => {
+                        try {
+                            engine.jobs.artifactWork.renew(asset.assetId, lease.ownerId, 60_000);
+                        }
+                        catch (error) {
+                            logger.warn("heartbeat-failed", { assetId: asset.assetId, error });
+                        }
+                    }, 20_000);
+                    let renderSucceeded = false;
+                    try {
+                        const probe = await probeVideo(asset.videoPath, { signal: ctx.signal });
+                        const durationInSeconds = probe.duration;
+                        const fps = Math.round(probe.fps) || 30;
+                        const durationInFrames = Math.max(1, Math.round(durationInSeconds * fps));
+                        // Detect the transcript at render time rather than trusting the
+                        // payload flag (captured at enqueue, before any auto-transcribe).
+                        // When subtitles are requested but no transcript exists yet,
+                        // transcribe inline under this asset's render lease.
+                        let allSegments = null;
+                        let rawTranscript = null;
+                        if ((subtitlesEnabled || keywordGraphicsEnabled) && !(await engine.files.read(asset.assetId, "elevenlabs.json")).ok) {
+                            await ensureElevenLabsTranscript(engine, asset.assetId);
+                        }
+                        const elevenlabsResult = await engine.files.read(asset.assetId, "elevenlabs.json");
+                        if (elevenlabsResult.ok) {
+                            rawTranscript = JSON.parse(elevenlabsResult.value.toString());
+                            allSegments = await resolveSubtitleSegments(engine, asset.assetId, rawTranscript, subtitleLanguage, ctx.signal);
+                        }
+                        let chunks = [];
+                        if (subtitlesEnabled && allSegments && highlightStyle !== "alive") {
+                            chunks = chunkSegments(allSegments, orientation, highlightStyle);
+                        }
+                        const alive = subtitlesEnabled && highlightStyle === "alive" && rawTranscript
+                            ? await aliveRenderTrack(engine, asset.assetId, {
+                                sourceWidth: probe.width,
+                                sourceHeight: probe.height,
+                                targetWidth,
+                                targetHeight,
+                            }, ctx.signal)
+                            : null;
+                        const keywordSegments = rawTranscript ? parseKeywordTranscript(rawTranscript) : [];
+                        const selectedKeywordGraphics = keywordGraphicsEnabled && rawTranscript
+                            ? keywordGraphicsKeywords?.length
+                                ? selectRequestedKeywordGraphics(keywordSegments, keywordGraphicsKeywords, {
+                                    lingerSeconds: keywordGraphicsLingerSeconds,
+                                }).graphics
+                                : selectKeywordGraphics(keywordSegments, {
+                                    maxCount: keywordGraphicsMaxCount,
+                                    lingerSeconds: keywordGraphicsLingerSeconds,
+                                })
+                            : [];
+                        let keywordGraphics = selectedKeywordGraphics;
+                        let keywordGraphicsSkipped = [];
+                        let keywordGraphicsPlacementFingerprint = null;
+                        if (keywordGraphicsEnabled && rawTranscript && elevenlabsResult.ok) {
+                            const manifestResult = await engine.files.manifest(asset.assetId);
+                            if (!manifestResult.ok)
+                                throw new Error(manifestResult.error.message);
+                            const sourceVideoFile = findVideoFile(manifestResult.value.files);
+                            if (!sourceVideoFile)
+                                throw new Error(`No source video found for ${asset.assetId}`);
+                            const fingerprint = keywordPlacementFingerprint(sourceVideoFile, elevenlabsResult.value, selectedKeywordGraphics);
+                            const analysis = await readKeywordPlacementAnalysis(engine, asset.assetId);
+                            const valid = await isKeywordPlacementCacheValid(engine, asset.assetId, analysis, fingerprint, selectedKeywordGraphics);
+                            if (!analysis || !valid) {
+                                throw new Error(`Face-safe keyword placement is missing or stale for ${asset.assetId}. Run /keywords @${asset.assetId} again.`);
+                            }
+                            const resolved = resolveKeywordPlacements(selectedKeywordGraphics, analysis, orientation, {
+                                subtitlesEnabled,
+                                subtitlePosition: position,
+                                subtitleStyle: highlightStyle,
+                                subtitleFontSize: fontSize,
+                            });
+                            keywordGraphics = resolved.graphics;
+                            keywordGraphicsSkipped = resolved.skipped;
+                            keywordGraphicsPlacementFingerprint = analysis.fingerprint;
+                        }
+                        // Copy video into bundle dir
+                        const videoCopyName = `source-${asset.assetId}-${Date.now()}${basename(asset.videoPath).replace(/^[^.]*/, "")}`;
+                        const videoCopyPath = join(bundleDir, videoCopyName);
+                        await copyFile(resolve(asset.videoPath), videoCopyPath);
+                        try {
+                            const inputProps = {
+                                videoSrc: videoCopyName,
+                                targetWidth,
+                                targetHeight,
+                                sourceWidth: probe.width,
+                                sourceHeight: probe.height,
+                                durationInFrames,
+                                fps,
+                                subtitlesEnabled,
+                                chunks,
+                                style: highlightStyle,
+                                position,
+                                fontSize,
+                                textColor,
+                                highlightColor,
+                                audioFadeIn,
+                                audioFadeOut,
+                                audioVolume,
+                                osgSrc: osgCopyName,
+                                osgPosition: osgPosition ?? "top-right",
+                                osgSize: osgSize ?? "medium",
+                                osgScale: osgScale ?? 1,
+                                osgOpacity: osgOpacity ?? 1,
+                                osgStartSeconds: osgStartSeconds ?? null,
+                                osgEndSeconds: osgEndSeconds ?? null,
+                                osgTailSeconds: osgTailSeconds ?? null,
+                                keywordGraphics,
+                                backgroundMode,
+                                strokeWidth,
+                                strokeColor,
+                                shadowBlur,
+                                shadowOpacity,
+                                aliveCues: alive?.cues ?? [],
+                                aliveSettings: alive?.settings ?? null,
+                            };
+                            const outputPath = join(asset.assetDir, outputFilename);
+                            const browserExecutable = await renderBrowserExecutable();
+                            const composition = await selectComposition({
+                                serveUrl: bundleDir,
+                                id: "render",
+                                inputProps: inputProps,
+                                timeoutInMilliseconds: 60_000,
+                                ...(browserExecutable ? { browserExecutable } : {}),
+                            });
+                            ctx.signal.throwIfAborted();
+                            await withRemotionCancellation(ctx.signal, (cancelSignal) => renderMedia({
+                                composition,
+                                serveUrl: bundleDir,
+                                codec: "h264",
+                                outputLocation: outputPath,
+                                inputProps: inputProps,
+                                videoBitrate: "8M",
+                                concurrency: 1,
+                                hardwareAcceleration: "if-possible",
+                                cancelSignal,
+                                ...(browserExecutable ? { browserExecutable } : {}),
+                            }));
+                            // Extract first frame as {orientation}.jpg
+                            const jpgFilename = outputFilename.replace(".mp4", ".jpg");
+                            const jpgPath = join(asset.assetDir, jpgFilename);
+                            try {
+                                await runFfmpeg(["-y", "-i", outputPath, "-frames:v", "1", "-q:v", "2", jpgPath], { signal: ctx.signal });
+                            }
+                            catch {
+                                ctx.signal.throwIfAborted();
+                            }
+                            // Extract orientation frames at timestamps
+                            const orientFramesDirName = `${orientation}_frames`;
+                            const orientFramesDir = join(asset.assetDir, orientFramesDirName);
+                            try {
+                                await mkdir(orientFramesDir, { recursive: true });
+                                const timestamps = generateTimestamps(durationInSeconds);
+                                for (const ts of timestamps) {
+                                    const framePath = join(orientFramesDir, `${formatTimestamp(ts)}.jpg`);
+                                    try {
+                                        await runFfmpeg([
+                                            "-y", "-i", outputPath,
+                                            "-ss", String(ts),
+                                            "-frames:v", "1",
+                                            "-q:v", "2",
+                                            "-strict", "unofficial",
+                                            framePath,
+                                        ], { signal: ctx.signal });
+                                    }
+                                    catch {
+                                        ctx.signal.throwIfAborted();
+                                    }
+                                }
+                            }
+                            catch {
+                                ctx.signal.throwIfAborted();
+                            }
+                            const renderedPaths = [outputFilename];
+                            if ((await stat(jpgPath).catch(() => null))?.isFile()) {
+                                renderedPaths.push(jpgFilename);
+                            }
+                            if ((await stat(orientFramesDir).catch(() => null))?.isDirectory()) {
+                                renderedPaths.push(orientFramesDirName);
+                            }
+                            await ingestWorkspaceOutputs(engine, asset.assetId, renderedPaths, "render", { orientation });
+                            const renderSettings = {
+                                subtitlesEnabled,
+                                subtitleLanguage,
+                                highlightStyle,
+                                position,
+                                fontSize,
+                                textColor,
+                                highlightColor,
+                                audioFadeIn,
+                                audioFadeOut,
+                                audioVolume,
+                                backgroundMode,
+                                strokeWidth,
+                                strokeColor,
+                                shadowBlur,
+                                shadowOpacity,
+                                aliveSettings: alive?.settings ?? null,
+                                osgImagePath: osgImagePath ?? undefined,
+                                osgAssetId: osgAssetId ?? undefined,
+                                osgPosition,
+                                osgSize,
+                                osgScale: osgScale ?? 1,
+                                osgOpacity: osgOpacity ?? 1,
+                                osgStartSeconds: osgStartSeconds ?? null,
+                                osgEndSeconds: osgEndSeconds ?? null,
+                                osgTailSeconds: osgTailSeconds ?? null,
+                                keywordGraphicsEnabled,
+                                keywordGraphicsMaxCount,
+                                keywordGraphicsLingerSeconds,
+                                keywordGraphicsKeywords,
+                                keywordGraphicsPlacementFingerprint,
+                                keywordGraphicsSkipped,
+                                renderedAt: new Date().toISOString(),
+                                outputs: [outputFilename, jpgFilename, orientFramesDirName],
+                            };
+                            await engine.metadata.artifacts.write(asset.assetId, `${orientation}.render`, renderSettings);
+                            rendered.push(asset.assetId);
+                            renderSucceeded = true;
+                        }
+                        finally {
+                            await unlink(videoCopyPath).catch(() => { });
+                        }
+                    }
+                    finally {
+                        clearInterval(heartbeat);
+                        if (renderSucceeded) {
+                            await engine.jobs.artifactWork.complete(asset.assetId, lease.ownerId);
+                        }
+                        else {
+                            await engine.jobs.artifactWork.fail(asset.assetId, lease.ownerId, {
+                                message: "render failed",
+                            });
+                        }
+                        await engine.jobs.locks.release(asset.assetDir);
+                    }
+                }
+                catch (err) {
+                    if (ctx.signal.aborted)
+                        throw err;
+                    failed.push({ assetId: asset.assetId, error: err instanceof Error ? err.message : String(err) });
+                }
+            }
+        }
+        finally {
+            if (osgCopyPath)
+                await unlink(osgCopyPath).catch(() => { });
+        }
+        if (rendered.length === 0 && failed.length > 0) {
+            throw new Error(`Render failed: ${failed.map((f) => `${f.assetId}: ${f.error}`).join("; ")}`);
+        }
+        return { success: failed.length === 0, rendered, failed };
+    });
+}

package/dist/jobs/render-qr-outro.js

@@ -0,0 +1,138 @@
+import { mkdtemp, readFile as readNodeFile, rm, unlink, writeFile as writeNodeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import { renderMedia, selectComposition } from "@remotion/renderer";
+import { registerJobHandler } from "../queue.js";
+import { buildOutroSpec, } from "../remotion/qr-outro-spec.js";
+import { DEFAULT_QR_OUTRO_SOUND_FILENAME } from "../remotion/qr-outro-audio.js";
+import { renderBrowserExecutable } from "../remotion/browser.js";
+import { getSharedBundleLocation } from "../remotion/shared-bundle.js";
+import { withRemotionCancellation } from "../remotion-cancellation.js";
+import { withLockedLocalLease } from "./_lease.js";
+import { processVideoFiles } from "./process-video.js";
+const LOCK_DURATION_MS = 15 * 60_000;
+async function stageAssetFile(engine, ref, bundleDir, stem) {
+    const read = await engine.files.read(ref.assetId, ref.filename);
+    if (!read.ok) {
+        throw new Error(`Failed to read ${ref.assetId}/${ref.filename}: ${read.error.message}`);
+    }
+    const filename = `${stem}${extname(ref.filename).toLowerCase()}`;
+    const path = join(bundleDir, filename);
+    await writeNodeFile(path, read.value);
+    return { filename, path };
+}
+function assertWrite(operation, result) {
+    if (!result.ok)
+        throw new Error(`${operation}: ${result.error.message}`);
+}
+export function registerRenderQrOutroJob(engine) {
+    registerJobHandler("render_qr_outro", async (payload, ctx) => {
+        ctx.signal.throwIfAborted();
+        const { bookId, assetId, orientation, qrImages, soundEffect, aspectRatio, durationSeconds, includeAudio = true, } = payload;
+        const outputManifest = await engine.files.manifest(assetId);
+        if (!outputManifest.ok) {
+            throw new Error(`Failed to resolve output asset: ${outputManifest.error.message}`);
+        }
+        const bundleDir = await getSharedBundleLocation();
+        ctx.signal.throwIfAborted();
+        const stagedPaths = [];
+        const tempDir = await mkdtemp(join(tmpdir(), "videocity-qr-outro-"));
+        try {
+            await withLockedLocalLease(engine, assetId, outputManifest.value.path, ctx, "render", {
+                durationMs: LOCK_DURATION_MS,
+                data: { state: `rendering-qr-outro-${orientation}` },
+            }, async () => {
+                ctx.signal.throwIfAborted();
+                const nonce = `${assetId}-${Date.now()}`;
+                const qrSrcs = [];
+                for (let index = 0; index < qrImages.length; index += 1) {
+                    ctx.signal.throwIfAborted();
+                    const qr = await stageAssetFile(engine, qrImages[index], bundleDir, `qr-outro-code-${nonce}-${index}`);
+                    stagedPaths.push(qr.path);
+                    qrSrcs.push(qr.filename);
+                }
+                let audioSrc = null;
+                if (includeAudio && soundEffect) {
+                    const audio = await stageAssetFile(engine, soundEffect, bundleDir, `qr-outro-audio-${nonce}`);
+                    stagedPaths.push(audio.path);
+                    audioSrc = audio.filename;
+                }
+                const inputProps = {
+                    qrSrcs,
+                    audioSrc,
+                    aspectRatio,
+                    durationSeconds: durationSeconds ?? null,
+                    includeAudio,
+                };
+                const browserExecutable = await renderBrowserExecutable();
+                const composition = await selectComposition({
+                    serveUrl: bundleDir,
+                    id: "qr-outro",
+                    inputProps: inputProps,
+                    timeoutInMilliseconds: 60_000,
+                    ...(browserExecutable ? { browserExecutable } : {}),
+                });
+                ctx.signal.throwIfAborted();
+                const tempOutputPath = join(tempDir, "original.mp4");
+                await withRemotionCancellation(ctx.signal, (cancelSignal) => renderMedia({
+                    composition,
+                    serveUrl: bundleDir,
+                    codec: "h264",
+                    audioCodec: "aac",
+                    muted: !includeAudio,
+                    outputLocation: tempOutputPath,
+                    inputProps: inputProps,
+                    videoBitrate: "8M",
+                    concurrency: 1,
+                    hardwareAcceleration: "if-possible",
+                    cancelSignal,
+                    ...(browserExecutable ? { browserExecutable } : {}),
+                }));
+                const output = await readNodeFile(tempOutputPath);
+                assertWrite(`Failed to write ${assetId}/original.mp4`, await engine.files.write(assetId, "original.mp4", output));
+                const spec = buildOutroSpec(aspectRatio, qrImages.length, durationSeconds);
+                const provenance = {
+                    origin: "create_qr_outro",
+                    qr_image_refs: qrImages.map((image) => image.assetId),
+                    sound_effect_ref: includeAudio ? soundEffect?.assetId ?? null : null,
+                    sound_effect_source: includeAudio
+                        ? soundEffect ? "asset" : "bundled_default"
+                        : "none",
+                    sound_effect_filename: includeAudio
+                        ? soundEffect?.filename ?? DEFAULT_QR_OUTRO_SOUND_FILENAME
+                        : null,
+                    include_audio: includeAudio,
+                    aspect_ratio: aspectRatio,
+                    fps: spec.fps,
+                    duration_seconds: spec.totalDurationSeconds,
+                    impact_frames: spec.impacts.map((impact) => impact.frame),
+                    rendered_at: new Date().toISOString(),
+                };
+                const metadata = await engine.metadata.artifacts.write(assetId, "qr-outro", provenance);
+                if (!metadata.ok) {
+                    throw new Error(`Failed to write QR outro metadata: ${metadata.error.message}`);
+                }
+                await processVideoFiles(engine, {
+                    type: "process_video",
+                    videoPath: join(outputManifest.value.path, "original.mp4"),
+                    assetId,
+                    assetDir: outputManifest.value.path,
+                    bookId,
+                    provenance,
+                    skipDownstreamJobs: true,
+                }, ctx.signal);
+                return { provenance };
+            }, {
+                durationMs: LOCK_DURATION_MS,
+                waitForActiveMs: 30_000,
+                meta: { orientation },
+            });
+            ctx.signal.throwIfAborted();
+            return { success: true, assetId };
+        }
+        finally {
+            await Promise.all(stagedPaths.map((path) => unlink(path).catch(() => undefined)));
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    });
+}