videobook 0.0.0-stage → 0.2.0

package/dist/jobs/process-video.js

@@ -0,0 +1,438 @@
+import { basename, dirname, extname, join } from "node:path";
+import { copyFile, mkdir, mkdtemp, readFile as fsReadFile, rm, writeFile as fsWriteFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { enqueueAssetTagging } from "./tag-asset.js";
+import { logger } from "../logger.js";
+import { registerJobHandler, queue } from "../queue.js";
+import { withLocalLease } from "./_lease.js";
+import { enqueueLazyAnalysisIfSlotted } from "../lazy-render.js";
+import { probeVideo, runFfmpeg, extractWaveform, isThumbnailBlank, H264_MEDIUM, AUDIO_OPTS, } from "../ffmpeg.js";
+import { formatTimestamp, generateTimestamps } from "../frame-utils.js";
+import { ingestWorkspaceOutputs } from "./_persist-output.js";
+import { getApiKey } from "../api-key.js";
+import { withTransientStorageRetry } from "./_storage-retry.js";
+import { videoProxyMetadata, videoProxyValidationError, } from "../video-proxy.js";
+export function planVideoTranscriptJobs(input) {
+    if (input.skipDownstreamJobs || !input.hasAudio)
+        return [];
+    const jobs = [];
+    if (input.hasOpenAiKey) {
+        jobs.push({
+            jobId: `transcribe-openai-${input.assetId}-${input.identity}`,
+            payload: {
+                type: "transcribe_video_audio",
+                videoPath: join(input.assetDir, input.videoFilename),
+                assetId: input.assetId,
+                assetDir: input.assetDir,
+                bookId: input.bookId,
+                sourceFilename: "original.mp3",
+                mediaRevision: input.identity,
+            },
+        });
+    }
+    if (input.hasElevenLabsKey) {
+        jobs.push({
+            jobId: `transcribe-elevenlabs-${input.assetId}-${input.identity}`,
+            payload: {
+                type: "transcribe",
+                audioPath: join(input.assetDir, "original.mp3"),
+                audioFilename: "original.mp3",
+                tagAudioEvents: true,
+                diarize: true,
+                assetId: input.assetId,
+                assetDir: input.assetDir,
+                bookId: input.bookId,
+            },
+        });
+    }
+    return jobs;
+}
+async function enqueueVideoTranscriptJobs(jobs) {
+    for (const job of jobs) {
+        try {
+            await queue.enqueue(job.jobId, job.payload);
+        }
+        catch (err) {
+            logger.warn("process-video-enqueue-failed", { jobType: job.payload.type, error: err });
+        }
+    }
+}
+async function videoTranscriptIdentity(engine, assetId, videoFilename) {
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok)
+        return String(Date.now());
+    const file = manifest.value.files.find((entry) => entry.name === videoFilename)
+        ?? manifest.value.files.find((entry) => entry.name === "original.mp4")
+        ?? manifest.value.files.find((entry) => entry.name === "original.mp3");
+    return file?.objectHash ?? String(Date.now());
+}
+// Write a derived binary file, skipping the write when the bytes are unchanged.
+//
+// The engine commits each write scoped to that file's path. A scoped
+// `git commit -- <path>` with no diff exits non-zero ("nothing to commit" on
+// stdout, empty stderr) whenever the rest of the tree is dirty — which it is
+// on a force re-process, since we just deleted original.jpg + frames. Audio is
+// stream-copied during watermarking, so re-extracting original.mp3 yields bytes
+// identical to the already-committed file; the scoped commit then finds nothing
+// and the engine surfaces a bare "Failed to commit file write:". Skipping the
+// no-op write lets idempotent re-processing succeed. Mirrors
+// writePlanFileIfChanged in plan-notebook.ts.
+async function writeBinaryIfChanged(engine, assetId, filename, data) {
+    const existing = await engine.files.read(assetId, filename);
+    if (existing.ok && existing.value.equals(data))
+        return;
+    const written = await engine.files.write(assetId, filename, data);
+    if (!written.ok) {
+        throw new Error(`writeFile ${filename} failed for ${assetId}: ${written.error.message}`);
+    }
+}
+export async function registerMediaStreams(engine, assetId, sourcePath, probe) {
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok) {
+        throw new Error(`Failed to read media manifest for ${assetId}: ${manifest.error.message}`);
+    }
+    const objectHash = manifest.value.files.find((file) => file.name === sourcePath)?.objectHash;
+    if (!objectHash)
+        throw new Error(`Media source is missing from the manifest: ${sourcePath}`);
+    for (const stream of [probe.videoStream, probe.audioStream]) {
+        if (!stream)
+            continue;
+        const registered = await engine.streams.register({
+            artifactId: assetId,
+            sourcePath,
+            objectHash,
+            streamIndex: stream.index,
+            kind: stream.video ? "video" : "audio",
+            timeBase: stream.timeBase,
+            durationTicks: stream.durationTicks,
+            codec: stream.codec,
+            ...(stream.video ? { video: stream.video } : {}),
+            ...(stream.audio ? { audio: stream.audio } : {}),
+        });
+        if (!registered.ok) {
+            throw new Error(`Failed to register media stream for ${assetId}: ${registered.error.message}`);
+        }
+    }
+}
+async function snapshotAssetFile(engine, assetId, filename, targetPath) {
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok) {
+        throw new Error(`Failed to read media manifest for ${assetId}: ${manifest.error.message}`);
+    }
+    if (!manifest.value.files.some((file) => file.name === filename))
+        return false;
+    const snapshot = await engine.files.readAtRevision(manifest.value.artifactId, filename, engine.head);
+    if (!snapshot.ok) {
+        throw new Error(`Failed to read immutable ${filename} for ${assetId}: ${snapshot.error.message}`);
+    }
+    await fsWriteFile(targetPath, snapshot.value);
+    return true;
+}
+async function persistProxyMetadata(engine, assetId, sourceFilename, proxy) {
+    const manifest = await engine.files.manifest(assetId);
+    if (!manifest.ok) {
+        throw new Error(`Failed to read media manifest for ${assetId}: ${manifest.error.message}`);
+    }
+    const sourceFile = manifest.value.files.find((file) => file.name === sourceFilename);
+    const proxyFile = manifest.value.files.find((file) => file.name === "proxy.mp4");
+    if (!sourceFile || !proxyFile) {
+        throw new Error(`Failed to record video proxy metadata for ${assetId}`);
+    }
+    const written = await engine.metadata.artifacts.write(assetId, "proxy", videoProxyMetadata(sourceFile, proxyFile, proxy));
+    if (!written.ok) {
+        throw new Error(`Failed to record video proxy metadata for ${assetId}: ${written.error.message}`);
+    }
+}
+export async function processVideoFiles(engine, payload, signal) {
+    const sourceWorkspace = await mkdtemp(join(tmpdir(), "videobook-source-"));
+    const sourceFilename = basename(payload.videoPath);
+    const sourcePath = join(sourceWorkspace, sourceFilename);
+    try {
+        if (!await snapshotAssetFile(engine, payload.assetId, sourceFilename, sourcePath)) {
+            await copyFile(payload.videoPath, sourcePath);
+        }
+        return await processVideoSnapshot(engine, { ...payload, videoPath: sourcePath }, signal);
+    }
+    finally {
+        await rm(sourceWorkspace, { recursive: true, force: true });
+    }
+}
+async function processVideoSnapshot(engine, payload, signal) {
+    const { videoPath, assetId, assetDir, bookId, provenance, force, skipDownstreamJobs, preserveAudioArtifacts, reviveVisualAnalysis, } = payload;
+    signal?.throwIfAborted();
+    const probe = await probeVideo(videoPath, { signal });
+    if (probe.videoCodec === null || probe.width <= 0 || probe.height <= 0) {
+        throw new Error(`process_video requires a video stream: ${assetId}`);
+    }
+    const { width, height, duration } = probe;
+    const sourceFilename = basename(videoPath);
+    const importedSource = await engine.files.writeFromPath(assetId, sourceFilename, videoPath);
+    if (!importedSource.ok) {
+        throw new Error(`Failed to persist source video ${sourceFilename}: ${importedSource.error.message}`);
+    }
+    // Generate original.mp4 alongside non-mp4 uploads so downstream consumers
+    // (browser <video>, ffmpeg jobs, transcribe) get a canonical container.
+    // The source file (original.mkv / .mov / etc.) stays on disk as the
+    // archival truth — only the derived mp4 is fresh work.
+    let activeVideoPath = videoPath;
+    const sourceExt = extname(videoPath).toLowerCase();
+    if (sourceExt !== ".mp4") {
+        const tempPath = join(dirname(videoPath), "canonical.mp4");
+        // Explicit -map drops subtitle/data/attachment streams that the mp4
+        // muxer can't handle (e.g. subrip from MKV rips), which would otherwise
+        // fail the whole transcode. Also pin to the first audio track so files
+        // with multiple language tracks pick a deterministic stream.
+        //
+        // Stream-copy when the source codec is already mp4-compatible (h264
+        // video, aac audio). For a 10-min h264 mkv this turns a multi-minute
+        // re-encode into a few-second remux. Fall back to libx264 / aac for
+        // anything else (hevc, vp9, dts, opus, etc).
+        const canCopyVideo = probe.videoCodec === "h264";
+        const canCopyAudio = probe.audioCodec === "aac";
+        const videoArgs = canCopyVideo ? ["-c:v", "copy"] : H264_MEDIUM;
+        const audioArgs = !probe.hasAudio
+            ? ["-an"]
+            : canCopyAudio
+                ? ["-c:a", "copy"]
+                : AUDIO_OPTS;
+        const transcodeArgs = [
+            "-y",
+            "-i", videoPath,
+            "-map", "0:v:0",
+            ...(probe.hasAudio ? ["-map", "0:a:0"] : []),
+            ...videoArgs,
+            ...audioArgs,
+            "-movflags", "+faststart",
+            "-f", "mp4",
+            tempPath,
+        ];
+        await runFfmpeg(transcodeArgs, { signal });
+        const mp4Buf = await fsReadFile(tempPath);
+        await writeBinaryIfChanged(engine, assetId, "original.mp4", mp4Buf);
+        activeVideoPath = tempPath;
+    }
+    const activeSourcePath = sourceExt === ".mp4" ? sourceFilename : "original.mp4";
+    const activeProbe = sourceExt === ".mp4" ? probe : await probeVideo(activeVideoPath, { signal });
+    await registerMediaStreams(engine, assetId, activeSourcePath, activeProbe);
+    let frameCount = 0;
+    {
+        await engine.metadata.artifacts.write(assetId, "original", { ...provenance, width, height, duration, fps: probe.fps, hasAudio: probe.hasAudio });
+        if (duration <= 0)
+            return { success: true, width, height, duration, frame_count: 0 };
+        if (force) {
+            const currentManifest = await engine.files.manifest(assetId);
+            if (currentManifest.ok) {
+                const staleFiles = currentManifest.value.files
+                    .map((file) => file.name)
+                    .filter((filename) => filename === "original.jpg" ||
+                    filename === "proxy.mp4" ||
+                    filename.startsWith("original_frames/") ||
+                    ["landscape", "portrait", "square"].some((orientation) => filename === `${orientation}.mp4` ||
+                        filename === `${orientation}.jpg` ||
+                        filename.startsWith(`${orientation}_frames/`)));
+                for (const filename of staleFiles) {
+                    await engine.files.delete(assetId, filename);
+                }
+            }
+            await rm(join(assetDir, "original_frames"), { recursive: true, force: true });
+            await rm(join(assetDir, "original.jpg"), { force: true }).catch(() => { });
+            // Renders are derived from the old source video — drop them so the UI
+            // falls back to original.mp4 and prompts a re-render.
+            for (const orient of ["landscape", "portrait", "square"]) {
+                await rm(join(assetDir, `${orient}.mp4`), { force: true }).catch(() => { });
+                await rm(join(assetDir, `${orient}.jpg`), { force: true }).catch(() => { });
+                await rm(join(assetDir, `${orient}_frames`), { recursive: true, force: true }).catch(() => { });
+                await engine.metadata.artifacts.delete(assetId, `${orient}.render`);
+            }
+            await engine.metadata.artifacts.delete(assetId, "proxy");
+        }
+        const proxyWorkspace = await mkdtemp(join(tmpdir(), "videobook-proxy-"));
+        const proxyPath = join(proxyWorkspace, "proxy.mp4");
+        try {
+            let proxyProbe = null;
+            if (await snapshotAssetFile(engine, assetId, "proxy.mp4", proxyPath)) {
+                try {
+                    const candidate = await probeVideo(proxyPath, { signal });
+                    if (videoProxyValidationError(activeProbe, candidate) === null) {
+                        proxyProbe = candidate;
+                    }
+                }
+                catch {
+                    proxyProbe = null;
+                }
+            }
+            if (!proxyProbe) {
+                const currentManifest = await engine.files.manifest(assetId);
+                if (!currentManifest.ok) {
+                    throw new Error(`Failed to read media manifest for ${assetId}: ${currentManifest.error.message}`);
+                }
+                if (currentManifest.value.files.some((file) => file.name === "proxy.mp4")) {
+                    const deleted = await engine.files.delete(assetId, "proxy.mp4");
+                    if (!deleted.ok)
+                        throw new Error(deleted.error.message);
+                }
+                await engine.metadata.artifacts.delete(assetId, "proxy");
+                const proxySourcePath = join(proxyWorkspace, `source${extname(activeSourcePath)}`);
+                if (!await snapshotAssetFile(engine, assetId, activeSourcePath, proxySourcePath)) {
+                    throw new Error(`Media source is missing from the manifest: ${activeSourcePath}`);
+                }
+                const proxyArgs = (fpsMode) => [
+                    "-y",
+                    "-i", proxySourcePath,
+                    ...fpsMode,
+                    "-map", "0:v:0",
+                    ...(activeProbe.hasAudio ? ["-map", "0:a:0"] : []),
+                    "-vf",
+                    "scale=1280:720:force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2",
+                    "-c:v", "libx264",
+                    "-preset", "veryfast",
+                    "-crf", "28",
+                    "-pix_fmt", "yuv420p",
+                    ...(activeProbe.hasAudio ? AUDIO_OPTS : ["-an"]),
+                    "-movflags", "+faststart",
+                    proxyPath,
+                ];
+                // Passthrough keeps the source's exact frame timing — retimed
+                // (change_video_speed) and VFR sources would otherwise be resampled
+                // back onto the nominal frame grid, dropping frames and drifting the
+                // proxy away from the canonical duration. Fall back to the default
+                // sync mode for sources whose timestamps the muxer rejects.
+                try {
+                    await runFfmpeg(proxyArgs(["-fps_mode:v", "passthrough"]), { signal });
+                }
+                catch {
+                    await runFfmpeg(proxyArgs([]), { signal });
+                }
+                const candidate = await probeVideo(proxyPath, { signal });
+                const validationError = videoProxyValidationError(activeProbe, candidate);
+                if (validationError) {
+                    throw new Error(`Invalid video proxy for ${assetId}: ${validationError}`);
+                }
+                const proxy = await engine.files.writeFromPath(assetId, "proxy.mp4", proxyPath);
+                if (!proxy.ok)
+                    throw new Error(proxy.error.message);
+                proxyProbe = candidate;
+            }
+            await persistProxyMetadata(engine, assetId, activeSourcePath, proxyProbe);
+        }
+        finally {
+            await rm(proxyWorkspace, { recursive: true, force: true });
+        }
+        const timestamps = generateTimestamps(duration);
+        frameCount = timestamps.length;
+        const framesDir = join(assetDir, "original_frames");
+        await mkdir(framesDir, { recursive: true });
+        for (const ts of timestamps) {
+            const framePath = join(framesDir, `${formatTimestamp(ts)}.jpg`);
+            try {
+                await runFfmpeg([
+                    "-y",
+                    "-ss", String(ts),
+                    "-i", activeVideoPath,
+                    "-frames:v", "1",
+                    "-q:v", "2",
+                    "-strict", "unofficial",
+                    framePath,
+                ], { signal });
+            }
+            catch {
+                // frame extraction failure is non-fatal
+            }
+        }
+        // Extract original.mp3 from the video (kept in sync with original.mp4 so
+        // standalone audio reads — timeline, transcription — match the source).
+        const existingMp3 = preserveAudioArtifacts
+            ? await engine.files.read(assetId, "original.mp3")
+            : null;
+        if (probe.hasAudio && (!existingMp3 || !existingMp3.ok)) {
+            const mp3TempPath = join(assetDir, "original.mp3.tmp");
+            await runFfmpeg(["-y", "-i", activeVideoPath, "-vn", "-acodec", "libmp3lame", "-q:a", "2", "-f", "mp3", mp3TempPath], { signal });
+            try {
+                const mp3Buf = await fsReadFile(mp3TempPath);
+                await writeBinaryIfChanged(engine, assetId, "original.mp3", mp3Buf);
+            }
+            finally {
+                await rm(mp3TempPath, { force: true });
+            }
+        }
+        const existingWaveform = preserveAudioArtifacts
+            ? await engine.metadata.waveforms.read(assetId)
+            : null;
+        if (!existingWaveform || !existingWaveform.ok) {
+            const waveform = await extractWaveform(activeVideoPath);
+            if (waveform.length > 0) {
+                const wavResult = await engine.metadata.waveforms.write(assetId, waveform);
+                if (!wavResult.ok) {
+                    logger.warn("waveform-write-failed", { assetId, error: wavResult.error });
+                }
+            }
+        }
+        // Create original.jpg from first frame if not already set (e.g., from OG image)
+        const thumbResult = await engine.files.read(assetId, "original.jpg");
+        if (!thumbResult.ok) {
+            try {
+                const firstFrameBuf = await fsReadFile(join(framesDir, "0.00.jpg"));
+                await engine.files.write(assetId, "original.jpg", firstFrameBuf);
+            }
+            catch { /* frame not available */ }
+        }
+        // If thumbnail is blank (all black/grey), replace with a mid-video frame
+        const thumbPath = join(assetDir, "original.jpg");
+        if (await isThumbnailBlank(thumbPath) && timestamps.length > 1) {
+            const midTs = timestamps[Math.floor(timestamps.length / 2)];
+            try {
+                const midFrameBuf = await fsReadFile(join(framesDir, `${formatTimestamp(midTs)}.jpg`));
+                await engine.files.write(assetId, "original.jpg", midFrameBuf);
+            }
+            catch { /* mid-frame not available */ }
+        }
+        await ingestWorkspaceOutputs(engine, assetId, ["original_frames"], "process_video", { width, height, duration, frame_count: frameCount });
+    }
+    // Speech-to-text stays eager: cheap and useful as
+    // a standalone artifact even if the asset never lands in a slot. Vision
+    // analysis (Gemini) is gated to slot drop in tools/assign-slot.ts — plus
+    // the slot-gated revival below for re-processed (trimmed/re-downloaded)
+    // videos, whose analysis sidecar was just invalidated.
+    const transcriptJobs = planVideoTranscriptJobs({
+        skipDownstreamJobs: Boolean(skipDownstreamJobs),
+        hasAudio: probe.hasAudio,
+        assetId,
+        assetDir,
+        bookId,
+        videoFilename: activeSourcePath,
+        identity: await videoTranscriptIdentity(engine, assetId, activeSourcePath),
+        hasOpenAiKey: Boolean(getApiKey("OPENAI_API_KEY")),
+        hasElevenLabsKey: Boolean(getApiKey("ELEVENLABS_API_KEY")),
+    });
+    if (process.env.NODE_ENV !== "test") {
+        await queue.enqueue(`semantic-index-${assetId}-${Date.now()}`, {
+            type: "semantic_index",
+            assetId,
+            bookId,
+        });
+        // Analysis revival below still respects slotting; tagging does not,
+        // because a Library clip has to be findable without being placed first.
+        await enqueueAssetTagging(engine, assetId);
+        if (!skipDownstreamJobs && probe.hasAudio) {
+            await enqueueVideoTranscriptJobs(transcriptJobs);
+        }
+        else if (!skipDownstreamJobs || reviveVisualAnalysis) {
+            // Silent video: no transcribe job will run, so revive the slot-drop
+            // vision analysis here; transcribe_video_audio's tail owns it for
+            // videos with audio (after the fresh transcript lands).
+            try {
+                await enqueueLazyAnalysisIfSlotted(engine, bookId, assetId);
+            }
+            catch {
+                // best-effort — analysis revival must not fail processing
+            }
+        }
+    }
+    return { success: true, width, height, duration, frame_count: frameCount };
+}
+export function registerProcessVideoJob(engine) {
+    registerJobHandler("process_video", async (payload, ctx) => {
+        const processPayload = payload;
+        return withLocalLease(engine, processPayload.assetId, ctx, "process", async () => withTransientStorageRetry(() => processVideoFiles(engine, processPayload, ctx.signal), ctx.signal));
+    });
+}

package/dist/jobs/register-all.js

@@ -0,0 +1,161 @@
+import { registerPostRecordJobs } from "./post-record.js";
+import { registerColdOpenJobs } from "./cold-open.js";
+import { bookManager } from "../engine.js";
+import { registerCopyLibraryAssetJob } from "./copy-library-asset.js";
+import { registerTranscribeJob } from "./transcribe.js";
+import { registerTranslateTranscriptJob } from "./translate-transcript.js";
+import { registerDownloadVideoJob } from "./download-video.js";
+import { registerArchiveClipJob } from "./archive-clip.js";
+import { registerRestoreArchiveClipJob } from "./restore-archive-clip.js";
+import { registerDoctorFixJob } from "./doctor-fix.js";
+import { registerTrimVideoJob } from "./trim-video.js";
+import { registerTrimAudioJob } from "./trim-audio.js";
+import { registerSplitVideoJob } from "./split-video.js";
+import { registerExtractVideoClipJob } from "./extract-video-clip.js";
+import { registerEvenSplitJob } from "./even-split.js";
+import { registerPadVideoJob } from "./pad-video.js";
+import { registerCropVideoJob } from "./crop-video.js";
+import { registerCropImageJob } from "./crop-image.js";
+import { registerApplyCutsJob } from "./apply-cuts.js";
+import { registerApplySfxJob } from "./apply-sfx.js";
+import { registerChangeVideoSpeedJob } from "./change-video-speed.js";
+import { registerTimewarpVideoJob } from "./timewarp-video.js";
+import { registerSyncVideoToAudioJob } from "./sync-video-to-audio.js";
+import { registerAudioBoostJob } from "./audio-boost.js";
+import { registerAudioMixJob } from "./audio-mix.js";
+import { registerReverseVideoJob } from "./reverse-video.js";
+import { registerInjectFirstFrameJob } from "./inject-first-frame.js";
+import { registerExtractFrameJob } from "./extract-frame.js";
+import { registerExtractNotebookFrameJob } from "./extract-notebook-frame.js";
+import { registerExtractNotebookAudioJob } from "./extract-notebook-audio.js";
+import { registerExtractAudioJob } from "./extract-audio.js";
+import { registerAnalyzeMusicJob } from "./analyze-music.js";
+import { registerPlanGoalJob } from "./plan-goal.js";
+import { registerAssembleGoalJob } from "./assemble-goal.js";
+import { registerCombineGoalJob } from "./combine-goal.js";
+import { registerFinishGoalJob } from "./finish-goal.js";
+import { registerLabelMusicSectionsJob } from "./label-music-sections.js";
+import { registerEditingMomentsJob } from "./analyze-editing-moments.js";
+import { registerExtractWaveformJob } from "./extract-waveform.js";
+import { registerExtractVideoPosterJob } from "./extract-video-poster.js";
+import { registerReplaceVideoAudioJob } from "./replace-video-audio.js";
+import { registerSpliceVideoJob } from "./splice-video.js";
+import { registerSmoothSceneConcatJob } from "./smooth-scene-concat.js";
+import { registerCompleteProviderTaskJob } from "./complete-provider-task.js";
+import { registerRenderProjectJob } from "./render-project.js";
+import { registerRenderQrOutroJob } from "./render-qr-outro.js";
+import { registerProcessVideoJob } from "./process-video.js";
+import { registerProcessAudioJob } from "./process-audio.js";
+import { registerTranscribeVideoAudioJob } from "./transcribe-video-audio.js";
+import { registerAnalyzeVideoJob } from "./analyze-video.js";
+import { registerAnalyzeKeywordPlacementJob } from "./analyze-keyword-placement.js";
+import { registerAnalyzeAliveCaptionsJob } from "./analyze-alive-captions.js";
+import { registerOsgPlacementJob } from "./osg-placement.js";
+import { registerBurnWatermarkJob } from "./burn-watermark.js";
+import { registerSuggestCutsJob } from "./suggest-cuts.js";
+import { registerSuggestSfxJob } from "./suggest-sfx.js";
+import { registerAnalyzeJokesJob } from "./analyze-jokes.js";
+import { registerDetectScenesJob } from "./detect-scenes.js";
+import { registerDescribeImageJob } from "./describe-image.js";
+import { registerRewriteScriptJob } from "./rewrite-script.js";
+import { registerRenderTimelineJob } from "./render-timeline.js";
+import { registerExportSequenceJob } from "./export-sequence.js";
+import { registerProcessImageJob } from "./process-image.js";
+import { registerIsolateVocalsJob } from "./isolate-vocals.js";
+import { registerCleanVideoAudioJob } from "./clean-video-audio.js";
+import { registerPostToXJob } from "./post-to-x.js";
+import { registerAcestepCoverJob } from "./generate-acestep-cover.js";
+import { registerExtendAudioJob } from "./extend-audio.js";
+import { registerRemoveSoundJob } from "./remove-sound.js";
+import { registerRunNotebookJob } from "./run-notebook.js";
+import { registerRelayoutNotebookJob } from "./relayout-notebook.js";
+import { registerRepairSearchIndexesJob } from "./repair-search-indexes.js";
+import { registerSemanticIndexJob } from "./semantic-index.js";
+import { registerBackfillAssetTagsJob } from "./backfill-asset-tags.js";
+import { registerForgetAssetJob } from "./forget-asset.js";
+import { registerTagAssetJob } from "./tag-asset.js";
+import { registerPrepareSearchReferenceJob } from "./prepare-search-reference.js";
+import { registerPrepareTemporalSearchJob } from "./prepare-temporal-search.js";
+import { registerImageSubjectJobs } from "./image-subjects.js";
+import { registerGenerateMediaJob } from "./generate-media.js";
+export function registerAllJobHandlers(engine, books = bookManager) {
+    registerTranscribeJob(engine);
+    registerTranslateTranscriptJob(engine);
+    registerDownloadVideoJob(engine);
+    registerArchiveClipJob(engine);
+    registerRestoreArchiveClipJob(engine);
+    registerDoctorFixJob(engine);
+    registerTrimVideoJob(engine);
+    registerTrimAudioJob(engine);
+    registerSplitVideoJob(engine);
+    registerExtractVideoClipJob(engine);
+    registerColdOpenJobs(engine);
+    registerEvenSplitJob(engine);
+    registerPadVideoJob(engine);
+    registerCropVideoJob(engine);
+    registerCropImageJob(engine);
+    registerApplyCutsJob(engine);
+    registerApplySfxJob(engine);
+    registerChangeVideoSpeedJob(engine);
+    registerTimewarpVideoJob(engine);
+    registerSyncVideoToAudioJob(engine);
+    registerAudioBoostJob(engine);
+    registerAudioMixJob(engine);
+    registerReverseVideoJob(engine);
+    registerInjectFirstFrameJob(engine);
+    registerExtractFrameJob(engine);
+    registerExtractNotebookFrameJob(engine);
+    registerExtractNotebookAudioJob(engine);
+    registerExtractAudioJob(engine);
+    registerExtractWaveformJob(engine);
+    registerExtractVideoPosterJob(engine);
+    registerAnalyzeMusicJob(engine);
+    registerPlanGoalJob(engine);
+    registerAssembleGoalJob(engine);
+    registerCombineGoalJob(engine);
+    registerFinishGoalJob(engine);
+    registerLabelMusicSectionsJob(engine);
+    registerEditingMomentsJob(engine);
+    registerReplaceVideoAudioJob(engine);
+    registerSpliceVideoJob(engine);
+    registerSmoothSceneConcatJob(engine);
+    registerCompleteProviderTaskJob(engine);
+    registerRenderProjectJob(engine);
+    registerRenderQrOutroJob(engine);
+    registerProcessVideoJob(engine);
+    registerProcessAudioJob(engine);
+    registerTranscribeVideoAudioJob(engine);
+    registerAnalyzeVideoJob(engine);
+    registerAnalyzeKeywordPlacementJob(engine);
+    registerAnalyzeAliveCaptionsJob(engine);
+    registerOsgPlacementJob(engine);
+    registerBurnWatermarkJob(engine);
+    registerSuggestCutsJob(engine);
+    registerSuggestSfxJob(engine);
+    registerAnalyzeJokesJob(engine);
+    registerDetectScenesJob(engine);
+    registerDescribeImageJob(engine);
+    registerRewriteScriptJob(engine);
+    registerRenderTimelineJob(engine);
+    registerExportSequenceJob(engine);
+    registerProcessImageJob(engine);
+    registerIsolateVocalsJob(engine);
+    registerCleanVideoAudioJob(engine);
+    registerGenerateMediaJob(engine);
+    registerAcestepCoverJob(engine);
+    registerExtendAudioJob(engine);
+    registerRemoveSoundJob(engine);
+    registerPostToXJob(engine);
+    registerPostRecordJobs(engine);
+    registerRunNotebookJob(engine);
+    registerRelayoutNotebookJob(engine);
+    registerSemanticIndexJob(engine);
+    registerTagAssetJob(engine);
+    registerBackfillAssetTagsJob(engine);
+    registerForgetAssetJob(engine);
+    registerRepairSearchIndexesJob(engine);
+    registerPrepareSearchReferenceJob(engine);
+    registerPrepareTemporalSearchJob(engine);
+    registerImageSubjectJobs(engine);
+    registerCopyLibraryAssetJob(books);
+}

package/dist/jobs/relayout-notebook.js

@@ -0,0 +1,78 @@
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { notebookDocumentsEqual, relayoutNotebookDocument, } from "../notebook-relayout.js";
+import { withNotebookMutation } from "../notebook-mutations.js";
+import { registerJobHandler, resolveBookEngine } from "../queue.js";
+export async function executeRelayoutNotebook(engine, payload) {
+    return await withNotebookMutation(payload.notebookId, async () => {
+        if (payload.expectedRevision && payload.expectedRevision !== engine.head) {
+            throw new Error(`Stale notebook revision: expected ${payload.expectedRevision}`);
+        }
+        return await relayoutNotebook(engine, payload);
+    });
+}
+async function relayoutNotebook(engine, payload) {
+    const before = engine.notebooks.read(payload.notebookId);
+    if (!before.ok)
+        throw new Error(before.error.message);
+    const next = relayoutNotebookDocument(engine, before.value);
+    if (notebookDocumentsEqual(before.value, next)) {
+        return {
+            changed: false,
+            notebook_id: payload.notebookId,
+            cell_count: next.cells.length,
+            edge_count: next.edges.length,
+            revision: engine.head,
+            cells: next.cells.map((cell) => ({
+                id: cell.id,
+                type: cell.type,
+                address: notebookGridTag(cell.slot),
+                slot: cell.slot,
+                output_artifact_id: cell.outputArtifactId ?? null,
+            })),
+        };
+    }
+    const write = await engine.notebooks.write(next, {
+        operation: "relayout_notebook",
+        details: { notebookId: payload.notebookId },
+    });
+    if (!write.ok)
+        throw new Error(write.error.message);
+    const after = engine.notebooks.read(payload.notebookId);
+    if (!after.ok)
+        throw new Error(after.error.message);
+    return {
+        changed: true,
+        notebook_id: payload.notebookId,
+        cell_count: after.value.cells.length,
+        edge_count: after.value.edges.length,
+        revision: write.value.hash,
+        cells: after.value.cells.map((cell) => ({
+            id: cell.id,
+            type: cell.type,
+            address: notebookGridTag(cell.slot),
+            slot: cell.slot,
+            output_artifact_id: cell.outputArtifactId ?? null,
+        })),
+    };
+}
+export function registerRelayoutNotebookJob(_fs) {
+    registerJobHandler("relayout_notebook", async (payload) => {
+        const notebookId = typeof payload.notebookId === "string"
+            ? payload.notebookId
+            : "";
+        const bookId = typeof payload.bookId === "string" ? payload.bookId : "";
+        if (!notebookId)
+            throw new Error("relayout_notebook requires notebookId");
+        if (!bookId)
+            throw new Error("relayout_notebook requires bookId");
+        const engine = await resolveBookEngine(bookId);
+        return executeRelayoutNotebook(engine, {
+            type: "relayout_notebook",
+            bookId,
+            notebookId,
+            ...(typeof payload.expectedRevision === "string"
+                ? { expectedRevision: payload.expectedRevision }
+                : {}),
+        });
+    });
+}