@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/library/diff.js

@@ -0,0 +1,122 @@
+// A word-level diff for History's side-by-side view. Browser-safe: the Library screen diffs the
+// two versions it already holds. Words and the whitespace between them are the units, so a
+// changed word is marked on its own and line breaks survive for the view to show.
+// Past this many changed words the two texts are too different for a word diff to help, and
+// the Myers trace would grow with it: the view shows the one removed and the other added.
+const maxEdits = 4000;
+export function tokens(text) {
+    return text.match(/\s+|[^\s]+/gu) ?? [];
+}
+// The parts of both texts in order. `same` parts belong to both sides, `removed` to the older
+// text only and `added` to the newer only; neighbours of one kind are joined.
+export function wordDiff(before, after) {
+    const a = tokens(before);
+    const b = tokens(after);
+    // The common head and tail are cut first: most edits touch a small part of a long prompt.
+    let head = 0;
+    while (head < a.length && head < b.length && a[head] === b[head])
+        head += 1;
+    let tail = 0;
+    while (tail < a.length - head &&
+        tail < b.length - head &&
+        a[a.length - 1 - tail] === b[b.length - 1 - tail])
+        tail += 1;
+    const parts = [];
+    push(parts, "same", a.slice(0, head).join(""));
+    const middleA = a.slice(head, a.length - tail);
+    const middleB = b.slice(head, b.length - tail);
+    for (const part of myers(middleA, middleB))
+        push(parts, part.op, part.text);
+    push(parts, "same", a.slice(a.length - tail).join(""));
+    return parts;
+}
+// One side of the side-by-side view: the older text keeps what was removed, the newer what
+// was added.
+export function sideOf(parts, side) {
+    const hidden = side === "before" ? "added" : "removed";
+    return parts.filter((part) => part.op !== hidden);
+}
+export function diffCounts(parts) {
+    const words = (op) => parts
+        .filter((part) => part.op === op)
+        .reduce((sum, part) => sum + tokens(part.text).filter((one) => one.trim() !== "").length, 0);
+    return { added: words("added"), removed: words("removed") };
+}
+function push(parts, op, text) {
+    if (text === "")
+        return;
+    const last = parts.at(-1);
+    if (last !== undefined && last.op === op)
+        parts[parts.length - 1] = { op, text: last.text + text };
+    else
+        parts.push({ op, text });
+}
+// Myers' O((N+M)D) shortest edit script, walked back from the end through the saved frontiers.
+function myers(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return [];
+    if (a.length === 0)
+        return [{ op: "added", text: b.join("") }];
+    if (b.length === 0)
+        return [{ op: "removed", text: a.join("") }];
+    const n = a.length;
+    const m = b.length;
+    const max = Math.min(n + m, maxEdits);
+    const offset = max + 1;
+    let v = new Int32Array(2 * max + 3);
+    const trace = [];
+    let found = false;
+    for (let d = 0; d <= max && !found; d += 1) {
+        trace.push(v.slice());
+        const next = v.slice();
+        for (let k = -d; k <= d; k += 2) {
+            const down = k === -d || (k !== d && (v[offset + k - 1] ?? 0) < (v[offset + k + 1] ?? 0));
+            let x = down ? (v[offset + k + 1] ?? 0) : (v[offset + k - 1] ?? 0) + 1;
+            let y = x - k;
+            while (x < n && y < m && a[x] === b[y]) {
+                x += 1;
+                y += 1;
+            }
+            next[offset + k] = x;
+            if (x >= n && y >= m) {
+                found = true;
+                break;
+            }
+        }
+        v = next;
+    }
+    if (!found)
+        return [
+            { op: "removed", text: a.join("") },
+            { op: "added", text: b.join("") },
+        ];
+    // Backtrack: each frontier in `trace` is the state before step d.
+    const script = [];
+    let x = n;
+    let y = m;
+    for (let d = trace.length - 1; d >= 0; d -= 1) {
+        const before = trace[d] ?? new Int32Array(0);
+        const k = x - y;
+        const down = k === -d || (k !== d && (before[offset + k - 1] ?? 0) < (before[offset + k + 1] ?? 0));
+        const previousK = down ? k + 1 : k - 1;
+        const previousX = before[offset + previousK] ?? 0;
+        const previousY = previousX - previousK;
+        while (x > previousX && y > previousY) {
+            script.push({ op: "same", text: a[x - 1] ?? "" });
+            x -= 1;
+            y -= 1;
+        }
+        if (d > 0) {
+            if (down)
+                script.push({ op: "added", text: b[y - 1] ?? "" });
+            else
+                script.push({ op: "removed", text: a[x - 1] ?? "" });
+            x = previousX;
+            y = previousY;
+        }
+    }
+    const parts = [];
+    for (const part of script.reverse())
+        push(parts, part.op, part.text);
+    return parts;
+}

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")