@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/estimate/requests.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { apiEquivalentOf, tokenCost } from "../run-cost/pricing.js";
+import { isLocalCliProvider, systemVoiceProvider } from "../settings/model.js";
 const quantity = z.number().finite().nonnegative();
 const common = z.object({
     stage: z.string(),
@@ -6,7 +8,12 @@ const common = z.object({
     variable: z.boolean().optional(),
     expectedWords: quantity.optional(),
 });
-const provider = common.extend({ provider: z.string(), model: z.string() });
+const provider = common.extend({
+    provider: z.string(),
+    model: z.string(),
+    // A CLI request whose API figure cannot be told in advance.
+    apiUnknown: z.literal(true).optional(),
+});
 const requestSchema = z.discriminatedUnion("kind", [
     provider
         .extend({ kind: z.literal("llm"), inputCharacters: quantity, outputCharacters: quantity })
@@ -26,6 +33,7 @@ export function estimateRequests(requests, catalogue) {
         low: rows.reduce((total, row) => total + (row.low ?? 0), 0),
         high: rows.reduce((total, row) => total + (row.high ?? 0), 0),
         unknown: rows.filter((row) => row.low === null).length,
+        ...apiTotals(rows),
         expectedWords: parsed.reduce((total, request) => total + (request.expectedWords ?? 0), 0),
         catalogueDate: catalogue.updatedAt,
         assumptions: [
@@ -39,16 +47,64 @@ export function groupEstimateRows(estimate) {
     const grouped = new Map();
     for (const row of estimate.rows) {
         const previous = grouped.get(row.stage);
+        const plan = previous?.onPlan === true || row.onPlan === true;
+        const sum = (left, right) => (left === null || right === null ? null : (left ?? 0) + (right ?? 0));
         grouped.set(row.stage, previous === undefined
             ? row
             : {
                 ...previous,
                 low: previous.low === null || row.low === null ? null : previous.low + row.low,
                 high: previous.high === null || row.high === null ? null : previous.high + row.high,
+                ...(plan
+                    ? {
+                        onPlan: true,
+                        apiLow: sum(previous.apiLow, row.apiLow),
+                        apiHigh: sum(previous.apiHigh, row.apiHigh),
+                    }
+                    : {}),
             });
     }
     const rows = [...grouped.values()];
-    return { ...estimate, rows, unknown: rows.filter((row) => row.low === null).length };
+    return {
+        ...estimate,
+        rows,
+        unknown: rows.filter((row) => row.low === null).length,
+        ...apiTotals(rows),
+    };
+}
+function apiTotals(rows) {
+    const plan = rows.filter((row) => row.onPlan === true);
+    if (plan.length === 0)
+        return {};
+    return {
+        apiLow: plan.reduce((total, row) => total + (row.apiLow ?? 0), 0),
+        apiHigh: plan.reduce((total, row) => total + (row.apiHigh ?? 0), 0),
+        apiUnknown: plan.filter((row) => row.apiLow === null || row.apiLow === undefined).length,
+    };
+}
+// A CLI call adds nothing to the bill - it runs on the user's plan - so it is known at $0,
+// with what the same tokens would cost through the API beside it, priced by the same
+// catalogue and the same token assumptions as a keyed model. A Codex image has no API
+// figure: how many drafts the agent draws is not known in advance.
+function onPlan(request, catalogue) {
+    const api = request.kind === "llm"
+        ? apiEquivalentOf(request.provider, request.model, catalogue)
+        : undefined;
+    const amount = api === undefined || request.kind !== "llm" || request.apiUnknown === true
+        ? null
+        : tokenCost(api.pricing, request.inputCharacters / 4, request.outputCharacters / 4);
+    return {
+        stage: request.stage,
+        low: 0,
+        high: 0,
+        detail: request.detail ??
+            (amount === null
+                ? "Runs on your CLI plan, so it adds no charge; no API price is listed for this model."
+                : `Runs on your CLI plan, so it adds no charge; priced as ${api?.name ?? "the API model"} through the API.`),
+        onPlan: true,
+        apiLow: amount === null ? null : amount * 0.5,
+        apiHigh: amount === null ? null : amount * 1.5,
+    };
 }
 function price(request, catalogue) {
     if (request.kind === "unknown")
@@ -65,6 +121,16 @@ function price(request, catalogue) {
             high: 0,
             detail: request.detail ?? "Local processing or retained output; no API fee.",
         };
+    if ((request.kind === "llm" || request.kind === "image") && isLocalCliProvider(request.provider))
+        return onPlan(request, catalogue);
+    if ((request.kind === "tts" || request.kind === "tts-estimate") &&
+        request.provider === systemVoiceProvider)
+        return {
+            stage: request.stage,
+            low: 0,
+            high: 0,
+            detail: "Spoken by your computer's built-in voice, so it costs nothing.",
+        };
     const family = request.kind === "tts-estimate" ? "tts" : request.kind;
     const model = catalogue[family].find((entry) => entry.provider === request.provider &&
         entry.id === request.model &&

package/dist/slices/eta/history.js

@@ -0,0 +1,56 @@
+import { modelKeyOf } from "./model.js";
+// How long steps took in finished runs, read from the stage rows' own start and finish times.
+// ceiling: the most recent finished steps are what the machine and the providers are like now;
+// a few hundred rows is a fraction of a millisecond to read and plenty for a median.
+const sampleLimit = 400;
+// A model's own history is used once it has this many finished steps; below that, every
+// step of the same kind is a fairer guess than one lucky or unlucky run.
+const ownModelMinimum = 2;
+export function readStageHistory(db) {
+    const samples = db
+        .prepare(`SELECT s.kind, s.started_at, s.finished_at, s.progress_total, p.config FROM stages s
+       JOIN projects p ON p.id=s.project_id
+       WHERE s.state='done' AND s.started_at IS NOT NULL AND s.finished_at IS NOT NULL
+       ORDER BY s.finished_at DESC LIMIT ?`)
+        .all(sampleLimit)
+        .flatMap((row) => {
+        const seconds = (Date.parse(String(row.finished_at)) - Date.parse(String(row.started_at))) / 1000;
+        if (!Number.isFinite(seconds) || seconds <= 0)
+            return [];
+        const kind = String(row.kind);
+        const units = typeof row.progress_total === "number" && row.progress_total > 0
+            ? row.progress_total
+            : undefined;
+        return [{ kind, model: modelKeyOf(kind, configOf(row.config)), seconds, units }];
+    });
+    return {
+        typicalSeconds: (kind, config, units) => {
+            const model = modelKeyOf(kind, config);
+            const own = samples.filter((one) => one.kind === kind && one.model === model);
+            const pool = own.length >= ownModelMinimum ? own : samples.filter((one) => one.kind === kind);
+            if (pool.length === 0)
+                return undefined;
+            // A step with a count scales with it: eight images take longer than two.
+            const counted = pool.filter((one) => one.units !== undefined);
+            if (units !== null && units > 0 && counted.length > 0)
+                return median(counted.map((one) => one.seconds / (one.units ?? 1))) * units;
+            return median(pool.map((one) => one.seconds));
+        },
+    };
+}
+function configOf(value) {
+    try {
+        const parsed = JSON.parse(String(value));
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function median(values) {
+    const sorted = values.toSorted((left, right) => left - right);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 1
+        ? (sorted[middle] ?? 0)
+        : ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+}

package/dist/slices/eta/model.js

@@ -0,0 +1,63 @@
+// Time left on a running step, said honestly. Two bases, in this order:
+// - progress: the step has counted some of its chapters, chunks or images, so the rest is
+//   estimated from the rate so far;
+// - history: nothing counted yet (a CLI image job drawing its first picture for minutes), so the
+//   estimate is how long the same kind of step, on the same provider and model when known,
+//   took in finished runs (`history.ts`), minus the time spent already.
+// Neither: "unknown", never a made-up number. A step past its usual time is "overdue".
+// Browser-safe: the project page and Home recompute it every second from the same inputs.
+export const etaBases = ["progress", "history", "overdue", "unknown"];
+// Undefined for a step that isn't running: a finished one has no time left, and a waiting one
+// hasn't started the clock.
+export function stageEta(stage, now) {
+    if (stage.state !== "running")
+        return undefined;
+    const started = stage.startedAt === null ? Number.NaN : Date.parse(stage.startedAt);
+    const spent = Number.isFinite(started) ? Math.max(0, (now - started) / 1000) : undefined;
+    const current = stage.progressCurrent ?? 0;
+    const total = stage.progressTotal ?? 0;
+    if (spent !== undefined && total > 0 && current > 0) {
+        if (current >= total)
+            return { basis: "progress", seconds: 0 };
+        return { basis: "progress", seconds: Math.round((spent / current) * (total - current)) };
+    }
+    const typical = stage.typicalSeconds;
+    if (typical === undefined || !Number.isFinite(typical) || typical <= 0)
+        return { basis: "unknown" };
+    const left = typical - (spent ?? 0);
+    return left > 0 ? { basis: "history", seconds: Math.round(left) } : { basis: "overdue" };
+}
+// "about 4 min left", "under a minute left", "about 1 h 10 min left", "finishing up",
+// "taking longer than usual", "time left unknown".
+export function etaLabel(eta) {
+    if (eta.basis === "unknown")
+        return "time left unknown";
+    if (eta.basis === "overdue")
+        return "taking longer than usual";
+    const seconds = eta.seconds ?? 0;
+    if (seconds <= 0)
+        return "finishing up";
+    if (seconds < 60)
+        return "under a minute left";
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `about ${String(minutes)} min left`;
+    const hours = Math.floor(minutes / 60);
+    const rest = minutes % 60;
+    return rest === 0
+        ? `about ${String(hours)} h left`
+        : `about ${String(hours)} h ${String(rest)} min left`;
+}
+export function modelKeyOf(kind, config) {
+    const choice = kind === "research" || kind === "article"
+        ? config.llm
+        : kind === "audio"
+            ? config.audio
+            : kind === "images" || kind === "thumbnail"
+                ? config.images
+                : undefined;
+    // A hand-edited config may hold anything here.
+    if (typeof choice?.provider !== "string" || typeof choice.model !== "string")
+        return undefined;
+    return `${choice.provider}/${choice.model}`;
+}

package/dist/slices/eta/view.js

@@ -0,0 +1,25 @@
+import { readStageHistory } from "./history.js";
+import { stageEta } from "./model.js";
+// The project's stage rows with each running step's time left. The history is read only when
+// something is running, so a finished project's page costs no extra query.
+export function stagesWithEta(db, stages, config, now) {
+    if (!stages.some((stage) => stage.state === "running"))
+        return [...stages];
+    const history = readStageHistory(db);
+    return stages.map((stage) => {
+        if (stage.state !== "running")
+            return stage;
+        const typical = history.typicalSeconds(stage.kind, config, stage.progressTotal);
+        const eta = stageEta({ ...stage, ...(typical === undefined ? {} : { typicalSeconds: typical }) }, now.valueOf());
+        return {
+            ...stage,
+            ...(typical === undefined ? {} : { typicalSeconds: Math.round(typical) }),
+            ...(eta === undefined
+                ? {}
+                : {
+                    etaBasis: eta.basis,
+                    ...(eta.seconds === undefined ? {} : { etaSeconds: eta.seconds }),
+                }),
+        };
+    });
+}

package/dist/slices/fixes/rules.js

@@ -0,0 +1,73 @@
+import { providers } from "../settings/model.js";
+const signIn = {
+    "claude-code": { name: "Claude Code", command: "claude auth login" },
+    codex: { name: "Codex", command: "codex login" },
+    gemini: { name: "Gemini", command: "gemini" },
+};
+const signedOut = /not signed in|sign-in has expired|not logged in|run\s+"?(?:codex login|claude auth login)|authentication required/i;
+const diskFull = /ENOSPC|no space left on device|disk (?:is )?full|not enough (?:free )?(?:disk )?space/i;
+const refusedWords = /refused to make|content (?:rules|policy|filter)|safety (?:system|filter)|flagged|moderation/i;
+const retiredModel = /\bunknown model\b|\bmodel\b[^\n]{0,80}?\b(?:not found|does not exist|retired|deprecated|decommissioned|no longer (?:available|supported)|is not available)/i;
+const keyTrouble = /did not accept the API key|API key is saved|invalid api key|key may be wrong/i;
+// Stages whose failed call draws an image from a prompt, which Soften and retry can reword.
+const drawn = ["images", "thumbnail"];
+export function fixFor(step) {
+    const reason = step.reason ?? "";
+    const cli = cliOf(step.provider, reason);
+    if (cli !== undefined && (signedOut.test(reason) || step.kind === "auth"))
+        return {
+            kind: "sign-in",
+            label: `Sign in to ${signIn[cli].name}`,
+            cli,
+            command: signIn[cli].command,
+        };
+    if (diskFull.test(reason))
+        return { kind: "free-space", label: "Free space" };
+    if (step.kind === "refusal" || refusedWords.test(reason))
+        return drawn.includes(step.stage)
+            ? { kind: "refused", label: "Soften and retry", soften: true }
+            : { kind: "refused", label: "Edit the prompt", soften: false };
+    if (retiredModel.test(reason))
+        return { kind: "switch-model", label: "Switch model" };
+    if (step.kind === "auth" || step.kind === "missing_key" || keyTrouble.test(reason)) {
+        const name = nameOf(step.provider);
+        return {
+            kind: "provider-settings",
+            label: name === undefined ? "Open Settings → Providers" : `Open Settings → Providers → ${name}`,
+            provider: step.provider ?? "",
+        };
+    }
+    return undefined;
+}
+// The CLI a failure names: the project's own choice, or the one its sentence mentions.
+function cliOf(provider, reason) {
+    if (provider === "claude-code" || provider === "gemini")
+        return provider;
+    if (provider === "codex" || provider === "codex-image")
+        return "codex";
+    if (/Codex CLI/.test(reason))
+        return "codex";
+    if (/Claude Code CLI/.test(reason))
+        return "claude-code";
+    if (/Gemini CLI/.test(reason))
+        return "gemini";
+    return undefined;
+}
+function nameOf(provider) {
+    return providers.find((one) => one.id === provider)?.displayName;
+}
+// Which provider a stage's calls go to, from the project's choices.
+export function stageProvider(config, stage) {
+    switch (stage) {
+        case "audio":
+            return config.audio?.provider;
+        case "images":
+        case "thumbnail":
+            return config.images?.provider;
+        case "research":
+        case "article":
+            return config.llm?.provider;
+        default:
+            return undefined;
+    }
+}

package/dist/slices/fonts/coverage.js

@@ -0,0 +1,82 @@
+import { fileURLToPath } from "node:url";
+import { languageInfo, languageLetters } from "../../kernel/ports/languages.js";
+import { resolveBoldFont, resolveFont } from "./catalog.js";
+import { discoverSystemFonts } from "./discovery.js";
+import { readFontFile } from "./files.js";
+import { mappedCodepoints, readFontMetadata } from "./sfnt.js";
+// Captions in a language the chosen font can't draw would come out as empty boxes. For every
+// language but English the chosen font is checked against that language's letters
+// (`languageLetters`); when it misses any, the captions use a bundled Noto font for the script,
+// else a font on this computer that has them all, else the render stops and says how to fix
+// it. English is never checked, so an English project renders with exactly the font it chose.
+// Small enough to ship: Latin, Greek and Cyrillic in one family, and the other alphabets'
+// own. Chinese, Japanese and Korean fonts run to 10-20 MB each, so they are not bundled.
+const bundled = {
+    latin: "NotoSans-Regular.ttf",
+    greek: "NotoSans-Regular.ttf",
+    cyrillic: "NotoSans-Regular.ttf",
+    arabic: "NotoSansArabic-Regular.ttf",
+    hebrew: "NotoSansHebrew-Regular.ttf",
+    devanagari: "NotoSansDevanagari-Regular.ttf",
+    thai: "NotoSansThai-Regular.ttf",
+};
+export function captionFontDeps(paths) {
+    return {
+        resolve: (id) => resolveFont(paths, id),
+        system: discoverSystemFonts,
+        bundledDir: fileURLToPath(new URL("../../assets/fonts/noto/", import.meta.url)),
+    };
+}
+// The font captions are drawn in, for the chosen font and the project language.
+export async function captionFont(deps, fontId, language) {
+    const chosen = await deps.resolve(fontId);
+    if (language === undefined || language === "en")
+        return chosen;
+    const letters = languageLetters(language);
+    if (await covers(chosen, letters))
+        return chosen;
+    const info = languageInfo(language);
+    const file = bundled[info.script];
+    if (file !== undefined) {
+        const font = await fontFile(`${deps.bundledDir}${file}`);
+        if (font !== undefined && (await covers(font, letters)))
+            return font;
+    }
+    for (const font of await deps.system())
+        if (await covers(font, letters))
+            return font;
+    throw new Error(`The caption font ${chosen.name} has no ${info.name} letters, and Slopify doesn't ship a font for ${info.name} (they are 10-20 MB). In Edit project → Subtitles, use Upload font in the caption font picker to add a font that has them (for example Noto Sans ${info.code === "ja" ? "JP" : info.code === "ko" ? "KR" : "SC"} from fonts.google.com), choose it there, then Try again.`);
+}
+// The same for text drawn bold (the shorts' captions): the chosen font's bold face when it has
+// the letters, else the fallback, which the renderer emboldens.
+export async function captionBoldFont(paths, fontId, language) {
+    if (language === undefined || language === "en")
+        return resolveBoldFont(paths, fontId);
+    const chosen = await resolveFont(paths, fontId);
+    const font = await captionFont(captionFontDeps(paths), fontId, language);
+    return font.path === chosen.path ? resolveBoldFont(paths, fontId) : font;
+}
+async function covers(font, letters) {
+    const bytes = await readFontFile(font.path);
+    if (bytes === undefined)
+        return false;
+    const found = mappedCodepoints(bytes, font.faceIndex, letters);
+    // A font whose cmap can't be read is taken at its word: it was chosen for this.
+    return found === undefined || found.size === letters.length;
+}
+async function fontFile(path) {
+    const bytes = await readFontFile(path);
+    const face = bytes === undefined ? undefined : readFontMetadata(bytes)?.[0];
+    if (face === undefined)
+        return undefined;
+    return {
+        id: "default",
+        name: face.name,
+        family: face.family,
+        source: "bundled",
+        path,
+        extension: ".ttf",
+        assName: face.assName,
+        faceIndex: 0,
+    };
+}

package/dist/slices/fonts/sfnt.js

@@ -260,3 +260,77 @@ function checksum(bytes) {
         sum = (sum + bytes.readUInt32BE(at)) >>> 0;
     return sum;
 }
+// Which of `codepoints` the face maps to a glyph, read from its Unicode cmap (format 4 or 12,
+// the two every modern font carries). Undefined when the font has neither; the caller then
+// cannot tell, and treats the font as covering what it was chosen for.
+export function mappedCodepoints(content, index, codepoints) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const face = directories(bytes)?.[index];
+    const table = face?.tables.get("cmap");
+    if (face === undefined || table === undefined || !validCmap(bytes, table))
+        return undefined;
+    const count = bytes.readUInt16BE(table.offset + 2);
+    let best;
+    for (let entry = 0; entry < count; entry += 1) {
+        const record = table.offset + 4 + entry * 8;
+        const platform = bytes.readUInt16BE(record);
+        const encoding = bytes.readUInt16BE(record + 2);
+        const at = table.offset + bytes.readUInt32BE(record + 4);
+        const format = bytes.readUInt16BE(at);
+        const unicode = platform === 0 || (platform === 3 && (encoding === 1 || encoding === 10));
+        if (!unicode || (format !== 4 && format !== 12))
+            continue;
+        if (best === undefined || format > best.format)
+            best = { at, format };
+    }
+    if (best === undefined)
+        return undefined;
+    const end = table.offset + table.length;
+    const found = new Set();
+    for (const codepoint of codepoints)
+        if (glyphOf(bytes, best.at, best.format, codepoint, end) !== 0)
+            found.add(codepoint);
+    return found;
+}
+function glyphOf(bytes, at, format, codepoint, end) {
+    if (format === 12) {
+        const groups = bytes.readUInt32BE(at + 12);
+        if (at + 16 + groups * 12 > end)
+            return 0;
+        for (let group = 0; group < groups; group += 1) {
+            const row = at + 16 + group * 12;
+            const first = bytes.readUInt32BE(row);
+            const last = bytes.readUInt32BE(row + 4);
+            if (codepoint >= first && codepoint <= last)
+                return bytes.readUInt32BE(row + 8) + (codepoint - first);
+        }
+        return 0;
+    }
+    if (codepoint > 0xffff)
+        return 0;
+    const segments = bytes.readUInt16BE(at + 6) / 2;
+    const ends = at + 14;
+    const starts = ends + segments * 2 + 2;
+    const deltas = starts + segments * 2;
+    const ranges = deltas + segments * 2;
+    if (ranges + segments * 2 > end)
+        return 0;
+    for (let segment = 0; segment < segments; segment += 1) {
+        const last = bytes.readUInt16BE(ends + segment * 2);
+        if (codepoint > last)
+            continue;
+        const first = bytes.readUInt16BE(starts + segment * 2);
+        if (codepoint < first)
+            return 0;
+        const delta = bytes.readInt16BE(deltas + segment * 2);
+        const range = bytes.readUInt16BE(ranges + segment * 2);
+        if (range === 0)
+            return (codepoint + delta) & 0xffff;
+        const glyphAt = ranges + segment * 2 + range + (codepoint - first) * 2;
+        if (glyphAt + 2 > end)
+            return 0;
+        const glyph = bytes.readUInt16BE(glyphAt);
+        return glyph === 0 ? 0 : (glyph + delta) & 0xffff;
+    }
+    return 0;
+}

package/dist/slices/images/run.js

@@ -6,6 +6,7 @@ import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.
 import { projectById, setStageProgress } from "../admission/repo.js";
 import { outputFileName, outputPath } from "../storage/layout.js";
 import { insertOutput, outputsOf } from "../storage/repo.js";
+import { imageCountsOf } from "./scale.js";
 // What an image piece carries between runs: what was asked for, and the file it came back
 // as once the provider answered. That is the whole of the resume.
 const imagePayload = z.object({
@@ -28,13 +29,13 @@ export async function runImages(deps, context, providers) {
     if (choice === undefined) {
         // Admission refuses a run whose images are Generate without a provider and a model, so
         // reaching here is a bug in admission rather than the user's.
-        throw new Error("No image model is set for this project. Choose one in Edit project → Providers, then Retry stage.");
+        throw new Error("No image model is set for this project. Choose one in Edit project → Providers, then Try again.");
     }
     const pieces = plan(deps, context, project.config);
     if (pieces.length === 0) {
         // Admission makes an image source mandatory and puts the Number at one or more, so an
         // empty plan is a bug upstream rather than a run with no pictures.
-        throw new Error("Slopify hit an internal error (no image prompt was selected). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (no image prompt was selected). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     // The run's own frame. The adapter turns it into whatever its provider spells the
     // closest supported size, and the render crops whatever is left over.
@@ -73,14 +74,16 @@ function plan(deps, context, config) {
         return existing;
     }
     const planned = [];
+    // Each prompt's Number, or more when the run scales its images (`scale.ts`).
+    const counts = imageCountsOf(config);
     for (const [at, picked] of config.imagePrompts.entries()) {
         // `slices/library/slots.ts` names the rendered body after the draft field that picked
         // it, so the run carries the substituted text under this key.
         const prompt = config.rendered[`imagePrompts.${String(at)}`];
         if (prompt === undefined) {
-            throw new Error(`Slopify hit an internal error (the image prompt ${picked.name} was never filled in). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
+            throw new Error(`Slopify hit an internal error (the image prompt ${picked.name} was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
         }
-        for (let send = 1; send <= picked.number; send += 1) {
+        for (let send = 1; send <= (counts[at] ?? picked.number); send += 1) {
             planned.push({
                 id: deps.ids.next(),
                 stageId: context.stage.id,
@@ -224,7 +227,7 @@ function report(deps, context, done, total) {
 }
 function payloadOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved image step is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved image step is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return imagePayload.parse(JSON.parse(piece.payload));
 }

package/dist/slices/images/scale.js

@@ -0,0 +1,84 @@
+import { imagesPerRunMax } from "../admission/rules.js";
+// ceiling: one image an hour is the least that still scales; one every 15 seconds is the
+// most, which is already as fast as the default Seconds per image shows them.
+export const imagesPerHourMin = 1;
+export const imagesPerHourMax = 240;
+// "Every N minutes" spells the same range.
+export const everyMinutesMin = 60 / imagesPerHourMax;
+export const everyMinutesMax = 60 / imagesPerHourMin;
+// ceiling: a hand-set run stops at `imagesPerRunMax` (60), which is one image every two
+// minutes of a two-hour video. A scaled run may plan up to 240, four hours at one a minute:
+// the images are drawn a few at a time under the image provider's own rate limits and the
+// render joins its clips one at a time, so the count costs time and money, both of which the
+// estimate shows before the run starts, rather than anything breaking. Past 240 the count is
+// capped and Play says so.
+export const scaledImagesMax = 240;
+export const expectedWordsMax = 100000;
+// Play's starting expected words (Review).
+export const defaultExpectedWords = 1500;
+// The estimate's own assumption (`estimate/requests.ts`).
+export const spokenWordsPerMinute = 150;
+// How many images a project's revision may hold: a scaled run's cap, else the hand-set one.
+export function imagesPerVideoMax(config) {
+    return config.imageScale === undefined ? imagesPerRunMax : scaledImagesMax;
+}
+export function wordCount(text) {
+    return text.split(/\s+/).filter((word) => word !== "").length;
+}
+export function narrationMinutes(words) {
+    return words / spokenWordsPerMinute;
+}
+// Images per hour, rounded to four places so "every 7 minutes" is stored as a plain number
+// that reads back as 7.
+export function perHourFromMinutes(minutes) {
+    return Math.round((60 / minutes) * 10000) / 10000;
+}
+// The setting as Play's control spells it: "every N minutes" when N is a whole or a quarter
+// minute, else "N per hour".
+export function imageScaleForm(scale) {
+    const minutes = 60 / scale.perHour;
+    const quarters = Math.round(minutes * 4);
+    return Math.abs(minutes * 4 - quarters) < 0.001
+        ? { every: "minutes", value: String(quarters / 4) }
+        : { every: "hour", value: String(scale.perHour) };
+}
+// What the length asks for, before the prompts' own Numbers are counted: one image per
+// started stretch, capped at `scaledImagesMax`.
+export function scaledTarget(scale) {
+    // The small epsilon keeps a length that is exactly a whole number of stretches (a rounded
+    // 60 / 7) from asking for one more.
+    const exact = (narrationMinutes(scale.words) * scale.perHour) / 60;
+    return Math.min(Math.max(Math.ceil(exact - 1e-9), 0), scaledImagesMax);
+}
+// Whether the run scales its images: set, and the images are generated from prompts.
+export function scalesImages(draft) {
+    return draft.imageScale !== undefined && draft.sources.images === "generate";
+}
+// How many images each ticked prompt makes, in prompt order. Without the setting it is each
+// prompt's Number, exactly as before it existed.
+export function imageCountsOf(draft) {
+    const counts = draft.imagePrompts.map((prompt) => prompt.number);
+    if (!scalesImages(draft) || counts.length === 0)
+        return counts;
+    const floor = counts.reduce((sum, count) => sum + count, 0);
+    const extra = scaledTarget(draft.imageScale) - floor;
+    for (let at = 0; at < extra; at += 1) {
+        const index = at % counts.length;
+        counts[index] = (counts[index] ?? 0) + 1;
+    }
+    return counts;
+}
+// The images the run makes from its prompts.
+export function plannedImageCount(draft) {
+    return imageCountsOf(draft).reduce((sum, count) => sum + count, 0);
+}
+// Admission's sentence for a stored setting out of range; Play's control says the same.
+export function imageScaleProblem(scale) {
+    if (!Number.isFinite(scale.perHour) ||
+        scale.perHour < imagesPerHourMin ||
+        scale.perHour > imagesPerHourMax)
+        return `Enter between ${String(imagesPerHourMin)} and ${String(imagesPerHourMax)} images per hour (one every ${String(everyMinutesMin)} to ${String(everyMinutesMax)} minutes) under Images → More images for long videos.`;
+    if (!Number.isInteger(scale.words) || scale.words < 1 || scale.words > expectedWordsMax)
+        return `Enter the expected words (Review) as a whole number between 1 and ${String(expectedWordsMax)}; the image count for long videos is planned from it.`;
+    return undefined;
+}