@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/subtitles/prepare.js

@@ -3,13 +3,15 @@ import { copyFileSync, createReadStream, existsSync, mkdirSync, mkdtempSync, rea
 import { join, relative, sep } from "node:path";
 import { z } from "zod";
 import { subtitleModelDir } from "../../kernel/paths.js";
+import { projectLanguage } from "../../kernel/ports/languages.js";
 import { projectById, setStageProgress } from "../admission/repo.js";
+import { captionFont, captionFontDeps } from "../fonts/coverage.js";
 import { resolveFont } from "../fonts/index.js";
 import { outputPath, projectDir } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
 import { spoken } from "../video/plan.js";
 import { captionCues, serializeAss, serializeSrt, serializeVtt } from "./captions.js";
-import { defaultSubtitles } from "./model.js";
+import { defaultSubtitles, timingOperation } from "./model.js";
 import { spokenText } from "./transcript.js";
 export const subtitleRoles = [
     "subtitles_srt",
@@ -52,24 +54,27 @@ export async function prepareSubtitles(deps, context, audio, frame) {
     setStageProgress(deps.db, context.stage.id, 0, 100);
     context.emit({ type: "stage.progress", projectId, stage: "video", current: 0, total: 100 });
     if (audio.length === 0)
-        throw new Error("Captions need narration audio, but this project has none. Turn captions off in Edit project → Subtitles, or turn narration on, then Retry stage.");
+        throw new Error("Captions need narration audio, but this project has none. Turn captions off in Edit project → Subtitles, or turn narration on, then Try again.");
     const outputs = outputsOf(deps.db, projectId);
     const segments = audio.map((segment) => ({
         ...segment,
         text: spoken(segment.kind) ? spokenText(deps, projectId, segment.kind, outputs) : "",
     }));
-    const key = await timingKey(segments, context.signal);
+    const language = projectLanguage(project.config);
+    const key = await timingKey(segments, language, context.signal);
     const cache = readCache(deps, projectId, outputs);
     const dir = projectDir(deps.paths, projectId);
     const directory = mkdtempSync(join(dir, "captions-"));
     try {
-        const font = await snapshotFont(deps, projectId, outputs, config.fontId, cache, directory);
+        const font = await snapshotFont(deps, projectId, outputs, config.fontId, cache, directory, language);
         const omissions = cache?.key === key ? [...cache.omissions] : [];
-        const words = cache?.key === key ? cache.words : await alignSegments(deps, context, segments, omissions);
+        const words = cache?.key === key
+            ? cache.words
+            : await alignSegments(deps, context, segments, omissions, language);
         context.signal.throwIfAborted();
         const cues = captionCues(words);
         if (cues.length === 0)
-            throw new Error("None of the narration could be matched to the article text, so captions can't be timed. Captions only work for English narration; if you uploaded your own audio, make sure it reads the article text, then Retry stage.");
+            throw new Error("None of the narration could be matched to the article text, so captions can't be timed. The narration must be in the project language set in Edit project → Language; if you uploaded your own audio, make sure it reads the article text, then Try again.");
         writeFileSync(join(directory, "subtitles.srt"), serializeSrt(cues), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.vtt"), serializeVtt(cues), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.ass"), serializeAss(cues, {
@@ -77,6 +82,8 @@ export async function prepareSubtitles(deps, context, audio, frame) {
             fontSize: config.fontSize,
             fontName: font.assName,
             position: config.position,
+            color: config.color,
+            outlineColor: config.outlineColor,
         }), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font, omissions }), {
             mode: 0o600,
@@ -103,9 +110,10 @@ export async function prepareSubtitles(deps, context, audio, frame) {
         throw error;
     }
 }
-async function timingKey(segments, signal) {
+async function timingKey(segments, language, signal) {
     // Bump when alignment normalization/model changes. Hash file contents, not timestamps.
-    const hash = createHash("sha256").update("wav2vec2-en-a19f851-v2-omissions");
+    // English hashes the operation it always did (`timingOperation`).
+    const hash = createHash("sha256").update(timingOperation(language));
     for (const segment of segments) {
         signal.throwIfAborted();
         hash.update(JSON.stringify({ kind: segment.kind, seconds: segment.seconds, text: segment.text }));
@@ -117,9 +125,9 @@ async function timingKey(segments, signal) {
     }
     return hash.digest("hex");
 }
-async function alignSegments(deps, context, segments, omissions) {
+async function alignSegments(deps, context, segments, omissions, language) {
     if (deps.alignSubtitles === undefined)
-        throw new Error("Slopify hit an internal error (the caption timing tool is missing from this build). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the caption timing tool is missing from this build). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const words = [];
     const total = segments.reduce((sum, segment) => sum + segment.seconds, 0);
     let offset = 0;
@@ -130,7 +138,8 @@ async function alignSegments(deps, context, segments, omissions) {
                 audioPath: segment.path,
                 onOmission: (omission) => omissions.push({ ...omission, start: omission.start + offset }),
                 text: segment.text,
-                cacheDir: subtitleModelDir(deps.paths.dataDir),
+                cacheDir: subtitleModelDir(deps.paths.dataDir, language),
+                ...(language === "en" ? {} : { language }),
                 ffmpeg: deps.ffmpeg,
                 signal: context.signal,
                 onProgress: (current, maximum) => {
@@ -147,7 +156,7 @@ async function alignSegments(deps, context, segments, omissions) {
             });
             for (const word of aligned) {
                 if (word.end > segment.seconds + 0.1)
-                    throw new Error("Caption timing came out longer than the narration audio. Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                    throw new Error("Caption timing came out longer than the narration audio. Try again; if it happens again, use Download diagnostics in Settings and report it.");
                 words.push({
                     ...word,
                     start: word.start + offset,
@@ -170,12 +179,14 @@ function readCache(deps, projectId, outputs) {
         return undefined;
     }
 }
-async function snapshotFont(deps, projectId, outputs, id, cache, directory) {
+async function snapshotFont(deps, projectId, outputs, id, cache, directory, language) {
     const previous = outputs.find((one) => one.role === "subtitle_font");
     const previousPath = previous === undefined ? undefined : outputPath(deps.paths, projectId, previous.path);
-    const saved = cache?.font.id === id && previousPath !== undefined && existsSync(previousPath)
-        ? { ...cache.font, path: previousPath }
-        : await resolveFont(deps.paths, id);
+    const saved = language !== "en"
+        ? await captionFont(captionFontDeps(deps.paths), id, language)
+        : cache?.font.id === id && previousPath !== undefined && existsSync(previousPath)
+            ? { ...cache.font, path: previousPath }
+            : await resolveFont(deps.paths, id);
     mkdirSync(join(directory, "fonts"), { mode: 0o700 });
     copyFileSync(saved.path, join(directory, "fonts", `selected${saved.extension}`));
     return { id: saved.id, name: saved.name, assName: saved.assName, extension: saved.extension };

package/dist/slices/subtitles/transcript.js

@@ -27,7 +27,7 @@ export function spokenText(deps, projectId, kind, outputs) {
                 return segment.text;
         }
     }
-    throw new Error(`The saved text of the ${kind === "body" ? "article" : kind} is missing, and captions need the text spoken in the narration. Use Re-run section on Article, then Retry stage.`);
+    throw new Error(`The saved text of the ${kind === "body" ? "article" : kind} is missing, and captions need the text spoken in the narration. Use More → Write the article again in the Article section, then Try again.`);
 }
 function payload(raw) {
     return textPayload.parse(JSON.parse(raw ?? "null"));

package/dist/slices/thumbnail/run.js

@@ -22,13 +22,13 @@ export async function runThumbnail(deps, context, providers) {
     if (source !== "from_prompt" && source !== "prompt_by_llm") {
         // Off is `skipped` and Provide is `provided` at project creation,
         // so the runner never starts this stage for either.
-        throw new Error(`Slopify hit an internal error (the thumbnail stage cannot run with its source set to ${source}). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
+        throw new Error(`Slopify hit an internal error (the thumbnail stage cannot run with its source set to ${source}). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
     }
     const choice = project.config.images;
     if (choice === undefined) {
         // Admission requires the image provider whenever the thumbnail is generated, so reaching
         // here is a bug in admission rather than the user's.
-        throw new Error("No image model is set for the thumbnail. Choose one in Edit project → Providers, then Retry stage.");
+        throw new Error("No image model is set for the thumbnail. Choose one in Edit project → Providers, then Try again.");
     }
     const result = source === "from_prompt" ? undefined : await byLlm(deps, context, providers, project);
     if (result !== undefined && !result.ok)
@@ -60,7 +60,7 @@ export async function runThumbnail(deps, context, providers) {
 function fromTemplate(project) {
     const rendered = project.config.rendered.thumbnailPrompt;
     if (rendered === undefined) {
-        throw new Error("Slopify hit an internal error (the thumbnail prompt was never filled in). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the thumbnail prompt was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return rendered;
 }
@@ -83,7 +83,7 @@ async function byLlm(deps, context, providers, project) {
     }
     if (llm === undefined) {
         // Admission requires the LLM row when the thumbnail source is Prompt by LLM.
-        throw new Error("No AI model is set for writing the thumbnail prompt. Choose one in Edit project → Providers, then Retry stage.");
+        throw new Error("No AI model is set for writing the thumbnail prompt. Choose one in Edit project → Providers, then Try again.");
     }
     const messages = thumbnailMessages(brief(deps, project));
     const answer = await providers.llm({
@@ -117,7 +117,7 @@ function named(choice) {
 function brief(deps, project) {
     const instruction = project.config.rendered.thumbnailPrompt;
     if (instruction === undefined) {
-        throw new Error("Slopify hit an internal error (the thumbnail prompt was never filled in). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the thumbnail prompt was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return {
         instruction,
@@ -133,7 +133,7 @@ function brief(deps, project) {
 function articleText(deps, projectId) {
     const article = outputsOf(deps.db, projectId).find((output) => output.role === "article_txt");
     if (article === undefined) {
-        throw new Error("The thumbnail prompt is written from the article, but the article isn't ready. Let the Article stage finish, then Retry stage.");
+        throw new Error("The thumbnail prompt is written from the article, but the article isn't ready. Let the Article stage finish, then Try again.");
     }
     return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
 }
@@ -212,7 +212,7 @@ function instructionsText(messages) {
 }
 function payloadOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (the saved thumbnail prompt is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the saved thumbnail prompt is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return writtenPayload.parse(JSON.parse(piece.payload));
 }

package/dist/slices/trash/model.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+// Settings → Trash. Deleting a project, a Library prompt or intro/outro, a template or a
+// schedule stamps it instead of removing it; it stays here this long, then the daily purge
+// removes it for good (a project's folder with it).
+export const trashDays = 30;
+export const trashMs = trashDays * 24 * 60 * 60_000;
+export const trashKinds = ["project", "prompt", "entry", "template", "schedule"];
+export const trashItemSchema = z.object({
+    kind: z.enum(trashKinds),
+    id: z.string(),
+    name: z.string(),
+    // What sort of prompt ("article", "image"…) or entry ("intro", "outro"); null otherwise.
+    detail: z.string().nullable(),
+    deletedAt: z.string(),
+    // When the daily purge removes it for good.
+    purgeAt: z.string(),
+    daysLeft: z.number().int().nonnegative(),
+});
+export const restoredSchema = z.object({
+    kind: z.enum(trashKinds),
+    id: z.string(),
+    name: z.string(),
+    // The name it came back under when a live item had taken the old one meanwhile.
+    renamedFrom: z.string().nullable(),
+});

package/dist/slices/trash/service.js

@@ -0,0 +1,273 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { deleteVersions, recordVersion } from "../library/history.js";
+import { nameMax } from "../library/model.js";
+import { entryById, promptById } from "../library/repo.js";
+import { deleteProject, projectBusy } from "../storage/delete-project.js";
+import { trashKinds, trashMs, } from "./model.js";
+// Settings → Trash: what was deleted in the last 30 days, put back or removed for good.
+//
+// Each kind keeps its stamp where it lives: a project in `project_trash` (the projects table is
+// read positionally in many places), a prompt, entry or template in its own `deleted_at`, and a
+// schedule in the `deleted_at` it always had as the tombstone that keeps its run history. A
+// schedule leaves the trash by getting `purged_at`; its row and history stay, as before.
+const dayMs = 24 * 60 * 60_000;
+// A template's name column allows this much (0008's CHECK on project_template_revisions).
+const templateNameMax = 200;
+const row = z.object({
+    id: z.string(),
+    name: z.string(),
+    detail: z.string().nullable(),
+    deleted_at: z.string(),
+});
+// Every kind in one statement, newest deletion first.
+const trashedRows = `
+  SELECT 'project' AS kind, p.id, p.title AS name, NULL AS detail, t.deleted_at
+    FROM project_trash t JOIN projects p ON p.id = t.project_id
+  UNION ALL SELECT 'prompt', id, name, kind, deleted_at FROM prompts WHERE deleted_at IS NOT NULL
+  UNION ALL SELECT 'entry', id, name, category, deleted_at FROM entries WHERE deleted_at IS NOT NULL
+  UNION ALL SELECT 'template', t.id, r.name, NULL, t.deleted_at
+    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 NOT NULL
+  UNION ALL SELECT 'schedule', id, name, NULL, deleted_at FROM schedules
+    WHERE deleted_at IS NOT NULL AND purged_at IS NULL`;
+export function listTrash(deps) {
+    const now = deps.clock.now().valueOf();
+    return deps.db
+        .prepare(`SELECT * FROM (${trashedRows}) ORDER BY deleted_at DESC, kind, id`)
+        .all()
+        .map((raw) => {
+        const parsed = row.extend({ kind: z.enum(trashKinds) }).parse(raw);
+        const purgeAt = Date.parse(parsed.deleted_at) + trashMs;
+        return {
+            kind: parsed.kind,
+            id: parsed.id,
+            name: parsed.name,
+            detail: parsed.detail,
+            deletedAt: parsed.deleted_at,
+            purgeAt: new Date(purgeAt).toISOString(),
+            daysLeft: Math.max(0, Math.ceil((purgeAt - now) / dayMs)),
+        };
+    });
+}
+// 07 Projects' Delete. Refused while the run is going, as removing it always was: the work
+// has to be stopped by the user first. A project waiting its turn (a queued batch item, a
+// checkpoint, work left over from a restart) simply stops being picked up: the runner holds a
+// project in the trash like a paused one and the batch queue moves on past it.
+export function trashProject(deps, projectId) {
+    return transact(deps.db, () => {
+        const found = deps.db
+            .prepare("SELECT (SELECT 1 FROM project_trash t WHERE t.project_id = p.id) AS trashed FROM projects p WHERE p.id = ?")
+            .get(projectId);
+        if (found === undefined || found.trashed === 1)
+            return { ok: false, reason: "not-found" };
+        if (projectBusy(deps, projectId))
+            return { ok: false, reason: "running" };
+        deps.db
+            .prepare("INSERT INTO project_trash (project_id, deleted_at) VALUES (?, ?)")
+            .run(projectId, deps.clock.now().toISOString());
+        return { ok: true, value: null };
+    });
+}
+// Puts the item back where it was. A prompt, entry or template whose name a live one has
+// taken meanwhile comes back as "Name (restored)", then "Name (restored 2)"…
+//
+// A schedule comes back paused with no next run, whatever it was when deleted (only a
+// canceled or completed one can be deleted): nothing runs until Resume is pressed on
+// Schedules, which picks the next occurrence from then. Its template must be live: one in the
+// trash is restored first, and one removed for good leaves the schedule nothing to run.
+export function restoreItem(deps, kind, id) {
+    return transact(deps.db, () => {
+        switch (kind) {
+            case "project":
+                return restoreProject(deps.db, id);
+            case "prompt":
+                return restoreLibrary(deps, "prompt", id);
+            case "entry":
+                return restoreLibrary(deps, "entry", id);
+            case "template":
+                return restoreTemplate(deps, id);
+            case "schedule":
+                return restoreSchedule(deps, id);
+        }
+    });
+}
+function restoreProject(db, id) {
+    const found = db
+        .prepare("SELECT p.title FROM project_trash t JOIN projects p ON p.id = t.project_id WHERE t.project_id = ?")
+        .get(id);
+    if (typeof found?.title !== "string")
+        return { ok: false, reason: "not-found" };
+    db.prepare("DELETE FROM project_trash WHERE project_id = ?").run(id);
+    return { ok: true, value: { kind: "project", id, name: found.title, renamedFrom: null } };
+}
+function restoreLibrary(deps, itemKind, id) {
+    const table = itemKind === "prompt" ? "prompts" : "entries";
+    const group = itemKind === "prompt" ? "kind" : "category";
+    const found = deps.db
+        .prepare(`SELECT name, ${group} AS grp FROM ${table} WHERE id = ? AND deleted_at IS NOT NULL`)
+        .get(id);
+    if (typeof found?.name !== "string" || typeof found.grp !== "string")
+        return { ok: false, reason: "not-found" };
+    const taken = deps.db.prepare(`SELECT 1 FROM ${table} WHERE ${group} = ? AND lower(name) = lower(?) AND deleted_at IS NULL`);
+    const grp = found.grp;
+    const name = freeName(found.name, nameMax, (candidate) => taken.get(grp, candidate) !== undefined);
+    const renamed = name !== found.name;
+    deps.db
+        .prepare(`UPDATE ${table} SET deleted_at = NULL, name = ?, updated_at = ${renamed ? "?" : "updated_at"} WHERE id = ?`)
+        .run(...(renamed ? [name, deps.clock.now().toISOString(), id] : [name, id]));
+    // A rename shows in History as a version of its own.
+    if (renamed) {
+        const item = itemKind === "prompt" ? promptById(deps.db, id) : entryById(deps.db, id);
+        if (item !== undefined)
+            recordVersion(deps.db, itemKind, item);
+    }
+    return {
+        ok: true,
+        value: { kind: itemKind, id, name, renamedFrom: renamed ? found.name : null },
+    };
+}
+function restoreTemplate(deps, id) {
+    const found = deps.db
+        .prepare(`SELECT r.name, 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.id = ? AND t.deleted_at IS NOT NULL`)
+        .get(id);
+    if (typeof found?.name !== "string" ||
+        typeof found.version !== "number" ||
+        typeof found.document_json !== "string")
+        return { ok: false, reason: "not-found" };
+    const taken = deps.db.prepare(`SELECT 1 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 lower(r.name) = lower(?)`);
+    const name = freeName(found.name, templateNameMax, (candidate) => taken.get(candidate) !== undefined);
+    deps.db.prepare("UPDATE project_templates SET deleted_at = NULL WHERE id = ?").run(id);
+    // A rename is a new version, as a rename in the template editor is; the versions a schedule
+    // or a draft names stay as they were.
+    if (name !== found.name) {
+        const version = found.version + 1;
+        deps.db
+            .prepare("INSERT INTO project_template_revisions(template_id,version,name,document_json,created_at) VALUES (?,?,?,?,?)")
+            .run(id, version, name, found.document_json, deps.clock.now().toISOString());
+        deps.db.prepare("UPDATE project_templates SET head_version = ? WHERE id = ?").run(version, id);
+    }
+    return {
+        ok: true,
+        value: {
+            kind: "template",
+            id,
+            name,
+            renamedFrom: name === found.name ? null : found.name,
+        },
+    };
+}
+function restoreSchedule(deps, id) {
+    const found = deps.db
+        .prepare(`SELECT s.name, s.template_id,
+        (SELECT t.deleted_at IS NOT NULL FROM project_templates t WHERE t.id = s.template_id) AS trashed
+       FROM schedules s WHERE s.id = ? AND s.deleted_at IS NOT NULL AND s.purged_at IS NULL`)
+        .get(id);
+    if (typeof found?.name !== "string")
+        return { ok: false, reason: "not-found" };
+    if (found.trashed === null)
+        return { ok: false, reason: "template-gone" };
+    if (found.trashed === 1)
+        return { ok: false, reason: "template-in-trash" };
+    const at = deps.clock.now().toISOString();
+    deps.db
+        .prepare(`UPDATE schedules SET deleted_at = NULL, status = 'paused', next_run_at = NULL,
+       version = version + 1, updated_at = ? WHERE id = ?`)
+        .run(at, id);
+    return { ok: true, value: { kind: "schedule", id, name: found.name, renamedFrom: null } };
+}
+// "Delete now": removes one item for good. A project's folder goes first, then its rows
+// (`slices/storage/delete-project.ts`); a folder that will not go leaves it in the trash.
+export function deleteNow(deps, kind, id) {
+    switch (kind) {
+        case "project": {
+            if (deps.db.prepare("SELECT 1 FROM project_trash WHERE project_id = ?").get(id) === undefined)
+                return { ok: false, reason: "not-found" };
+            const removed = deleteProject(deps, id);
+            if (removed.ok)
+                return { ok: true, value: null };
+            return {
+                ok: false,
+                reason: removed.reason === "no-project" ? "not-found" : removed.reason,
+                ...(removed.detail === undefined ? {} : { detail: removed.detail }),
+            };
+        }
+        case "prompt":
+        case "entry":
+            return transact(deps.db, () => {
+                const table = kind === "prompt" ? "prompts" : "entries";
+                const changed = deps.db
+                    .prepare(`DELETE FROM ${table} WHERE id = ? AND deleted_at IS NOT NULL`)
+                    .run(id).changes;
+                if (Number(changed) === 0)
+                    return { ok: false, reason: "not-found" };
+                deleteVersions(deps.db, kind, id);
+                return { ok: true, value: null };
+            });
+        case "template": {
+            // Revisions cascade. A schedule in the trash may still name it: that schedule can then
+            // no longer be restored (`restoreSchedule`), only removed.
+            const changed = deps.db
+                .prepare("DELETE FROM project_templates WHERE id = ? AND deleted_at IS NOT NULL")
+                .run(id).changes;
+            return Number(changed) === 0 ? { ok: false, reason: "not-found" } : { ok: true, value: null };
+        }
+        case "schedule": {
+            // Gone from the trash; the row stays as the history Schedules lists under Deleted.
+            const changed = deps.db
+                .prepare("UPDATE schedules SET purged_at = ? WHERE id = ? AND deleted_at IS NOT NULL AND purged_at IS NULL")
+                .run(deps.clock.now().toISOString(), id).changes;
+            return Number(changed) === 0 ? { ok: false, reason: "not-found" } : { ok: true, value: null };
+        }
+    }
+}
+// The daily purge: everything deleted more than 30 days ago goes for good. A failure on one
+// item is logged and leaves it for the next pass; the rest still go.
+export function purgeExpired(deps) {
+    const cutoff = new Date(deps.clock.now().valueOf() - trashMs).toISOString();
+    let removed = 0;
+    let kept = 0;
+    for (const item of listTrash(deps)) {
+        if (item.deletedAt > cutoff)
+            continue;
+        const result = deleteNow(deps, item.kind, item.id);
+        if (result.ok)
+            removed++;
+        else {
+            kept++;
+            deps.log.write("warn", "trash.purge", {
+                ...(item.kind === "project" ? { projectId: item.id } : {}),
+                detail: `${item.kind} ${item.id}: ${result.detail ?? result.reason}`,
+            });
+        }
+    }
+    return { removed, kept };
+}
+export function createTrashPurge(deps) {
+    let last;
+    return {
+        tick: () => {
+            const now = deps.clock.now().valueOf();
+            if (last !== undefined && now - last < dayMs)
+                return undefined;
+            last = now;
+            return purgeExpired(deps);
+        },
+    };
+}
+// The name itself when free, else "Name (restored)", "Name (restored 2)"… cut to fit `max`.
+export function freeName(name, max, taken) {
+    if (!taken(name))
+        return name;
+    for (let n = 1;; n++) {
+        const suffix = n === 1 ? " (restored)" : ` (restored ${String(n)})`;
+        const candidate = `${name.slice(0, Math.max(1, max - suffix.length)).trimEnd()}${suffix}`;
+        if (!taken(candidate))
+            return candidate;
+    }
+}

package/dist/slices/tutorials/anchors.js

@@ -0,0 +1,57 @@
+// The tutorials are the GitHub wiki's pages (docs/wiki), so their links name sections the way
+// GitHub does: `[text](Page-Name#section-anchor)`. These helpers work out those anchors, for
+// the server's search, the web page that scrolls to them and the test that checks every help
+// entry's Learn more link. Pure: the web bundle imports this file.
+export const tutorialPageIdPattern = /^[A-Za-z0-9][A-Za-z0-9-]{0,79}$/;
+// A heading's text as GitHub renders it: link targets, code ticks and emphasis marks dropped.
+export function headingText(markdown) {
+    return markdown
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/`([^`]*)`/g, "$1")
+        .replace(/(\*\*|__)(.+?)\1/g, "$2")
+        .replace(/(^|[^\p{L}\p{N}])[*_]([^*_]+)[*_](?![\p{L}\p{N}])/gu, "$1$2")
+        .replace(/<[^>]+>/g, "")
+        .trim();
+}
+// GitHub's anchor for a heading's text: lower case, punctuation dropped, each space a hyphen.
+export function githubSlug(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\p{M} _-]/gu, "")
+        .replace(/ /g, "-");
+}
+const headingLine = /^ {0,3}(#{1,6})\s+(.+?)\s*#*\s*$/;
+// Every heading of a page in order, with GitHub's anchor; a repeated anchor gets `-1`, `-2`.
+// `#` inside fenced code is not a heading.
+export function tutorialHeadings(markdown) {
+    const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+    const seen = new Map();
+    const headings = [];
+    let fenced = false;
+    for (const [line, raw] of lines.entries()) {
+        if (/^\s*(```|~~~)/.test(raw))
+            fenced = !fenced;
+        const match = fenced ? null : headingLine.exec(raw);
+        if (match === null)
+            continue;
+        const text = headingText(match[2] ?? "");
+        const base = githubSlug(text);
+        const count = seen.get(base) ?? 0;
+        seen.set(base, count + 1);
+        headings.push({
+            level: (match[1] ?? "#").length,
+            text,
+            anchor: count === 0 ? base : `${base}-${String(count)}`,
+            line,
+        });
+    }
+    return headings;
+}
+// The anchors a page offers, for checking a link.
+export function tutorialAnchors(markdown) {
+    return new Set(tutorialHeadings(markdown).map((heading) => heading.anchor));
+}
+// A page id as a title when the sidebar gives none: "Play-Overview" → "Play Overview".
+export function pageTitleOf(id) {
+    return id.replace(/-/g, " ");
+}