@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/narration/steering.js

@@ -9,21 +9,32 @@ function atoms(source, from, to, spans) {
         const span = spans.get(at);
         if (span !== undefined) {
             if (span.end > to || span.end <= at)
-                throw new Error("Slopify hit an internal error (a pronunciation fix spans more than one word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a pronunciation fix spans more than one word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             result.push({ text: span.text, spokenText: source.slice(at, span.end) });
             at = span.end;
         }
         else {
             const point = source.codePointAt(at);
             if (point === undefined)
-                throw new Error("Slopify hit an internal error (a narration position is outside the article text). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a narration position is outside the article text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             const text = String.fromCodePoint(point);
-            result.push({ text, spokenText: text });
+            // An empty span is a later word of a multi-word alias (its spoken form sits on the first
+            // word), so the whitespace in front of it would leave two spaces where one word was.
+            // It stays in the spoken (transcript) text, which the captions are aligned against.
+            result.push({ text: silencedBefore(source, at, spans) ? "" : text, spokenText: text });
             at += text.length;
         }
     }
     return result;
 }
+function silencedBefore(source, at, spans) {
+    if (!/\s/u.test(source[at] ?? ""))
+        return false;
+    let next = at;
+    while (next < source.length && /\s/u.test(source[next] ?? ""))
+        next += 1;
+    return spans.get(next)?.text === "";
+}
 function checkedSpans(source, pronunciation) {
     const spans = new Map();
     let end = 0;
@@ -34,7 +45,7 @@ function checkedSpans(source, pronunciation) {
             span.end <= span.start ||
             span.end > source.length ||
             !/^[^\s\uD800-\uDFFF]+$/u.test(source.slice(span.start, span.end)))
-            throw new Error("Slopify hit an internal error (pronunciation fixes overlap or split a word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (pronunciation fixes overlap or split a word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         spans.set(span.start, span);
         end = span.end;
     }

package/dist/slices/notifications/notifier.js

@@ -1,5 +1,5 @@
 import { redact } from "../../kernel/log.js";
-import { noticeOf, noticeText, webhookBody } from "./rules.js";
+import { noticeOf, noticeText, reviewNoticeText, topicsNoticeText, webhookBody } from "./rules.js";
 import { sendFailureText } from "./send.js";
 export function createRunNotifier(deps) {
     // ceiling: one entry per project seen since boot, a few dozen bytes each.
@@ -15,19 +15,44 @@ export function createRunNotifier(deps) {
         if (subject === undefined)
             return;
         const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
+        post(url, { ...text, link: deps.link?.(projectId) }, kind, { projectId });
+    };
+    // Once per verdict: a review asked again for the same item replaces its verdict in place.
+    // ceiling: one id per flagged verdict since boot.
+    const flagged = new Set();
+    const notifyReview = (event) => {
+        if (flagged.has(event.verdictId))
+            return;
+        flagged.add(event.verdictId);
+        const url = deps.url();
+        if (url === null)
+            return;
+        const subject = deps.subject(event.projectId);
+        if (subject === undefined)
+            return;
+        const text = reviewNoticeText({
+            title: subject.title,
+            stage: event.stage,
+            reason: event.reason,
+        });
+        post(url, { ...text, link: deps.link?.(event.projectId) }, "review", {
+            projectId: event.projectId,
+        });
+    };
+    const post = (url, text, kind, about) => {
         const body = redact(webhookBody(text));
         const sending = deps
             .send(url, body)
             .then((result) => {
             if (!result.ok)
                 deps.log.write("warn", "notification.failed", {
-                    projectId,
+                    ...about,
                     detail: `${kind} notification not delivered: ${sendFailureText(result)}`,
                 });
         })
             .catch((error) => {
             deps.log.write("warn", "notification.failed", {
-                projectId,
+                ...about,
                 detail: `${kind} notification not delivered: ${error instanceof Error ? error.message : String(error)}`,
             });
         })
@@ -48,6 +73,10 @@ export function createRunNotifier(deps) {
                         reasons.delete(event.projectId);
                     return;
                 }
+                if (event.type === "review.flagged") {
+                    notifyReview(event);
+                    return;
+                }
                 if (event.type !== "project.state")
                     return;
                 const previous = states.get(event.projectId);
@@ -65,6 +94,21 @@ export function createRunNotifier(deps) {
                 });
             }
         },
+        observeTopics: (event) => {
+            if (closed || event.added === 0)
+                return;
+            try {
+                const url = deps.url();
+                if (url === null)
+                    return;
+                post(url, topicsNoticeText(event), "topics", {});
+            }
+            catch (error) {
+                deps.log.write("warn", "notification.failed", {
+                    detail: `topics notification skipped: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
         close: () => {
             closed = true;
         },

package/dist/slices/notifications/rules.js

@@ -8,6 +8,8 @@ export function noticeOf(previous, next) {
     switch (next) {
         case "done":
             return "ready";
+        case "partial":
+            return "partial";
         case "failed":
             return "failed";
         case "pending":
@@ -16,6 +18,23 @@ export function noticeOf(previous, next) {
             return undefined;
     }
 }
+const reviewItemNames = {
+    article: "the article",
+    images: "an image",
+    narration: "the narration",
+    thumbnail: "the thumbnail",
+    shorts: "a short",
+};
+export function reviewNoticeText(subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    const reason = shortReason(subject.reason);
+    const item = reviewItemNames[subject.stage] ?? "an item";
+    const headline = `Review needs a decision: ${title}`;
+    return {
+        headline: reason === undefined ? headline : `${headline} — ${reason}`,
+        detail: `The automatic review flagged ${item} and kept it. Open the project and press Overrule to keep it or Redo to make it again.`,
+    };
+}
 const reasonMax = 140;
 // A provider's failure can run to paragraphs; a notification has a line.
 export function shortReason(reason) {
@@ -34,6 +53,16 @@ export function noticeText(kind, subject) {
             return subject.makesVideo
                 ? { headline: `Video ready: ${title}`, detail: "Open the project to watch it." }
                 : { headline: `Run finished: ${title}`, detail: "Open the project to see its files." };
+        case "partial": {
+            const reason = shortReason(subject.reason);
+            const made = subject.makesVideo
+                ? `Video ready with problems: ${title}`
+                : `Run finished with problems: ${title}`;
+            return {
+                headline: reason === undefined ? made : `${made} — ${reason}`,
+                detail: "Open the project to see which step failed and the button that fixes it.",
+            };
+        }
         case "failed": {
             const reason = shortReason(subject.reason);
             return {
@@ -44,18 +73,34 @@ export function noticeText(kind, subject) {
         case "waiting":
             return {
                 headline: `Waiting for you: ${title}`,
-                detail: "Open the project to review the held step or press Resume.",
+                detail: "Open the project to review the held step or press Continue the run.",
             };
     }
 }
+export function topicsNoticeText(subject) {
+    const name = subject.scheduleName.trim() === "" ? "Untitled schedule" : subject.scheduleName.trim();
+    const count = subject.added;
+    const total = subject.waiting > count ? ` ${String(subject.waiting)} are waiting in all.` : "";
+    return {
+        headline: `${String(count)} new ${count === 1 ? "topic is" : "topics are"} waiting for you`,
+        detail: `Open Calendar → Suggested topics → ${name} to queue or reject ${count === 1 ? "it" : "them"}.${total}`,
+    };
+}
 export const testNotice = {
     headline: "Slopify test notification",
-    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you.",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you, and when a review needs your decision.",
 };
 // The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
 // but the project's title, what happened and the provider's own short reason goes in it.
 export function webhookBody(text) {
-    return `${text.headline}\n${text.detail}\n`;
+    return `${text.headline}\n${text.detail}\n${text.link === undefined ? "" : `${text.link}\n`}`;
+}
+// Where a project opens in the browser, from the address the server listens on. A wildcard
+// (0.0.0.0 in Docker) or loopback address is reached as localhost from the same machine.
+export function projectLink(host, port, projectId) {
+    const wildcard = host === "0.0.0.0" || host === "::" || host === "" || host === "127.0.0.1";
+    const authority = wildcard ? "localhost" : host.includes(":") ? `[${host}]` : host;
+    return `http://${authority}:${String(port)}/projects/${encodeURIComponent(projectId)}`;
 }
 export const notificationUrlMax = 2048;
 // Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:

package/dist/slices/onboarding/copy.js

@@ -0,0 +1,143 @@
+import { copyFileSync, lstatSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { transact } from "../../kernel/db/tx.js";
+import { executionPlan } from "../rebuild/runtime-plan.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { projectRows } from "../storage/backup-export.js";
+import { projectTables } from "../storage/backup-format.js";
+import { projectDir } from "../storage/layout.js";
+// ceiling: one pass per layer of the step graph (text, narration, timing, picks, prompts,
+// images, renders); far more than any plan has.
+const rebindPasses = 40;
+export function copyProject(deps, sourceId, title) {
+    const source = projectDir(deps.paths, sourceId);
+    const tables = projectTables.map((table) => [table, projectRows(deps.db, table, sourceId)]);
+    const ids = new Map([[sourceId, deps.ids.next()]]);
+    for (const [, rows] of tables)
+        for (const row of rows)
+            for (const [column, value] of Object.entries(row))
+                if ((column === "id" || column === "publication_id" || column === "admission_id") &&
+                    typeof value === "string" &&
+                    // ceiling: every id Slopify makes is a 26-character ULID or a 36-character UUID; a
+                    // shorter value could match inside unrelated text.
+                    value.length >= 16 &&
+                    !ids.has(value))
+                    ids.set(value, deps.ids.next());
+    const pattern = new RegExp([...ids.keys()]
+        .toSorted((left, right) => right.length - left.length)
+        .map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join("|"), "g");
+    const remap = (text) => text.replace(pattern, (id) => ids.get(id) ?? id);
+    const projectId = ids.get(sourceId) ?? sourceId;
+    const target = projectDir(deps.paths, projectId);
+    const at = deps.clock.now().toISOString();
+    try {
+        for (const file of listFiles(source)) {
+            const to = join(target, remap(file));
+            mkdirSync(dirname(to), { recursive: true, mode: 0o700 });
+            copyFileSync(join(source, file), to);
+        }
+        transact(deps.db, () => {
+            deps.db.exec("PRAGMA defer_foreign_keys = ON");
+            for (const [table, rows] of tables)
+                for (const row of rows) {
+                    const copied = Object.fromEntries(Object.entries(row).map(([column, value]) => [
+                        column,
+                        typeof value === "string" ? remap(value) : value,
+                    ]));
+                    insert(deps.db, table, table === "projects" ? { ...copied, title, created_at: at, updated_at: at } : copied);
+                }
+            rebind(deps, projectId);
+        });
+    }
+    catch (error) {
+        rmSync(target, { recursive: true, force: true });
+        throw error;
+    }
+    return { projectId };
+}
+// Re-stamps the copy's finished steps with the fingerprints its own ids give them.
+function rebind(deps, projectId) {
+    const revisionId = currentRevisionId(deps.db, projectId);
+    if (revisionId === undefined)
+        return;
+    for (let pass = 0; pass < rebindPasses; pass++) {
+        const view = getRevisionView(deps, projectId, revisionId);
+        if (view === undefined)
+            return;
+        const plan = executionPlan(deps, view, deps.catalogue);
+        const changes = new Map();
+        for (const change of plan.changedInputs)
+            if (change.before !== null && change.after !== null && change.before !== change.after)
+                changes.set(change.before, change.after);
+        // A finished piece also records the request it answered, which covers the same ids.
+        for (const recipe of plan.recipes)
+            for (const piece of view.pieces)
+                if (piece.selected && piece.key === recipe.key && piece.piece.payload !== null) {
+                    const request = requestOf(piece.piece.payload);
+                    if (request !== undefined &&
+                        recipe.requestFingerprint !== null &&
+                        request !== recipe.requestFingerprint)
+                        changes.set(request, recipe.requestFingerprint);
+                }
+        if (changes.size === 0) {
+            deps.db
+                .prepare("UPDATE project_revisions SET fingerprints=? WHERE id=?")
+                .run(JSON.stringify(Object.fromEntries(plan.recipes.map((row) => [row.key, row.fingerprint]))), revisionId);
+            return;
+        }
+        for (const [before, after] of changes)
+            for (const [table, column] of [
+                ["revision_outputs", "fingerprint"],
+                ["revision_pieces", "fingerprint"],
+                ["revision_outputs", "descriptor"],
+                ["revision_pieces", "descriptor"],
+                ["project_revisions", "content"],
+            ])
+                deps.db
+                    .prepare(`UPDATE ${table} SET ${column}=replace(${column},?,?) WHERE project_id=? AND instr(${column},?)>0`)
+                    .run(before, after, projectId, before);
+    }
+    throw new Error("Slopify hit an internal error (the copy of the sample kept changing while its steps were matched up). Delete the copy and try Make my own copy again; if it happens again, use Download diagnostics in Settings and report it.");
+}
+function requestOf(payload) {
+    try {
+        const value = JSON.parse(payload);
+        return typeof value === "object" &&
+            value !== null &&
+            "requestFingerprint" in value &&
+            typeof value.requestFingerprint === "string"
+            ? value.requestFingerprint
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function listFiles(root) {
+    const out = [];
+    const walk = (directory) => {
+        let names;
+        try {
+            names = readdirSync(directory);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const path = join(directory, name);
+            const stat = lstatSync(path);
+            if (stat.isDirectory())
+                walk(path);
+            else if (stat.isFile())
+                out.push(relative(root, path).split(sep).join("/"));
+        }
+    };
+    walk(root);
+    return out;
+}
+function insert(db, table, row) {
+    const columns = Object.keys(row);
+    db.prepare(`INSERT INTO ${table} (${columns.join(",")}) VALUES (${columns.map(() => "?").join(",")})`).run(...columns.map((column) => row[column] ?? null));
+}

package/dist/slices/onboarding/first-run.js

@@ -0,0 +1,72 @@
+import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { templateById } from "../project-templates/repo.js";
+import { starterPacks } from "./packs.js";
+import { sampleProjectIds } from "./sample.js";
+import { firstRunDismissed, readPackRecords } from "./state.js";
+// The first-run screen shows on a fresh install and never again once it is skipped or a real
+// project (anything but the samples) exists. Reading it writes nothing: a real project that
+// exists before the screen was recorded as done is reported as `settle`, and the client
+// records it with POST /dismiss, so deleting every project later does not bring it back.
+export function firstRunView(db, statuses) {
+    const samples = sampleProjectIds(db);
+    const real = db
+        .prepare("SELECT 1 FROM projects WHERE id IS NOT ? AND id IS NOT ? AND id IS NOT ? LIMIT 1")
+        .get(samples.library, samples.audiobook, samples.podcast) !== undefined;
+    const dismissed = firstRunDismissed(db);
+    const packs = readPackRecords(db);
+    return {
+        show: !real && !dismissed,
+        settle: real && !dismissed,
+        voice: firstVoice(statuses),
+        sampleProjectId: samples.library,
+        samples,
+        clis: detectedClis(statuses),
+        // A pack counts as added only with its template: the first short adds a pack's prompts and
+        // voice but no template, and Add pack must still be able to add that template later (or
+        // again, after it was deleted).
+        packs: starterPacks.map((pack) => {
+            const template = packs[pack.id]?.template;
+            const kept = template !== undefined && templateById(db, template) !== undefined;
+            return {
+                id: pack.id,
+                name: pack.name,
+                summary: pack.summary,
+                installed: kept,
+                templateId: kept ? template : null,
+            };
+        }),
+    };
+}
+// Who would narrate a first short: a keyed voice provider when one has a key, else the
+// computer's own voice when a speech program was found.
+export function firstVoice(statuses) {
+    const keyed = statuses.find((row) => row.family === "tts" && row.readiness.kind === "keyed" && readinessIsUsable(row.readiness));
+    const system = statuses.find((row) => row.readiness.kind === "local")?.readiness;
+    const local = system?.kind === "local" ? system : undefined;
+    return {
+        keyed: keyed?.displayName ?? null,
+        system: {
+            available: local?.available === true,
+            engine: local?.engine ?? null,
+            issue: local?.issue ?? null,
+        },
+    };
+}
+// What this machine can make without a key: each agent CLI Slopify found, and whether it
+// answers (installed, a supported version, signed in as far as the probe can tell).
+export function detectedClis(statuses) {
+    return ["claude-code", "codex", "gemini"].map((id) => {
+        const status = statuses.find((row) => row.id === id);
+        const readiness = status?.readiness;
+        const cli = readiness?.kind === "cli" ? readiness : undefined;
+        return {
+            id,
+            name: status?.displayName ?? id,
+            installed: cli?.installed === true,
+            ready: cli?.installed === true && cli.issue === undefined,
+            version: cli?.version ?? null,
+            issue: cli?.issue ?? null,
+            draws: id === "codex",
+        };
+    });
+}

package/dist/slices/onboarding/full-video.js

@@ -0,0 +1,81 @@
+import { projectById } from "../admission/repo.js";
+import { usesShortMode } from "../admission/short-mode.js";
+import { promptById } from "../library/repo.js";
+import { createDraft } from "../play-drafts/service.js";
+import { templateById } from "../project-templates/repo.js";
+import { freshTemplateDraft } from "../project-templates/setup.js";
+import { installPack } from "./install.js";
+import { starterPacks, starterSet } from "./packs.js";
+import { readPackRecords } from "./state.js";
+import { packTemplate } from "./template.js";
+// The pack whose short script the short was written from. A short made without a pack, or
+// whose pack's prompts were since renamed or removed, is the starter set's.
+export function shortPack(deps, articlePrompt) {
+    const records = readPackRecords(deps.db);
+    for (const pack of starterPacks) {
+        const id = records[pack.id]?.prompts.shortScript;
+        if (id !== undefined && promptById(deps.db, id)?.name === articlePrompt)
+            return pack;
+    }
+    return starterSet;
+}
+export function fullVideoDraft(deps, input) {
+    const project = projectById(deps.db, input.projectId);
+    if (project === undefined)
+        return { ok: false, reason: "not-found" };
+    const config = project.config;
+    if (!usesShortMode(config))
+        return { ok: false, reason: "not-short" };
+    const topic = config.values.topic?.trim() || project.title;
+    const pack = shortPack(deps, config.articlePrompt ?? "");
+    const document = packDocument(deps, pack);
+    if (document === undefined)
+        return { ok: false, reason: "not-found" };
+    const provider = (choice, fallback) => choice === undefined || fallback.provider !== ""
+        ? fallback
+        : {
+            provider: choice.provider,
+            model: choice.model,
+            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
+        };
+    const form = document.form;
+    return createDraft(deps, {
+        id: input.draftId,
+        document: {
+            ...document,
+            form: {
+                ...form,
+                title: project.title,
+                values: { ...form.values, topic },
+                llm: provider(config.llm, form.llm),
+                images: provider(config.images, form.images),
+                audio: config.audio === undefined
+                    ? form.audio
+                    : {
+                        ...form.audio,
+                        provider: config.audio.provider,
+                        model: config.audio.model,
+                        voice: config.audio.voice,
+                    },
+            },
+        },
+    });
+}
+// A pack's own template, as Templates → Apply to Play opens it. The starter set has no long
+// video prompt of its own and no template, so it is its settings without one saved.
+function packDocument(deps, pack) {
+    const withTemplate = pack.id !== starterSet.id;
+    const installed = installPack(deps, pack.id, { template: withTemplate });
+    if (!installed.ok)
+        return undefined;
+    const { templateId } = installed.value;
+    if (!withTemplate || templateId === null)
+        return packTemplate(pack, installed.value.prompts, installed.value.voice ?? pack.voice.voiceId);
+    const template = templateById(deps.db, templateId);
+    if (template === undefined)
+        return undefined;
+    return freshTemplateDraft(deps, template.document, {
+        id: template.id,
+        version: template.version,
+    });
+}

package/dist/slices/onboarding/install.js

@@ -0,0 +1,119 @@
+import { transact } from "../../kernel/db/tx.js";
+import { detectSlots } from "../admission/substitute.js";
+import { nameMax } from "../library/model.js";
+import { insertPrompt, promptById, promptByName } from "../library/repo.js";
+import { templateById, templateSummaries } from "../project-templates/repo.js";
+import { createTemplate } from "../project-templates/service.js";
+import { insertVoice, listVoices } from "../settings/repo.js";
+import { packById } from "./packs.js";
+import { readPackRecords, writePackRecord } from "./state.js";
+import { packTemplate } from "./template.js";
+// Installs a pack into the library. Idempotent: an item the pack installed before, and that
+// still exists, is kept as it is, even if it was edited since. A user's own prompt, voice or
+// template is never overwritten: a prompt with the pack's name and the pack's exact text is
+// used as it is, and any other one with that name makes the pack's copy come in as
+// "<name> (2)". `template: false` installs the prompts and the voice only (what the
+// 60-second short needs).
+export function installPack(deps, packId, options = { template: true }) {
+    const pack = packById(packId);
+    if (pack === undefined)
+        return { ok: false, reason: "not-found" };
+    return transact(deps.db, () => {
+        const before = readPackRecords(deps.db)[pack.id];
+        let added = false;
+        const at = deps.clock.now().toISOString();
+        const prompts = {};
+        const names = {};
+        for (const prompt of pack.prompts) {
+            const kept = before?.prompts[prompt.key];
+            const existing = kept === undefined ? undefined : promptById(deps.db, kept);
+            if (existing !== undefined) {
+                prompts[prompt.key] = existing.id;
+                names[prompt.key] = existing.name;
+                continue;
+            }
+            const placed = placePrompt(deps, prompt.kind, prompt.name, prompt.body, at);
+            added ||= placed.added;
+            prompts[prompt.key] = placed.prompt.id;
+            names[prompt.key] = placed.prompt.name;
+        }
+        const voice = placeVoice(deps, pack, before);
+        added ||= voice.added;
+        let template = before?.template;
+        if (options.template && (template === undefined || !templateById(deps.db, template))) {
+            const id = deps.uuid();
+            const created = createTemplate(deps, {
+                id,
+                name: freeTemplateName(deps, `${pack.name} starter`),
+                document: packTemplate(pack, names, voice.voiceId),
+            });
+            if (!created.ok)
+                throw new Error(`Slopify hit an internal error (the ${pack.name} pack's template was refused: ${created.reason}). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
+            template = id;
+            added = true;
+        }
+        const record = {
+            installedAt: before?.installedAt ?? at,
+            prompts,
+            voice: voice.id,
+            ...(template === undefined ? {} : { template }),
+        };
+        writePackRecord(deps.db, pack.id, record);
+        return {
+            ok: true,
+            value: {
+                packId: pack.id,
+                added,
+                prompts: names,
+                templateId: template ?? null,
+                voice: voice.voiceId,
+            },
+        };
+    });
+}
+function placePrompt(deps, kind, name, body, at) {
+    for (let n = 1;; n += 1) {
+        const suffix = n === 1 ? "" : ` (${String(n)})`;
+        const candidate = `${name.slice(0, nameMax - suffix.length).trimEnd()}${suffix}`;
+        const taken = promptByName(deps.db, kind, candidate);
+        if (taken?.body === body)
+            return { prompt: taken, added: false };
+        if (taken !== undefined)
+            continue;
+        const prompt = {
+            id: deps.ids.next(),
+            kind,
+            name: candidate,
+            body,
+            slots: detectSlots(body).names,
+            updatedAt: at,
+        };
+        insertPrompt(deps.db, prompt);
+        return { prompt, added: true };
+    }
+}
+// The suggested voice as a saved voice, so Play's voice list offers it. One the user already
+// saved under the same voice ID is used as it is, name and all.
+function placeVoice(deps, pack, before) {
+    const voices = listVoices(deps.db);
+    const same = voices.find((voice) => (before?.voice !== undefined && voice.id === before.voice) ||
+        (voice.provider === pack.voice.provider && voice.voiceId === pack.voice.voiceId));
+    if (same !== undefined)
+        return { id: same.id, voiceId: same.voiceId, added: false };
+    const id = deps.ids.next();
+    insertVoice(deps.db, {
+        id,
+        provider: pack.voice.provider,
+        name: pack.voice.name,
+        voiceId: pack.voice.voiceId,
+    });
+    return { id, voiceId: pack.voice.voiceId, added: true };
+}
+function freeTemplateName(deps, name) {
+    const taken = new Set(templateSummaries(deps.db).map((row) => row.name.toLowerCase()));
+    for (let n = 1;; n += 1) {
+        const candidate = n === 1 ? name : `${name} (${String(n)})`;
+        if (!taken.has(candidate.toLowerCase()))
+            return candidate;
+    }
+}