@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/template-studio/scope.js

@@ -0,0 +1,124 @@
+import { detectSlots } from "../admission/substitute.js";
+// What a template's paid sample makes: a short taste of one video about the sample topic, so a
+// Save costs cents, not a whole video. The limits are the document's (fewer pictures, one
+// thumbnail, one short, no checkpoints) and the steps' (`config.sample`: the article's outline
+// and first chapter, the narration's opening).
+// The most pictures a sample draws.
+export const samplePictures = 4;
+// The narration a sample says: about 30 seconds, the length of the video sample.
+export const sampleSpokenWords = 80;
+// The shortest short a sample cuts: its narration is only about 30-45 seconds, so a template's
+// own minimum (45 s or more for the starter packs) would leave nothing to cut.
+export const sampleShortMinSeconds = 15;
+// Put under the article prompt of a sample, unless the person asked for the full script. The
+// prompt anatomy shows it as Slopify's.
+export const sampleArticleInstruction = "This is a short sample of the script: write the outline and only chapter 1, then stop.";
+// The template's setup as its sample runs it. Every keyword the title names and the template
+// leaves empty is the topic; a title without one is the topic itself. A section the user
+// provides at run time has no sample, so it is off here, with no file to attach; text the
+// template holds is kept.
+export function sampleDocument(template, scope) {
+    const { form } = template;
+    const topic = scope.topic.trim();
+    const names = detectSlots(form.title).names;
+    const values = Object.create(null);
+    for (const [name, value] of Object.entries(form.values))
+        values[name] = value;
+    for (const name of names)
+        if ((values[name] ?? "").trim() === "")
+            values[name] = topic;
+    const off = (source) => (source === "provide" ? "off" : source);
+    // Text the template itself holds (pasted research or article) is the same in every run, so
+    // the sample uses it; a file is added to each video in Play, so there is none here.
+    const kept = (source, text) => source === "provide" && text.trim() !== "" ? source : off(source);
+    const research = kept(form.sources.research, form.provided.research);
+    const article = kept(form.sources.article, form.provided.article);
+    const sources = {
+        research,
+        article,
+        audio: off(form.sources.audio),
+        images: off(form.sources.images),
+        thumbnail: off(form.sources.thumbnail),
+        video: off(form.sources.video),
+        ...(form.sources.document === undefined ? {} : { document: off(form.sources.document) }),
+    };
+    const reviews = form.reviews === undefined
+        ? undefined
+        : form.reviews.reviewer === "agent"
+            ? // An agent's reviews are answered outside Slopify: the sample never asks it.
+                { ...form.reviews, stages: {} }
+            : form.reviews;
+    const { imageScale: _scaled, ...unscaled } = form;
+    return {
+        ...template,
+        variants: [],
+        form: {
+            ...unscaled,
+            title: names.length === 0 ? topic : form.title,
+            values,
+            sources,
+            checkpoints: [],
+            thumbnailCount: 1,
+            imagePrompts: cappedPrompts(form.imagePrompts, samplePictures),
+            ...(form.shorts === undefined
+                ? {}
+                : {
+                    shorts: {
+                        ...form.shorts,
+                        count: form.shorts.enabled ? "1" : form.shorts.count,
+                        minSeconds: sampleShortMinimum(form.shorts.minSeconds),
+                    },
+                }),
+            ...(reviews === undefined ? {} : { reviews }),
+            ...(form.reference === undefined || form.reference.source !== "provide"
+                ? {}
+                : { reference: { ...form.reference, source: "off" } }),
+            ...(form.ambientBed === undefined || form.ambientBed.source !== "upload"
+                ? {}
+                : { ambientBed: { ...form.ambientBed, source: "none" } }),
+            provided: {
+                research: research === "provide" ? form.provided.research : "",
+                article: article === "provide" ? form.provided.article : "",
+                audio: null,
+                thumbnail: null,
+                images: [],
+                ...(form.provided.reference === undefined ? {} : { reference: null }),
+                ...(form.provided.shortsMusic === undefined ? {} : { shortsMusic: null }),
+                ...(form.provided.ambientBed === undefined ? {} : { ambientBed: null }),
+            },
+        },
+    };
+}
+// The image prompts with at most `most` pictures between them, in order: each keeps its own
+// number while they fit, and a prompt past the limit draws none.
+function cappedPrompts(prompts, most) {
+    let left = most;
+    return prompts.flatMap((prompt) => {
+        const wanted = Number.parseInt(prompt.number, 10);
+        const count = Math.min(Number.isFinite(wanted) && wanted > 0 ? wanted : 1, left);
+        left -= count;
+        return count > 0 ? [{ ...prompt, number: String(count) }] : [];
+    });
+}
+// The opening of the narration a sample says: whole sentences up to about `words` words, at
+// least the first sentence.
+export function sampleNarrationText(text, words = sampleSpokenWords) {
+    const sentences = text.match(/[^.!?\n]+(?:[.!?]+["')\]]*|\n+|$)/gu) ?? [text];
+    let kept = "";
+    let count = 0;
+    for (const sentence of sentences) {
+        const size = sentence.split(/\s+/u).filter((word) => word !== "").length;
+        if (kept !== "" && count + size > words)
+            break;
+        kept += sentence;
+        count += size;
+    }
+    return kept.trim();
+}
+// The template's minimum, or the sample's when the template's is longer (or not a number).
+function sampleShortMinimum(minSeconds) {
+    const wanted = Number.parseInt(minSeconds, 10);
+    return Number.isFinite(wanted) && wanted <= sampleShortMinSeconds
+        ? minSeconds
+        : String(sampleShortMinSeconds);
+}

package/dist/slices/template-studio/sections.js

@@ -0,0 +1,176 @@
+import { templateSections } from "./model.js";
+export const sourceSections = {
+    research: "subject",
+    article: "script",
+    audio: "voice",
+    images: "pictures",
+    thumbnail: "thumbnail",
+    video: "video",
+    document: "document",
+};
+const providedSections = {
+    research: "subject",
+    article: "script",
+    audio: "voice",
+    thumbnail: "thumbnail",
+    images: "pictures",
+    reference: "pictures",
+    shortsMusic: "shorts",
+    ambientBed: "video",
+};
+export const formSections = {
+    title: "subject",
+    language: "subject",
+    values: "subject",
+    checkpoints: "reviews",
+    reviews: "reviews",
+    format: "video",
+    sources: null,
+    provided: null,
+    llm: "script",
+    articlePrompt: "script",
+    intro: "script",
+    outro: "script",
+    audio: "voice",
+    narrationPrompt: "voice",
+    loudness: "voice",
+    sentencePause: "voice",
+    paragraphPause: "voice",
+    removeBreaths: "voice",
+    deEss: "voice",
+    levelSentences: "voice",
+    chunking: "voice",
+    voices: "voice",
+    images: "pictures",
+    reference: "pictures",
+    imagePrompts: "pictures",
+    imageScale: "pictures",
+    imageScenes: "pictures",
+    subtitles: "video",
+    imageSeconds: "video",
+    edgeSilenceSeconds: "video",
+    zoomPercent: "video",
+    motionStyle: "video",
+    silenceGapSeconds: "video",
+    videoEdit: "video",
+    ambientBed: "video",
+    showFigures: "video",
+    useBrandKit: "video",
+    thumbnailPrompt: "thumbnail",
+    thumbnailCount: "thumbnail",
+    shorts: "shorts",
+    document: "document",
+    youtubeDescription: "upload",
+    descriptionPrompt: "upload",
+    social: "upload",
+};
+export const documentSections = {
+    schemaVersion: null,
+    librarySnapshot: null,
+    templateSource: null,
+    section: null,
+    channelId: "subject",
+    variants: "subject",
+    queue: "schedule",
+    expectedWords: "script",
+    previewText: "voice",
+    fontUpload: "video",
+};
+// The section a setting belongs to, by its path in the template document (`form.audio.voice`).
+// Null for what no section shows (the schema version, Play's open tab).
+export function sectionOfField(path) {
+    const [top, field, key] = path;
+    if (top !== "form")
+        return top === undefined ? null : (lookup(documentSections, top) ?? null);
+    if (field === "sources")
+        return key === undefined ? null : (lookup(sourceSections, key) ?? null);
+    if (field === "provided")
+        return key === undefined ? null : (lookup(providedSections, key) ?? null);
+    return field === undefined ? null : (lookup(formSections, field) ?? null);
+}
+function lookup(table, key) {
+    return Object.hasOwn(table, key) ? table[key] : undefined;
+}
+// The section a piece of rebuild work shows its sample in, by its work key (`article:body`,
+// `image:harbor`, `review:article:body`). Undefined for a key no section shows.
+export function sectionOfWork(key) {
+    if (key.startsWith("review:"))
+        return "reviews";
+    const prefix = key.split(":")[0] ?? "";
+    return workPrefixes[prefix];
+}
+const workPrefixes = {
+    research: "subject",
+    article: "script",
+    entry: "script",
+    script: "script",
+    audio: "voice",
+    narration: "voice",
+    level: "voice",
+    voices: "voice",
+    image: "pictures",
+    images: "pictures",
+    reference: "pictures",
+    figure: "pictures",
+    thumbnail: "thumbnail",
+    export: "video",
+    subtitles: "video",
+    video: "video",
+    animate: "video",
+    shorts: "shorts",
+    youtube: "upload",
+    social: "upload",
+    document: "document",
+};
+// What a section's sample is made from: a change in a section outdates the samples after it.
+// Reviews judge the script, voice, pictures and thumbnail, so a change there outdates reviews;
+// the schedule depends on nothing but itself and the subject (titles come from the topics).
+const dependents = {
+    subject: ["script", "schedule"],
+    script: ["voice", "pictures", "thumbnail", "document", "upload", "reviews"],
+    voice: ["video", "reviews"],
+    pictures: ["video", "thumbnail", "reviews"],
+    video: ["shorts", "upload"],
+    thumbnail: ["reviews"],
+    shorts: [],
+    document: [],
+    reviews: [],
+    upload: [],
+    schedule: [],
+};
+// Every section whose sample a change from `before` to `after` outdates, in pipeline order.
+export function affectedSections(before, after) {
+    const changed = new Set();
+    for (const path of changedPaths(before, after, [])) {
+        const section = sectionOfField(path);
+        if (section !== null)
+            changed.add(section);
+    }
+    return withDependents([...changed]);
+}
+// The sections given and every section whose sample is made from them, in pipeline order.
+export function withDependents(sections) {
+    const affected = new Set();
+    const visit = (section) => {
+        if (affected.has(section))
+            return;
+        affected.add(section);
+        for (const next of dependents[section])
+            visit(next);
+    };
+    for (const section of sections)
+        visit(section);
+    return templateSections.filter((section) => affected.has(section));
+}
+// Paths go down to the third level (`form.sources.audio`), where every section boundary lies.
+function changedPaths(before, after, path) {
+    if (JSON.stringify(before) === JSON.stringify(after))
+        return [];
+    if (path.length >= 3 || !isRecord(before) || !isRecord(after))
+        return [path];
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+    return [...keys].flatMap((key) => changedPaths(before[key], after[key], [...path, key]));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/slices/template-studio/service.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { lastAgentConnection } from "../agents/connection.js";
+import { snapshotEntry, snapshotPrompt } from "../library/snapshot.js";
+import { readNotificationUrl } from "../notifications/settings.js";
+import { templateById } from "../project-templates/repo.js";
+import { scheduleRows } from "../schedules/repo.js";
+import { readProviderDefaults } from "../settings/first-run.js";
+import { listVoices, readJsonSetting } from "../settings/repo.js";
+import { freeChecks } from "./checks.js";
+import { checkedVersion, gateOf, isGated, runnableVersion } from "./gate.js";
+import { queuedJob, runningJob } from "./jobs.js";
+import { fallbackSampleTopic } from "./model.js";
+import { paidView } from "./paid-view.js";
+import { gatesOf, sampleOf } from "./repo.js";
+import { reviewsPath } from "./reviews-path.js";
+import { monthlyCost, upcomingRuns } from "./schedule-sample.js";
+import { baseStatuses, madeStatuses } from "./status.js";
+export function createPriceCache() {
+    // ceiling: one entry per schedule and template version seen since boot, a few bytes each.
+    const prices = new Map();
+    return { get: (key) => prices.get(key), set: (key, price) => void prices.set(key, price) };
+}
+export function priceKey(schedule, template) {
+    return `${schedule.id}@${String(schedule.version)}:${template.id}@${String(template.version)}`;
+}
+export const sampleTopicKey = "templateStudio.sampleTopic.default";
+export function defaultSampleTopic(db) {
+    const topic = readJsonSetting(db, sampleTopicKey, z.string(), fallbackSampleTopic).trim();
+    return topic === "" ? fallbackSampleTopic : topic;
+}
+// The schedules that run a template now: not deleted, not finished.
+export function templateSchedules(db, templateId) {
+    return scheduleRows(db).filter((schedule) => 
+    // A design schedule names a design template, never a project template.
+    schedule.templateKind === "project" &&
+        schedule.templateId === templateId &&
+        schedule.deletedAt === null &&
+        (schedule.status === "active" || schedule.status === "paused"));
+}
+function fitOf(schedule) {
+    const { cadence } = schedule;
+    return {
+        id: schedule.id,
+        name: schedule.name,
+        topicKeyword: schedule.topicKeyword,
+        runDays: cadence.kind === "weekly"
+            ? cadence.days
+            : cadence.kind === "daily"
+                ? [0, 1, 2, 3, 4, 5, 6]
+                : [],
+        releases: schedule.releases.map((release) => ({
+            day: release.day,
+            shorts: release.shorts.length,
+        })),
+        paused: schedule.status === "paused",
+    };
+}
+function bodiesOf(db, document) {
+    const snapshot = document.librarySnapshot;
+    if (snapshot === undefined)
+        return [];
+    return [
+        ...snapshot.prompts.map((prompt) => snapshotPrompt(db, snapshot, prompt.kind, prompt.name)?.body ?? prompt.body),
+        ...snapshot.entries.map((entry) => snapshotEntry(db, snapshot, entry.category, entry.name)?.body ?? entry.body),
+    ];
+}
+// The providers' readiness probes CLIs, which takes seconds: every caller in the window
+// shares one lookup, and a failed one is never kept.
+export function createReadinessCache(load, now = Date.now, ttlMs = 30_000) {
+    let held;
+    return () => {
+        const at = now();
+        if (held !== undefined && at - held.at < ttlMs)
+            return held.value;
+        const value = load();
+        const entry = { at, value };
+        held = entry;
+        value.catch(() => {
+            if (held === entry)
+                held = undefined;
+        });
+        return value;
+    };
+}
+const missingTemplate = "This template no longer exists; it may have been deleted. Go to Templates to see your templates.";
+// The studio page's content, answered without waiting for the providers' readiness: the
+// checks that need it are read on their own (`getStudioChecks`).
+export async function getStudio(deps, id) {
+    const template = templateById(deps.db, id);
+    if (template === undefined)
+        return { ok: false, reason: "not-found", message: missingTemplate };
+    const gates = gatesOf(deps.db, id);
+    const sample = sampleOf(deps.db, id);
+    const schedules = templateSchedules(deps.db, id);
+    const now = deps.clock.now();
+    const cost = monthlyCost(schedules, pricesOf(deps, schedules, template), now);
+    const running = runningJob(deps.db);
+    const queued = queuedJob(deps.db, id);
+    const free = deps.free.view(id, template.document, {
+        running: running?.templateId === id && running.templateVersion === template.version,
+        queued: queued !== undefined,
+    });
+    const paid = paidView(deps, id, template);
+    return {
+        ok: true,
+        value: {
+            template,
+            gate: gateOf(gates, template.version),
+            runnableVersion: runnableVersion(gates, template.version) ?? null,
+            gated: isGated(gates),
+            checkedVersion: checkedVersion(gates, template.version) ?? null,
+            sample: {
+                topic: sample?.topic ?? defaultSampleTopic(deps.db),
+                topicSource: sample?.topicSource ?? "fixed",
+                fullScript: sample?.fullScript ?? false,
+            },
+            sections: carriedSentences(baseStatuses(template.document, {
+                ...madeStatuses(free, schedules.length, cost),
+                ...paid.statuses,
+            }), gates.find((gate) => gate.version === template.version)),
+            paid: paid.view,
+            free,
+            schedule: { runs: upcomingRuns(schedules, template.document, now), cost },
+            reviews: reviewsPath(template.document),
+        },
+    };
+}
+// A version Slopify wrote itself keeps its gate, but what it changed has no sample yet: each
+// stale section says who made the change.
+function carriedSentences(sections, gate) {
+    if (gate?.state !== "carried" || gate.carriedFrom === null)
+        return sections;
+    const why = `Slopify made version ${String(gate.version)} from version ${String(gate.carriedFrom)} itself (a retired model switched, or a new name on restore).`;
+    return sections.map((section) => section.state === "stale" ? { ...section, sentence: `${why} ${section.sentence}` } : section);
+}
+function pricesOf(deps, schedules, template) {
+    return new Map(schedules.flatMap((schedule) => {
+        const price = deps.prices.get(priceKey(schedule, template));
+        return price === undefined ? [] : [[schedule.id, price]];
+    }));
+}
+// The free checks a template passes before Mark ready. The providers' readiness is the slow
+// part, so the page asks for these on their own.
+export async function getStudioChecks(deps, id) {
+    const template = templateById(deps.db, id);
+    if (template === undefined)
+        return { ok: false, reason: "not-found", message: missingTemplate };
+    const statuses = await deps.providerStatuses();
+    const schedules = templateSchedules(deps.db, id);
+    const now = deps.clock.now();
+    const cost = monthlyCost(schedules, pricesOf(deps, schedules, template), now);
+    return {
+        ok: true,
+        value: {
+            version: template.version,
+            checks: freeChecks({
+                templateId: id,
+                document: template.document,
+                bodies: bodiesOf(deps.db, template.document),
+                providers: new Map(statuses.map((status) => [
+                    status.id,
+                    { name: status.displayName, ready: readinessIsUsable(status.readiness) },
+                ])),
+                defaults: readProviderDefaults(deps.db),
+                schedules: schedules.map(fitOf),
+                voices: listVoices(deps.db),
+                monthlyCost: cost,
+                notificationUrl: readNotificationUrl(deps.db) !== null,
+                agentSeenAt: lastAgentConnection(deps.db),
+                now,
+            }),
+        },
+    };
+}

package/dist/slices/template-studio/status.js

@@ -0,0 +1,191 @@
+import { sectionLabel, templateSections, } from "./model.js";
+import { affectedSections } from "./sections.js";
+// What a section's sample is made from, by the step that makes it; null for a section whose
+// sample never depends on a source (the schedule).
+function sourceOf(document, section) {
+    const { form } = document;
+    switch (section) {
+        // Text the template itself holds is in every run, and in its sample (`scope.ts`).
+        case "subject":
+            return heldText(form.sources.research, form.provided.research);
+        case "script":
+            return heldText(form.sources.article, form.provided.article);
+        case "voice":
+            return form.sources.audio;
+        case "pictures":
+            return form.sources.images;
+        case "thumbnail":
+            return form.sources.thumbnail;
+        case "video":
+            return form.sources.video;
+        case "document":
+            return form.sources.document ?? "off";
+        case "shorts":
+            return form.shorts?.enabled === true && form.sources.video !== "off" ? "generate" : "off";
+        case "upload":
+            return form.sources.video;
+        case "reviews": {
+            const on = (form.checkpoints?.length ?? 0) > 0 ||
+                Object.values(form.reviews?.stages ?? {}).some((stage) => stage.mode !== "off");
+            return on ? "generate" : "off";
+        }
+        case "schedule":
+            return null;
+    }
+}
+function heldText(source, text) {
+    return source === "provide" && text.trim() !== "" ? "held" : source;
+}
+// One press of Make sample makes every paid section's sample at once, so its sentence names
+// them: "Make sample makes the samples of Title and keywords, Article and Narration together,
+// about the sample topic."
+export function makeSampleSentence(document) {
+    const made = paidSections
+        .filter((id) => {
+        const source = sourceOf(document, id);
+        return source !== "off" && source !== "provide";
+    })
+        .map((id) => sectionLabel[id]);
+    if (made.length <= 1)
+        return "Make sample shows what this section makes, about the sample topic.";
+    const names = `${made.slice(0, -1).join(", ")} and ${made.at(-1) ?? ""}`;
+    return `Make sample makes the samples of ${names} together, about the sample topic.`;
+}
+const offSentence = {
+    subject: "Research is off: the script is written from the topic alone.",
+    script: "The article is off.",
+    voice: "The narration is off.",
+    pictures: "Images are off.",
+    thumbnail: "The thumbnail is off.",
+    video: "The video is off.",
+    shorts: "Shorts are off.",
+    document: "The PDF is off.",
+    reviews: "No pause or AI check is on.",
+    upload: "No video, so there is no YouTube description or post.",
+    schedule: "",
+};
+// Each section's state before any sample: off, provided at run time (no sample, never blocks
+// Mark ready), or waiting for its first sample. Samples made since replace these (`free` and,
+// later, the paid samples' versions).
+export function baseStatuses(document, made = {}) {
+    return templateSections.map((id) => {
+        const label = sectionLabel[id];
+        const source = sourceOf(document, id);
+        if (source === "off")
+            return { id, label, state: "off", sentence: offSentence[id] };
+        if (source === "provide")
+            return {
+                id,
+                label,
+                state: "provided",
+                sentence: "Provided at run time: you add the file to each video, so there is no sample.",
+            };
+        return (made[id] ?? {
+            id,
+            label,
+            state: "stale",
+            sentence: paidSections.includes(id)
+                ? makeSampleSentence(document)
+                : "Make sample shows what this section makes, about the sample topic.",
+        });
+    });
+}
+// What the free samples say of their sections. The voice's own sample is a paid one; until it
+// is made, Voice shows the loudness before and after.
+export function madeStatuses(free, schedules, cost) {
+    const of = (id, sample) => sample.state === "off"
+        ? undefined
+        : { id, label: sectionLabel[id], state: sample.state, sentence: sample.sentence };
+    const made = {};
+    const video = of("video", free.video);
+    if (video !== undefined)
+        made.video = video;
+    const voice = of("voice", free.loudness);
+    if (voice !== undefined)
+        made.voice = voice;
+    const document = of("document", free.document);
+    if (document !== undefined)
+        made.document = document;
+    made.reviews = {
+        id: "reviews",
+        label: sectionLabel.reviews,
+        state: "current",
+        sentence: "Where a run pauses for you, and which AI checks run.",
+    };
+    made.schedule =
+        schedules === 0
+            ? {
+                id: "schedule",
+                label: sectionLabel.schedule,
+                state: "off",
+                sentence: "No schedule runs this template yet.",
+            }
+            : {
+                id: "schedule",
+                label: sectionLabel.schedule,
+                state: cost?.problem === null || cost === null ? "current" : "stale",
+                sentence: cost?.problem ??
+                    (cost !== null && cost.paused.schedules === schedules
+                        ? `${schedules === 1 ? "1 paused schedule uses" : `${String(schedules)} paused schedules use`} this template: its next runs once resumed, and what they would cost a month.`
+                        : "The next runs with the titles their topics fill, and the cost a month."),
+            };
+    return made;
+}
+// The sections a paid sample shows: what the providers make. The video, the PDF and the
+// schedule keep their free samples; the voice shows the loudness until a paid one is made.
+export const paidSections = [
+    "subject",
+    "script",
+    "voice",
+    "pictures",
+    "thumbnail",
+    "shorts",
+    "upload",
+];
+// What each paid section's sample is for the current version: made for it, being made,
+// waiting (with why and what to press), failed (with the step's own sentence), or made for an
+// older version and outdated by a change since. A section the change since the last made
+// sample never touched keeps that sample, current.
+export function paidStatuses(input) {
+    const row = input.versions.find((one) => one.templateVersion === input.headVersion);
+    const done = input.versions.find((one) => one.state === "done" && one.templateVersion <= input.headVersion);
+    const madeFrom = done === undefined ? undefined : input.documentOf(done.templateVersion);
+    const changed = new Set(madeFrom === undefined || done === undefined
+        ? paidSections
+        : affectedSections(madeFrom, input.headDocument));
+    const status = (id, state, sentence) => ({
+        id,
+        label: sectionLabel[id],
+        state,
+        sentence,
+    });
+    const made = {};
+    if (row === undefined && done === undefined)
+        return made;
+    for (const id of paidSections) {
+        if (row?.state === "done") {
+            made[id] = status(id, "current", `Made for version ${String(input.headVersion)}.`);
+            continue;
+        }
+        if (!changed.has(id) && done !== undefined) {
+            made[id] = status(id, "current", `Made for version ${String(done.templateVersion)}; nothing it shows changed since.`);
+            continue;
+        }
+        const pending = row?.state === "queued" || row?.state === "making";
+        if (pending && (input.running || row?.state === "making"))
+            made[id] = status(id, "making", `Making the sample of version ${String(input.headVersion)}.`);
+        else if (pending)
+            made[id] = status(id, "waiting", input.busyElsewhere
+                ? "Waits for another template's sample to finish."
+                : "Queued: it starts in a moment.");
+        else if (row?.state === "held")
+            made[id] = status(id, "waiting", row.heldReason ?? "Waiting. Press Make sample to make it.");
+        else if (row?.state === "failed")
+            made[id] = status(id, "needs-fix", row.heldReason ?? "The sample failed. Press Make sample to try again.");
+        else
+            made[id] = status(id, "stale", done === undefined
+                ? makeSampleSentence(input.headDocument)
+                : `Changed since the sample of version ${String(done.templateVersion)}. Press Make sample to see it again.`);
+    }
+    return made;
+}