@gentbajko/slopify 3.0.12 → 3.0.14

package/dist/edge/events/hub.js

@@ -7,6 +7,12 @@ export function createHub(deps) {
     // changes, so the newest one is kept here and replayed to whoever opens next; a page
     // that loads mid-render would otherwise be told nothing is running.
     let tally = { type: "running.count", count: 0 };
+    const present = (event) => deps.presentEvent !== undefined
+        ? deps.presentEvent(event)
+        : deps.acceptEvent?.(event) === false
+            ? undefined
+            : event;
+    const heartbeatMs = deps.heartbeatMs ?? 20_000;
     const send = (subscriber, event) => {
         // writeSSE rejects on a socket that is already gone, asynchronously and long after
         // emit() returned, so a dead subscriber is dropped here instead of at the call site.
@@ -38,6 +44,15 @@ export function createHub(deps) {
         }
         else {
             signal.addEventListener("abort", subscriber.drop, { once: true });
+            if (heartbeatMs > 0) {
+                const beat = setInterval(() => {
+                    subscriber.stream
+                        .writeSSE({ event: "ping", data: "", id: deps.ids.next() })
+                        .catch(() => subscriber.drop());
+                }, heartbeatMs);
+                beat.unref?.();
+                void done.then(() => clearInterval(beat));
+            }
         }
         return subscriber;
     };
@@ -51,33 +66,38 @@ export function createHub(deps) {
                 }
             });
             if (set.has(subscriber))
-                for (const event of previews.snapshot(projectId))
-                    if (deps.acceptEvent?.(event) !== false)
-                        send(subscriber, event);
+                for (const event of previews.snapshot(projectId)) {
+                    const shown = present(event);
+                    if (shown !== undefined)
+                        send(subscriber, shown);
+                }
             return subscriber.done;
         },
         subscribeGlobal: (stream, signal) => {
             const subscriber = join(globals, stream, signal, () => { });
             if (globals.has(subscriber)) {
                 send(subscriber, tally);
+                // What the AI models are writing right now, so a page opened mid-call shows it.
+                for (const event of previews.snapshotAll()) {
+                    const shown = present(event);
+                    if (shown !== undefined)
+                        send(subscriber, shown);
+                }
             }
             return subscriber.done;
         },
         emit: (projectId, event) => {
-            const accepted = deps.acceptEvent?.(event) !== false;
-            if (accepted || event.type === "stage.state")
+            const shown = present(event);
+            if (shown !== undefined)
+                previews.observe(shown);
+            else if (event.type === "stage.state")
                 previews.observe(event);
-            if (!accepted)
+            if (shown === undefined)
                 return;
-            for (const subscriber of projects.get(projectId) ?? []) {
-                send(subscriber, event);
-            }
-            if (event.type === "project.state" ||
-                event.type === "project.updated" ||
-                event.type === "review.flagged") {
-                for (const subscriber of globals)
-                    send(subscriber, event);
-            }
+            for (const subscriber of projects.get(projectId) ?? [])
+                send(subscriber, shown);
+            for (const subscriber of globals)
+                send(subscriber, shown);
         },
         emitGlobal: (event) => {
             if (event.type === "running.count") {

package/dist/edge/events/preview-cache.js

@@ -39,5 +39,6 @@ export function createPreviewCache() {
             }
         },
         snapshot: (projectId) => [...(projects.get(projectId)?.values() ?? [])],
+        snapshotAll: () => [...projects.values()].flatMap((calls) => [...calls.values()]),
     };
 }

package/dist/edge/events/visibility.js

@@ -1,4 +1,7 @@
 import { currentRevisionId } from "../../slices/revisions/repo.js";
+// Whether the work an event came from is the current revision's: made for it, or carried to it
+// from an older revision by an edit that left it unchanged (a video still rendering after a
+// thumbnail redo is still the project's video).
 export function currentWorkOrigin(db, projectId, origin) {
     if (currentRevisionId(db, projectId) === undefined)
         return origin.revisionId === undefined && origin.workId === undefined;
@@ -13,21 +16,52 @@ export function currentWorkOrigin(db, projectId, origin) {
     JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
       AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
     LEFT JOIN revision_work_pieces p ON p.id=r.piece_id AND p.work_id=w.id
-    WHERE w.project_id=? AND w.revision_id=? AND w.id=?
+    WHERE w.project_id=? AND w.id=?
       AND (? IS NULL OR r.piece_id=?)
       AND (r.piece_id IS NULL OR (p.work_key=r.work_key AND p.fingerprint=r.fingerprint))
   `)
-        .get(projectId, origin.revisionId, origin.workId, origin.workPieceId ?? null, origin.workPieceId ?? null) !== undefined);
+        .get(projectId, origin.workId, origin.workPieceId ?? null, origin.workPieceId ?? null) !==
+        undefined);
 }
-export function currentProjectEvent(db, event) {
+// The event as the project's pages should see it, or undefined for one they must not: work the
+// current revision no longer wants. Carried work is told under the current revision, since
+// that is the revision the pages show.
+export function currentEvent(db, event) {
     if (event.type === "project.updated")
-        return true;
+        return event;
     if (event.type === "project.state" &&
         event.revisionId === undefined &&
         event.workId === undefined)
-        return true;
+        return event;
     const head = currentRevisionId(db, event.projectId);
-    if (head !== event.revisionId)
-        return false;
-    return currentWorkOrigin(db, event.projectId, event);
+    if (head === undefined)
+        return currentWorkOrigin(db, event.projectId, event) ? event : undefined;
+    if (!currentWorkOrigin(db, event.projectId, event))
+        return undefined;
+    return event.revisionId === head ? event : { ...event, revisionId: head };
+}
+export function currentProjectEvent(db, event) {
+    return currentEvent(db, event) !== undefined;
+}
+// `currentEvent` for the hub. The streamed text (a token at a time) asks the same question many
+// times a second, so its answer is kept for a second per piece of work.
+export function eventPresenter(db, now = Date.now) {
+    const seen = new Map();
+    return (event) => {
+        if (event.type !== "llm.preview" && event.type !== "article.delta")
+            return currentEvent(db, event);
+        const key = [event.projectId, event.revisionId, event.workId, event.workPieceId].join("|");
+        const hit = seen.get(key);
+        if (hit !== undefined && now() - hit.at < 1000)
+            return !hit.shown
+                ? undefined
+                : hit.revisionId === undefined || hit.revisionId === event.revisionId
+                    ? event
+                    : { ...event, revisionId: hit.revisionId };
+        const shown = currentEvent(db, event);
+        if (seen.size > 512)
+            seen.clear();
+        seen.set(key, { at: now(), shown: shown !== undefined, revisionId: shown?.revisionId });
+        return shown;
+    };
 }

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/main.js

@@ -14,7 +14,7 @@ import { createCatalogueStore } from "./catalog/store.js";
 import { createAutostart } from "./edge/autostart/index.js";
 import { dockerActivationCommitted, dockerFilesLayout, dockerFolderConfiguration, } from "./edge/docker-install/activation.js";
 import { createHub, observedHub } from "./edge/events/hub.js";
-import { currentProjectEvent } from "./edge/events/visibility.js";
+import { eventPresenter } from "./edge/events/visibility.js";
 import { createApp } from "./edge/http/app.js";
 import { createMutationLifecycle, drainMutationsWithDeadline } from "./edge/http/mutations.js";
 import { limitRequestTimes } from "./edge/http/timeouts.js";
@@ -219,7 +219,7 @@ export async function boot(config, options = {}) {
         const hub = observedHub(createHub({
             ids,
             log,
-            acceptEvent: (event) => currentProjectEvent(eventDb, event),
+            presentEvent: eventPresenter(eventDb),
         }), (event) => {
             notifier.observe(event);
             episodes?.observe(event);

package/dist/patch-notes/3.0.13.md

@@ -0,0 +1,43 @@
+# Slopify 3.0.13
+
+Released 30 September 2026.
+
+3.0.13 makes every page update live again, tightens the project page, adds run sounds, and fixes Restore and a thumbnail change that remade every image.
+
+## Highlights
+
+- **Pages update live again.** Steps, images, progress and finished runs show up without refreshing, on every page and in every tab.
+- **Run sounds.** A chime when a run starts and a different one when it ends.
+- **History → Restore works again** on projects with scenes, looks, shorts or a YouTube description.
+
+## Live updates
+
+- Each page now keeps one live connection instead of one per project it shows. With a few tabs open, the connections ran out and the page's own requests waited forever: updates arrived but nothing could reload.
+- A run that goes on after an edit (a video still rendering after a thumbnail redo) shows its progress again.
+- The projects list, home and calendar move when steps start and finish, not only when a project changes.
+- The video render's progress moves in tenths of a percent, so a two-hour render moves every few seconds.
+- Pages showing a running project also look again every 15 seconds, in case an update was missed.
+
+## Project page
+
+- The header is one row: the way back, the title, the meta line and the buttons. Each stage's summary sits beside its title, and the run clock sits in the meta line instead of a row of its own, so the content starts much higher.
+- The article shows its word and character count beside its title (the narrated text, without its sources and glossary).
+- **Live** plays the finished narration, with its waveform, and plays the parts so far while it is spoken. Its length reads in hours and minutes.
+
+## Run clock and cost
+
+- The run clock keeps counting through work carried over from before an edit, instead of freezing.
+- **Cost so far** shows the run's working time once it stops, for example "2 h 14 min of work".
+
+## Notifications
+
+- **Run sounds** (Settings → Notifications, on by default): two rising notes when a run starts, three brighter ones when it finishes, fails or waits for you. **Play start** and **Play end** let you hear them. With browser notifications on, a start also shows "Started: *title*".
+
+## Fixes
+
+- **History → Restore this revision** stopped with "unknown kind of step" on projects with Scenes from the article, `{{Appearance}}`, shorts, a YouTube description, levelled narration or animated images.
+- Changing a project's thumbnail settings marked every image outdated. The thumbnails' scenes are now written by a step of their own in the Thumbnail stage.
+
+## Upgrading from 3.0.12
+
+- **Nothing becomes outdated.** A project whose thumbnail prompt uses `{{Scene}}` writes its thumbnail scenes in the new step the next time the thumbnail is made.

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/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "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",
+    "version": "3.0.13",
+    "date": "2026-09-30"
+  },
   {
     "id": "3.0.12",
     "title": "Slopify 3.0.12",

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,