@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/library/history.js

@@ -0,0 +1,100 @@
+// Prompt history: every save of a Library prompt or intro/outro keeps a version, and History
+// lists, compares and restores them. A version is the whole saved row - name, body, kind and
+// mode - so restoring one puts back exactly what was saved then.
+import { z } from "zod";
+import { entryModes } from "./model.js";
+export const libraryItemKinds = ["prompt", "entry"];
+// Saves come from this one-user app, so every version is the user's. The column exists so a
+// version written by something else (an import, a future automatic update) can say so.
+export const versionAuthor = "you";
+const versionRow = z.object({
+    version: z.number().int().positive(),
+    kind: z.string(),
+    mode: z.enum(entryModes).nullable(),
+    name: z.string(),
+    body: z.string(),
+    author: z.string(),
+    restored_from: z.number().int().nullable(),
+    created_at: z.string(),
+});
+function kindOf(item) {
+    return "kind" in item ? item.kind : item.category;
+}
+function modeOf(item) {
+    return "mode" in item ? item.mode : null;
+}
+// Newest first: History opens on what is saved now.
+export function listVersions(db, itemKind, itemId) {
+    return db
+        .prepare("SELECT version,kind,mode,name,body,author,restored_from,created_at FROM library_versions WHERE item_kind=? AND item_id=? ORDER BY version DESC")
+        .all(itemKind, itemId)
+        .map((row) => toVersion(versionRow.parse(row)));
+}
+export function versionOf(db, itemKind, itemId, version) {
+    const row = db
+        .prepare("SELECT version,kind,mode,name,body,author,restored_from,created_at FROM library_versions WHERE item_kind=? AND item_id=? AND version=?")
+        .get(itemKind, itemId, version);
+    return row === undefined ? undefined : toVersion(versionRow.parse(row));
+}
+// Records the row as saved. A save that changed nothing (the editor's Save pressed twice, a
+// restore of the version already current) adds no version, so History lists real changes only.
+// A row with no versions at all - one a backup or a portable import wrote straight into the
+// table - gets its saved text as version 1 before the new one, so History never starts from
+// a version the user never saw.
+export function recordVersion(db, itemKind, item, options = {}) {
+    const latest = listVersions(db, itemKind, item.id)[0];
+    let next = (latest?.version ?? 0) + 1;
+    if (latest === undefined && options.previous !== undefined && !same(options.previous, item)) {
+        insert(db, itemKind, options.previous, 1, null, options.previous.updatedAt);
+        next = 2;
+    }
+    if (latest !== undefined && sameAsVersion(latest, item))
+        return;
+    insert(db, itemKind, item, next, options.restoredFrom ?? null, item.updatedAt);
+}
+export function deleteVersions(db, itemKind, itemId) {
+    db.prepare("DELETE FROM library_versions WHERE item_kind=? AND item_id=?").run(itemKind, itemId);
+}
+// History for a row with no versions yet (written by an import): its saved text as version 1,
+// said rather than stored, since reading must not write.
+export function versionsOrCurrent(db, itemKind, item) {
+    const versions = listVersions(db, itemKind, item.id);
+    if (versions.length > 0)
+        return versions;
+    return [
+        {
+            version: 1,
+            kind: kindOf(item),
+            mode: modeOf(item),
+            name: item.name,
+            body: item.body,
+            author: versionAuthor,
+            restoredFrom: null,
+            createdAt: item.updatedAt,
+        },
+    ];
+}
+function insert(db, itemKind, item, version, restoredFrom, createdAt) {
+    db.prepare("INSERT INTO library_versions (item_kind,item_id,version,kind,mode,name,body,author,restored_from,created_at) VALUES (?,?,?,?,?,?,?,?,?,?)").run(itemKind, item.id, version, kindOf(item), modeOf(item), item.name, item.body, versionAuthor, restoredFrom, createdAt);
+}
+function same(a, b) {
+    return (a.name === b.name && a.body === b.body && kindOf(a) === kindOf(b) && modeOf(a) === modeOf(b));
+}
+function sameAsVersion(version, item) {
+    return (version.name === item.name &&
+        version.body === item.body &&
+        version.kind === kindOf(item) &&
+        version.mode === modeOf(item));
+}
+function toVersion(row) {
+    return {
+        version: row.version,
+        kind: row.kind,
+        mode: row.mode,
+        name: row.name,
+        body: row.body,
+        author: row.author,
+        restoredFrom: row.restored_from,
+        createdAt: row.created_at,
+    };
+}

package/dist/slices/library/model.js

@@ -9,6 +9,9 @@ export const promptKinds = [
     "narration",
     "description",
     "shorts",
+    "review",
+    // Speaker turns for a multi-voice run (`slices/voices/script.ts`), in place of an article.
+    "script",
 ];
 export const entryCategories = ["intro", "outro"];
 // The name is what the Play pickers show, so it shares admission's title bound.

package/dist/slices/library/photorealistic.js

@@ -0,0 +1,49 @@
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { promptById, promptByName } from "./repo.js";
+// An Image prompt's "Draws photorealistic pictures" tick (Library → Prompts → the prompt).
+// Pictures an image model draws in such a style can pass for real scenes, which is YouTube's
+// third AI use case (`slices/studio/disclosure.ts`); a stylised, painterly or illustrated
+// style can't, so the tick is off unless the person sets it. One row of the key/value
+// `settings` table holds the ticked prompts' ids, so the flag needs no column of its own, keeps
+// through edits and renames, and travels with a backup. A prompt in the trash keeps its tick
+// for when it is restored.
+export const photorealisticPromptsKey = "library.photorealisticPrompts";
+export function photorealisticPromptIds(db) {
+    const stored = readSetting(db, photorealisticPromptsKey);
+    if (stored === undefined)
+        return new Set();
+    try {
+        const value = JSON.parse(stored);
+        return new Set(Array.isArray(value) ? value.filter((one) => typeof one === "string") : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+// The prompts as the Library lists them, the ticked ones marked.
+export function withPhotorealistic(db, prompts) {
+    const ticked = photorealisticPromptIds(db);
+    return prompts.map((prompt) => ticked.has(prompt.id) ? { ...prompt, photorealistic: true } : prompt);
+}
+export function setPromptPhotorealistic(db, id, on) {
+    const prompt = promptById(db, id);
+    if (prompt === undefined)
+        return { ok: false, reason: "not-found" };
+    if (prompt.kind !== "image")
+        return { ok: false, reason: "not-an-image-prompt" };
+    const others = [...photorealisticPromptIds(db)].filter((one) => one !== id);
+    const next = on ? [...others, id].sort() : others;
+    if (next.length === 0)
+        db.prepare("DELETE FROM settings WHERE key = ?").run(photorealisticPromptsKey);
+    else
+        writeSetting(db, photorealisticPromptsKey, JSON.stringify(next));
+    return { ok: true };
+}
+// Whether the Image prompt a project names draws photorealistic pictures. A name the Library
+// no longer has (deleted or renamed since) is not ticked.
+export function namesPhotorealisticPrompt(db, name) {
+    if (name === undefined || name.trim() === "")
+        return false;
+    const prompt = promptByName(db, "image", name.trim());
+    return prompt !== undefined && photorealisticPromptIds(db).has(prompt.id);
+}

package/dist/slices/library/repo.js

@@ -23,6 +23,8 @@ 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(?)";
+// A row in the trash is invisible to every read and write here; `slices/trash` owns it.
+const live = "deleted_at IS NULL";
 // The lists on 04 Prompts and the pickers on Play sort by name.
 const byNameOrder = "ORDER BY lower(name)";
 export function insertPrompt(db, prompt) {
@@ -32,27 +34,30 @@ export function insertPrompt(db, prompt) {
 // 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 = ?")
+        .prepare(`UPDATE prompts SET kind = ?, name = ?, body = ?, slots = ?, updated_at = ? WHERE id = ? AND ${live}`)
         .run(prompt.kind, prompt.name, prompt.body, JSON.stringify(prompt.slots), prompt.updatedAt, prompt.id);
     return Number(result.changes) > 0;
 }
-// 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;
+// Delete moves the row to the trash (Settings → Trash): it keeps its versions and leaves
+// every list and lookup here. No foreign key points at it, so a project that used the
+// template keeps its own rendered text either way. `slices/trash` removes it for good.
+export function trashPrompt(db, id, at) {
+    return (Number(db.prepare(`UPDATE prompts SET deleted_at = ? WHERE id = ? AND ${live}`).run(at, id).changes) > 0);
 }
 export function listPrompts(db) {
     return db
-        .prepare(`SELECT * FROM prompts ${byNameOrder}`)
+        .prepare(`SELECT * FROM prompts WHERE ${live} ${byNameOrder}`)
         .all()
         .map((row) => toPrompt(promptRow.parse(row)));
 }
 export function promptById(db, id) {
-    const row = db.prepare("SELECT * FROM prompts WHERE id = ?").get(id);
+    const row = db.prepare(`SELECT * FROM prompts WHERE id = ? AND ${live}`).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);
+    const row = db
+        .prepare(`SELECT * FROM prompts WHERE kind = ? AND ${byName} AND ${live}`)
+        .get(kind, name);
     return row === undefined ? undefined : toPrompt(promptRow.parse(row));
 }
 export function insertEntry(db, entry) {
@@ -60,26 +65,26 @@ export function insertEntry(db, entry) {
 }
 export function replaceEntry(db, entry) {
     const result = db
-        .prepare("UPDATE entries SET category = ?, mode = ?, name = ?, body = ?, slots = ?, updated_at = ? WHERE id = ?")
+        .prepare(`UPDATE entries SET category = ?, mode = ?, name = ?, body = ?, slots = ?, updated_at = ? WHERE id = ? AND ${live}`)
         .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 trashEntry(db, id, at) {
+    return (Number(db.prepare(`UPDATE entries SET deleted_at = ? WHERE id = ? AND ${live}`).run(at, id).changes) > 0);
 }
 export function listEntries(db) {
     return db
-        .prepare(`SELECT * FROM entries ${byNameOrder}`)
+        .prepare(`SELECT * FROM entries WHERE ${live} ${byNameOrder}`)
         .all()
         .map((row) => toEntry(entryRow.parse(row)));
 }
 export function entryById(db, id) {
-    const row = db.prepare("SELECT * FROM entries WHERE id = ?").get(id);
+    const row = db.prepare(`SELECT * FROM entries WHERE id = ? AND ${live}`).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}`)
+        .prepare(`SELECT * FROM entries WHERE category = ? AND ${byName} AND ${live}`)
         .get(category, name);
     return row === undefined ? undefined : toEntry(entryRow.parse(row));
 }

package/dist/slices/library/save.js

@@ -1,31 +1,57 @@
 // Creating, editing and deleting a template. One rule set covers prompts
 // and entries, so both go through the same three outcomes.
 import { isUniqueConstraint } from "../../kernel/db/index.js";
+import { transact } from "../../kernel/db/tx.js";
 import { detectSlots } from "../admission/substitute.js";
+import { recordVersion, versionOf } from "./history.js";
 import { lintEntry, lintPrompt } from "./lint.js";
-import { deleteEntry, deletePrompt, insertEntry, insertPrompt, replaceEntry, replacePrompt, } from "./repo.js";
+import { entryCategories, promptKinds } from "./model.js";
+import { entryById, insertEntry, insertPrompt, promptById, replaceEntry, replacePrompt, trashEntry, trashPrompt, } 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(() => {
+    return written(deps.db, () => {
         insertPrompt(deps.db, prompt);
+        recordVersion(deps.db, "prompt", prompt);
         return true;
     }, prompt);
 }
-// A save overwrites; there is no version history, so the row is replaced whole.
-export function updatePrompt(deps, id, draft) {
+// A save replaces the row whole and keeps what was saved as a new version (`history.ts`).
+export function updatePrompt(deps, id, draft, restoredFrom) {
     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);
+    return written(deps.db, () => {
+        const previous = promptById(deps.db, id);
+        if (!replacePrompt(deps.db, prompt))
+            return false;
+        recordVersion(deps.db, "prompt", prompt, {
+            previous,
+            ...(restoredFrom === undefined ? {} : { restoredFrom }),
+        });
+        return true;
+    }, prompt);
+}
+// Restore saves an old version again, as a new version that says where it came from, so the
+// versions after it stay in History.
+export function restorePrompt(deps, id, version) {
+    const saved = versionOf(deps.db, "prompt", id, version);
+    const kind = promptKinds.find((one) => one === saved?.kind);
+    if (saved === undefined || kind === undefined || promptById(deps.db, id) === undefined)
+        return { ok: false, reason: "not-found" };
+    return updatePrompt(deps, id, { kind, name: saved.name, body: saved.body }, version);
 }
+// Delete moves the prompt to the trash with its history; Settings → Trash puts it back or
+// removes it for good (`slices/trash`).
 export function removePrompt(deps, id) {
-    return deletePrompt(deps.db, id) ? { ok: true, value: null } : { ok: false, reason: "not-found" };
+    return trashPrompt(deps.db, id, deps.clock.now().toISOString())
+        ? { ok: true, value: null }
+        : { ok: false, reason: "not-found" };
 }
 export function createEntry(deps, draft) {
     const fields = lintEntry(draft);
@@ -33,21 +59,43 @@ export function createEntry(deps, draft) {
         return { ok: false, reason: "invalid", fields };
     }
     const entry = { id: deps.ids.next(), ...entryOf(deps, draft) };
-    return written(() => {
+    return written(deps.db, () => {
         insertEntry(deps.db, entry);
+        recordVersion(deps.db, "entry", entry);
         return true;
     }, entry);
 }
-export function updateEntry(deps, id, draft) {
+export function updateEntry(deps, id, draft, restoredFrom) {
     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);
+    return written(deps.db, () => {
+        const previous = entryById(deps.db, id);
+        if (!replaceEntry(deps.db, entry))
+            return false;
+        recordVersion(deps.db, "entry", entry, {
+            previous,
+            ...(restoredFrom === undefined ? {} : { restoredFrom }),
+        });
+        return true;
+    }, entry);
+}
+export function restoreEntry(deps, id, version) {
+    const saved = versionOf(deps.db, "entry", id, version);
+    const category = entryCategories.find((one) => one === saved?.kind);
+    if (saved === undefined ||
+        category === undefined ||
+        saved.mode === null ||
+        entryById(deps.db, id) === undefined)
+        return { ok: false, reason: "not-found" };
+    return updateEntry(deps, id, { category, mode: saved.mode, name: saved.name, body: saved.body }, version);
 }
 export function removeEntry(deps, id) {
-    return deleteEntry(deps.db, id) ? { ok: true, value: null } : { ok: false, reason: "not-found" };
+    return trashEntry(deps.db, id, deps.clock.now().toISOString())
+        ? { 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.
@@ -74,9 +122,11 @@ function entryOf(deps, draft) {
 // 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) {
+// The row and its version are written together: a save either lands with its version or not
+// at all.
+function written(db, write, value) {
     try {
-        return write() ? { ok: true, value } : { ok: false, reason: "not-found" };
+        return transact(db, write) ? { ok: true, value } : { ok: false, reason: "not-found" };
     }
     catch (error) {
         if (isUniqueConstraint(error)) {

package/dist/slices/library/slots.js

@@ -4,6 +4,9 @@
 // is the one that runs.
 import { normaliseDraft, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
+import { reviewPromptKey } from "../reviews/model.js";
+import { activeReviewStages } from "../reviews/rules.js";
+import { usesScriptPrompt } from "../voices/model.js";
 import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
 export function pickTemplates(db, input, snapshot) {
     const draft = normaliseDraft(input);
@@ -14,7 +17,7 @@ export function pickTemplates(db, input, snapshot) {
     const text = [];
     const image = [];
     if (sources.article === "generate") {
-        body(db, "article", draft.articlePrompt, "articlePrompt", missing, text, "article", snapshot);
+        body(db, usesScriptPrompt(draft) ? "script" : "article", draft.articlePrompt, "articlePrompt", missing, text, "article", snapshot);
     }
     const intro = pickEntry(db, "intro", draft.intro, missing, snapshot);
     if (usesNarrationPreparation(draft))
@@ -30,6 +33,9 @@ export function pickTemplates(db, input, snapshot) {
         body(db, "shorts", draft.shorts?.prompt, "shorts.prompt", missing, text, "shorts", snapshot);
         body(db, "image", draft.shorts?.imagePrompt, "shorts.imagePrompt", missing, image, "shortsImage", snapshot);
     }
+    // Each reviewed stage's Review prompt; none picked is the stage's built-in one.
+    for (const stage of activeReviewStages(draft))
+        body(db, "review", draft.reviews?.stages[stage]?.prompt, `reviews.stages.${stage}.prompt`, missing, text, reviewPromptKey(stage), snapshot);
     // The establishing image's prompt: an image prompt like the others, its keywords filled the
     // same way.
     if (usesReference(draft) && draft.reference?.source === "prompt")

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

@@ -0,0 +1,153 @@
+// "Used by": the templates, schedules and projects that name a Library prompt or intro/outro.
+// Everything refers to the Library by name (a template's form, a schedule's template, a
+// project revision's config), so the match is the name, without regard to case, within the
+// prompt's kind or the entry's category - the same rule the unique indexes and
+// `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();
+// 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)
+        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() !== "");
+}
+export function uses(value, ref) {
+    const wanted = ref.name.trim().toLowerCase();
+    return namesIn(value, ref).some((name) => name.trim().toLowerCase() === wanted);
+}
+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) {
+    // 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 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)
+        .flatMap((row) => {
+        const parsed = templateRow.parse(row);
+        return uses(formOf(parsed.document_json), ref) ? [{ id: parsed.id, name: parsed.name }] : [];
+    });
+    // A schedule runs the template version it was saved with, so that 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
+       ORDER BY lower(s.name),s.id`)
+        .all(plain)
+        .flatMap((row) => {
+        const parsed = scheduleRow.parse(row);
+        return uses(formOf(parsed.document_json), ref)
+            ? [{ id: parsed.id, name: parsed.name, status: parsed.status }]
+            : [];
+    });
+    const revisionRows = db
+        .prepare(`SELECT r.project_id,p.title,r.id AS revision_id,r.config,h.revision_id AS head,
+        (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
+       ORDER BY p.created_at DESC,p.id,r.created_at`)
+        .all(plain)
+        .map((row) => revisionRow.parse(row));
+    const projects = new Map();
+    for (const row of revisionRows) {
+        if (!uses(JSON.parse(row.config), ref))
+            continue;
+        const seen = projects.get(row.project_id);
+        projects.set(row.project_id, {
+            id: row.project_id,
+            title: row.title,
+            revisions: (seen?.revisions ?? 0) + 1,
+            totalRevisions: row.total,
+            current: (seen?.current ?? false) || row.head === row.revision_id,
+        });
+    }
+    // A project from before revisions existed has none yet; its own config is what it ran with.
+    for (const row of db
+        .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)
+        .map((row) => legacyRow.parse(row))) {
+        if (uses(JSON.parse(row.config), ref))
+            projects.set(row.id, {
+                id: row.id,
+                title: row.title,
+                revisions: 0,
+                totalRevisions: 0,
+                current: true,
+            });
+    }
+    return { templates, schedules, projects: [...projects.values()] };
+}
+const templateRow = z.object({ id: z.string(), name: z.string(), document_json: z.string() });
+const scheduleRow = z.object({
+    id: z.string(),
+    name: z.string(),
+    status: z.string(),
+    document_json: z.string(),
+});
+const revisionRow = z.object({
+    project_id: z.string(),
+    title: z.string(),
+    revision_id: z.string(),
+    config: z.string(),
+    head: z.string().nullable(),
+    total: z.number(),
+});
+const legacyRow = z.object({ id: z.string(), title: z.string(), config: z.string() });

package/dist/slices/loudness/level-pieces.js

@@ -0,0 +1,41 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { levelFile, measurable } from "./loudnorm.js";
+import { pieceLufs, pieceTruePeak, spreadOf } from "./model.js";
+// Every narration piece brought to the one common loudness before the join (`levelFile`), each
+// written again as a WAV in `directory` for the join to read in their place. They come out in one format (44.1 kHz mono, which is what the
+// multi-voice join already brings every turn to), so the plain concat can join them too. A piece
+// too short or quiet to measure keeps its own level. Each levelled piece is measured again, so
+// the report says what the levelling did, not what it meant to do.
+const format = { sampleRate: 44100, channels: 1 };
+const goal = { lufs: pieceLufs, truePeak: pieceTruePeak };
+export async function levelPieces(run, files, directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const levelled = [];
+    const before = [];
+    const after = [];
+    let skipped = 0;
+    for (const [index, file] of files.entries()) {
+        run.signal.throwIfAborted();
+        const output = join(directory, `piece-${String(index + 1).padStart(4, "0")}.wav`);
+        const measured = await levelFile(run, file, output, goal, format);
+        levelled.push(output);
+        if (!measurable(measured.before)) {
+            skipped += 1;
+            continue;
+        }
+        before.push(measured.before.integrated);
+        if (measurable(measured.after))
+            after.push(measured.after.integrated);
+    }
+    return {
+        files: levelled,
+        report: {
+            pieces: files.length,
+            skipped,
+            spreadBefore: spreadOf(before),
+            spreadAfter: spreadOf(after),
+            target: pieceLufs,
+        },
+    };
+}