videobook 0.0.0-stage → 0.2.0

package/dist/jobs/analyze-jokes.js

@@ -0,0 +1,143 @@
+import { z } from "zod";
+import { registerJobHandler } from "../queue.js";
+import { getApiKey } from "../api-key.js";
+import { INTELLIGENCE_MODEL, buildIntelligenceResponses, firstResponseText, intelligenceRequest, } from "../openai-intelligence.js";
+import { withLocalLease } from "./_lease.js";
+const JOKE_TYPES = [
+    "pun",
+    "self_deprecating",
+    "observational",
+    "absurdist",
+    "callback",
+    "sarcasm",
+    "wordplay",
+    "misdirection",
+    "hyperbole",
+    "irony",
+    "anti_humor",
+    "other",
+];
+const SYSTEM_PROMPT = `You are a comedy writer analyzing a transcript of a stand-up or monologue clip. Identify the distinct jokes in the bit.
+
+For each joke:
+- Classify its primary type, choosing exactly one value from the allowed set.
+- Quote the joke verbatim from the transcript (the punchline plus the minimal setup needed to understand it).
+- Give the start and end time in seconds, drawn from the word-timing table.
+- Explain in one sentence why it works.
+
+RULES:
+- Do not invent jokes. Only use lines present in the transcript.
+- start < end, and both must fall within the clip's word timings.
+- Prefer a few clear, well-formed jokes over an exhaustive list.
+- Output JSON only.`;
+const JOKES_JSON_SCHEMA = {
+    type: "object",
+    required: ["jokes", "summary"],
+    additionalProperties: false,
+    properties: {
+        jokes: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["type", "text", "start", "end", "why"],
+                additionalProperties: false,
+                properties: {
+                    type: { type: "string", enum: JOKE_TYPES },
+                    text: { type: "string" },
+                    start: { type: "number" },
+                    end: { type: "number" },
+                    why: { type: "string" },
+                },
+            },
+        },
+        summary: { type: "string" },
+    },
+};
+const JokeSchema = z.object({
+    type: z.enum(JOKE_TYPES),
+    text: z.string(),
+    start: z.number(),
+    end: z.number(),
+    why: z.string(),
+});
+const ModelOutputSchema = z.object({
+    jokes: z.array(JokeSchema),
+    summary: z.string(),
+});
+function spokenWords(words) {
+    return words.filter((w) => w.type === "word");
+}
+function buildJokesContext(eleven) {
+    const table = spokenWords(eleven.words)
+        .map((w) => `${w.start.toFixed(2)}-${w.end.toFixed(2)} ${w.text.trim()}`)
+        .join("\n");
+    return [
+        "TRANSCRIPT:",
+        eleven.text,
+        "",
+        "WORD TIMINGS (start-end seconds, one word per line):",
+        table,
+    ].join("\n");
+}
+export function registerAnalyzeJokesJob(engine) {
+    registerJobHandler("analyze_jokes", async (payload, ctx) => {
+        const { assetId } = payload;
+        return withLocalLease(engine, assetId, ctx, "analyze", async () => {
+            const apiKey = getApiKey("OPENAI_API_KEY");
+            if (!apiKey)
+                throw new Error("OPENAI_API_KEY environment variable is not set");
+            const read = await engine.files.read(assetId, "elevenlabs.json");
+            if (!read.ok) {
+                throw new Error(`No ElevenLabs transcript found for ${assetId} — run /transcribe @${assetId} first.`);
+            }
+            let eleven;
+            try {
+                eleven = JSON.parse(read.value.toString());
+            }
+            catch {
+                throw new Error(`elevenlabs.json for ${assetId} is not valid JSON`);
+            }
+            if (!Array.isArray(eleven.words) || spokenWords(eleven.words).length === 0) {
+                throw new Error(`No ElevenLabs transcript found for ${assetId} — run /transcribe @${assetId} first.`);
+            }
+            const responses = buildIntelligenceResponses(apiKey, { timeout: 240_000 });
+            const result = await responses(intelligenceRequest({
+                instructions: SYSTEM_PROMPT,
+                input: [{ role: "user", content: buildJokesContext(eleven) }],
+                text: {
+                    format: {
+                        type: "json_schema",
+                        name: "analyze_jokes_result",
+                        schema: JOKES_JSON_SCHEMA,
+                        strict: true,
+                    },
+                },
+                max_output_tokens: 4096,
+            }), ctx.signal);
+            const outputText = firstResponseText(result);
+            let parsed;
+            try {
+                parsed = ModelOutputSchema.parse(JSON.parse(outputText));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                throw new Error(`Model output failed schema validation: ${msg}`);
+            }
+            const final = {
+                jokes: parsed.jokes,
+                summary: parsed.summary,
+                based_on: {
+                    transcript_source: "elevenlabs",
+                    word_count: spokenWords(eleven.words).length,
+                },
+                model: INTELLIGENCE_MODEL,
+                asset_id: assetId,
+            };
+            const writeResult = await engine.files.write(assetId, ".analyze-jokes.json", JSON.stringify(final, null, 2));
+            if (!writeResult.ok) {
+                throw new Error(`Jokes analyzed but failed to persist: ${writeResult.error.message}`);
+            }
+            return { success: true, jokes: parsed.jokes.length };
+        });
+    });
+}

package/dist/jobs/analyze-keyword-placement.js

@@ -0,0 +1,155 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import sharp from "sharp";
+import { getApiKey } from "../api-key.js";
+import { runFfmpeg, probeVideo } from "../ffmpeg.js";
+import { detectOccupiedRegions } from "../vision-regions.js";
+import { writeKeywordPlacementAnalysis } from "../keyword-placement-cache.js";
+import { registerJobHandler } from "../queue.js";
+import { KEYWORD_FRAME_CACHE_FILENAME, KEYWORD_PLACEMENT_VERSION, keywordCueId, } from "../remotion/keyword-placement.js";
+import { withLockedLocalLease } from "./_lease.js";
+const LOCK_DURATION_MS = 300_000;
+const CELL_WIDTH = 640;
+const IMAGE_HEIGHT = 360;
+const LABEL_HEIGHT = 48;
+const CELL_HEIGHT = IMAGE_HEIGHT + LABEL_HEIGHT;
+const CONTACT_SHEET_COLUMNS = 2;
+const SYSTEM_PROMPT = `You are a precise video-layout analyst. Each attached image is a frame extracted at the exact midpoint of a spoken keyword.
+
+For every frame, identify all occupied regions that cinematic keyword typography must not cover:
+- every visible human face, including partial faces and faces in posters or screens
+- every existing visible text block, subtitle, caption, title, logo, watermark, or graphic
+
+Return one entry for every cue_id. Coordinates use a normalized image scale from 0 to 1000: x and y are the top-left corner, followed by width and height. Use tight boxes around the visible occupied content. Do not return boxes for bodies, clothing, scenery, microphones, or ordinary objects. Return an empty occupied_regions array only when none of the listed content is visible. Never omit, rename, or duplicate a cue_id.`;
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+async function createContactSheet(frames) {
+    const cells = await Promise.all(frames.map(async (frame) => {
+        const image = await sharp(frame.buffer)
+            .resize({
+            width: CELL_WIDTH,
+            height: IMAGE_HEIGHT,
+            fit: "contain",
+            background: "#080808",
+        })
+            .jpeg({ quality: 88 })
+            .toBuffer();
+        const label = Buffer.from(`<svg width="${CELL_WIDTH}" height="${LABEL_HEIGHT}" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="#080808"/><text x="18" y="32" fill="#ffffff" font-family="serif" font-size="22">${escapeXml(frame.text)} · ${frame.frameTime.toFixed(3)}s</text></svg>`);
+        return sharp({
+            create: {
+                width: CELL_WIDTH,
+                height: CELL_HEIGHT,
+                channels: 3,
+                background: "#080808",
+            },
+        }).composite([
+            { input: label, left: 0, top: 0 },
+            { input: image, left: 0, top: LABEL_HEIGHT },
+        ]).jpeg({ quality: 88 }).toBuffer();
+    }));
+    const rows = Math.ceil(cells.length / CONTACT_SHEET_COLUMNS);
+    return sharp({
+        create: {
+            width: CELL_WIDTH * CONTACT_SHEET_COLUMNS,
+            height: CELL_HEIGHT * rows,
+            channels: 3,
+            background: "#080808",
+        },
+    }).composite(cells.map((input, index) => ({
+        input,
+        left: index % CONTACT_SHEET_COLUMNS * CELL_WIDTH,
+        top: Math.floor(index / CONTACT_SHEET_COLUMNS) * CELL_HEIGHT,
+    }))).jpeg({ quality: 88 }).toBuffer();
+}
+export async function extractKeywordFrames(videoPath, graphics, duration, signal) {
+    const tempDir = await mkdtemp(join(tmpdir(), "videocity-keyword-frames-"));
+    try {
+        const frames = [];
+        for (let index = 0; index < graphics.length; index++) {
+            signal?.throwIfAborted();
+            const graphic = graphics[index];
+            const requestedTime = graphic.frameTime ?? graphic.start;
+            const frameTime = Math.max(0, Math.min(Math.max(0, duration - 0.05), requestedTime));
+            const framePath = join(tempDir, `${index.toString().padStart(2, "0")}.jpg`);
+            await runFfmpeg([
+                "-y",
+                "-ss", frameTime.toFixed(6),
+                "-i", videoPath,
+                "-frames:v", "1",
+                "-vf", "scale=1280:1280:force_original_aspect_ratio=decrease",
+                "-q:v", "2",
+                framePath,
+            ], { signal });
+            frames.push({
+                cueId: keywordCueId(graphic),
+                text: graphic.text,
+                frameTime,
+                buffer: await readFile(framePath),
+            });
+        }
+        return { frames, contactSheet: await createContactSheet(frames) };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function analyzeFrames(frames, apiKey, signal) {
+    return detectOccupiedRegions(frames.map((frame) => ({
+        id: frame.cueId,
+        label: `keyword=${frame.text}; timestamp=${frame.frameTime.toFixed(3)}s`,
+        buffer: frame.buffer,
+    })), {
+        apiKey,
+        signal,
+        instructions: SYSTEM_PROMPT,
+        schemaName: "keyword_placement_analysis",
+        errorLabel: "Keyword placement",
+        timeout: 240_000,
+        maxOutputTokens: 8192,
+    });
+}
+async function writeContactSheetIfChanged(engine, assetId, contactSheet) {
+    const existing = await engine.files.read(assetId, KEYWORD_FRAME_CACHE_FILENAME);
+    if (existing.ok && existing.value.equals(contactSheet))
+        return;
+    const write = await engine.files.write(assetId, KEYWORD_FRAME_CACHE_FILENAME, contactSheet);
+    if (!write.ok)
+        throw new Error(`Failed to persist keyword frame cache: ${write.error.message}`);
+}
+export function registerAnalyzeKeywordPlacementJob(engine) {
+    registerJobHandler("analyze_keyword_placement", async (payload, ctx) => {
+        const { assetId, assetDir, videoPath, fingerprint, graphics, } = payload;
+        return withLockedLocalLease(engine, assetId, assetDir, ctx, "analyze", { durationMs: LOCK_DURATION_MS, data: { state: "analyzing-keyword-placement" } }, async () => {
+            const apiKey = getApiKey("OPENAI_API_KEY");
+            if (!apiKey)
+                throw new Error("OPENAI_API_KEY is not set");
+            const probe = await probeVideo(videoPath, { signal: ctx.signal });
+            const extracted = await extractKeywordFrames(videoPath, graphics, probe.duration, ctx.signal);
+            const regions = await analyzeFrames(extracted.frames, apiKey, ctx.signal);
+            const analysis = {
+                version: KEYWORD_PLACEMENT_VERSION,
+                fingerprint,
+                sourceWidth: probe.width,
+                sourceHeight: probe.height,
+                frameCacheFilename: KEYWORD_FRAME_CACHE_FILENAME,
+                analyzedAt: new Date().toISOString(),
+                cues: extracted.frames.map((frame) => ({
+                    cueId: frame.cueId,
+                    text: frame.text,
+                    frameTime: frame.frameTime,
+                    regions: regions.get(frame.cueId) ?? [],
+                })),
+            };
+            await writeContactSheetIfChanged(engine, assetId, extracted.contactSheet);
+            await writeKeywordPlacementAnalysis(engine, assetId, analysis);
+            return { analysis };
+        }, { durationMs: LOCK_DURATION_MS, waitForActiveMs: 30_000 });
+    });
+}

package/dist/jobs/analyze-music.js

@@ -0,0 +1,14 @@
+import { registerJobHandler, queue } from "../queue.js";
+import { analyzeMusicSource } from "../rhythm/music-analysis.js";
+export function registerAnalyzeMusicJob(engine) {
+    registerJobHandler("analyze_music", async (payload, context) => {
+        const result = await analyzeMusicSource(engine, String(payload.musicArtifactId), String(payload.analysisId), String(payload.streamId), context.signal);
+        if (payload.sections === true) {
+            await queue.enqueue(`music-sections-${payload.musicArtifactId}-${payload.analysisId}`, {
+                type: "label_music_sections", bookId: payload.bookId, artifactId: payload.musicArtifactId,
+                analysisId: payload.analysisId, streamId: payload.streamId,
+            });
+        }
+        return result;
+    });
+}

package/dist/jobs/analyze-video.js

@@ -0,0 +1,282 @@
+import { join } from "node:path";
+import { logger } from "../logger.js";
+import { registerJobHandler, queue } from "../queue.js";
+import { getApiKey } from "../api-key.js";
+import { sampleEvenly } from "../frame-utils.js";
+import { buildIntelligenceResponses, firstResponseText, intelligenceRequest, } from "../openai-intelligence.js";
+import { DOWNSTREAM_LEASE_WAIT_MS, withLocalLease, } from "./_lease.js";
+import { findAudioFile } from "videobook-engine";
+import { readAndAssessDialog } from "../dialog-quality.js";
+import { readAssetTranscript } from "../transcript-projection.js";
+import { enqueueLazyTimelineRender } from "../lazy-render.js";
+import { enqueueAssetTagging } from "./tag-asset.js";
+import { frameVocabularyFor, MAX_AUTOMATIC_TAGS } from "../tag-vocabulary.js";
+const MAX_FRAMES = 15;
+const FALLBACK_ANALYSIS = {
+    summary: "", scenes: [], tags: [], mood: "",
+    subjects: [], actions: [], setting: "", textOnScreen: [],
+    burnedInSubtitles: null,
+    onScreenGraphic: null,
+    recommendedSubtitlePosition: "bottom",
+    recommendedOsgPosition: "top-right",
+    subjectPlacement: "center",
+};
+const SYSTEM_PROMPT = `You are a video analysis expert. Analyze the provided video frames, metadata, and transcription (if available) to produce a comprehensive JSON analysis.
+
+Return a JSON object with these fields:
+- "summary": A 2-3 sentence description of the video content
+- "scenes": An array of scene descriptions, each with "timestamp" (approximate seconds), "description", and "tags" (array of strings)
+- "tags": Top-level tags for the entire video (array of strings)
+- "editorialTags": Up to ${MAX_AUTOMATIC_TAGS} {facet, label} records for grouping footage. Use only visible evidence: people (${frameVocabularyFor("people").join(", ")}), places (${frameVocabularyFor("places").join(", ")}), editing (${frameVocabularyFor("editing").join(", ")}). Return [] when unsupported. Never infer camera movement, sound, interview roles, names or exact geographic locations from these sparse frames. Never convert a negated claim or an incidental object into a tag.
+- "mood": The overall mood/tone of the video
+- "subjects": Array of main subjects/people/objects featured
+- "subjectPlacement": Horizontal placement of the primary subject across the sampled frames: "left", "center", or "right"
+- "actions": Array of key actions or events that occur
+- "setting": Description of the environment/location
+- "textOnScreen": Array of any visible text in the frames
+- "burnedInSubtitles": Detect if subtitles or captions are already burned into the video frames. If detected, return an object with "detected": true, "position": one of "top", "middle", or "bottom" indicating where the text appears, and "confidence": "high", "medium", or "low". If no burned-in subtitles are found, return null. Look for persistent text overlays that appear across multiple frames in a consistent position — these are distinct from occasional on-screen titles or graphics.
+- "onScreenGraphic": Detect if there is a watermark, logo, or channel graphic burned into the video. If detected, return an object with "detected": true, "position": one of "top-left", "top-right", "bottom-left", or "bottom-right" indicating the corner where it appears, "description": a brief description of what it is (e.g. "TikTok logo", "channel watermark"), and "confidence": "high", "medium", or "low". If none found, return null.
+- "recommendedSubtitlePosition": Based on what is already on screen, recommend the best position ("top", "middle", or "bottom") for adding subtitle overlays that will not conflict with any detected burned-in subtitles or on-screen graphics. If burned-in subtitles are at the bottom, recommend "top". If nothing is detected, default to "bottom".
+- "recommendedOsgPosition": Based on what is already on screen, recommend the best corner ("top-left", "top-right", "bottom-left", or "bottom-right") for placing an overlay graphic that will not conflict with any detected on-screen graphics. If nothing is detected, default to "top-right".`;
+const ANALYZE_VIDEO_JSON_SCHEMA = {
+    type: "object",
+    required: [
+        "summary",
+        "scenes",
+        "tags",
+        "editorialTags",
+        "mood",
+        "subjects",
+        "subjectPlacement",
+        "actions",
+        "setting",
+        "textOnScreen",
+        "burnedInSubtitles",
+        "onScreenGraphic",
+        "recommendedSubtitlePosition",
+        "recommendedOsgPosition",
+    ],
+    additionalProperties: false,
+    properties: {
+        summary: { type: "string" },
+        scenes: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["timestamp", "description", "tags"],
+                additionalProperties: false,
+                properties: {
+                    timestamp: { type: "number" },
+                    description: { type: "string" },
+                    tags: { type: "array", items: { type: "string" } },
+                },
+            },
+        },
+        tags: { type: "array", items: { type: "string" } },
+        editorialTags: {
+            type: "array", maxItems: MAX_AUTOMATIC_TAGS,
+            items: {
+                type: "object", additionalProperties: false, required: ["facet", "label"],
+                properties: { facet: { type: "string", enum: ["people", "places", "editing"] }, label: { type: "string" } },
+            },
+        },
+        mood: { type: "string" },
+        subjects: { type: "array", items: { type: "string" } },
+        subjectPlacement: { type: "string", enum: ["left", "center", "right"] },
+        actions: { type: "array", items: { type: "string" } },
+        setting: { type: "string" },
+        textOnScreen: { type: "array", items: { type: "string" } },
+        burnedInSubtitles: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["detected", "position", "confidence"],
+                    additionalProperties: false,
+                    properties: {
+                        detected: { type: "boolean" },
+                        position: { type: "string", enum: ["top", "middle", "bottom"] },
+                        confidence: { type: "string", enum: ["high", "medium", "low"] },
+                    },
+                },
+                { type: "null" },
+            ],
+        },
+        onScreenGraphic: {
+            anyOf: [
+                {
+                    type: "object",
+                    required: ["detected", "position", "description", "confidence"],
+                    additionalProperties: false,
+                    properties: {
+                        detected: { type: "boolean" },
+                        position: {
+                            type: "string",
+                            enum: ["top-left", "top-right", "bottom-left", "bottom-right"],
+                        },
+                        description: { type: "string" },
+                        confidence: { type: "string", enum: ["high", "medium", "low"] },
+                    },
+                },
+                { type: "null" },
+            ],
+        },
+        recommendedSubtitlePosition: {
+            type: "string",
+            enum: ["top", "middle", "bottom"],
+        },
+        recommendedOsgPosition: {
+            type: "string",
+            enum: ["top-left", "top-right", "bottom-left", "bottom-right"],
+        },
+    },
+};
+function sampleFrames(frames) {
+    return sampleEvenly(frames, MAX_FRAMES);
+}
+export function registerAnalyzeVideoJob(engine) {
+    registerJobHandler("analyze_video", async (payload, ctx) => {
+        const { assetId, assetDir, bookId, hasTranscription, purpose, } = payload;
+        const result = await withLocalLease(engine, assetId, ctx, "analyze", async () => {
+            {
+                const metaResult = await engine.metadata.artifacts.read(assetId, "original");
+                const metadata = metaResult.ok ? metaResult.value : null;
+                const listResult = await engine.files.listSubdir(assetId, "original_frames");
+                const frameFiles = listResult.ok
+                    ? listResult.value
+                        .filter((f) => f.endsWith(".jpg"))
+                        .sort((a, b) => parseFloat(a) - parseFloat(b))
+                    : [];
+                const sampled = sampleFrames(frameFiles);
+                if (sampled.length === 0) {
+                    throw new Error(`No frames to analyze for ${assetId}; process the video before analyzing it`);
+                }
+                const frameParts = [];
+                for (const file of sampled) {
+                    const frameRead = await engine.files.read(assetId, `original_frames/${file}`);
+                    if (!frameRead.ok)
+                        throw new Error(frameRead.error.message);
+                    frameParts.push({ type: "input_text", text: `Frame timestamp: ${parseFloat(file).toFixed(3)}s` }, {
+                        type: "input_image",
+                        image_url: `data:image/jpeg;base64,${Buffer.from(frameRead.value).toString("base64")}`,
+                        detail: "high",
+                    });
+                }
+                // Prefers ElevenLabs word cues, falls back to the plain ingest transcript —
+                // a manual /transcribe leaves only the former behind.
+                let transcriptionText = "";
+                if (hasTranscription) {
+                    const transcript = await readAssetTranscript(engine, assetId);
+                    if (transcript.kind === "timed" || transcript.kind === "plain") {
+                        transcriptionText = transcript.text;
+                    }
+                }
+                const contextParts = [];
+                if (metadata) {
+                    const durationStr = typeof metadata.duration === "number" ? `${metadata.duration.toFixed(1)}s` : "unknown";
+                    contextParts.push(`Video metadata: ${metadata.width}x${metadata.height}, duration ${durationStr}`);
+                }
+                if (transcriptionText) {
+                    contextParts.push(`Transcription:\n${transcriptionText}`);
+                }
+                contextParts.push(`${sampled.length} frames from the video are attached below.`);
+                const userContent = [
+                    { type: "input_text", text: contextParts.join("\n\n") },
+                    ...frameParts,
+                ];
+                let analysis = FALLBACK_ANALYSIS;
+                const apiKey = getApiKey("OPENAI_API_KEY");
+                if (apiKey) {
+                    try {
+                        const responses = buildIntelligenceResponses(apiKey, { timeout: 180_000 });
+                        const response = await responses(intelligenceRequest({
+                            instructions: SYSTEM_PROMPT,
+                            input: [{ role: "user", content: userContent }],
+                            text: {
+                                format: {
+                                    type: "json_schema",
+                                    name: "video_analysis",
+                                    schema: ANALYZE_VIDEO_JSON_SCHEMA,
+                                    strict: true,
+                                },
+                            },
+                            max_output_tokens: 4096,
+                        }), ctx.signal);
+                        analysis = JSON.parse(firstResponseText(response));
+                    }
+                    catch (e) {
+                        logger.error("video-analysis-failed", { assetId, error: e });
+                    }
+                }
+                const jsonString = JSON.stringify(analysis, null, 2);
+                await engine.files.write(assetId, ".original.analysis.json", jsonString);
+                await queue.enqueue(`semantic-index-${assetId}-analysis-${Date.now()}`, {
+                    type: "semantic_index",
+                    assetId,
+                    bookId,
+                });
+                const usedFallback = analysis === FALLBACK_ANALYSIS;
+                // A failed analysis wrote the empty fallback shape; tagging it would fence
+                // the asset against the next successful run, so only a real result is
+                // offered to the tagger.
+                if (!usedFallback) {
+                    await enqueueAssetTagging(engine, assetId);
+                }
+                // Auto-transcribe trigger (replaces the whitelist-tool gate). Run only if
+                // the analysis says there's real dialog, ElevenLabs/Kie is configured, no
+                // prior failure or in-progress task, and we haven't already transcribed.
+                if (purpose !== "tagging") {
+                    await maybeEnqueueAutoTranscribe(engine, assetId, assetDir, bookId);
+                }
+                return { success: true, fallback: usedFallback, analysis };
+            }
+        }, { waitForActiveMs: DOWNSTREAM_LEASE_WAIT_MS });
+        // Rendering follows analysis for assets on a timeline. A run that exists
+        // only to feed the tagger has no timeline behind it, so it renders nothing.
+        if (purpose !== "tagging") {
+            try {
+                await enqueueLazyTimelineRender(engine, bookId, assetId);
+            }
+            catch (err) {
+                void err;
+            }
+        }
+        return result;
+    });
+}
+async function maybeEnqueueAutoTranscribe(engine, assetId, assetDir, bookId) {
+    if (!getApiKey("ELEVENLABS_API_KEY"))
+        return;
+    const manifestResult = await engine.files.manifest(assetId);
+    if (!manifestResult.ok)
+        return;
+    const manifest = manifestResult.value;
+    const fileNames = new Set(manifest.files.map((f) => f.name));
+    if (fileNames.has("elevenlabs.json"))
+        return;
+    const errorRow = await engine.jobs.failures.read(assetId);
+    if (errorRow.ok && errorRow.value !== null)
+        return;
+    const dialog = await readAndAssessDialog(engine, assetId);
+    if (!dialog.hasDialog)
+        return;
+    const artifact = engine.artifacts.get(assetId);
+    if (!artifact.ok)
+        return;
+    const audioFile = findAudioFile(manifest.files, artifact.value.kind);
+    if (!audioFile)
+        return;
+    // Stable dedupe key, shared with sync's auto-transcribe: when this trigger
+    // races an overlapping sync poll, the queue collapses both onto one job
+    // instead of paying for two ElevenLabs transcriptions.
+    const jobId = `auto-transcribe-${assetId}`;
+    await queue.enqueue(jobId, {
+        type: "transcribe",
+        audioPath: join(manifest.path, audioFile.name),
+        audioFilename: audioFile.name,
+        tagAudioEvents: true,
+        diarize: true,
+        assetId,
+        assetDir,
+        bookId,
+    });
+}