@gentbajko/slopify 0.1.0

package/dist/slices/images/run.js

@@ -0,0 +1,221 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
+import { projectById, setStageProgress } from "../admission/repo.js";
+import { outputFileName, outputPath } from "../storage/layout.js";
+import { insertOutput, outputsOf } from "../storage/repo.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 of §Q73.
+const imagePayload = z.object({
+    promptName: z.string(),
+    prompt: z.string(),
+    // Which ticked prompt this send belongs to, and which send of that prompt it is. Both
+    // are stored rather than derived, because §Q75 lets the user delete an image and the
+    // pieces that are left must still say where each one came from.
+    promptIndex: z.number(),
+    indexInPrompt: z.number(),
+    file: z.string().optional(),
+});
+export async function runImages(deps, context, providers) {
+    const { projectId } = context.stage;
+    const project = projectById(deps.db, projectId);
+    if (project === undefined) {
+        throw new Error(`project ${projectId} has no row`);
+    }
+    const choice = project.config.images;
+    if (choice === undefined) {
+        // Admission refuses a run whose images are Generate without a provider and a model
+        // (`logic/04` step 2), so reaching here is a bug in admission rather than the user's.
+        throw new Error("the run has no image provider or model");
+    }
+    const pieces = plan(deps, context, project.config);
+    if (pieces.length === 0) {
+        // `logic/04` §Q31 makes an image source mandatory and step 3 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("the run ticked no image prompt");
+    }
+    // Step 1: the run's own frame. The adapter turns it into whatever its provider spells
+    // the closest supported size, and `logic/11` step 4 crops whatever is left over.
+    const made = await sendAll(deps, context, providers, choice, pieces, project.format);
+    // logic/16 step 3: "images made (stored images)". Only the ones this run stored, so a
+    // resume does not count an image the previous run made (§Q73) and a single regenerated
+    // image counts as one (§Q103, scenario 12: "regenerations count again").
+    //
+    // ceiling: a run that fails partway records nothing, so the images it did store are
+    // counted by no event and the resume counts only its own. logic/16 step 2 puts one
+    // event on the stage completing; the upgrade, if the drift ever matters, is an event
+    // per image.
+    deps.count("stage.completed", {
+        stage: "images",
+        provider: choice.provider,
+        model: choice.model,
+        images: made,
+    });
+    deps.log.write("info", "images.done", {
+        projectId,
+        stage: "images",
+        detail: `${String(pieces.length)} images from ${String(project.config.imagePrompts.length)} prompts`,
+    });
+}
+// Step 2 with `logic/04` §Q30: "for each ticked image prompt, send its rendered text
+// Number times as independent parallel calls". The plan is made once and kept, so a retry
+// finds the rows the first run wrote and sends only what did not land (§Q73).
+//
+// `idx` is the slideshow order of §Q72 - prompts in selection order, then the index within
+// each prompt - so the order is fixed here and never depends on which image arrives first.
+function plan(deps, context, config) {
+    const existing = piecesOf(deps.db, context.stage.id, "image");
+    if (existing.length > 0) {
+        return existing;
+    }
+    const planned = [];
+    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 (`logic/03`).
+        const prompt = config.rendered[`imagePrompts.${String(at)}`];
+        if (prompt === undefined) {
+            throw new Error(`the run has no rendered text for the image prompt ${picked.name}`);
+        }
+        for (let send = 1; send <= picked.number; send += 1) {
+            planned.push({
+                id: deps.ids.next(),
+                stageId: context.stage.id,
+                kind: "image",
+                idx: planned.length + 1,
+                state: "pending",
+                payload: JSON.stringify({
+                    promptName: picked.name,
+                    prompt,
+                    promptIndex: at + 1,
+                    indexInPrompt: send,
+                }),
+            });
+        }
+    }
+    transact(deps.db, () => {
+        for (const piece of planned) {
+            insertPiece(deps.db, piece);
+        }
+    });
+    return planned;
+}
+// §Q73: an image a previous run stored is not made again, and one that fails fails the
+// whole stage while its siblings finish and keep their images for the next resume. A
+// refusal is the wrapper's to make terminal (§Q74); nothing here counts attempts.
+async function sendAll(deps, context, providers, choice, pieces, format) {
+    const { projectId } = context.stage;
+    // Read once, before anything is written: a piece counts as landed only when its row and
+    // its file both survived, and the parallel sends below each add one of each.
+    const stored = outputsOf(deps.db, projectId);
+    const total = pieces.length;
+    let done = pieces.filter((piece) => landed(deps, projectId, piece, stored)).length;
+    report(deps, context, done, total);
+    const outcomes = await Promise.all(pieces.map(async (piece) => {
+        const asked = payloadOf(piece);
+        if (landed(deps, projectId, piece, stored)) {
+            return { ok: true, made: false };
+        }
+        setPiece(deps.db, piece.id, "running", piece.payload);
+        try {
+            const made = await providers.forPiece(piece.id).image({
+                provider: choice.provider,
+                model: choice.model,
+                prompt: asked.prompt,
+                aspect: format,
+            });
+            const file = keep(deps, projectId, piece.idx, made);
+            // §Q76: the prompt text, the prompt name, the index within the prompt, the
+            // provider and the model travel with the image.
+            const output = record(deps, projectId, piece, asked, file, made, choice);
+            // The row and the file are both there before the piece says so: a crash between
+            // them leaves a piece that is not `done`, which the next run simply sends again.
+            setPiece(deps.db, piece.id, "done", JSON.stringify({ ...asked, file }));
+            done += 1;
+            // Step 3: the project page fills in as each one arrives.
+            context.emit({ type: "image.landed", projectId, outputId: output.id, index: piece.idx });
+            report(deps, context, done, total);
+            return { ok: true, made: true };
+        }
+        catch (error) {
+            // A cancel is not this image failing: `logic/13` §Q112 counts an aborted call as
+            // nothing, and the resume runs a `pending` image exactly as a failed one.
+            setPiece(deps.db, piece.id, context.signal.aborted ? "pending" : "failed", piece.payload);
+            return { ok: false, error };
+        }
+    }));
+    let made = 0;
+    for (const outcome of outcomes) {
+        if (!outcome.ok) {
+            throw outcome.error;
+        }
+        made += outcome.made ? 1 : 0;
+    }
+    return made;
+}
+// An image counts as landed only when its row and its file are both still there: they are
+// written one after the other, the boot reconcile can remove a file whose row survived,
+// and §Q75 lets the user delete one on purpose. Answering "done" for a missing file would
+// hand the render a path to nothing.
+function landed(deps, projectId, piece, stored) {
+    const file = payloadOf(piece).file;
+    if (file === undefined) {
+        return false;
+    }
+    if (!stored.some((output) => output.role === "image" && output.path === file)) {
+        return false;
+    }
+    return existsSync(outputPath(deps.paths, projectId, file));
+}
+function keep(deps, projectId, idx, made) {
+    // Step 3: "stored as received (png or jpg)". The adapter read the mime off the bytes,
+    // so the extension is what the file actually is rather than what a header claimed.
+    const name = outputFileName("image", idx, made.mime === "image/png" ? ".png" : ".jpg", "images");
+    const target = outputPath(deps.paths, projectId, name);
+    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    writeFileSync(target, made.bytes, { mode: 0o600 });
+    return name;
+}
+function record(deps, projectId, piece, asked, file, made, choice) {
+    const output = {
+        id: deps.ids.next(),
+        projectId,
+        stageKind: "images",
+        role: "image",
+        path: file,
+        originalFilename: null,
+        bytes: made.bytes.byteLength,
+        durationMs: null,
+        // `index` is the slideshow place `logic/11` sorts on, and it is the piece's own `idx`
+        // rather than the order the images came back in (§Q72).
+        meta: {
+            index: piece.idx,
+            promptName: asked.promptName,
+            prompt: asked.prompt,
+            provider: choice.provider,
+            model: choice.model,
+        },
+        createdAt: deps.clock.now().toISOString(),
+    };
+    insertOutput(deps.db, output);
+    return output;
+}
+// `logic/01` §Q6: "k of N images made". Written as well as emitted, so a page opened
+// mid-stage reads the count off the row rather than waiting for the next image.
+function report(deps, context, done, total) {
+    setStageProgress(deps.db, context.stage.id, done, total);
+    context.emit({
+        type: "stage.progress",
+        projectId: context.stage.projectId,
+        stage: "images",
+        current: done,
+        total,
+    });
+}
+function payloadOf(piece) {
+    if (piece.payload === null) {
+        throw new Error(`image ${piece.id} has no payload`);
+    }
+    return imagePayload.parse(JSON.parse(piece.payload));
+}

package/dist/slices/library/lint.js

@@ -0,0 +1,53 @@
+// What `logic/15` step 2 asks of a save: a name, a body, and no lint error. The slot
+// grammar is not restated here - it is admission/substitute.ts's, imported so the editor
+// and the run see the same parse of the same body.
+import { detectSlots } from "../admission/substitute.js";
+import { bodyMax, nameMax } from "./model.js";
+export function lintPrompt(draft) {
+    return lint(draft.name, draft.body);
+}
+export function lintEntry(draft) {
+    return lint(draft.name, draft.body);
+}
+function lint(name, body) {
+    const fields = [];
+    const trimmed = name.trim();
+    if (trimmed === "") {
+        fields.push({ field: "name", message: "A name is required." });
+    }
+    else if (trimmed.length > nameMax) {
+        fields.push({ field: "name", message: `A name is at most ${String(nameMax)} characters.` });
+    }
+    if (body.trim() === "") {
+        fields.push({ field: "body", message: "A body is required." });
+        return fields;
+    }
+    if (body.length > bodyMax) {
+        fields.push({ field: "body", message: `A body is at most ${String(bodyMax)} characters.` });
+        return fields;
+    }
+    for (const error of detectSlots(body).errors) {
+        fields.push({ field: "body", message: describe(error, body) });
+    }
+    return fields;
+}
+// The parser reports a character offset; a person editing a textarea counts lines and
+// columns, so the message says both what is wrong and where.
+function describe(error, body) {
+    const where = positionOf(body, error.at);
+    switch (error.kind) {
+        case "unclosed":
+            return `The \`{{\` at ${where} is never closed.`;
+        case "empty":
+            return `The slot at ${where} has no name.`;
+        case "nested":
+            return `The slot at ${where} holds a brace; slots do not nest.`;
+    }
+}
+function positionOf(body, at) {
+    const before = body.slice(0, at);
+    const lastBreak = before.lastIndexOf("\n");
+    const line = before.split("\n").length;
+    const column = at - lastBreak;
+    return `line ${String(line)}, column ${String(column)}`;
+}

package/dist/slices/library/model.js

@@ -0,0 +1,13 @@
+// The two template libraries `logic/15` governs: prompts of three kinds, and the
+// intro/outro entries. §Q121 puts one rule set over both, which is why the drafts, the
+// lint and the save path below are shared rather than mirrored.
+export { entryModes } from "../admission/model.js";
+// mockup §Q6 and §Q13; the CHECK constraint on `prompts.kind` holds the same three.
+export const promptKinds = ["article", "image", "thumbnail"];
+export const entryCategories = ["intro", "outro"];
+// The name is what the Play pickers show, so it shares admission's title bound.
+export const nameMax = 200;
+// ceiling: `logic/15` sets no length for a body, and the §Q6 sample article prompt is
+// already a page long. This is a sanity bound on a trust boundary, not a product rule;
+// raising it is a one-line change with no schema consequence.
+export const bodyMax = 100_000;

package/dist/slices/library/repo.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { entryCategories, entryModes, promptKinds } from "./model.js";
+// A row naming a kind, category or mode this build does not know can only come from a
+// hand-edited database or a downgrade; parsing throws rather than hiding a saved row.
+const promptRow = z.object({
+    id: z.string(),
+    kind: z.enum(promptKinds),
+    name: z.string(),
+    body: z.string(),
+    slots: z.string(),
+    updated_at: z.string(),
+});
+const entryRow = z.object({
+    id: z.string(),
+    category: z.enum(entryCategories),
+    mode: z.enum(entryModes),
+    name: z.string(),
+    body: z.string(),
+    slots: z.string(),
+    updated_at: z.string(),
+});
+const slotsColumn = z.array(z.string());
+// `lower(name)` and not `name COLLATE NOCASE`: it is the expression the unique indexes
+// are built on, so a lookup by name reads the index instead of the table.
+const byName = "lower(name) = lower(?)";
+// `logic/15` step 5: the lists on 04 Prompts and the pickers on Play sort by name.
+const byNameOrder = "ORDER BY lower(name)";
+export function insertPrompt(db, prompt) {
+    db.prepare("INSERT INTO prompts (id, kind, name, body, slots, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(prompt.id, prompt.kind, prompt.name, prompt.body, JSON.stringify(prompt.slots), prompt.updatedAt);
+}
+// §Q122: the kind may change after creation, so the update writes it like any other
+// column. Returns false when no row has that id.
+export function replacePrompt(db, prompt) {
+    const result = db
+        .prepare("UPDATE prompts SET kind = ?, name = ?, body = ?, slots = ?, updated_at = ? WHERE id = ?")
+        .run(prompt.kind, prompt.name, prompt.body, JSON.stringify(prompt.slots), prompt.updatedAt, prompt.id);
+    return Number(result.changes) > 0;
+}
+// §Q123: no foreign key points at this row, so a project that used the template keeps
+// its own rendered text and nothing cascades.
+export function deletePrompt(db, id) {
+    return Number(db.prepare("DELETE FROM prompts WHERE id = ?").run(id).changes) > 0;
+}
+export function listPrompts(db) {
+    return db
+        .prepare(`SELECT * FROM prompts ${byNameOrder}`)
+        .all()
+        .map((row) => toPrompt(promptRow.parse(row)));
+}
+export function promptById(db, id) {
+    const row = db.prepare("SELECT * FROM prompts WHERE id = ?").get(id);
+    return row === undefined ? undefined : toPrompt(promptRow.parse(row));
+}
+export function promptByName(db, kind, name) {
+    const row = db.prepare(`SELECT * FROM prompts WHERE kind = ? AND ${byName}`).get(kind, name);
+    return row === undefined ? undefined : toPrompt(promptRow.parse(row));
+}
+export function insertEntry(db, entry) {
+    db.prepare("INSERT INTO entries (id, category, mode, name, body, slots, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(entry.id, entry.category, entry.mode, entry.name, entry.body, JSON.stringify(entry.slots), entry.updatedAt);
+}
+export function replaceEntry(db, entry) {
+    const result = db
+        .prepare("UPDATE entries SET category = ?, mode = ?, name = ?, body = ?, slots = ?, updated_at = ? WHERE id = ?")
+        .run(entry.category, entry.mode, entry.name, entry.body, JSON.stringify(entry.slots), entry.updatedAt, entry.id);
+    return Number(result.changes) > 0;
+}
+export function deleteEntry(db, id) {
+    return Number(db.prepare("DELETE FROM entries WHERE id = ?").run(id).changes) > 0;
+}
+export function listEntries(db) {
+    return db
+        .prepare(`SELECT * FROM entries ${byNameOrder}`)
+        .all()
+        .map((row) => toEntry(entryRow.parse(row)));
+}
+export function entryById(db, id) {
+    const row = db.prepare("SELECT * FROM entries WHERE id = ?").get(id);
+    return row === undefined ? undefined : toEntry(entryRow.parse(row));
+}
+export function entryByName(db, category, name) {
+    const row = db
+        .prepare(`SELECT * FROM entries WHERE category = ? AND ${byName}`)
+        .get(category, name);
+    return row === undefined ? undefined : toEntry(entryRow.parse(row));
+}
+function toPrompt(row) {
+    return {
+        id: row.id,
+        kind: row.kind,
+        name: row.name,
+        body: row.body,
+        slots: parseSlots(row.slots),
+        updatedAt: row.updated_at,
+    };
+}
+function toEntry(row) {
+    return {
+        id: row.id,
+        category: row.category,
+        mode: row.mode,
+        name: row.name,
+        body: row.body,
+        slots: parseSlots(row.slots),
+        updatedAt: row.updated_at,
+    };
+}
+// A JSON column never reaches a caller as a string.
+function parseSlots(slots) {
+    const parsed = JSON.parse(slots);
+    return slotsColumn.parse(parsed);
+}

package/dist/slices/library/save.js

@@ -0,0 +1,87 @@
+// Creating, editing and deleting a template (`logic/15`). One rule set covers prompts
+// and entries (§Q121), so both go through the same three outcomes.
+import { isUniqueConstraint } from "../../kernel/db/index.js";
+import { detectSlots } from "../admission/substitute.js";
+import { lintEntry, lintPrompt } from "./lint.js";
+import { deleteEntry, deletePrompt, insertEntry, insertPrompt, replaceEntry, replacePrompt, } from "./repo.js";
+export function createPrompt(deps, draft) {
+    const fields = lintPrompt(draft);
+    if (fields.length > 0) {
+        return { ok: false, reason: "invalid", fields };
+    }
+    const prompt = { id: deps.ids.next(), ...promptOf(deps, draft) };
+    return written(() => {
+        insertPrompt(deps.db, prompt);
+        return true;
+    }, prompt);
+}
+// §Q125: a save overwrites; there is no version history, so the row is replaced whole.
+export function updatePrompt(deps, id, draft) {
+    const fields = lintPrompt(draft);
+    if (fields.length > 0) {
+        return { ok: false, reason: "invalid", fields };
+    }
+    const prompt = { id, ...promptOf(deps, draft) };
+    return written(() => replacePrompt(deps.db, prompt), prompt);
+}
+export function removePrompt(deps, id) {
+    return deletePrompt(deps.db, id) ? { ok: true, value: null } : { ok: false, reason: "not-found" };
+}
+export function createEntry(deps, draft) {
+    const fields = lintEntry(draft);
+    if (fields.length > 0) {
+        return { ok: false, reason: "invalid", fields };
+    }
+    const entry = { id: deps.ids.next(), ...entryOf(deps, draft) };
+    return written(() => {
+        insertEntry(deps.db, entry);
+        return true;
+    }, entry);
+}
+export function updateEntry(deps, id, draft) {
+    const fields = lintEntry(draft);
+    if (fields.length > 0) {
+        return { ok: false, reason: "invalid", fields };
+    }
+    const entry = { id, ...entryOf(deps, draft) };
+    return written(() => replaceEntry(deps.db, entry), entry);
+}
+export function removeEntry(deps, id) {
+    return deleteEntry(deps.db, id) ? { ok: true, value: null } : { ok: false, reason: "not-found" };
+}
+// The stored `slots` is recomputed from the body on every save, so the column can never
+// describe a body that is no longer there.
+function promptOf(deps, draft) {
+    return {
+        kind: draft.kind,
+        name: draft.name.trim(),
+        body: draft.body,
+        slots: detectSlots(draft.body).names,
+        updatedAt: deps.clock.now().toISOString(),
+    };
+}
+function entryOf(deps, draft) {
+    return {
+        category: draft.category,
+        mode: draft.mode,
+        name: draft.name.trim(),
+        body: draft.body,
+        slots: detectSlots(draft.body).names,
+        updatedAt: deps.clock.now().toISOString(),
+    };
+}
+// §Q122's uniqueness is the schema's: `prompts(kind, lower(name))` and
+// `entries(category, lower(name))`. A read-then-write check would answer from a row a
+// second writer could delete between the two statements, so the index decides and the
+// raw SQLite error never leaves this module.
+function written(write, value) {
+    try {
+        return write() ? { ok: true, value } : { ok: false, reason: "not-found" };
+    }
+    catch (error) {
+        if (isUniqueConstraint(error)) {
+            return { ok: false, reason: "duplicate-name" };
+        }
+        throw error;
+    }
+}

package/dist/slices/library/slots.js

@@ -0,0 +1,86 @@
+// What a run needs from the library at the moment Play is pressed: the saved bodies of
+// the picked templates, the slot names they ask for, and the rendered text stored on the
+// project. `logic/04` §Q34 fixes the timing - the bodies are read at the click, not at
+// selection, so an edit made in between is the one that runs.
+import { collectFields, render } from "../admission/substitute.js";
+import { entryByName, promptByName } from "./repo.js";
+export function pickTemplates(db, draft) {
+    const { sources } = draft;
+    const missing = [];
+    // `logic/03` step 3: only the prompts of stages set to Generate, plus the picked
+    // entries. A prompt left selected on a stage set to Provide asks for no field.
+    const text = [];
+    const image = [];
+    if (sources.article === "generate") {
+        body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article");
+    }
+    const intro = pickEntry(db, "intro", draft.intro, missing);
+    const outro = pickEntry(db, "outro", draft.outro, missing);
+    push(text, "intro", intro);
+    push(text, "outro", outro);
+    if (sources.images === "generate") {
+        for (const [index, picked] of draft.imagePrompts.entries()) {
+            const field = `imagePrompts.${String(index)}.name`;
+            body(db, "image", picked.name, field, missing, image, `imagePrompts.${String(index)}`);
+        }
+    }
+    // Both Generate modes read the same thumbnail template; Prompt by LLM sends it as the
+    // instruction rather than to the image provider (`logic/10` step 1).
+    if (sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") {
+        body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt");
+    }
+    const fields = collectFields(text.map((picked) => picked.body), image.map((picked) => picked.body));
+    return {
+        draft: withSavedModes(draft, intro, outro),
+        requiredSlots: fields.map((field) => field.name),
+        bodies: [...text, ...image],
+        missing,
+    };
+}
+// `logic/03` step 5 and step 6: every picked body rendered once, with the trimmed values
+// admission has already accepted, and stored on the project.
+export function renderPicked(picked, values) {
+    const rendered = {};
+    for (const { key, body: text } of picked.bodies) {
+        rendered[key] = render(text, values);
+    }
+    return rendered;
+}
+function body(db, kind, name, field, missing, into, key) {
+    // An unpicked prompt is admission's rule to state ("Pick an article prompt."), so this
+    // says nothing about it and the form marks the field once.
+    if (name === undefined || name.trim() === "") {
+        return;
+    }
+    const prompt = promptByName(db, kind, name);
+    if (prompt === undefined) {
+        missing.push({ field, message: `That ${kind} prompt no longer exists; pick another.` });
+        return;
+    }
+    into.push({ key, body: prompt.body });
+}
+function pickEntry(db, category, choice, missing) {
+    if (choice === undefined) {
+        return undefined;
+    }
+    const entry = entryByName(db, category, choice.name);
+    if (entry === undefined) {
+        missing.push({
+            field: category,
+            message: `That ${category} entry no longer exists; pick another.`,
+        });
+    }
+    return entry;
+}
+function push(into, key, entry) {
+    if (entry !== undefined) {
+        into.push({ key, body: entry.body });
+    }
+}
+function withSavedModes(draft, intro, outro) {
+    return {
+        ...draft,
+        ...(intro === undefined ? {} : { intro: { name: intro.name, mode: intro.mode } }),
+        ...(outro === undefined ? {} : { outro: { name: outro.name, mode: outro.mode } }),
+    };
+}

package/dist/slices/narration/chunk.js

@@ -0,0 +1,71 @@
+// `logic/08` step 2, the run's chunking choice: "Whole text = one request; Per paragraph
+// = one request per paragraph; Every ~N words = consecutive chunks, each ending at the
+// last sentence boundary at or before N words, default N = 500 (§Q69)."
+//
+// Pure, and the only place the rule lives: 03-conventions puts chunking with substitution
+// and the render plan in the functional core, so it is testable with no I/O at all and
+// `run.ts` does nothing but call it.
+export const chunkModes = ["whole", "paragraph", "words"];
+export const defaultChunkWords = 500;
+// A run created before Play carried the control sends the whole text as one request,
+// which is step 2's first case and the one that adds nothing the user did not ask for.
+export const defaultChunking = { mode: "whole" };
+// A run of blank lines is one paragraph break, not several, and a line of nothing but
+// spaces between two paragraphs is still a break: strip-markdown output is full of both.
+const paragraphBreak = /\r?\n[ \t\r]*(?:\r?\n[ \t\r]*)+/;
+export function chunkNarration(text, chunking) {
+    switch (chunking.mode) {
+        case "whole":
+            return nonEmpty([text]);
+        case "paragraph":
+            return nonEmpty(text.split(paragraphBreak));
+        case "words":
+            return wordRuns(text, chunking.words ?? defaultChunkWords);
+    }
+}
+// What "N words" counts: runs of non-space. Exported because it is half of the rule -
+// a test that asserts a chunk fits in N has to count the same way the cut did.
+export function wordsIn(text) {
+    return text.split(/\s+/).filter((word) => word !== "").length;
+}
+function wordRuns(text, budget) {
+    // A budget below one word would end every chunk before it started; one sentence is the
+    // floor because the rule never cuts inside a sentence.
+    const limit = Math.max(1, Math.floor(budget));
+    const chunks = [];
+    let current = "";
+    let count = 0;
+    for (const sentence of sentences(text)) {
+        const words = wordsIn(sentence);
+        // "the last sentence boundary at or before N words": the sentence that would push the
+        // count past the budget starts the next chunk instead of being split.
+        if (count > 0 && count + words > limit) {
+            chunks.push(current);
+            current = "";
+            count = 0;
+        }
+        current += sentence;
+        count += words;
+    }
+    chunks.push(current);
+    // A single sentence longer than the budget lands here whole, on its own: §Q69 caps
+    // nothing, and a cut inside a clause would be an audible pause the writer never wrote.
+    // The provider's own per-request limit is what refuses it, as an error on the stage.
+    return nonEmpty(chunks);
+}
+// ceiling: segmented as English. `Intl.Segmenter` is the platform's own sentence breaker
+// (ICU ships with Node), so no dependency and no regex full of abbreviations; the locale
+// is fixed because a run carries no language and the default one varies by machine. The
+// upgrade is a language on the run configuration, passed through to here.
+function* sentences(text) {
+    // Built per call rather than held at module scope: the standards forbid a module-level
+    // singleton, and constructing one costs microseconds against a call that just read an
+    // article off disk.
+    const segmenter = new Intl.Segmenter("en", { granularity: "sentence" });
+    for (const part of segmenter.segment(text)) {
+        yield part.segment;
+    }
+}
+function nonEmpty(parts) {
+    return parts.map((part) => part.trim()).filter((part) => part !== "");
+}