@gentbajko/slopify 2.3.1 → 2.5.0

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

@@ -0,0 +1,328 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { usesShorts } from "../admission/rules.js";
+import { resolveBoldFont } from "../fonts/index.js";
+import { clipWords } from "../shorts/captions.js";
+import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
+import { defaultShortsPrompt, musicVolumeOf, shortImageCount, shortsSpeedOf, } from "../shorts/model.js";
+import { checkPicks, keepNumbers, noPicksMessage, pickMessages, pickRetryMessages, } from "../shorts/pick.js";
+import { checkImagePrompts } from "../shorts/prompts.js";
+import { renderShort } from "../shorts/render.js";
+import { allocateAsset, discardPreparedAssets, sealAsset, writeAsset } from "../storage/assets.js";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { probeDurationMs } from "../video/ffmpeg.js";
+import { sentencesText, transcriptSentences } from "../youtube/transcript.js";
+import { shortsPickKey } from "./recipe-shorts.js";
+import { exportSnapshot, revisionAudio } from "./runtime-export-inputs.js";
+import { imageCall } from "./runtime-image.js";
+import { savedCatalogue } from "./runtime-plan.js";
+import { preparedResult, preparedTexts, publishResult } from "./runtime-publication.js";
+import { wordsSchema } from "./runtime-subtitles.js";
+// The Shorts step's four kinds of work (`recipe-shorts.ts`): the pick, each clip's image
+// prompts, each image, and each clip's render. Each is one piece of its own, so a failure
+// names the clip it belongs to and Retry stage redoes only what did not finish.
+export async function executeShortsRecipe(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 snapshot = exportSnapshot(deps, context, piece);
+    if (!usesShorts(snapshot.view.revision.config))
+        throw setupError();
+    if (piece.key === "shorts:pick")
+        return pick(deps, context, providers, piece, snapshot);
+    const matched = /^shorts:(\d+):(prompts|image:(\d+)|render)$/.exec(piece.key);
+    const number = Number(matched?.[1]);
+    if (matched === null || !Number.isInteger(number))
+        throw setupError();
+    const clip = savedClips(snapshot).find((one) => one.number === number);
+    if (clip === undefined)
+        throw new Error("The clip this short was cut from is no longer among the picked shorts. Use Pick different moments in Edit project → Shorts, then Retry stage.");
+    if (matched[2] === "prompts")
+        return prompts(deps, context, providers, piece, snapshot, clip);
+    if (matched[2] === "render")
+        return render(deps, context, piece, snapshot, clip);
+    return image(deps, context, providers, piece, clip, Number(matched[3]));
+}
+async function pick(deps, context, providers, piece, snapshot) {
+    const input = piece.input;
+    if (input.kind !== "local" || input.operation !== "shorts-pick-v1")
+        throw setupError();
+    const { view } = snapshot;
+    const config = view.revision.config;
+    const shorts = config.shorts;
+    if (shorts === undefined)
+        throw setupError();
+    const llm = config.llm;
+    if (llm === undefined || llm.provider.trim() === "" || llm.model.trim() === "")
+        throw new Error("Shorts need an AI text model to pick the clips, and none is chosen. Choose one in Edit project → Providers, then Retry stage.");
+    const sentences = transcriptSentences(timingWords(deps, context, view));
+    if (sentences.length === 0)
+        throw new Error("The narration's word timing holds no words, so there is nothing to cut shorts from. Use Re-run section on Video, then Retry stage.");
+    const audio = await revisionAudio(deps, context, view);
+    const durationSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    const limits = {
+        count: shorts.count,
+        minSeconds: shorts.minSeconds,
+        maxSeconds: shorts.maxSeconds,
+        durationSeconds,
+    };
+    // Nothing to ask the model for, and nothing to pay for.
+    if (durationSeconds < shorts.minSeconds)
+        throw new Error(noPicksMessage([], limits));
+    const saved = Array.isArray(input.values) ? input.values[4] : undefined;
+    const brief = {
+        instruction: typeof saved === "string" && saved.trim() !== "" ? saved : defaultShortsPrompt,
+        title: config.title,
+        durationSeconds,
+        count: shorts.count,
+        minSeconds: shorts.minSeconds,
+        maxSeconds: shorts.maxSeconds,
+        sentences: sentencesText(sentences),
+    };
+    const ask = llmCall(deps, context, piece, view, (text) => {
+        const checked = checkPicks(text, sentences, limits);
+        return checked.ok ? undefined : checked.reason;
+    });
+    const first = await providers.forPiece(piece.id).llm(ask(pickMessages(brief)));
+    if (!first.ok)
+        return "held";
+    let checked = checkPicks(first.value.text, sentences, limits);
+    if (!checked.ok)
+        throw new Error(checked.reason);
+    // One more ask when clips were missing or broke the rules, with what was wrong; then
+    // whichever answer held more usable clips.
+    if (checked.picks.length < shorts.count && checked.problems.length > 0) {
+        if (!context.maySubmit(piece.id))
+            return "held";
+        const second = await providers
+            .forPiece(piece.id)
+            .llm(ask(pickRetryMessages(brief, first.value.text, checked.problems)));
+        if (!second.ok)
+            return "held";
+        const again = checkPicks(second.value.text, sentences, limits);
+        if (again.ok && again.picks.length >= checked.picks.length)
+            checked = again;
+    }
+    if (checked.picks.length === 0)
+        throw new Error(noPicksMessage(checked.problems, limits));
+    // A clip picked again with the same sentences keeps its number and seed, so its prompts,
+    // images and render are reused; the new ones carry this pick's token.
+    const previous = pickedShortsOf(view.pieces.find((row) => row.key === shortsPickKey && row.selected)?.piece.payload);
+    const picks = keepNumbers(checked.picks, previous?.shorts ?? [], view.revision.content.regenerationTokens[shortsPickKey] ?? null);
+    await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
+        [
+            "shorts",
+            "shorts.json",
+            JSON.stringify({
+                shorts: picks.map(({ text: _text, seed: _seed, ...clip }) => clip),
+            }, null, 2),
+        ],
+    ]), {
+        shorts: picks,
+        durationSeconds,
+        // The numbered transcript's times, which a range set by hand is measured against.
+        sentences: sentences.map(({ start, end, text }) => ({ start, end, text })),
+    }, null, 
+    // The shorts past the new count, from a pick that made more.
+    (key) => Number(/^shorts:(\d+):/.exec(key)?.[1] ?? 0) > picks.length);
+    return "done";
+}
+async function prompts(deps, context, providers, piece, snapshot, clip) {
+    const input = piece.input;
+    if (input.kind !== "llm")
+        throw setupError();
+    const count = shortImageCount(clip.end - clip.start, snapshot.view.revision.config.imageSeconds);
+    const answer = await providers.forPiece(piece.id).llm({
+        provider: input.provider,
+        model: input.model,
+        ...(input.thinking === null ? {} : { thinking: input.thinking }),
+        thinkingConfig: input.thinkingConfig,
+        messages: input.messages,
+        webSearch: false,
+        previewLabel: piece.key,
+        check: (value) => {
+            const checked = checkImagePrompts(value.text, count);
+            return checked.ok ? undefined : checked.reason;
+        },
+    });
+    if (!answer.ok)
+        return "held";
+    const checked = checkImagePrompts(answer.value.text, count);
+    if (!checked.ok)
+        throw new Error(checked.reason);
+    const images = new RegExp(`^shorts:${String(clip.number)}:image:(\\d+)$`);
+    await publishResult(deps, context, piece, [], { prompts: checked.prompts }, null, 
+    // The images past this count, from a longer clip made before.
+    (key) => Number(images.exec(key)?.[1] ?? 0) > count);
+    return "done";
+}
+async function image(deps, context, providers, piece, clip, index) {
+    const input = piece.input;
+    if (input.kind !== "image")
+        throw setupError();
+    const made = await providers
+        .forPiece(piece.id)
+        .image(imageCall(deps, context.work.projectId, input, `Short ${String(clip.number)} image ${String(index)}`));
+    if (!made.ok)
+        return "held";
+    const asset = writeAsset(deps, context.work.projectId, made.value.mime === "image/jpeg" ? "short-image.jpg" : "short-image.png", made.value.bytes);
+    const output = preparedResult(deps, context, piece, "short_image", asset, null, {
+        short: clip.number,
+        sentences: [clip.first, clip.last],
+        index,
+        prompt: input.prompt,
+        provider: input.provider,
+        model: input.model,
+    });
+    await publishResult(deps, context, piece, [output], { prompt: input.prompt }, asset);
+    return "done";
+}
+async function render(deps, context, piece, snapshot, clip) {
+    const { view, plan } = snapshot;
+    const config = view.revision.config;
+    const prefix = `shorts:${String(clip.number)}:image:`;
+    const images = plan.recipes
+        .filter((recipe) => recipe.key.startsWith(prefix))
+        .toSorted((left, right) => imageIndex(left.key) - imageIndex(right.key))
+        .map((recipe) => {
+        const row = view.outputs.find((one) => one.workKey === recipe.key && one.selected && one.available && one.state === "ready");
+        if (row === undefined)
+            throw new Error(`Short ${String(clip.number)} is missing one of its images. Retry stage to make it again; if it keeps happening, use Make this short again in Edit project → Shorts.`);
+        return outputPath(deps.paths, context.work.projectId, row.output.path);
+    });
+    const words = clipWords(timingWords(deps, context, view), clip.start, clip.end);
+    const timeline = await revisionAudio(deps, context, view);
+    // The bundled Barlow is drawn in its own Bold face; any other font is emboldened.
+    const font = await resolveBoldFont(deps.paths, config.subtitles?.fontId ?? "default");
+    const shorts = config.shorts;
+    const speed = shorts === undefined ? 1 : shortsSpeedOf(shorts);
+    const music = await backgroundMusic(deps, context, view);
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const pending = allocateAsset(deps, context.work.projectId, "short.mp4");
+    const prepared = [];
+    const seconds = (clip.end - clip.start) / speed;
+    try {
+        await renderShort({
+            bin: deps.ffmpeg,
+            timeline,
+            start: clip.start,
+            end: clip.end,
+            images,
+            imageSeconds: config.imageSeconds,
+            motionStyle: config.motionStyle,
+            zoomPercent: config.zoomPercent,
+            words,
+            font,
+            ...(shorts?.titleOnScreen === true ? { title: clip.title } : {}),
+            speed,
+            music,
+            output: pending.absolutePath,
+            scratch: projectDir(deps.paths, context.work.projectId),
+            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 / (seconds * 10))),
+                total: 100,
+            }),
+        });
+        context.signal.throwIfAborted();
+        const durationMs = await probeDurationMs(deps.ffmpeg, pending.absolutePath, context.signal, deps.log);
+        const asset = sealAsset(deps, pending);
+        prepared.push(preparedResult(deps, context, piece, "short_video", asset, durationMs, {
+            short: clip.number,
+            sentences: [clip.first, clip.last],
+        }));
+        await publishResult(deps, context, piece, prepared, { short: clip.number, start: clip.start, end: clip.end, durationMs }, asset);
+        // One per rendered short, with no stage: stage "video" would read as a finished video.
+        // Its pick and prompt tokens are not counted here.
+        deps.count?.("stage.completed", { shorts: 1 });
+        return "done";
+    }
+    finally {
+        discardPreparedAssets(deps, [pending, ...prepared.map((one) => one.asset)]);
+    }
+}
+// The clips the pick saved for this plan, with any range set by hand in place: the
+// selected pick whose fingerprint is the one the plan asks for.
+function savedClips(snapshot) {
+    const recipe = snapshot.plan.recipes.find((one) => one.key === shortsPickKey);
+    const row = snapshot.view.pieces.find((one) => one.key === shortsPickKey &&
+        one.selected &&
+        one.piece.state === "done" &&
+        one.fingerprint === recipe?.fingerprint);
+    const picked = pickedShortsOf(row?.piece.payload);
+    const shorts = snapshot.view.revision.config.shorts;
+    if (picked === undefined || recipe === undefined || shorts === undefined)
+        return [];
+    return effectiveClips(picked, snapshot.view.revision.content.shortsRanges, recipe.fingerprint, shorts);
+}
+// The project's background music for the shorts, checked readable before the render so a
+// bad file is named as the music rather than as a failed render.
+async function backgroundMusic(deps, context, view) {
+    const assetId = view.revision.content.shortsMusic;
+    const shorts = view.revision.config.shorts;
+    if (assetId === undefined || shorts === undefined)
+        return undefined;
+    const fix = "Choose another file under Background music in Edit project → Shorts, or remove the music, then Retry stage.";
+    const row = z
+        .object({ path: z.string() })
+        .safeParse(deps.db
+        .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+        .get(context.work.projectId, assetId));
+    if (!row.success)
+        throw new Error(`The shorts' background music file is no longer in the project. ${fix}`);
+    const path = outputPath(deps.paths, context.work.projectId, row.data.path);
+    let durationMs;
+    try {
+        durationMs = await probeDurationMs(deps.ffmpeg, path, context.signal, deps.log);
+    }
+    catch (error) {
+        context.signal.throwIfAborted();
+        throw new Error(`The shorts' background music couldn't be read as audio (${error instanceof Error ? error.message : String(error)}). ${fix}`);
+    }
+    if (durationMs <= 0)
+        throw new Error(`The shorts' background music file holds no sound. ${fix}`);
+    return { path, volume: musicVolumeOf(shorts) };
+}
+function timingWords(deps, context, view) {
+    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 shorts are cut and captioned from, is missing. Use Re-run section on Video, then Retry stage.");
+    return wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8"))).words;
+}
+// The project's text model, with the thinking settings saved for this step's catalogue.
+function llmCall(deps, context, piece, view, check) {
+    const llm = view.revision.config.llm ?? { provider: "", model: "" };
+    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);
+    return (messages) => ({
+        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) => check(value.text),
+    });
+}
+function imageIndex(key) {
+    return Number(key.split(":").at(-1));
+}
+function setupError() {
+    return new Error("Slopify hit an internal error (a Shorts step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+}

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

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
 import { sourceOf } from "../admission/model.js";
-import { usesYoutubeDescription } from "../admission/rules.js";
+import { usesShorts, usesYoutubeDescription } from "../admission/rules.js";
 import { currentRevisionId } from "../revisions/repo.js";
 import { getRevisionView } from "../revisions/view.js";
 import { settleScheduleRunsForProject } from "../schedules/repo.js";
+import { editNeedsTiming } from "../video/edit-settings.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
 import { workPieces } from "./work-records.js";
 const workRow = z.object({
@@ -33,10 +34,13 @@ export function executionStages(deps, projectId) {
         .filter((row) => workPieces(deps.db, String(row.id)).some((piece) => {
         if (!keys.has(piece.key))
             return false;
-        // Hand-edited captions need no timing, unless the YouTube description reads it.
+        // Hand-edited captions need no timing, unless the YouTube description, the shorts
+        // or the video's edit read it.
         if (piece.key === "subtitles:timing" &&
             view?.revision.content.subtitleCues !== undefined &&
-            !usesYoutubeDescription(view.revision.config))
+            !usesYoutubeDescription(view.revision.config) &&
+            !usesShorts(view.revision.config) &&
+            !editNeedsTiming(view.revision.config))
             return false;
         if (piece.input.kind === "deferred" && piece.key.endsWith(":future")) {
             const cacheKey = String(row.id);

package/dist/slices/rebuild/service-readiness.js

@@ -1,4 +1,5 @@
 import { checkRuntimeModel } from "../../catalog/runtime-models.js";
+import { referenceRefusal, takesReferenceImage } from "../../catalog/schema.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { cliPathChanged } from "../settings/cli-paths.js";
 import { isLocalCliProvider } from "../settings/model.js";
@@ -38,7 +39,7 @@ export async function checkReadiness(deps, snapshot, view) {
             });
             continue;
         }
-        const result = await checkRuntimeModel(deps.modelsFor, choice.provider, choice.family, choice.model, choice.family === "llm" ? (choice.thinking ?? undefined) : undefined);
+        const result = await checkRuntimeModel(deps.modelsFor, choice.provider, choice.family, choice.model, choice.family === "tts" ? undefined : (choice.thinking ?? undefined));
         if (result === "missing")
             fields.push({
                 field: `${choice.family}.model`,
@@ -112,6 +113,19 @@ export function localReadiness(deps, snapshot, view, providers, catalogue) {
                     field: `work.${recipe.key}.aspect`,
                     message: "The model does not support this output shape.",
                 });
+            // Only the keyed providers' models are listed; the Codex CLI always takes a reference.
+            if (model !== undefined &&
+                input.reference !== undefined &&
+                !takesReferenceImage(model) &&
+                !fields.some((row) => row.field === "reference.source"))
+                fields.push({ field: "reference.source", message: referenceRefusal });
+            if (model !== undefined &&
+                input.thinking !== undefined &&
+                !fields.some((row) => row.field === "images.thinking"))
+                fields.push({
+                    field: "images.thinking",
+                    message: "This image model has no effort setting. Set the images' Effort back to Model default under Providers.",
+                });
         }
     }
     return fields;

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

@@ -33,12 +33,24 @@ export function transitionRevisionWork(deps, input) {
             const logicalKey = input.logicalKeys?.[row.work_key] ?? row.logical_key ?? row.work_key;
             const before = baseFingerprints[logicalKey];
             const after = input.fingerprints[logicalKey];
+            // Work unfolded under another step (a short's prompts, images and render under the
+            // pick) is planned under its own key too once it is known. It carries over only while
+            // that key still wants the same work; when it changed (a short made again), the new
+            // step is reserved afresh below. A short's step the new plan doesn't list yet waits on
+            // an answer that changed, so it is unfolded again once that answer lands.
+            const own = logicalKey === row.work_key ? undefined : input.fingerprints[row.work_key];
+            if (own !== undefined && own !== row.fingerprint)
+                continue;
+            if (own === undefined && logicalKey !== row.work_key && row.work_key.startsWith("shorts:"))
+                continue;
             if (before !== undefined &&
                 before === after &&
                 (input.baseFingerprints !== undefined ||
                     before === (row.desired_fingerprint ?? row.fingerprint))) {
                 db.prepare(`INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint,logical_key,desired_fingerprint) VALUES (?,?,?,?,?,?,?,?)`).run(input.projectId, input.revisionId, row.work_key, row.work_id, row.piece_id, row.fingerprint, logicalKey, after);
                 carried.add(logicalKey);
+                if (own !== undefined)
+                    carried.add(row.work_key);
             }
         }
         const live = db.prepare("SELECT id FROM revision_work WHERE project_id=?").all(input.projectId);
@@ -58,6 +70,15 @@ export function transitionRevisionWork(deps, input) {
             const exact = input.recipes?.find((row) => row.key === key);
             if (exact !== undefined && exact.fingerprint !== fp)
                 throw new Error("Slopify hit an internal error (a planned step doesn't match the saved project version). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+            // An undo, a restore or a save repeated while a step waits for Resume asks for a
+            // step the project already has a row for. A finished one is the result itself; a
+            // held copy nobody started is the same placeholder. Minting another each time left a
+            // new held row per save, and an undo re-queued work that had already finished.
+            const existing = existingWork(db, input.projectId, key, fp);
+            if (existing !== undefined) {
+                db.prepare(`INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint) VALUES (?,?,?,?,?,?)`).run(input.projectId, input.revisionId, key, existing.workId, existing.pieceId, fp);
+                continue;
+            }
             const kind = exact?.stage ?? stageForKey(key);
             const stage = db
                 .prepare("SELECT id FROM stages WHERE project_id=? AND kind=?")
@@ -90,6 +111,24 @@ export function transitionRevisionWork(deps, input) {
         }
     });
 }
+// A finished row wins over a held one. A held row counts only while nothing ran for it:
+// no attempt, nothing submitted, and no planning context (admission gives a row that).
+function existingWork(db, projectId, key, fingerprint) {
+    const row = db
+        .prepare(`SELECT w.id AS work_id,p.id AS piece_id FROM revision_work w
+      JOIN revision_work_pieces p ON p.work_id=w.id
+      WHERE w.project_id=? AND p.work_key=? AND p.fingerprint=? AND (
+        (w.state='done' AND p.state='done') OR
+        (w.state='pending' AND w.dispatch_state='held' AND p.state='held'
+          AND p.submitted_at IS NULL AND w.recipe_context IS NULL
+          AND NOT EXISTS(SELECT 1 FROM attempts a WHERE a.work_id=w.id))
+      )
+      ORDER BY CASE w.state WHEN 'done' THEN 0 ELSE 1 END, w.rowid DESC LIMIT 1`)
+        .get(projectId, key, fingerprint);
+    return row === undefined
+        ? undefined
+        : { workId: z.string().parse(row.work_id), pieceId: z.string().parse(row.piece_id) };
+}
 function stageForKey(key) {
     const prefix = key.split(":")[0];
     if (prefix === "research")
@@ -98,7 +137,7 @@ function stageForKey(key) {
         return "article";
     if (prefix === "audio" || prefix === "narration")
         return "audio";
-    if (prefix === "image")
+    if (prefix === "image" || prefix === "reference")
         return "images";
     if (prefix === "thumbnail")
         return "thumbnail";

package/dist/slices/revisions/adopt-content.js

@@ -30,6 +30,13 @@ export function baselineContent(deps, project, outputs, pieces, assets, template
         if (asset !== undefined)
             provided[stage] = asset.id;
     }
+    // An uploaded establishing image, attached when the run started.
+    if (project.config.reference?.source === "provide") {
+        const output = outputs.find((row) => row.role === "reference");
+        const asset = output === undefined ? undefined : assets.get(output.path);
+        if (asset !== undefined)
+            provided.reference = asset.id;
+    }
     const imageDefinitions = {};
     const order = [];
     const imagePieces = pieces.filter((row) => row.kind === "image");

package/dist/slices/revisions/adopt.js

@@ -13,7 +13,9 @@ import { getRevisionView } from "./view.js";
 export function ensureBaseline(deps, projectId) {
     return withProjectControl(deps.db, projectId, () => adoptBaseline(deps, projectId));
 }
-export function adoptBaseline(deps, projectId, templates) {
+export function adoptBaseline(deps, projectId, templates, 
+// The Shorts step's background music a new run was started with, already a project asset.
+supplied = {}) {
     return transact(deps.db, () => {
         const project = projectById(deps.db, projectId);
         if (project === undefined)
@@ -29,7 +31,10 @@ export function adoptBaseline(deps, projectId, templates) {
         const stages = stagesOf(deps.db, projectId);
         const pieces = stages.flatMap((stage) => allPiecesOf(deps.db, stage.id));
         const assets = adoptAssets(deps, projectId, outputs, pieces);
-        const content = baselineContent(deps, project, outputs, pieces, assets, templates);
+        const content = {
+            ...baselineContent(deps, project, outputs, pieces, assets, templates),
+            ...(supplied.shortsMusic === undefined ? {} : { shortsMusic: supplied.shortsMusic }),
+        };
         const fingerprints = baselineFingerprints(project, outputs, pieces, content, stages);
         const revision = {
             id: deps.ids.next(),

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

@@ -1,5 +1,7 @@
 import { statSync } from "node:fs";
 import { z } from "zod";
+import { referenceKey } from "../admission/model.js";
+import { usesReference } from "../admission/rules.js";
 import { outputPath, stagingPath } from "../storage/layout.js";
 import { stagedFileById } from "../storage/repo.js";
 export function bindUpload(content, upload, assetId) {
@@ -11,6 +13,8 @@ export function bindUpload(content, upload, assetId) {
             ...content,
             narrationOverrides: { ...content.narrationOverrides, [to.key]: { kind: "asset", assetId } },
         };
+    if (to.kind === "shortsMusic")
+        return { ...content, shortsMusic: assetId };
     const image = content.imageDefinitions[to.imageKey];
     if (image === undefined)
         throw new Error("Validated image destination disappeared.");
@@ -29,13 +33,18 @@ export function validateUploads(deps, edit) {
     for (const [index, upload] of (edit.uploads ?? []).entries()) {
         const field = `uploads.${index}`;
         const to = upload.destination;
-        if ((to.kind === "provided" && edit.config.sources[to.stage] !== "provide") ||
+        if ((to.kind === "provided" && !providesOwnFile(edit.config, to.stage)) ||
             (to.kind === "narration" && edit.config.sources.audio !== "generate") ||
             (to.kind === "image" && edit.config.sources.images === "off"))
             fields.push({
                 field,
                 message: "This section is off or not set to use your own file. Change the section's setting first, then add the file.",
             });
+        if (to.kind === "shortsMusic" && edit.config.shorts?.enabled !== true)
+            fields.push({
+                field,
+                message: "Background music is only used by the shorts. Turn Shorts on in Edit project → Shorts, then add the music.",
+            });
         const destination = JSON.stringify(to);
         if (staged.has(upload.stagedFileId) || destinations.has(destination))
             fields.push({
@@ -45,7 +54,13 @@ export function validateUploads(deps, edit) {
         staged.add(upload.stagedFileId);
         destinations.add(destination);
         const file = stagedFileById(deps.db, upload.stagedFileId);
-        const kind = to.kind === "provided" ? to.stage : to.kind === "image" ? "images" : "audio";
+        const kind = to.kind === "provided"
+            ? to.stage === "reference"
+                ? "images"
+                : to.stage
+            : to.kind === "image"
+                ? "images"
+                : "audio";
         if (file === undefined ||
             file.state !== "staged" ||
             file.stageKind !== kind ||
@@ -70,7 +85,7 @@ export function validateUploads(deps, edit) {
 export function validateAssetReferences(deps, projectId, content, prepared) {
     const fields = [];
     const refs = [];
-    for (const key of ["research", "article", "audio", "thumbnail"]) {
+    for (const key of ["research", "article", "audio", "thumbnail", "reference"]) {
         const id = content.provided[key];
         if (id !== undefined)
             refs.push([`content.provided.${key}`, id, key, false]);
@@ -87,7 +102,10 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
         audio: ["audio_body", "audio_intro", "audio_outro", "audio_export"],
         images: ["image"],
         thumbnail: ["thumbnail"],
+        reference: ["reference"],
     };
+    // The establishing image is the Images stage's.
+    const stageOf = (kind) => (kind === "reference" ? "images" : kind);
     for (const [field, id, kind, allowPiece] of refs) {
         if (!prepared.some((row) => row.id === id && row.projectId === projectId) &&
             deps.db
@@ -100,7 +118,7 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
         if (!prepared.some((row) => row.id === id) &&
             deps.db
                 .prepare("SELECT 1 FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? AND json_extract(descriptor,'$.role') IN (SELECT value FROM json_each(?))")
-                .get(projectId, id, kind, JSON.stringify(roles[kind])) === undefined &&
+                .get(projectId, id, stageOf(kind), JSON.stringify(roles[kind])) === undefined &&
             (!allowPiece ||
                 deps.db
                     .prepare("SELECT 1 FROM revision_pieces WHERE project_id=? AND asset_id=? AND stage_kind=? AND json_extract(descriptor,'$.kind') IN (SELECT value FROM json_each(?))")
@@ -115,6 +133,17 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
                 message: "This file cannot be used in this section. Choose a file of the right kind.",
             });
     }
+    // The shorts' music is uploaded with this edit, or was this project's music before.
+    const music = content.shortsMusic;
+    if (music !== undefined &&
+        !prepared.some((row) => row.id === music && row.projectId === projectId) &&
+        deps.db
+            .prepare("SELECT 1 FROM project_revisions WHERE project_id=? AND json_extract(content,'$.shortsMusic')=? LIMIT 1")
+            .get(projectId, music) === undefined)
+        fields.push({
+            field: "content.shortsMusic",
+            message: "This music file does not belong to this project. Reload the page and choose the music again.",
+        });
     return fields;
 }
 export async function measureAudio(deps, projectId, path) {
@@ -132,12 +161,25 @@ export function assetPath(deps, projectId, id) {
         .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
         .get(projectId, id)).path;
 }
+// A stage whose own file the project uses: Provide for audio and the thumbnail, Upload for the
+// establishing image.
+export function providesOwnFile(config, kind) {
+    return kind === "reference"
+        ? usesReference(config) && config.reference?.source === "provide"
+        : config.sources[kind] === "provide";
+}
+// Where each provided file is published: its work key and output role.
+export const providedOutput = {
+    audio: { workKey: "audio:provided", role: "audio_body" },
+    thumbnail: { workKey: "thumbnail:image", role: "thumbnail" },
+    reference: { workKey: referenceKey, role: "reference" },
+};
 export function providedAssetSelected(base, kind, assetId) {
-    return (base.revision.config.sources[kind] === "provide" &&
+    return (providesOwnFile(base.revision.config, kind) &&
         base.outputs.some((row) => row.selected &&
             row.assetId === assetId &&
-            row.workKey === (kind === "audio" ? "audio:provided" : "thumbnail:image") &&
-            row.output.role === (kind === "audio" ? "audio_body" : "thumbnail")));
+            row.workKey === providedOutput[kind].workKey &&
+            row.output.role === providedOutput[kind].role));
 }
 export function validateReplacementAvailability(deps, base, edit) {
     const previous = new Set([
@@ -145,10 +187,10 @@ export function validateReplacementAvailability(deps, base, edit) {
         ...Object.values(base.revision.content.imageDefinitions).map((row) => row.assetId),
         ...Object.values(base.revision.content.narrationOverrides).flatMap((row) => row.kind === "asset" ? [row.assetId] : []),
     ]);
-    for (const kind of ["audio", "thumbnail"]) {
+    for (const kind of ["audio", "thumbnail", "reference"]) {
         const assetId = edit.content.provided[kind];
         if (assetId !== undefined &&
-            edit.config.sources[kind] === "provide" &&
+            providesOwnFile(edit.config, kind) &&
             !providedAssetSelected(base, kind, assetId) &&
             !edit.uploads?.some((row) => row.destination.kind === "provided" && row.destination.stage === kind))
             previous.delete(assetId);