videobook 0.0.0-stage → 0.2.0

package/dist/jobs/apply-cuts.js

@@ -0,0 +1,83 @@
+import { join, basename } from "node:path";
+import { registerJobHandler, queue } from "../queue.js";
+import { runFfmpeg, probeVideo, H264_MEDIUM, AUDIO_OPTS } from "../ffmpeg.js";
+import { withLockedLocalLease } from "./_lease.js";
+import { replaceArtifactFileFromPath } from "./_persist-output.js";
+const LOCK_DURATION_MS = 600_000;
+const STALE_DERIVATIVES = [
+    ".original.analysis.json",
+    ".analysis.gpt4otrans.json",
+    "elevenlabs.json",
+    ".suggest-cuts.json",
+];
+function buildKeepSegments(cuts, duration) {
+    const keeps = [];
+    let cursor = 0;
+    for (const c of cuts) {
+        if (c.cut_start > cursor)
+            keeps.push([cursor, c.cut_start]);
+        cursor = c.cut_end;
+    }
+    if (cursor < duration)
+        keeps.push([cursor, duration]);
+    return keeps;
+}
+function buildFilterGraph(keeps, hasAudio) {
+    const parts = [];
+    keeps.forEach(([s, e], i) => {
+        parts.push(`[0:v]trim=start=${s}:end=${e},setpts=PTS-STARTPTS[v${i}]`);
+        if (hasAudio) {
+            parts.push(`[0:a]atrim=start=${s}:end=${e},asetpts=PTS-STARTPTS[a${i}]`);
+        }
+    });
+    const concatInputs = keeps
+        .map((_, i) => (hasAudio ? `[v${i}][a${i}]` : `[v${i}]`))
+        .join("");
+    const tail = hasAudio ? "[v][a]" : "[v]";
+    parts.push(`${concatInputs}concat=n=${keeps.length}:v=1:a=${hasAudio ? 1 : 0}${tail}`);
+    return parts.join(";");
+}
+export function registerApplyCutsJob(engine) {
+    registerJobHandler("apply_cuts", async (payload, ctx) => {
+        const { inputPath, outputPath, cuts, duration, hasAudio, assetId, assetDir, bookId, } = payload;
+        const result = await withLockedLocalLease(engine, assetId, assetDir, ctx, "apply_cuts", { durationMs: LOCK_DURATION_MS, data: { state: "cutting" } }, async () => {
+            const effectiveDuration = duration > 0 ? duration : (await probeVideo(inputPath)).duration;
+            const keeps = buildKeepSegments(cuts, effectiveDuration);
+            if (keeps.length === 0) {
+                throw new Error("Cuts cover entire video — nothing left to keep.");
+            }
+            const filter = buildFilterGraph(keeps, hasAudio);
+            const args = [
+                "-y", "-i", inputPath,
+                "-filter_complex", filter,
+                "-map", "[v]",
+                ...(hasAudio ? ["-map", "[a]"] : []),
+                ...H264_MEDIUM,
+                ...(hasAudio ? AUDIO_OPTS : []),
+                outputPath,
+            ];
+            await runFfmpeg(args);
+            const inputFilename = basename(inputPath);
+            await replaceArtifactFileFromPath(engine, assetId, inputFilename, outputPath);
+            for (const stale of STALE_DERIVATIVES) {
+                await engine.files.delete(assetId, stale);
+            }
+            const newVideoPath = join(assetDir, inputFilename);
+            return { newVideoPath, keptSegments: keeps.length };
+        }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: 30_000 });
+        await queue.enqueue(`process-video-${assetId}-${Date.now()}`, {
+            type: "process_video",
+            videoPath: result.newVideoPath,
+            assetId,
+            assetDir,
+            bookId,
+            provenance: {
+                origin: "apply_cuts",
+                cuts,
+                applied_at: new Date().toISOString(),
+            },
+            force: true,
+        });
+        return { success: true, kept_segments: result.keptSegments };
+    });
+}

package/dist/jobs/apply-sfx.js

@@ -0,0 +1,107 @@
+import { createElevenLabs } from "../usage-providers.js";
+import { join, basename } from "node:path";
+import { registerJobHandler, queue } from "../queue.js";
+import { requireApiKey } from "../api-key.js";
+import { probeVideo, runFfmpeg, AUDIO_OPTS } from "../ffmpeg.js";
+import { withLockedLocalLease } from "./_lease.js";
+import { replaceArtifactFileFromPath } from "./_persist-output.js";
+const LOCK_DURATION_MS = 1_800_000;
+// Tail fade as a click-suppressor in case a cue ends on a transient.
+const SFX_FADE_OUT_S = 0.2;
+const STALE_DERIVATIVES = [
+    ".original.analysis.json",
+    ".analysis.gpt4otrans.json",
+    "elevenlabs.json",
+    ".suggest-sfx.json",
+];
+async function generateAndWriteSfx(provider, engine, entry, index, assetId) {
+    const text = entry.prompt ?? `${entry.type}: ${entry.description}`;
+    const audio = await provider.v1.soundGeneration({
+        text,
+        duration_seconds: entry.duration_seconds,
+        prompt_influence: 0.75,
+    });
+    const filename = `original.sfx.${index}.mp3`;
+    const writeResult = await engine.files.write(assetId, filename, Buffer.from(audio));
+    if (!writeResult.ok)
+        throw new Error(`SFX ${index} write failed: ${writeResult.error.message}`);
+    return filename;
+}
+export function buildMixFilter(sfx, hasAudio, videoDurationSeconds) {
+    const parts = [];
+    if (hasAudio) {
+        parts.push("[0:a:0]aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo[base]");
+    }
+    else {
+        if (!Number.isFinite(videoDurationSeconds) || videoDurationSeconds <= 0) {
+            throw new Error(`Invalid silent video duration: ${videoDurationSeconds}`);
+        }
+        parts.push(`anullsrc=channel_layout=stereo:sample_rate=48000,atrim=duration=${videoDurationSeconds},asetpts=PTS-STARTPTS,aformat=sample_fmts=fltp:channel_layouts=stereo[base]`);
+    }
+    sfx.forEach((entry, i) => {
+        const ms = Math.round(entry.timestamp * 1000);
+        const filters = [
+            "aresample=48000",
+            "aformat=sample_fmts=fltp:channel_layouts=stereo",
+        ];
+        const fadeDur = Math.min(SFX_FADE_OUT_S, entry.duration_seconds / 4);
+        if (fadeDur > 0.01) {
+            filters.push(`afade=t=out:st=${entry.duration_seconds - fadeDur}:d=${fadeDur}`);
+        }
+        if (ms > 0)
+            filters.push(`adelay=${ms}|${ms}`);
+        parts.push(`[${i + 1}:a:0]${filters.join(",")}[s${i}]`);
+    });
+    const mixInputs = `[base]${sfx.map((_, i) => `[s${i}]`).join("")}`;
+    parts.push(`${mixInputs}amix=inputs=${sfx.length + 1}:duration=first:dropout_transition=0:normalize=0[outa]`);
+    return parts.join(";");
+}
+export async function mixSfxIntoVideo(videoPath, sfxPaths, outputPath, sfx, signal) {
+    if (sfxPaths.length !== sfx.length) {
+        throw new Error("SFX file count does not match the requested cue count");
+    }
+    const source = await probeVideo(videoPath, { signal });
+    const duration = source.videoDuration > 0 ? source.videoDuration : source.duration;
+    const filter = buildMixFilter(sfx, source.hasAudio, duration);
+    const ffmpegArgs = ["-y", "-i", videoPath];
+    for (const sfxPath of sfxPaths) {
+        ffmpegArgs.push("-i", sfxPath);
+    }
+    ffmpegArgs.push("-filter_complex", filter, "-map", "0:v", "-c:v", "copy", "-map", "[outa]", ...AUDIO_OPTS, outputPath);
+    await runFfmpeg(ffmpegArgs, { signal });
+}
+export function registerApplySfxJob(engine) {
+    registerJobHandler("apply_sfx", async (payload, ctx) => {
+        const { videoPath, outputPath, sfx, assetId, assetDir, bookId, } = payload;
+        const apiKey = requireApiKey("ELEVENLABS_API_KEY");
+        const result = await withLockedLocalLease(engine, assetId, assetDir, ctx, "apply_sfx", { durationMs: LOCK_DURATION_MS, data: { state: "applying_sfx" } }, async () => {
+            const provider = createElevenLabs({ apiKey, timeout: 60_000 });
+            const generatedFilenames = await Promise.all(sfx.map((entry, i) => generateAndWriteSfx(provider, engine, entry, i, assetId)));
+            await mixSfxIntoVideo(videoPath, generatedFilenames.map((filename) => join(assetDir, filename)), outputPath, sfx, ctx.signal);
+            const inputFilename = basename(videoPath);
+            await replaceArtifactFileFromPath(engine, assetId, inputFilename, outputPath);
+            for (const fn of generatedFilenames) {
+                await engine.files.delete(assetId, fn).catch(() => { });
+            }
+            for (const stale of STALE_DERIVATIVES) {
+                await engine.files.delete(assetId, stale);
+            }
+            const newVideoPath = join(assetDir, inputFilename);
+            return { newVideoPath, sfxCount: sfx.length };
+        }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: 30_000 });
+        await queue.enqueue(`process-video-${assetId}-${Date.now()}`, {
+            type: "process_video",
+            videoPath: result.newVideoPath,
+            assetId,
+            assetDir,
+            bookId,
+            provenance: {
+                origin: "apply_sfx",
+                sfx_count: result.sfxCount,
+                applied_at: new Date().toISOString(),
+            },
+            force: true,
+        });
+        return { success: true, sfx_count: result.sfxCount };
+    });
+}

package/dist/jobs/archive-clip.js

@@ -0,0 +1,458 @@
+import { createElevenLabs } from "../usage-providers.js";
+import { findAudioFile, findPrimaryMediaFile, findVideoFile } from "videobook-engine";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join, posix } from "node:path";
+import { YtDlp } from "ytdlp-nodejs";
+import { ytdlpRunOptions } from "../ytdlp-binary.js";
+import { registerJobHandler } from "../queue.js";
+import { getApiKey, requireApiKey } from "../api-key.js";
+import { probeVideo } from "../ffmpeg.js";
+import { buildIntelligenceResponses, firstResponseText, intelligenceRequest, } from "../openai-intelligence.js";
+import { validateDownloadOutput } from "./download-video.js";
+import { withLocalLease } from "./_lease.js";
+import { chunkStarts, chunkLength, extractAudioChunk } from "./_audio-chunks.js";
+import { archiveTags, assetSnapshotKey, assetSnapshotPrefix, chunkKey, clipKey, contentTypeForFilename, hashFile, indexKey, ingestKey, mergeArchiveIngests, personMarkerKey, topicMarkerKey, transcriptJsonKey, transcriptTextKey, } from "../archive-b2.js";
+import { ARCHIVE_STORE_BOUNDARY, getArchiveStore, readArchiveIngests, } from "../archive-store.js";
+const MEDIA_EXTENSIONS = new Set([".mp4", ".mov", ".webm", ".avi", ".mkv", ".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"]);
+const CHUNK_SECONDS = 20 * 60;
+const ELEVENLABS_TIMEOUT_MS = 10 * 60_000;
+const ENRICHMENT_JSON_SCHEMA = {
+    type: "object",
+    required: ["topics", "people"],
+    additionalProperties: false,
+    properties: {
+        topics: { type: "array", items: { type: "string" } },
+        people: { type: "array", items: { type: "string" } },
+    },
+};
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function sourceTitle(title, fallback) {
+    const value = title?.trim() || fallback?.trim();
+    return value || undefined;
+}
+function pickMediaFile(files, kind) {
+    const full = files.find((file) => /^original_full\.(mp4|mov|webm|avi|mkv)$/i.test(file.name));
+    return full
+        ?? findPrimaryMediaFile(files, kind)
+        ?? findVideoFile(files)
+        ?? findAudioFile(files, kind);
+}
+function buildAssetSnapshot(manifest, bookId, assetId) {
+    const files = manifest.files.map((file) => ({
+        relativePath: file.name,
+        filePath: join(manifest.path, file.name),
+    }));
+    for (const [dir, names] of Object.entries(manifest.directories ?? {})) {
+        for (const name of names) {
+            const relativePath = posix.join(dir, name);
+            files.push({
+                relativePath,
+                filePath: join(manifest.path, dir, name),
+            });
+        }
+    }
+    return { bookId, assetId, files };
+}
+async function readAnalysisTopics(engine, assetId) {
+    const read = await engine.files.read(assetId, ".original.analysis.json");
+    if (!read.ok)
+        return [];
+    try {
+        const parsed = JSON.parse(new TextDecoder().decode(read.value));
+        const topics = [
+            ...readStringArray(parsed.tags),
+            ...readStringArray(parsed.actions),
+        ];
+        const scenes = Array.isArray(parsed.scenes) ? parsed.scenes : [];
+        for (const scene of scenes) {
+            if (scene && typeof scene === "object") {
+                topics.push(...readStringArray(scene.tags));
+            }
+        }
+        return topics;
+    }
+    catch {
+        return [];
+    }
+}
+async function prepareAssetMedia(engine, payload) {
+    if (!payload.assetId) {
+        throw new Error("asset archive requires assetId");
+    }
+    const manifest = await engine.files.manifest(payload.assetId);
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const artifact = engine.artifacts.get(payload.assetId);
+    if (!artifact.ok)
+        throw new Error(artifact.error.message);
+    const media = pickMediaFile(manifest.value.files, artifact.value.kind);
+    if (!media)
+        throw new Error(`No media file found in asset ${payload.assetId}`);
+    const extension = extname(media.name).toLowerCase();
+    if (!MEDIA_EXTENSIONS.has(extension)) {
+        throw new Error(`Archive only supports video/audio media, got ${media.name}`);
+    }
+    const title = sourceTitle(payload.title, media.name.replace(/\.[^.]+$/, ""));
+    return {
+        mediaPath: join(manifest.value.path, media.name),
+        filename: `original${extension}`,
+        source: {
+            kind: "asset",
+            book_id: payload.bookId,
+            asset_id: payload.assetId,
+            ...(title ? { title } : {}),
+            created_at: new Date().toISOString(),
+        },
+        analysisTopics: await readAnalysisTopics(engine, payload.assetId),
+        assetSnapshot: buildAssetSnapshot(manifest.value, payload.bookId, payload.assetId),
+    };
+}
+async function prepareUrlMedia(payload) {
+    if (!payload.url)
+        throw new Error("url archive requires url");
+    const dir = await mkdtemp(join(tmpdir(), "videocity-archive-"));
+    const outputPath = join(dir, "original.mp4");
+    const ytdlp = new YtDlp(ytdlpRunOptions());
+    try {
+        await ytdlp
+            .download(payload.url)
+            .setOutputTemplate(outputPath)
+            .addArgs("--merge-output-format", "mp4")
+            .addArgs("--no-playlist")
+            .run();
+        await validateDownloadOutput(outputPath);
+        return {
+            mediaPath: outputPath,
+            filename: "original.mp4",
+            source: {
+                kind: "url",
+                url: payload.url,
+                ...(payload.title?.trim() ? { title: payload.title.trim() } : {}),
+                created_at: new Date().toISOString(),
+            },
+            cleanup: () => rm(dir, { recursive: true, force: true }),
+            analysisTopics: [],
+        };
+    }
+    catch (error) {
+        await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function offsetCharacter(char, seconds) {
+    return { ...char, start: char.start + seconds, end: char.end + seconds };
+}
+function offsetWord(word, seconds) {
+    return {
+        ...word,
+        start: word.start + seconds,
+        end: word.end + seconds,
+        ...(word.characters ? { characters: word.characters.map((char) => offsetCharacter(char, seconds)) } : {}),
+    };
+}
+function transcriptFromResponse(response) {
+    if ("words" in response)
+        return response;
+    if ("transcripts" in response && response.transcripts[0])
+        return response.transcripts[0];
+    throw new Error("ElevenLabs returned an async acknowledgement instead of a transcript");
+}
+function mergeTranscripts(chunks, duration) {
+    const words = chunks.flatMap((chunk) => chunk.transcript.words.map((word) => offsetWord(word, chunk.offset)));
+    const texts = chunks.map((chunk) => chunk.transcript.text.trim()).filter(Boolean);
+    const first = chunks[0]?.transcript;
+    return {
+        language_code: first?.language_code ?? "und",
+        language_probability: first?.language_probability ?? 0,
+        text: texts.join(" ").trim(),
+        words,
+        channel_index: first?.channel_index ?? 0,
+        transcription_id: null,
+        audio_duration_secs: duration ?? chunks.reduce((sum, chunk) => sum + chunk.transcript.audio_duration_secs, 0),
+    };
+}
+async function transcribeMedia(store, args) {
+    const probe = await probeVideo(args.mediaPath);
+    if (!probe.hasAudio) {
+        const empty = {
+            language_code: args.languageCode ?? "und",
+            language_probability: 0,
+            text: "",
+            words: [],
+            channel_index: 0,
+            transcription_id: null,
+            audio_duration_secs: probe.duration,
+        };
+        await store.putJson(transcriptJsonKey(store, args.sha256), empty);
+        await store.putText(transcriptTextKey(store, args.sha256), "");
+        return {
+            transcript: {
+                json_key: transcriptJsonKey(store, args.sha256),
+                text_key: transcriptTextKey(store, args.sha256),
+                chunk_count: 0,
+                provider: "elevenlabs",
+            },
+            text: "",
+            duration: probe.duration,
+        };
+    }
+    const apiKey = requireApiKey("ELEVENLABS_API_KEY");
+    const provider = createElevenLabs({ apiKey, timeout: ELEVENLABS_TIMEOUT_MS });
+    const dir = await mkdtemp(join(tmpdir(), "videocity-archive-audio-"));
+    const chunks = [];
+    try {
+        const starts = chunkStarts(probe.duration, CHUNK_SECONDS);
+        for (let index = 0; index < starts.length; index++) {
+            const start = starts[index];
+            const length = chunkLength(probe.duration, start, CHUNK_SECONDS);
+            const chunkPath = join(dir, `chunk-${String(index).padStart(3, "0")}.mp3`);
+            await extractAudioChunk(args.mediaPath, start, length, chunkPath);
+            const bytes = await readFile(chunkPath);
+            const file = new Blob([new Uint8Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength))], { type: "audio/mpeg" });
+            const request = {
+                model_id: "scribe_v2",
+                file,
+                tag_audio_events: args.tagAudioEvents,
+                diarize: args.diarize,
+                ...(args.languageCode ? { language_code: args.languageCode } : {}),
+            };
+            const response = await provider.v1.speechToText(request);
+            await store.putJson(chunkKey(store, args.sha256, index), response);
+            chunks.push({ transcript: transcriptFromResponse(response), offset: start });
+        }
+        const merged = mergeTranscripts(chunks, probe.duration);
+        await store.putJson(transcriptJsonKey(store, args.sha256), merged);
+        await store.putText(transcriptTextKey(store, args.sha256), merged.text);
+        return {
+            transcript: {
+                json_key: transcriptJsonKey(store, args.sha256),
+                text_key: transcriptTextKey(store, args.sha256),
+                chunk_count: chunks.length,
+                provider: "elevenlabs",
+            },
+            text: merged.text,
+            duration: probe.duration,
+        };
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+function sampleTranscript(text) {
+    const clean = text.replace(/\s+/g, " ").trim();
+    if (clean.length <= 14000)
+        return clean;
+    const head = clean.slice(0, 6000);
+    const middleStart = Math.max(0, Math.floor(clean.length / 2) - 3000);
+    const middle = clean.slice(middleStart, middleStart + 6000);
+    const tail = clean.slice(-4000);
+    return [head, middle, tail].join("\n\n");
+}
+async function enrichMetadata(title, transcript) {
+    const apiKey = getApiKey("OPENAI_API_KEY");
+    const sample = sampleTranscript(transcript);
+    if (!apiKey || (!title && !sample))
+        return { topics: [], people: [] };
+    try {
+        const responses = buildIntelligenceResponses(apiKey, { timeout: 120_000 });
+        const response = await responses(intelligenceRequest({
+            instructions: "Identify searchable subjects and named people. People must be named people only, not generic roles.",
+            input: [{
+                    role: "user",
+                    content: `Title: ${title ?? ""}\n\nTranscript sample:\n${sample}`,
+                }],
+            text: {
+                format: {
+                    type: "json_schema",
+                    name: "archive_metadata",
+                    schema: ENRICHMENT_JSON_SCHEMA,
+                    strict: true,
+                },
+            },
+            max_output_tokens: 1000,
+        }));
+        const outputText = firstResponseText(response);
+        const parsed = JSON.parse(outputText);
+        return {
+            topics: readStringArray(parsed.topics),
+            people: readStringArray(parsed.people),
+        };
+    }
+    catch {
+        return { topics: [], people: [] };
+    }
+}
+async function writeMarkers(args) {
+    const marker = {
+        sha256: args.ingest.sha256,
+        ingest_id: args.ingest.ingest_id,
+        title: args.ingest.title,
+        topics: args.ingest.topics,
+        people: args.ingest.people,
+        index_key: indexKey(args.store, args.ingest.sha256),
+        created_at: args.ingest.created_at,
+    };
+    await Promise.all([
+        ...args.ingest.topics.map((topic) => args.store.putJson(topicMarkerKey(args.store, topic.key, args.ingest.sha256, args.ingest.ingest_id), marker)),
+        ...args.ingest.people.map((person) => args.store.putJson(personMarkerKey(args.store, person.key, args.ingest.sha256, args.ingest.ingest_id), marker)),
+    ]);
+}
+async function buildAndWriteIndex(args) {
+    const ingests = await readArchiveIngests(args.store, args.sha256);
+    const index = mergeArchiveIngests(ingests, {
+        sha256: args.sha256,
+        mediaKey: args.mediaKey,
+        filename: args.filename,
+        contentType: args.contentType,
+        sizeBytes: args.sizeBytes,
+        transcript: args.transcript,
+        duration: args.duration,
+        existing: args.existing,
+    });
+    await args.store.putJson(indexKey(args.store, args.sha256), index);
+    return index;
+}
+async function uploadAssetSnapshot(args) {
+    if (!args.snapshot)
+        return null;
+    const prefix = assetSnapshotPrefix(args.store, args.sha256);
+    let fileCount = 0;
+    for (const file of args.snapshot.files) {
+        const key = assetSnapshotKey(args.store, args.sha256, file.relativePath);
+        await args.store.uploadFile(key, file.filePath, contentTypeForFilename(file.relativePath));
+        fileCount += 1;
+    }
+    return { prefix, fileCount };
+}
+async function runArchive(engine, payload) {
+    const prepared = payload.url ? await prepareUrlMedia(payload) : await prepareAssetMedia(engine, payload);
+    try {
+        const store = getArchiveStore();
+        const sha256 = await hashFile(prepared.mediaPath);
+        const existing = await store.getJson(indexKey(store, sha256));
+        const duplicate = existing !== null;
+        const contentType = duplicate ? existing.media.content_type : contentTypeForFilename(prepared.filename);
+        const mediaKey = duplicate ? existing.media.key : clipKey(store, sha256, prepared.filename);
+        const size = duplicate ? existing.media.size_bytes : (await import("node:fs/promises")).stat(prepared.mediaPath).then((item) => item.size);
+        const sizeBytes = await size;
+        let transcript = existing?.transcript ?? null;
+        let transcriptText = "";
+        let duration = existing?.duration ?? null;
+        if (!duplicate) {
+            if (!(await store.exists(mediaKey))) {
+                await store.uploadFile(mediaKey, prepared.mediaPath, contentType);
+            }
+            const transcriptResult = await transcribeMedia(store, {
+                mediaPath: prepared.mediaPath,
+                sha256,
+                languageCode: payload.languageCode,
+                tagAudioEvents: payload.tagAudioEvents,
+                diarize: payload.diarize,
+            });
+            transcript = transcriptResult.transcript;
+            transcriptText = transcriptResult.text;
+            duration = transcriptResult.duration;
+        }
+        const assetSnapshot = await uploadAssetSnapshot({
+            snapshot: prepared.assetSnapshot,
+            sha256,
+            store,
+        });
+        const title = sourceTitle(payload.title, prepared.source.title);
+        const enriched = duplicate ? { topics: [], people: [] } : await enrichMetadata(title ?? null, transcriptText);
+        const manualTopics = archiveTags(payload.topics, "manual");
+        const manualPeople = archiveTags(payload.people, "manual");
+        const autoTopics = archiveTags([...prepared.analysisTopics, ...enriched.topics], "auto");
+        const autoPeople = archiveTags(enriched.people, "auto");
+        const ingest = {
+            schema_version: 1,
+            ingest_id: payload.ingestId,
+            sha256,
+            source: prepared.source,
+            title: title ?? null,
+            topics: [...manualTopics, ...autoTopics],
+            people: [...manualPeople, ...autoPeople],
+            created_at: new Date().toISOString(),
+        };
+        await store.putJson(ingestKey(store, sha256, payload.ingestId), ingest);
+        await writeMarkers({ ingest, store });
+        const index = await buildAndWriteIndex({
+            sha256,
+            mediaKey,
+            filename: duplicate ? existing.media.filename : prepared.filename,
+            contentType,
+            sizeBytes,
+            transcript,
+            duration,
+            existing,
+            store,
+        });
+        return {
+            archive_id: sha256,
+            cache_role: ARCHIVE_STORE_BOUNDARY.role,
+            sha256,
+            duplicate,
+            ingest_id: payload.ingestId,
+            asset_snapshot_prefix: assetSnapshot?.prefix ?? null,
+            asset_snapshot_file_count: assetSnapshot?.fileCount ?? 0,
+            topics: index.topics.map((topic) => topic.label),
+            people: index.people.map((person) => person.label),
+            title: index.title,
+            sources: index.sources,
+            transcript: index.transcript,
+            duration: index.duration,
+        };
+    }
+    finally {
+        await prepared.cleanup?.();
+    }
+}
+async function writeArchiveMetadata(engine, payload, result) {
+    if (!payload.assetId)
+        return;
+    const archiveId = result.archive_id;
+    if (typeof archiveId !== "string")
+        return;
+    const write = await engine.metadata.artifacts.write(payload.assetId, "archive", {
+        archive_id: archiveId,
+        ingest_id: result.ingest_id,
+        duplicate: result.duplicate,
+        asset_snapshot_prefix: result.asset_snapshot_prefix,
+        asset_snapshot_file_count: result.asset_snapshot_file_count,
+        topics: result.topics,
+        people: result.people,
+        title: result.title,
+        sources: result.sources,
+        transcript: result.transcript,
+        duration: result.duration,
+        cache_role: result.cache_role,
+        archived_at: new Date().toISOString(),
+    });
+    if (!write.ok)
+        throw new Error(write.error.message);
+}
+export function registerArchiveClipJob(engine) {
+    registerJobHandler("archive_clip", async (payload, ctx) => {
+        const p = payload;
+        if (p.assetId) {
+            return withLocalLease(engine, p.assetId, ctx, "archive", async () => {
+                const result = await runArchive(engine, p);
+                await writeArchiveMetadata(engine, p, result);
+                return result;
+            });
+        }
+        return runArchive(engine, { ...p, ingestId: p.ingestId || randomUUID() });
+    });
+}
+export const __archiveClipJobTest = {
+    archiveTags,
+    buildAssetSnapshot,
+    mergeTranscripts,
+    sampleTranscript,
+};