@gentbajko/slopify 3.0.13 → 3.0.15

package/dist/edge/http/entries.js

@@ -3,6 +3,7 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { versionsOrCurrent } from "../../slices/library/history.js";
 import { entryCategories, entryModes } from "../../slices/library/model.js";
+import { formerNames } from "../../slices/library/rename.js";
 import { entryById, listEntries } from "../../slices/library/repo.js";
 import { createEntry, removeEntry, restoreEntry, updateEntry } from "../../slices/library/save.js";
 import { usedBy } from "../../slices/library/used-by.js";
@@ -51,7 +52,7 @@ export function entryRoutes(deps) {
         const entry = entryById(deps.db, c.req.valid("param").id);
         return entry === undefined
             ? refused(c, { ok: false, reason: "not-found" }, "entry")
-            : c.json(usedBy(deps.db, { item: "entry", category: entry.category, name: entry.name }));
+            : c.json(usedBy(deps.db, { item: "entry", category: entry.category, name: entry.name }, formerNames(deps.db, "entry", entry.id, entry.name)));
     })
         .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
         const result = removeEntry(library, c.req.valid("param").id);

package/dist/edge/http/prompts.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { versionsOrCurrent } from "../../slices/library/history.js";
 import { promptKinds } from "../../slices/library/model.js";
 import { setPromptPhotorealistic, withPhotorealistic, } from "../../slices/library/photorealistic.js";
+import { formerNames } from "../../slices/library/rename.js";
 import { listPrompts, promptById } from "../../slices/library/repo.js";
 import { createPrompt, removePrompt, restorePrompt, updatePrompt, } from "../../slices/library/save.js";
 import { usedBy } from "../../slices/library/used-by.js";
@@ -70,7 +71,7 @@ export function promptRoutes(deps) {
         const prompt = promptById(deps.db, c.req.valid("param").id);
         return prompt === undefined
             ? refused(c, { ok: false, reason: "not-found" }, "prompt")
-            : c.json(usedBy(deps.db, { item: "prompt", kind: prompt.kind, name: prompt.name }));
+            : c.json(usedBy(deps.db, { item: "prompt", kind: prompt.kind, name: prompt.name }, formerNames(deps.db, "prompt", prompt.id, prompt.name)));
     })
         // A project holds its own rendered text, so nothing cascades and a
         // template used by past projects is deleted like any other.

package/dist/patch-notes/3.0.14.md

@@ -0,0 +1,24 @@
+# Slopify 3.0.14
+
+Released 30 September 2026.
+
+3.0.14 fixes two things in the Library: **Used by** on Review and Script prompts, and renaming a prompt or an intro/outro that templates and drafts still use.
+
+## Highlights
+
+- **Renaming a prompt no longer breaks what uses it.** Templates, schedules and open Play drafts take the new name.
+- **Used by is right for Review and Script prompts.**
+
+## Library
+
+- Renaming a prompt or an intro/outro now renames it in every template and every Play draft you are still editing, so they keep using it. Schedules follow their template. Before, they kept the old name and fell back to the copy saved with the template.
+- A project keeps the name its run used. **Used by** still lists it after a rename.
+
+## Fixes
+
+- **Used by** on a Review or Script prompt listed the templates and projects that used *image* prompts of the same name. It now lists the automatic reviews that pick the Review prompt, and the multi-voice script runs that pick the Script prompt.
+- **Used by** now lists a schedule by the template as it is now, which is what the schedule runs, instead of the version it was saved with.
+
+## Upgrading from 3.0.13
+
+- **Nothing becomes outdated.** Templates and drafts that already name an old name keep working as before; the next rename carries them along.

package/dist/patch-notes/3.0.15.md

@@ -0,0 +1,17 @@
+# Slopify 3.0.15
+
+Released 30 September 2026.
+
+3.0.15 makes a garbled narration chunk get recorded again even when the project is busy.
+
+## Fixes
+
+- When the captions caught a garbled sentence, Slopify said it was recording that narration chunk again, but if another step of the project was still running at that moment (its PDF, say), the retry gave up and the video stayed failed. The retry now waits for that step and starts as soon as it finishes.
+
+## Under the hood
+
+- Faster CI and releases: Docker images build beside the npm publish, the Windows install check uses one warm cache, and unchanged Windows and Docker checks are skipped.
+
+## Upgrading from 3.0.14
+
+- **Nothing becomes outdated.**

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.0.15",
+    "title": "Slopify 3.0.15",
+    "version": "3.0.15",
+    "date": "2026-09-30"
+  },
+  {
+    "id": "3.0.14",
+    "title": "Slopify 3.0.14",
+    "version": "3.0.14",
+    "date": "2026-09-30"
+  },
   {
     "id": "3.0.13",
     "title": "Slopify 3.0.13",

package/dist/slices/library/rename.js

@@ -0,0 +1,94 @@
+// Renaming a Library prompt or intro/outro. Everything names the Library by name, so a rename
+// rewrites the name where a future run reads it: each live template's current version (its
+// form and the copy it saved of the Library) and every Play draft still being edited.
+// Schedules run their template as it is now, so they follow. A project revision is the record
+// of what its run used and keeps the old name; "Used by" finds it through `formerNames`.
+import { z } from "zod";
+import { renamedIn } from "./used-by.js";
+const documentRow = z.object({ key: z.string(), version: z.number(), document_json: z.string() });
+// The template document or Play draft document with the form, and the Library copy it saved,
+// naming `to`; undefined when neither named the old name.
+function renamedDocument(json, ref, id, to) {
+    const document = JSON.parse(json);
+    if (typeof document !== "object" || document === null)
+        return undefined;
+    const next = { ...document };
+    let changed = false;
+    const form = renamedIn(next.form, ref, to);
+    if (form !== undefined) {
+        next.form = form;
+        changed = true;
+    }
+    const snapshot = renamedSnapshot(next.librarySnapshot, ref, id, to);
+    if (snapshot !== undefined) {
+        next.librarySnapshot = snapshot;
+        changed = true;
+    }
+    return changed ? JSON.stringify(next) : undefined;
+}
+// The saved copy of a renamed item is found by the new name once the Library row is gone.
+function renamedSnapshot(value, ref, id, to) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const snapshot = value;
+    const listKey = ref.item === "prompt" ? "prompts" : "entries";
+    const rows = snapshot[listKey];
+    if (!Array.isArray(rows))
+        return undefined;
+    const from = ref.name.trim().toLowerCase();
+    let changed = false;
+    const next = rows.map((row) => {
+        if (typeof row !== "object" || row === null)
+            return row;
+        const one = row;
+        const sameKind = ref.item === "prompt" ? one.kind === ref.kind : one.category === ref.category;
+        const named = typeof one.name === "string" && one.name.trim().toLowerCase() === from;
+        if (!sameKind || one.name === to || (one.id !== id && !named))
+            return row;
+        changed = true;
+        return { ...one, name: to };
+    });
+    return changed ? { ...snapshot, [listKey]: next } : undefined;
+}
+// Runs inside the save's transaction, so the rename and the rewritten references land
+// together or not at all.
+export function renameReferences(db, ref, id, to) {
+    if (ref.name === to)
+        return;
+    const templates = db
+        .prepare(`SELECT t.id AS key,r.version,r.document_json FROM project_templates t
+       JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version
+       WHERE t.deleted_at IS NULL`)
+        .all()
+        .map((row) => documentRow.parse(row));
+    const updateTemplate = db.prepare("UPDATE project_template_revisions SET document_json=? WHERE template_id=? AND version=?");
+    for (const row of templates) {
+        const next = renamedDocument(row.document_json, ref, id, to);
+        if (next !== undefined)
+            updateTemplate.run(next, row.key, row.version);
+    }
+    const drafts = db
+        .prepare("SELECT id AS key,version,document_json FROM play_drafts WHERE state='active'")
+        .all()
+        .map((row) => documentRow.parse(row));
+    const updateDraft = db.prepare("UPDATE play_drafts SET document_json=? WHERE id=?");
+    for (const row of drafts) {
+        const next = renamedDocument(row.document_json, ref, id, to);
+        if (next !== undefined)
+            updateDraft.run(next, row.key);
+    }
+}
+// The names an item had before, other than its current one, that no other live item of the
+// same kind or category holds now.
+export function formerNames(db, itemKind, id, current) {
+    const table = itemKind === "prompt" ? "prompts" : "entries";
+    const group = itemKind === "prompt" ? "kind" : "category";
+    const rows = db
+        .prepare(`SELECT DISTINCT v.name FROM library_versions v
+       WHERE v.item_kind=? AND v.item_id=? AND lower(v.name)<>lower(?)
+       AND NOT EXISTS (
+         SELECT 1 FROM ${table} o WHERE o.id<>v.item_id AND o.${group}=v.kind
+         AND lower(o.name)=lower(v.name) AND o.deleted_at IS NULL)`)
+        .all(itemKind, id, current);
+    return rows.map((row) => z.object({ name: z.string() }).parse(row).name);
+}

package/dist/slices/library/save.js

@@ -6,6 +6,7 @@ import { detectSlots } from "../admission/substitute.js";
 import { recordVersion, versionOf } from "./history.js";
 import { lintEntry, lintPrompt } from "./lint.js";
 import { entryCategories, promptKinds } from "./model.js";
+import { renameReferences } from "./rename.js";
 import { entryById, insertEntry, insertPrompt, promptById, replaceEntry, replacePrompt, trashEntry, trashPrompt, } from "./repo.js";
 export function createPrompt(deps, draft) {
     const fields = lintPrompt(draft);
@@ -30,6 +31,8 @@ export function updatePrompt(deps, id, draft, restoredFrom) {
         const previous = promptById(deps.db, id);
         if (!replacePrompt(deps.db, prompt))
             return false;
+        if (previous !== undefined)
+            renameReferences(deps.db, { item: "prompt", kind: previous.kind, name: previous.name }, id, prompt.name);
         recordVersion(deps.db, "prompt", prompt, {
             previous,
             ...(restoredFrom === undefined ? {} : { restoredFrom }),
@@ -75,6 +78,8 @@ export function updateEntry(deps, id, draft, restoredFrom) {
         const previous = entryById(deps.db, id);
         if (!replaceEntry(deps.db, entry))
             return false;
+        if (previous !== undefined)
+            renameReferences(deps.db, { item: "entry", category: previous.category, name: previous.name }, id, entry.name);
         recordVersion(deps.db, "entry", entry, {
             previous,
             ...(restoredFrom === undefined ? {} : { restoredFrom }),

package/dist/slices/library/used-by.js

@@ -5,92 +5,119 @@
 // `snapshot.ts` use.
 import { z } from "zod";
 import { liveProject } from "../admission/repo.js";
-// The fields of a Play form or a run config that name Library items. Both shapes carry the
-// same names; a run config holds the intro and outro as `{ name }` and a form as the name.
-const named = z.string().optional().catch(undefined);
-const refsShape = z
-    .object({
-    articlePrompt: named,
-    narrationPrompt: named,
-    thumbnailPrompt: named,
-    descriptionPrompt: named,
-    imagePrompts: z
-        .array(z.object({ name: z.string() }).loose())
-        .optional()
-        .catch(undefined),
-    reference: z.object({ prompt: named }).loose().optional().catch(undefined),
-    shorts: z.object({ prompt: named, imagePrompt: named }).loose().optional().catch(undefined),
-    intro: z
-        .union([z.string(), z.object({ name: z.string() }).loose()])
-        .optional()
-        .catch(undefined),
-    outro: z
-        .union([z.string(), z.object({ name: z.string() }).loose()])
-        .optional()
-        .catch(undefined),
-})
-    .loose();
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function field(owner, key) {
+    return owner === undefined ? [] : [{ get: () => owner[key], set: (name) => (owner[key] = name) }];
+}
+// An intro or outro: the name in a form, `{ name, mode }` in a run config.
+function entrySlot(owner, key) {
+    const held = record(owner[key]);
+    return held === undefined ? field(owner, key) : field(held, "name");
+}
+function scriptRun(value) {
+    return record(value.sources)?.audio === "generate" && record(value.voices)?.source === "script";
+}
+function slotsIn(value, ref) {
+    if (ref.item === "entry")
+        return entrySlot(value, ref.category);
+    const shorts = record(value.shorts);
+    switch (ref.kind) {
+        case "article":
+            return scriptRun(value) ? [] : field(value, "articlePrompt");
+        case "script":
+            return scriptRun(value) ? field(value, "articlePrompt") : [];
+        case "narration":
+            return field(value, "narrationPrompt");
+        case "thumbnail":
+            return field(value, "thumbnailPrompt");
+        case "description":
+            return field(value, "descriptionPrompt");
+        case "shorts":
+            return field(shorts, "prompt");
+        case "review":
+            return Object.values(record(record(value.reviews)?.stages) ?? {}).flatMap((stage) => field(record(stage), "prompt"));
+        case "image":
+            return [
+                ...(Array.isArray(value.imagePrompts) ? value.imagePrompts : []).flatMap((one) => field(record(one), "name")),
+                ...field(record(value.reference), "prompt"),
+                ...field(shorts, "imagePrompt"),
+            ];
+    }
+}
 // The names a form or config holds for one kind of prompt or category of entry.
 export function namesIn(value, ref) {
-    const parsed = refsShape.safeParse(value);
-    if (!parsed.success)
+    const form = record(value);
+    if (form === undefined)
         return [];
-    const form = parsed.data;
-    const entryName = (one) => one === undefined ? undefined : typeof one === "string" ? one : one.name;
-    const names = ref.item === "entry"
-        ? [ref.category === "intro" ? entryName(form.intro) : entryName(form.outro)]
-        : ref.kind === "article"
-            ? [form.articlePrompt]
-            : ref.kind === "narration"
-                ? [form.narrationPrompt]
-                : ref.kind === "thumbnail"
-                    ? [form.thumbnailPrompt]
-                    : ref.kind === "description"
-                        ? [form.descriptionPrompt]
-                        : ref.kind === "shorts"
-                            ? [form.shorts?.prompt]
-                            : [
-                                ...(form.imagePrompts ?? []).map((one) => one.name),
-                                form.reference?.prompt,
-                                form.shorts?.imagePrompt,
-                            ];
-    return names.filter((name) => name !== undefined && name.trim() !== "");
+    return slotsIn(form, ref)
+        .map((slot) => slot.get())
+        .filter((name) => typeof name === "string" && name.trim() !== "");
 }
-export function uses(value, ref) {
-    const wanted = ref.name.trim().toLowerCase();
-    return namesIn(value, ref).some((name) => name.trim().toLowerCase() === wanted);
+// A copy of the form or config with every place that names `from` naming `to` instead, or
+// undefined when nothing names it.
+export function renamedIn(value, ref, to) {
+    const form = record(value);
+    if (form === undefined)
+        return undefined;
+    const copy = structuredClone(form);
+    const from = ref.name.trim().toLowerCase();
+    let changed = false;
+    for (const slot of slotsIn(copy, ref)) {
+        const name = slot.get();
+        if (typeof name !== "string" || name.trim().toLowerCase() !== from || name === to)
+            continue;
+        slot.set(to);
+        changed = true;
+    }
+    return changed ? copy : undefined;
+}
+export function uses(value, ref, formerNames = []) {
+    const wanted = new Set([ref.name, ...formerNames].map((name) => name.trim().toLowerCase()));
+    return namesIn(value, ref).some((name) => wanted.has(name.trim().toLowerCase()));
 }
 const documentShape = z.object({ form: z.unknown() }).loose();
 function formOf(json) {
     const parsed = documentShape.safeParse(JSON.parse(json));
     return parsed.success ? parsed.data.form : undefined;
 }
-export function usedBy(db, ref) {
+// `formerNames` are names the item had before a rename that no other item holds now: a
+// project revision keeps the name its run used (`rename.ts` leaves revisions alone), so a
+// renamed prompt still finds the projects that ran it.
+export function usedBy(db, ref, formerNames = []) {
     // A name that appears nowhere in the JSON cannot match, so SQL skips those rows before any
     // is parsed. JSON escapes quotes and backslashes, so only a plain name is pre-filtered.
     // SQLite's lower() folds ASCII only, so a name with anything else is not pre-filtered.
-    const plain = /^[\x20-\x7e]*$/u.test(ref.name) && !/["\\]/u.test(ref.name)
-        ? ref.name.trim().toLowerCase()
-        : "";
+    const names = [ref.name, ...formerNames];
+    const plain = names.every((name) => /^[\x20-\x7e]*$/u.test(name) && !/["\\]/u.test(name))
+        ? names.map((name) => name.trim().toLowerCase())
+        : [""];
+    const mentions = (column) => `(${plain.map(() => `instr(lower(${column}),?)>0`).join(" OR ")})`;
+    const matches = (value) => uses(value, ref, formerNames);
     const templates = db
         .prepare(`SELECT t.id,r.name,r.document_json FROM project_templates t
        JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version
-       WHERE t.deleted_at IS NULL AND instr(lower(r.document_json),?)>0 ORDER BY lower(r.name),t.id`)
-        .all(plain)
+       WHERE t.deleted_at IS NULL AND ${mentions("r.document_json")} ORDER BY lower(r.name),t.id`)
+        .all(...plain)
         .flatMap((row) => {
         const parsed = templateRow.parse(row);
-        return uses(formOf(parsed.document_json), ref) ? [{ id: parsed.id, name: parsed.name }] : [];
+        return matches(formOf(parsed.document_json)) ? [{ id: parsed.id, name: parsed.name }] : [];
     });
-    // A schedule runs the template version it was saved with, so that version is what it uses.
+    // A schedule runs its template as it is now (`schedules/scheduler.ts`), so the template's
+    // current version is what it uses.
     const schedules = db
         .prepare(`SELECT s.id,s.name,s.status,r.document_json FROM schedules s
-       JOIN project_template_revisions r ON r.template_id=s.template_id AND r.version=s.template_version
-       WHERE s.deleted_at IS NULL AND s.status IN ('active','paused') AND instr(lower(r.document_json),?)>0
+       JOIN project_templates t ON t.id=s.template_id
+       JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version
+       WHERE s.deleted_at IS NULL AND s.status IN ('active','paused') AND ${mentions("r.document_json")}
        ORDER BY lower(s.name),s.id`)
-        .all(plain)
+        .all(...plain)
         .flatMap((row) => {
         const parsed = scheduleRow.parse(row);
-        return uses(formOf(parsed.document_json), ref)
+        return matches(formOf(parsed.document_json))
             ? [{ id: parsed.id, name: parsed.name, status: parsed.status }]
             : [];
     });
@@ -99,13 +126,13 @@ export function usedBy(db, ref) {
         (SELECT count(*) FROM project_revisions x WHERE x.project_id=r.project_id) AS total
        FROM project_revisions r JOIN projects p ON p.id=r.project_id
        LEFT JOIN project_heads h ON h.project_id=r.project_id
-       WHERE ${liveProject("p")} AND instr(lower(r.config),?)>0
+       WHERE ${liveProject("p")} AND ${mentions("r.config")}
        ORDER BY p.created_at DESC,p.id,r.created_at`)
-        .all(plain)
+        .all(...plain)
         .map((row) => revisionRow.parse(row));
     const projects = new Map();
     for (const row of revisionRows) {
-        if (!uses(JSON.parse(row.config), ref))
+        if (!matches(JSON.parse(row.config)))
             continue;
         const seen = projects.get(row.project_id);
         projects.set(row.project_id, {
@@ -121,10 +148,10 @@ export function usedBy(db, ref) {
         .prepare(`SELECT p.id,p.title,p.config FROM projects p
        WHERE ${liveProject("p")}
        AND NOT EXISTS (SELECT 1 FROM project_revisions r WHERE r.project_id=p.id)
-       AND instr(lower(p.config),?)>0 ORDER BY p.created_at DESC,p.id`)
-        .all(plain)
+       AND ${mentions("p.config")} ORDER BY p.created_at DESC,p.id`)
+        .all(...plain)
         .map((row) => legacyRow.parse(row))) {
-        if (uses(JSON.parse(row.config), ref))
+        if (matches(JSON.parse(row.config)))
             projects.set(row.id, {
                 id: row.id,
                 title: row.title,

package/dist/slices/rebuild/narration-retry.js

@@ -105,6 +105,16 @@ async function recordAgain(deps, retry) {
             detail: `Recording ${retry.chunkKey} again (try ${String(retry.tries)} of ${String(narrationRetryLimit)}).`,
         });
     }
+    else if (result.reason === "running") {
+        // Another step of the project is still going (its PDF, say): the retry waits for it and
+        // starts when that step finishes, which kicks this again (`onFinished`). Giving up here
+        // left the video failed with a message promising a retry that never came.
+        deps.log.write("info", "narration.retry", {
+            projectId: retry.projectId,
+            detail: `Recording ${retry.chunkKey} again once the project's running steps finish.`,
+        });
+        return;
+    }
     else {
         settle(deps.db, retry, "failed", refusal(result), now);
         deps.log.write("warn", "narration.retry", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "3.0.13",
+  "version": "3.0.15",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",