@gentbajko/slopify 2.0.3 → 2.1.0

package/dist/slices/rebuild/recipe-youtube.js

@@ -0,0 +1,33 @@
+import { usesYoutubeDescription } from "../admission/rules.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+import { renderedPrompt } from "./recipe-text.js";
+// The YouTube description is written from the word timing, so it waits for
+// `subtitles:timing` and nothing else: it runs beside the render, and a change to the
+// motion, zoom, images or captions' look leaves it current. The transcript is only known once
+// the timing lands, so the request is built when the step runs (`runtime-youtube.ts`); what
+// identifies it here is the timing it reads, the prompt, the model and the title.
+export function youtubeRecipes(context, exports) {
+    const { config } = context;
+    const timing = exports.find((value) => value.key === "subtitles:timing");
+    if (!usesYoutubeDescription(config) || timing === undefined)
+        return [];
+    return [
+        recipe(context, "youtube:description", "video", {
+            kind: "local",
+            version: 1,
+            operation: "youtube-description-v1",
+            values: [
+                resourceIdentity(context, timing),
+                config.llm?.provider ?? "",
+                config.llm?.model ?? "",
+                config.llm?.thinking ?? null,
+                // Blank means the built-in prompt; the step fills it in, so a new built-in wording
+                // ships as a new operation version rather than a silent change here.
+                config.descriptionPrompt?.trim() ? renderedPrompt(context, "description") : "",
+                config.title,
+            ],
+        }, [timing.key], 
+        // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
+        { kind: "provider" }),
+    ];
+}

package/dist/slices/rebuild/recovery-selection.js

@@ -16,6 +16,8 @@ export function sectionRoots(view, plan, stage) {
                     ["body-narration", "intro-narration", "outro-narration"].includes(row.input.operation)));
         if (stage === "article")
             return row.key === "article:body" && row.kind === "provider";
+        if (stage === "document")
+            return row.key === "document:pdf";
         return row.kind === "provider";
     })
         .map((row) => row.key);

package/dist/slices/rebuild/recovery.js

@@ -158,16 +158,21 @@ export async function recoverProject(deps, projectId, raw) {
                 fields: blocked.map((row) => ({ field: row.key, message: row.reason })),
             });
         if (input.action.kind === "rerun" &&
-            input.action.stage === "video" &&
+            (input.action.stage === "video" || input.action.stage === "document") &&
             preview.value.preview.work.some((row) => row.kind === "provider" && row.disposition !== "reuse"))
             return finish({
                 ok: false,
                 reason: "readiness",
                 fields: [
-                    {
-                        field: "video",
-                        message: "Source media is incomplete. Use Resume to recover it before rerunning the export.",
-                    },
+                    input.action.stage === "video"
+                        ? {
+                            field: "video",
+                            message: "Source media is incomplete. Use Resume to recover it before rerunning the export.",
+                        }
+                        : {
+                            field: "document",
+                            message: "The article or thumbnail the document is made from isn't finished. Use Resume to finish it, then Re-run section on Document.",
+                        },
                 ],
             });
         const conflict = rerunKeys.length > 0 ? activeConflict(deps, projectId, rerunKeys) : undefined;

package/dist/slices/rebuild/runtime-actions.js

@@ -72,5 +72,7 @@ function keyStage(key) {
         return "thumbnail";
     if (prefix === "research")
         return "research";
+    if (prefix === "document")
+        return "document";
     return "video";
 }

package/dist/slices/rebuild/runtime-document.js

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { readDocumentAssets } from "../document/fonts.js";
+import { documentThemeOf } from "../document/model.js";
+import { renderDocument } from "../document/render.js";
+import { builtInTheme } from "../document/theme.js";
+import { writeAsset } from "../storage/assets.js";
+import { outputPath } from "../storage/layout.js";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { preparedResult, publishResult } from "./runtime-publication.js";
+// Lays the saved article out as a PDF. Local and quick: no provider, no charge.
+export async function executeDocumentRecipe(deps, context, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    context.signal.throwIfAborted();
+    const view = documentView(deps, context, piece);
+    const { projectId } = context.work;
+    const text = (role, workKey) => {
+        const row = ready(view, role, workKey);
+        return row === undefined
+            ? null
+            : readFileSync(outputPath(deps.paths, projectId, row.output.path), "utf8");
+    };
+    const config = view.revision.config;
+    const article = view.revision.content.articleEdited === true || config.sources.article === "provide"
+        ? view.articleMarkdown
+        : text("article_md", "article:body");
+    if (article === null)
+        throw new Error("The article isn't finished yet, so there's nothing to make the document from. Let the Article stage finish (Resume, or Retry stage on Article), then use Retry stage on Document.");
+    const thumbnail = ready(view, "thumbnail", "thumbnail:image");
+    let cover = null;
+    if (config.sources.thumbnail !== "off" && thumbnail !== undefined) {
+        try {
+            cover = new Uint8Array(readFileSync(outputPath(deps.paths, projectId, thumbnail.output.path)));
+        }
+        catch (error) {
+            throw new Error(`The document's cover is the project's thumbnail, and its file can't be read (${error instanceof Error ? error.message : String(error)}). Regenerate or upload the thumbnail again (Re-run section on Thumbnail, or Edit project → Thumbnail), then use Retry stage on Document.`, { cause: error });
+        }
+    }
+    const rendered = renderDocument({
+        title: config.title,
+        articleMarkdown: article,
+        researchNotes: config.sources.research === "off" ? null : text("notes", "research:notes"),
+        cover,
+        theme: builtInTheme(documentThemeOf(config.document)),
+        writtenOn: deps.clock.now(),
+        assets: readDocumentAssets(),
+    });
+    if (rendered.cover === "unsupported")
+        deps.log.write("warn", "document.cover", {
+            projectId,
+            stage: "document",
+            detail: "The thumbnail is not a PNG, JPEG or WebP image, so the document has no cover.",
+        });
+    context.signal.throwIfAborted();
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const asset = writeAsset(deps, projectId, "document.pdf", rendered.bytes);
+    // publishResult discards the file itself when the publication doesn't commit.
+    await publishResult(deps, context, piece, [preparedResult(deps, context, piece, "document_pdf", asset)], { pages: rendered.pages, words: rendered.words, cover: rendered.cover });
+    deps.count?.("stage.completed", { stage: "document" });
+    return "done";
+}
+function documentView(deps, context, piece) {
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    if (view === undefined || row === undefined)
+        throw new Error("Slopify hit an internal error (the project version the document belongs to is missing). Use Retry stage on Document; if it happens again, use Download diagnostics in Settings and report it.");
+    const recipe = executionPlan(deps, view, savedCatalogue(row.recipe_context)).recipes.find((one) => one.key === piece.key && one.fingerprint === piece.fingerprint);
+    if (recipe === undefined || recipe.unresolved)
+        throw new Error("The project changed after this document was queued, so it no longer matches the saved article. Use Rebuild affected outputs (or Retry stage on Document) to make it from the current version.");
+    return view;
+}
+function ready(view, role, workKey) {
+    return view.outputs.find((row) => row.selected &&
+        row.available &&
+        row.state === "ready" &&
+        row.workKey === workKey &&
+        row.output.role === role);
+}

package/dist/slices/rebuild/runtime-export-inputs.js

@@ -49,6 +49,7 @@ export async function revisionAudio(deps, context, view) {
             ? await input("audio_outro")
             : undefined,
         gapSeconds: config.silenceGapSeconds,
+        edgeSeconds: config.edgeSilenceSeconds,
     }, config.sources.video === "off" ? 1 / 48000 : 1 / 30);
 }
 export function revisionTranscript(deps, snapshot, kind) {

package/dist/slices/rebuild/runtime-export.js

@@ -3,8 +3,10 @@ import { extname, join, relative, sep } from "node:path";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath, projectDir } from "../storage/layout.js";
 import { audioExportArgs } from "../video/audio-export.js";
-import { renderArgs, runFfmpeg } from "../video/ffmpeg.js";
+import { withPaths } from "../video/edit-list.js";
+import { runFfmpeg } from "../video/ffmpeg.js";
 import { planRender } from "../video/plan.js";
+import { renderSlideshow } from "../video/slideshow.js";
 import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export-inputs.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
 export async function executeExportRecipe(deps, context, piece) {
@@ -56,6 +58,10 @@ export async function executeExportRecipe(deps, context, piece) {
             : planRender({
                 format: config.format,
                 gapSeconds: config.silenceGapSeconds,
+                edgeSeconds: config.edgeSilenceSeconds,
+                imageSeconds: config.imageSeconds,
+                zoomPercent: config.zoomPercent,
+                motionStyle: config.motionStyle,
                 body: segment("body"),
                 intro: segment("intro"),
                 outro: segment("outro"),
@@ -71,6 +77,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 channels: 2,
                 codec: "pcm_s16le",
                 gapSeconds: config.silenceGapSeconds,
+                edgeSeconds: config.edgeSilenceSeconds,
                 totalSeconds,
                 audio: audio.map((row) => ({
                     ...row,
@@ -81,29 +88,38 @@ export async function executeExportRecipe(deps, context, piece) {
             : {
                 ...plan,
                 output: pending.path,
-                audio: plan.audio.map((row) => ({
-                    ...row,
-                    path: row.path === null ? null : relativePath(row.path),
-                })),
-                images: plan.images.map((row) => ({ ...row, path: relativePath(row.path) })),
+                editList: withPaths(plan.editList, relativePath),
                 subtitles: config.subtitles,
             };
         if (!context.maySubmit(piece.id))
             return "held";
-        await runFfmpeg({
-            bin: deps.ffmpeg,
-            args: plan === undefined ? audioExportArgs(audio, pending.absolutePath) : renderArgs(plan, burn),
-            cwd: directory,
-            signal: context.signal,
-            log: deps.log,
-            onProgress: (elapsedMs) => context.emit({
-                type: "stage.progress",
-                projectId: context.work.projectId,
-                stage: "video",
-                current: Math.min(100, Math.round(elapsedMs / (totalSeconds * 10))),
-                total: 100,
-            }),
+        const onProgress = (elapsedMs) => context.emit({
+            type: "stage.progress",
+            projectId: context.work.projectId,
+            stage: "video",
+            current: Math.min(100, Math.round(elapsedMs / (totalSeconds * 10))),
+            total: 100,
         });
+        if (plan === undefined)
+            await runFfmpeg({
+                bin: deps.ffmpeg,
+                args: audioExportArgs(audio, pending.absolutePath),
+                signal: context.signal,
+                log: deps.log,
+                onProgress,
+            });
+        else
+            await renderSlideshow({
+                bin: deps.ffmpeg,
+                edit: plan.editList,
+                output: plan.output,
+                burnSubtitles: burn,
+                cwd: directory,
+                scratch: projectDirectory,
+                signal: context.signal,
+                log: deps.log,
+                onProgress,
+            });
         context.signal.throwIfAborted();
         const asset = sealAsset(deps, pending);
         prepared.push(preparedResult(deps, context, piece, wav ? "audio_export" : "video", asset, Math.round(totalSeconds * 1000), { subtitlesMode: mode }));

package/dist/slices/rebuild/runtime-piece-label.js

@@ -8,6 +8,10 @@ export function pieceLabel(deps, context, piece) {
         return "Thumbnail";
     if (key === "article:body")
         return "Article";
+    if (key === "document:pdf")
+        return "Document";
+    if (key === "youtube:description")
+        return "YouTube description";
     if (key === "entry:intro:text")
         return "Intro text";
     if (key === "entry:outro:text")

package/dist/slices/rebuild/runtime-publication.js

@@ -127,6 +127,7 @@ function pieceIndex(deps, context, piece) {
         "subtitles:files",
         "export:wav",
         "export:video",
+        "document:pdf",
         "narration:files:body",
         "narration:files:intro",
         "narration:files:outro",

package/dist/slices/rebuild/runtime-run.js

@@ -1,8 +1,10 @@
+import { executeDocumentRecipe } from "./runtime-document.js";
 import { executeExportRecipe } from "./runtime-export.js";
 import { executeLocalRecipe } from "./runtime-local.js";
 import { pieceLabel } from "./runtime-piece-label.js";
 import { executeProviderRecipe } from "./runtime-provider.js";
 import { executeSubtitleRecipe } from "./runtime-subtitles.js";
+import { executeYoutubeRecipe } from "./runtime-youtube.js";
 import { workPieces } from "./work-records.js";
 export async function runRevisionInvocation(deps, context, providers) {
     const pieces = workPieces(deps.db, context.work.workId).filter((piece) => !piece.key.startsWith("article:continuation:"));
@@ -16,9 +18,15 @@ export async function runRevisionInvocation(deps, context, providers) {
                 ? await executeSubtitleRecipe(deps, context, piece)
                 : piece.key.startsWith("export:")
                     ? await executeExportRecipe(deps, context, piece)
-                    : piece.input.kind === "llm" || piece.input.kind === "tts" || piece.input.kind === "image"
-                        ? await executeProviderRecipe(deps, context, providers, piece)
-                        : await executeLocalRecipe(deps, context, piece);
+                    : piece.key.startsWith("document:")
+                        ? await executeDocumentRecipe(deps, context, piece)
+                        : piece.key.startsWith("youtube:")
+                            ? await executeYoutubeRecipe(deps, context, providers, piece)
+                            : piece.input.kind === "llm" ||
+                                piece.input.kind === "tts" ||
+                                piece.input.kind === "image"
+                                ? await executeProviderRecipe(deps, context, providers, piece)
+                                : await executeLocalRecipe(deps, context, piece);
             if (outcome === "held")
                 return outcome;
         }

package/dist/slices/rebuild/runtime-store.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { sourceOf } from "../admission/model.js";
+import { usesYoutubeDescription } from "../admission/rules.js";
 import { currentRevisionId } from "../revisions/repo.js";
 import { getRevisionView } from "../revisions/view.js";
 import { settleScheduleRunsForProject } from "../schedules/repo.js";
@@ -31,7 +33,10 @@ export function executionStages(deps, projectId) {
         .filter((row) => workPieces(deps.db, String(row.id)).some((piece) => {
         if (!keys.has(piece.key))
             return false;
-        if (piece.key === "subtitles:timing" && view?.revision.content.subtitleCues !== undefined)
+        // Hand-edited captions need no timing, unless the YouTube description reads it.
+        if (piece.key === "subtitles:timing" &&
+            view?.revision.content.subtitleCues !== undefined &&
+            !usesYoutubeDescription(view.revision.config))
             return false;
         if (piece.input.kind === "deferred" && piece.key.endsWith(":future")) {
             const cacheKey = String(row.id);
@@ -101,7 +106,7 @@ export function executionStandings(deps, projectId, derived) {
         return [];
     const work = derived ?? executionStages(deps, projectId);
     return stageKinds.map((kind) => {
-        const source = view.revision.config.sources[kind];
+        const source = sourceOf(view.revision.config.sources, kind);
         const group = work
             .filter((entry) => entry.kind === kind)
             .map((entry) => {

package/dist/slices/rebuild/runtime-subtitles.js

@@ -7,10 +7,13 @@ import { validateCues } from "../revisions/rules.js";
 import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
 import { captionCues, serializeAss, serializeSrt, serializeVtt } from "../subtitles/captions.js";
+import { spoken } from "../video/plan.js";
 import { exportSnapshot, retainedOutput, revisionAudio, revisionTranscript, } from "./runtime-export-inputs.js";
 import { narrationChunks, narrationTextParts, } from "./runtime-narration-text.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
-const wordsSchema = z.object({
+// The saved `subtitles.json`: every word at its time in the final video. The YouTube
+// description reads it too (`runtime-youtube.ts`).
+export const wordsSchema = z.object({
     key: z.string(),
     words: z.array(z.object({
         text: z.string(),
@@ -46,7 +49,7 @@ export async function executeSubtitleRecipe(deps, context, piece) {
 async function timing(deps, context, piece, snapshot) {
     const audio = await revisionAudio(deps, context, snapshot.view);
     if (audio.length === 0)
-        throw new Error("Captions need narration audio, but this project has none. Turn captions off in Edit project → Subtitles, or turn narration on, then Retry stage.");
+        throw new Error("Captions and the YouTube description need narration audio, but this project has none. Turn captions and the YouTube description off in Edit project, or turn narration on, then Retry stage.");
     const alignSubtitles = deps.alignSubtitles;
     if (alignSubtitles === undefined)
         throw new Error("Slopify hit an internal error (the caption timing tool is missing from this build). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
@@ -59,7 +62,7 @@ async function timing(deps, context, piece, snapshot) {
     for (const segment of audio) {
         context.signal.throwIfAborted();
         const { path, kind } = segment;
-        if (path !== null && kind !== "gap") {
+        if (path !== null && spoken(kind)) {
             const aligned = await located(snapshot, kind, () => alignSubtitles({
                 audioPath: path,
                 text: revisionTranscript(deps, snapshot, kind),

package/dist/slices/rebuild/runtime-youtube.js

@@ -0,0 +1,84 @@
+import { readFileSync } from "node:fs";
+import { outputPath } from "../storage/layout.js";
+import { assembleDescription, checkDescriptionAnswer, descriptionMessages, tagsText, } from "../youtube/answer.js";
+import { defaultDescriptionPrompt } from "../youtube/model.js";
+import { transcriptPassages, transcriptText } from "../youtube/transcript.js";
+import { exportSnapshot, revisionAudio } from "./runtime-export-inputs.js";
+import { savedCatalogue } from "./runtime-plan.js";
+import { preparedTexts, publishResult } from "./runtime-publication.js";
+import { wordsSchema } from "./runtime-subtitles.js";
+// Writes the YouTube description and tags from the saved word timing: the transcript's
+// passages carry their start in the final video, so the chapters the model picks are real
+// times. An answer that breaks YouTube's chapter or tag rules is a failed attempt, which the
+// provider wrapper asks again while attempts remain.
+export async function executeYoutubeRecipe(deps, context, providers, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    context.signal.throwIfAborted();
+    const input = piece.input;
+    if (input.kind !== "local" || input.operation !== "youtube-description-v1")
+        throw new Error("Slopify hit an internal error (the YouTube description step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+    const { view } = exportSnapshot(deps, context, piece);
+    const config = view.revision.config;
+    const llm = config.llm;
+    if (llm === undefined || llm.provider.trim() === "" || llm.model.trim() === "")
+        throw new Error("The YouTube description needs an AI text model, and none is chosen. Choose one in Edit project → Providers, then Retry stage.");
+    const timing = view.outputs.find((row) => row.selected &&
+        row.available &&
+        row.state === "ready" &&
+        row.workKey === "subtitles:timing" &&
+        row.output.role === "subtitle_words");
+    if (timing === undefined)
+        throw new Error("The narration's word timing, which the YouTube description's chapters come from, is missing. Use Re-run section on Video, then Retry stage.");
+    const { words } = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8")));
+    const passages = transcriptPassages(words);
+    if (passages.length === 0)
+        throw new Error("The narration's word timing holds no words, so there is nothing to write the YouTube description from. Use Re-run section on Video, then Retry stage.");
+    // The same timeline the timing walked: silence at the start, intro, gaps, body, outro and
+    // silence at the end.
+    const audio = await revisionAudio(deps, context, view);
+    const durationSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    const saved = Array.isArray(input.values) ? input.values[4] : undefined;
+    const instruction = typeof saved === "string" && saved.trim() !== "" ? saved : defaultDescriptionPrompt;
+    const messages = descriptionMessages({
+        instruction,
+        title: config.title,
+        durationSeconds,
+        transcript: transcriptText(passages),
+    });
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const model = savedCatalogue(row?.recipe_context).llm.find((one) => one.provider === llm.provider && one.id === llm.model);
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const answer = await providers.forPiece(piece.id).llm({
+        provider: llm.provider,
+        model: llm.model,
+        ...(llm.thinking === undefined ? {} : { thinking: llm.thinking }),
+        thinkingConfig: llm.thinking === undefined ? null : (model?.llm.thinking?.[llm.thinking] ?? null),
+        messages,
+        webSearch: false,
+        previewLabel: piece.key,
+        check: (value) => {
+            const checked = checkDescriptionAnswer(value.text, durationSeconds);
+            return checked.ok ? undefined : checked.reason;
+        },
+    });
+    if (!answer.ok)
+        return "held";
+    const checked = checkDescriptionAnswer(answer.value.text, durationSeconds);
+    if (!checked.ok)
+        throw new Error(checked.reason);
+    const description = assembleDescription(checked.value);
+    const tags = tagsText(checked.value.tags);
+    await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
+        ["youtube_description", "description.txt", description],
+        ["youtube_tags", "tags.txt", tags],
+    ]), { description, tags: checked.value.tags, chapters: checked.value.chapters, durationSeconds });
+    return "done";
+}

package/dist/slices/rebuild/transition-repo.js

@@ -104,5 +104,7 @@ function stageForKey(key) {
         return "thumbnail";
     if (prefix === "export" || prefix === "subtitles" || prefix === "video")
         return "video";
+    if (prefix === "document")
+        return "document";
     throw new Error("Slopify hit an internal error (unknown kind of step). Try again; if it happens again, use Download diagnostics in Settings and report it.");
 }

package/dist/slices/reruns/cascade.js

@@ -14,9 +14,9 @@ function staleStages(input) {
             return withDependents([action.stage], input);
         case "article-edit": {
             // An article edit re-runs audio, LLM-mode intro/outro text, the LLM-written
-            // thumbnail and the video, leaving prompt-based images untouched. The video comes
-            // along as a dependent of the audio, so it is never named here.
-            const roots = ["audio"];
+            // thumbnail, the document and the video, leaving prompt-based images untouched. The
+            // video comes along as a dependent of the audio, so it is never named here.
+            const roots = ["audio", "document"];
             if (input.thumbnailSource === "prompt_by_llm") {
                 roots.push("thumbnail");
             }
@@ -64,6 +64,8 @@ function withDependents(roots, input) {
     }
     return found;
 }
+// A stage with no row is not part of the run (a project from before the Document stage
+// may lack one), so it is stepped over like a skipped one.
 function stateOf(stages, kind) {
-    return stages.find((stage) => stage.kind === kind)?.state ?? "pending";
+    return stages.find((stage) => stage.kind === kind)?.state ?? "skipped";
 }

package/dist/slices/revisions/mutation-cues.js

@@ -82,7 +82,9 @@ export function validateProposedCues(base, edit, plan, prepared, durations) {
     if (parts.some((one) => one === undefined))
         return fail();
     const seconds = parts.reduce((sum, one) => sum + (one ?? 0), 0) / 1000 +
-        Math.max(0, keys.length - 1) * plan.config.silenceGapSeconds;
+        Math.max(0, keys.length - 1) * plan.config.silenceGapSeconds +
+        // The lead-in and the tail are part of the timeline the cues are timed against.
+        2 * plan.config.edgeSilenceSeconds;
     return validateCues(cues.cues, seconds);
 }
 export function measuredOutputs(deps, base, durations) {

package/dist/slices/revisions/projection.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { insertPiece } from "../../kernel/runner/piece-repo.js";
+import { sourceOf } from "../admission/model.js";
 import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
 import { insertOutput } from "../storage/repo.js";
 import { insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, selectOutputRecord, selectPieceRecord, } from "./repo.js";
 export function ensureRevisionStages(deps, revision) {
     for (const kind of stageKinds) {
-        const source = revision.config.sources[kind];
+        const source = sourceOf(revision.config.sources, kind);
         deps.db
             .prepare("INSERT INTO stages(id,project_id,kind,source,state) VALUES (?,?,?,?,?) ON CONFLICT(project_id,kind) DO UPDATE SET source=excluded.source")
             .run(deps.ids.next(), revision.projectId, kind, source, source === "off" ? "skipped" : "pending");

package/dist/slices/storage/downloads.js

@@ -19,6 +19,7 @@ const contentTypes = {
     ".ogg": "audio/ogg",
     ".opus": "audio/opus",
     ".mp4": "video/mp4",
+    ".pdf": "application/pdf",
     ".srt": "application/x-subrip; charset=utf-8",
     ".vtt": "text/vtt; charset=utf-8",
 };

package/dist/slices/storage/layout.js

@@ -54,6 +54,12 @@ export function outputFileName(role, index, extension, stageKind) {
             return `instructions-${stageKind}.txt`;
         case "video":
             return "video.mp4";
+        case "document_pdf":
+            return "document.pdf";
+        case "youtube_description":
+            return "description.txt";
+        case "youtube_tags":
+            return "tags.txt";
         case "audio_body":
             return `audio-body${extension}`;
         case "audio_export":

package/dist/slices/storage/model.js

@@ -24,5 +24,8 @@ export const outputRoles = [
     "subtitle_ass",
     "subtitle_font",
     "instructions",
+    "document_pdf",
+    "youtube_description",
+    "youtube_tags",
 ];
 export const stagedFileStates = ["copying", "staged"];

package/dist/slices/subtitles/prepare.js

@@ -7,6 +7,7 @@ import { projectById, setStageProgress } from "../admission/repo.js";
 import { resolveFont } from "../fonts/index.js";
 import { outputPath, projectDir } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
+import { spoken } from "../video/plan.js";
 import { captionCues, serializeAss, serializeSrt, serializeVtt } from "./captions.js";
 import { defaultSubtitles } from "./model.js";
 import { spokenText } from "./transcript.js";
@@ -55,7 +56,7 @@ export async function prepareSubtitles(deps, context, audio, frame) {
     const outputs = outputsOf(deps.db, projectId);
     const segments = audio.map((segment) => ({
         ...segment,
-        text: segment.kind === "gap" ? "" : spokenText(deps, projectId, segment.kind, outputs),
+        text: spoken(segment.kind) ? spokenText(deps, projectId, segment.kind, outputs) : "",
     }));
     const key = await timingKey(segments, context.signal);
     const cache = readCache(deps, projectId, outputs);

package/dist/slices/telemetry/model.js

@@ -3,7 +3,7 @@ import { stageKinds } from "../../kernel/pipeline.js";
 // One install event, one per project created, one per stage completing.
 export const telemetryEventTypes = ["install", "project.created", "stage.completed"];
 // Counting is finer than a stage: one event per research, article, intro/outro text, audio
-// segment (body, intro, outro), images, thumbnail and video. The three that are not whole
+// segment (body, intro, outro), images, thumbnail, video and document. The three that are not whole
 // stages are named by `segment` beside the stage that produced them - the article stage
 // writes the intro and outro texts, the audio stage narrates all three - so the event type
 // stays `stage.completed` and the pair (stage, segment) says which unit it is.

package/dist/slices/video/audio-export.js

@@ -6,17 +6,18 @@ import { outputsOf } from "../storage/repo.js";
 import { prepareSubtitles } from "../subtitles/prepare.js";
 import { audioExportArgs } from "./audio-export-args.js";
 import { audioInputs } from "./audio-inputs.js";
+import { runFfmpeg } from "./ffmpeg.js";
 import { audioTimeline } from "./plan.js";
 import { reusableAudioExport } from "./reuse-audio.js";
 import { writeExport } from "./write-export.js";
 import { writeSubtitles } from "./write-subtitles.js";
 export { audioExportArgs } from "./audio-export-args.js";
 const rate = 48000;
-export async function exportAudioWav(deps, context, gapSeconds) {
+export async function exportAudioWav(deps, context, gapSeconds, edgeSeconds) {
     const { projectId } = context.stage;
     const outputs = outputsOf(deps.db, projectId);
     const input = await audioInputs(deps, projectId, outputs, context.signal);
-    const audio = audioTimeline({ ...input, gapSeconds }, 1 / rate);
+    const audio = audioTimeline({ ...input, gapSeconds, edgeSeconds }, 1 / rate);
     const totalSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
     const dir = projectDir(deps.paths, projectId);
     const sources = outputs.filter((output) => ["audio_body", "audio_intro", "audio_outro"].includes(output.role));
@@ -25,6 +26,7 @@ export async function exportAudioWav(deps, context, gapSeconds) {
         channels: 2,
         codec: "pcm_s16le",
         gapSeconds,
+        edgeSeconds,
         totalSeconds,
         audio: audio.map((segment) => ({
             ...segment,
@@ -52,6 +54,12 @@ export async function exportAudioWav(deps, context, gapSeconds) {
         totalSeconds,
         record: plan,
         subtitles,
-        args: (part) => audioExportArgs(audio, part),
+        render: (part, onProgress) => runFfmpeg({
+            bin: deps.ffmpeg,
+            args: audioExportArgs(audio, part),
+            signal: context.signal,
+            log: deps.log,
+            onProgress,
+        }),
     });
 }