@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/storage/backup-format.js

@@ -7,7 +7,8 @@ import { fontMaxBytes } from "../fonts/model.js";
 //   data/library.json            settings, library, templates, schedules, drafts
 //   data/usage.json              the Usage screen's event log
 //   data/projects/<id>.json      one per project: every row it needs to open and keep going
-//   files/...                    the bytes: project folders, uploaded fonts, draft uploads
+//   files/...                    the bytes: project folders, uploaded fonts, draft uploads and
+//                                the pictures kept in the database (cast, end screen)
 //   checksums.json               a SHA-256 per file, written as the files streamed out
 //
 // Rows travel as the database holds them, table by table, with the schema version they fit;
@@ -24,6 +25,9 @@ export const projectMember = (id) => `data/projects/${id}.json`;
 export const projectFileMember = (id, path) => `files/projects/${id}/${path}`;
 export const fontMember = (name) => `files/fonts/${name}`;
 export const stagedMember = (id) => `files/staging/${id}`;
+// A picture from image_blobs, named by its SHA-256: the database keeps the bytes (cast
+// pictures, the end screen image), so they travel as files rather than inside a JSON row.
+export const imageMember = (sha256) => `files/images/${sha256}`;
 // Every table a project's rows live in, parents before children. The queue is left out on
 // purpose: a backup never carries a project that is waiting to run.
 export const projectTables = [
@@ -49,6 +53,15 @@ export const projectTables = [
     "review_checkpoints",
     "review_checkpoint_approvals",
     "project_recovery_requests",
+    "youtube_description_edits",
+    "project_uploads",
+    // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
+    // current wait, a lease of this install) and prompt_softening (a pending one-off request).
+    "review_verdicts",
+    "provider_usage",
+    "plan_limit_readings",
+    "project_channels",
+    "project_trash",
 ];
 export const libraryTables = [
     "settings",
@@ -56,14 +69,27 @@ export const libraryTables = [
     "entries",
     "voices",
     "document_themes",
+    "narration_aliases",
     "project_templates",
     "project_template_revisions",
     "schedules",
     "schedule_runs",
+    "schedule_topics",
     "staged_files",
     "play_drafts",
     "play_draft_attachments",
     "project_template_instantiations",
+    // Since 2.5.0: prompt history, channels with their cast, episode memories and existing
+    // videos. image_blobs travel as files (`imageMember`), listed in the library part's `images`.
+    "library_versions",
+    "channels",
+    "cast_members",
+    "cast_images",
+    "episode_memories",
+    "channel_videos",
+    // Since 3.0.0: what topic generation, episode summaries and cast pictures cost, which
+    // belongs to a schedule or channel rather than a project.
+    "standalone_usage",
 ];
 export const usageTables = ["telemetry_events"];
 // Ceilings a well-formed backup of a real install stays far below. They bound what a hostile
@@ -118,6 +144,15 @@ export const manifestSchema = z
     bytes: z.number().int().min(0),
 })
     .strict();
+// A picture in image_blobs is at most this large (cast uploads are capped well below it).
+export const backupMaxImageBytes = 64 * 1024 * 1024;
+export const backupImage = z
+    .object({
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    mime: z.enum(["image/png", "image/jpeg"]),
+    bytes: z.number().int().min(1).max(backupMaxImageBytes),
+})
+    .strict();
 const fileEntry = z.object({ path: relativePath, bytes: z.number().int().min(0) }).strict();
 export const libraryPartSchema = z
     .object({
@@ -133,6 +168,8 @@ export const libraryPartSchema = z
     staged: z
         .array(z.object({ id: backupId, bytes: z.number().int().positive() }).strict())
         .max(10_000),
+    // Absent in backups made before channels.
+    images: z.array(backupImage).max(100_000).optional(),
 })
     .strict();
 export const usagePartSchema = z.object({ tables: tablesOf(usageTables) }).strict();

package/dist/slices/storage/backup-import.js

@@ -1,12 +1,13 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statfsSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statfsSync, } from "node:fs";
 import { open } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { ZodError } from "zod";
 import { migrate, newestMigration } from "../../kernel/db/migrate.js";
 import { transact } from "../../kernel/db/tx.js";
-import { projectById } from "../admission/repo.js";
+import { projectByIdIncludingTrash } from "../admission/repo.js";
+import { castOfChannel, channelById } from "../channels/repo.js";
 import { documentThemeNameMax, documentThemeNameProblems } from "../document/model.js";
 import { documentThemeSchema } from "../document/theme-schema.js";
 import { nameMax } from "../library/model.js";
@@ -16,7 +17,7 @@ import { revisionById } from "../revisions/repo.js";
 import { runsForSchedule, scheduleRows } from "../schedules/repo.js";
 import { allTelemetryEvents } from "../telemetry/repo.js";
 import { projectRows, rowsOf } from "./backup-export.js";
-import { backupMaxJsonBytes, backupMaxManifestBytes, backupSchemaVersion, checksumsMember, checksumsSchema, fontMember, libraryMember, libraryPartSchema, libraryTables, manifestHead, manifestMember, manifestSchema, projectFileMember, projectMember, projectPartSchema, projectTables, stagedMember, usageMember, usagePartSchema, usageTables, } from "./backup-format.js";
+import { backupMaxJsonBytes, backupMaxManifestBytes, backupSchemaVersion, checksumsMember, checksumsSchema, fontMember, imageMember, libraryMember, libraryPartSchema, libraryTables, manifestHead, manifestMember, manifestSchema, projectFileMember, projectMember, projectPartSchema, projectTables, stagedMember, usageMember, usagePartSchema, usageTables, } from "./backup-format.js";
 import { outputPath, projectDir, stagingPath } from "./layout.js";
 import { checkLibraryRows, exportableSettings, installedUploadedFontFiles, validFontContent, } from "./portable.js";
 import { readTar, TarFormatError } from "./tar.js";
@@ -225,7 +226,10 @@ async function receive(body, file) {
     finally {
         await handle.close();
     }
-    return hash.digest("hex");
+    const digest = hash.digest("hex");
+    if (file.image !== undefined && digest !== file.image)
+        throw damaged(`the picture ${file.image} in it is damaged.`);
+    return digest;
 }
 // Loads every row into a scratch database at the schema the backup was written with, carries
 // it forward with this build's migrations, and checks it with the same readers the app uses.
@@ -282,6 +286,16 @@ function prepare(deps, work, manifest, library, usage, parts, expected) {
                 font: { id, extension },
             });
         }
+        for (const image of library.images ?? []) {
+            const keep = deps.db.prepare("SELECT 1 FROM image_blobs WHERE sha256=?").get(image.sha256) === undefined;
+            expect(imageMember(image.sha256), {
+                bytes: image.bytes,
+                destination: keep ? join(work, "images", image.sha256) : undefined,
+                image: image.sha256,
+            });
+            if (keep)
+                needed += image.bytes;
+        }
         for (const staged of library.staged) {
             const keep = keptStaged.has(staged.id);
             expect(stagedMember(staged.id), {
@@ -292,7 +306,7 @@ function prepare(deps, work, manifest, library, usage, parts, expected) {
                 needed += staged.bytes;
         }
         checkFreeSpace(deps.paths.dataDir, needed);
-        return { scratch, projects, skippedProjects, drafts };
+        return { scratch, projects, skippedProjects, drafts, images: library.images ?? [] };
     }
     catch (error) {
         scratch.close();
@@ -319,12 +333,23 @@ function loadScratch(clock, manifest, library, usage, parts) {
             if (known.size === 0 || Object.keys(row).some((column) => !known.has(column)))
                 throw damaged(`it has ${table} records that don't fit the Slopify version it names.`);
             try {
-                insertRow(scratch, table, row);
+                // The default channel is already there: every install makes it (0032) with the same id.
+                insertRow(scratch, table, row, table === "channels" ? "INSERT OR REPLACE" : "INSERT");
             }
             catch {
                 throw damaged(`it has a ${table} record Slopify can't read.`);
             }
         };
+        // The pictures' bytes arrive after this, as files; a stand-in row lets their links check.
+        for (const image of library.images ?? [])
+            try {
+                scratch
+                    .prepare("INSERT OR IGNORE INTO image_blobs(sha256,mime,bytes,created_at) VALUES (?,?,X'00','')")
+                    .run(image.sha256, image.mime);
+            }
+            catch {
+                throw damaged("it has pictures that don't fit the Slopify version it names.");
+            }
         for (const table of libraryTables)
             for (const row of library.tables[table] ?? [])
                 insert(table, row);
@@ -370,11 +395,20 @@ function loadScratch(clock, manifest, library, usage, parts) {
 function checkScratch(deps, scratch, library, parts) {
     const unreadable = (what) => damaged(`it has ${what} Slopify can't read.`);
     try {
+        // Names are unique among the items outside the trash (0039); one in the trash is checked
+        // on its own.
+        const prompt = "SELECT id,kind,name,body,slots,updated_at FROM prompts";
+        const entry = "SELECT id,category,mode,name,body,slots,updated_at FROM entries";
         checkLibraryRows({
-            prompts: rowsOf(scratch, "SELECT * FROM prompts"),
-            entries: rowsOf(scratch, "SELECT * FROM entries"),
-            voices: rowsOf(scratch, "SELECT * FROM voices"),
+            prompts: rowsOf(scratch, `${prompt} WHERE deleted_at IS NULL`),
+            entries: rowsOf(scratch, `${entry} WHERE deleted_at IS NULL`),
+            // A voice's languages are checked as the settings export reads them (`languages`).
+            voices: rowsOf(scratch, "SELECT id,provider,name,voice_id,languages_json FROM voices").map(({ languages_json: languages, ...voice }) => typeof languages === "string" ? { ...voice, languages: JSON.parse(languages) } : voice),
         });
+        for (const row of rowsOf(scratch, `${prompt} WHERE deleted_at IS NOT NULL`))
+            checkLibraryRows({ prompts: [row], entries: [], voices: [] });
+        for (const row of rowsOf(scratch, `${entry} WHERE deleted_at IS NOT NULL`))
+            checkLibraryRows({ prompts: [], entries: [row], voices: [] });
     }
     catch {
         throw unreadable("a prompt, intro, outro or voice");
@@ -401,6 +435,16 @@ function checkScratch(deps, scratch, library, parts) {
     catch {
         throw unreadable("a document theme");
     }
+    try {
+        for (const row of rowsOf(scratch, "SELECT id FROM channels")) {
+            if (channelById(scratch, String(row.id)) === undefined)
+                throw new Error("channel");
+            castOfChannel(scratch, String(row.id));
+        }
+    }
+    catch {
+        throw unreadable("a channel or cast member");
+    }
     try {
         for (const schedule of scheduleRows(scratch))
             runsForSchedule(scratch, schedule.id);
@@ -428,7 +472,7 @@ function checkScratch(deps, scratch, library, parts) {
     }
     for (const project of parts) {
         try {
-            if (projectById(scratch, project.id) === undefined)
+            if (projectByIdIncludingTrash(scratch, project.id) === undefined)
                 throw new Error("project");
             for (const row of rowsOf(scratch, "SELECT id FROM project_revisions WHERE project_id=?", project.id))
                 revisionById(scratch, project.id, String(row.id));
@@ -516,14 +560,14 @@ function commit(deps, work, manifest, prepared) {
             }
             const prompts = mergeNamed(db, scratch, {
                 table: "prompts",
-                sameName: "SELECT body FROM prompts WHERE kind=? AND lower(name)=lower(?)",
+                sameName: "SELECT body FROM prompts WHERE kind=? AND lower(name)=lower(?) AND deleted_at IS NULL",
                 key: (row) => [row.kind ?? null],
                 same: (row, existing) => existing.body === row.body,
                 max: nameMax,
             });
             const entries = mergeNamed(db, scratch, {
                 table: "entries",
-                sameName: "SELECT mode,body FROM entries WHERE category=? AND lower(name)=lower(?)",
+                sameName: "SELECT mode,body FROM entries WHERE category=? AND lower(name)=lower(?) AND deleted_at IS NULL",
                 key: (row) => [row.category ?? null],
                 same: (row, existing) => existing.mode === row.mode && existing.body === row.body,
                 max: nameMax,
@@ -535,6 +579,9 @@ function commit(deps, work, manifest, prepared) {
                 same: (row, existing) => existing.values_json === row.values_json,
                 max: documentThemeNameMax,
             });
+            mergeVersions(db, scratch, "prompt", prompts.inserted);
+            mergeVersions(db, scratch, "entry", entries.inserted);
+            const channelCounts = mergeChannels(db, scratch, work, prepared.images, now);
             let voicesAdded = 0;
             let voicesSkipped = 0;
             for (const row of rowsOf(scratch, "SELECT * FROM voices ORDER BY rowid")) {
@@ -546,6 +593,23 @@ function commit(deps, work, manifest, prepared) {
                     voicesAdded += 1;
                 }
             }
+            // Library → Aliases: an alias for a written form this install already has is kept as
+            // it is here; the others are added after this install's own, in the backup's order.
+            const narrationAliases = { added: 0, renamed: 0, skipped: 0 };
+            let position = Number(db.prepare("SELECT coalesce(max(position),-1) AS n FROM narration_aliases").get()?.n ?? -1);
+            for (const row of rowsOf(scratch, "SELECT * FROM narration_aliases ORDER BY position,rowid")) {
+                const caseSensitive = row.case_sensitive === 1;
+                if (has("SELECT 1 FROM narration_aliases WHERE id=?", String(row.id)) ||
+                    has(caseSensitive
+                        ? "SELECT 1 FROM narration_aliases WHERE case_sensitive=1 AND written=?"
+                        : "SELECT 1 FROM narration_aliases WHERE case_sensitive=0 AND lower(written)=lower(?)", String(row.written)))
+                    narrationAliases.skipped += 1;
+                else {
+                    position += 1;
+                    insertRow(db, "narration_aliases", { ...row, position });
+                    narrationAliases.added += 1;
+                }
+            }
             const templates = { added: 0, renamed: 0, skipped: 0 };
             for (const template of rowsOf(scratch, "SELECT * FROM project_templates ORDER BY rowid")) {
                 const id = String(template.id);
@@ -557,9 +621,11 @@ function commit(deps, work, manifest, prepared) {
                 let renamed = false;
                 for (const revision of rowsOf(scratch, "SELECT * FROM project_template_revisions WHERE template_id=? ORDER BY version", id)) {
                     let next = revision;
-                    if (revision.version === template.head_version) {
+                    // Names clash only among templates outside the trash, like prompts'.
+                    if (revision.version === template.head_version &&
+                        typeof template.deleted_at !== "string") {
                         const name = String(revision.name);
-                        const taken = (candidate) => has("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.id<>? AND lower(r.name)=lower(?)", id, candidate);
+                        const taken = (candidate) => has("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.id<>? AND t.deleted_at IS NULL AND lower(r.name)=lower(?)", id, candidate);
                         if (taken(name)) {
                             next = { ...revision, name: importedName(name, 200, taken) };
                             renamed = true;
@@ -582,12 +648,19 @@ function commit(deps, work, manifest, prepared) {
                 // Two installs running one schedule would make every project twice. It comes in
                 // paused; Resume on the Schedules screen starts it here.
                 const active = schedule.status === "active";
-                insertRow(db, "schedules", active ? { ...schedule, status: "paused", updated_at: now } : schedule);
+                insertRow(db, "schedules", 
+                // A generation the other install was running does not carry over.
+                active
+                    ? { ...schedule, status: "paused", updated_at: now, topics_generating_at: null }
+                    : { ...schedule, topics_generating_at: null });
                 if (active)
                     schedules.paused += 1;
                 for (const run of rowsOf(scratch, "SELECT * FROM schedule_runs WHERE schedule_id=? ORDER BY rowid", String(schedule.id)))
                     if (!has("SELECT 1 FROM schedule_runs WHERE id=?", String(run.id)))
                         insertRow(db, "schedule_runs", run);
+                for (const topic of rowsOf(scratch, "SELECT * FROM schedule_topics WHERE schedule_id=? ORDER BY rowid", String(schedule.id)))
+                    if (!has("SELECT 1 FROM schedule_topics WHERE id=?", String(topic.id)))
+                        insertRow(db, "schedule_topics", topic);
                 schedules.added += 1;
             }
             const drafts = { added: 0, renamed: 0, skipped: 0 };
@@ -624,6 +697,10 @@ function commit(deps, work, manifest, prepared) {
                     fonts += 1;
                 }
             const alreadyImported = has("SELECT 1 FROM backup_imports WHERE backup_id=?", manifest.backupId);
+            // Run cost made for a schedule or channel: a call already here, from an earlier import
+            // of the same backup, is kept once.
+            for (const row of rowsOf(scratch, "SELECT * FROM standalone_usage ORDER BY rowid"))
+                insertRow(db, "standalone_usage", row, "INSERT OR IGNORE");
             let events = 0;
             if (!alreadyImported)
                 for (const event of rowsOf(scratch, "SELECT * FROM telemetry_events ORDER BY rowid")) {
@@ -662,9 +739,11 @@ function commit(deps, work, manifest, prepared) {
                     appVersion: manifest.appVersion,
                 },
                 projects: { imported, skipped },
-                prompts,
-                entries,
+                prompts: counts(prompts),
+                entries: counts(entries),
+                ...channelCounts,
                 documentThemes,
+                narrationAliases,
                 templates,
                 schedules,
                 voices: { added: voicesAdded, renamed: 0, skipped: voicesSkipped },
@@ -694,10 +773,15 @@ function commit(deps, work, manifest, prepared) {
 // Library items whose name is unique per kind: same id is the same item and is skipped; the
 // same name with the same content is skipped; the same name with other content comes in as
 // "<name> (imported)".
+//
+// A prompt or intro/outro in the backup's trash comes in as it is, still in the trash: names
+// only have to be unique among the items that are not (0039), and the name lookups here only
+// see those.
 function mergeNamed(db, scratch, rule) {
     let added = 0;
     let renamed = 0;
     let skipped = 0;
+    const inserted = new Set();
     for (const row of rowsOf(scratch, `SELECT * FROM ${rule.table} ORDER BY rowid`)) {
         if (db.prepare(`SELECT 1 FROM ${rule.table} WHERE id=?`).get(String(row.id)) !== undefined) {
             skipped += 1;
@@ -705,9 +789,11 @@ function mergeNamed(db, scratch, rule) {
         }
         const name = String(row.name);
         const lookup = (candidate) => db.prepare(rule.sameName).get(...rule.key(row), candidate);
-        const existing = lookup(name);
+        const trashed = typeof row.deleted_at === "string";
+        const existing = trashed ? undefined : lookup(name);
         if (existing === undefined) {
             insertRow(db, rule.table, row);
+            inserted.add(String(row.id));
             added += 1;
         }
         else if (rule.same(row, existing)) {
@@ -718,10 +804,96 @@ function mergeNamed(db, scratch, rule) {
                 ...row,
                 name: importedName(name, rule.max, (candidate) => lookup(candidate) !== undefined),
             });
+            inserted.add(String(row.id));
             renamed += 1;
         }
     }
-    return { added, renamed, skipped };
+    return { added, renamed, skipped, inserted };
+}
+// A prompt's or intro/outro's History comes with it when the item itself came in; an item
+// that was already here keeps the history it has.
+function mergeVersions(db, scratch, itemKind, inserted) {
+    for (const row of rowsOf(scratch, "SELECT * FROM library_versions WHERE item_kind=? ORDER BY item_id,version", itemKind))
+        if (inserted.has(String(row.item_id)))
+            insertRow(db, "library_versions", row, "INSERT OR IGNORE");
+}
+// The default channel has the same id on every install (0032), so the backup's default is
+// always "already here". While this install's own default is still as it was made (never
+// renamed or edited), it takes the backup's name, brand kit, brief and settings; otherwise it
+// is kept. Any other channel whose id is here is skipped. Cast members, their pictures,
+// episode memories and existing videos then come in by id into whichever channel is here.
+function mergeChannels(db, scratch, work, images, now) {
+    const has = (sql, ...params) => db.prepare(sql).get(...params) !== undefined;
+    const channels = { added: 0, renamed: 0, skipped: 0 };
+    for (const row of rowsOf(scratch, "SELECT * FROM channels ORDER BY rowid")) {
+        const id = String(row.id);
+        const local = db
+            .prepare("SELECT is_default,version,brand_json,series_brief FROM channels WHERE id=?")
+            .get(id);
+        if (local === undefined) {
+            insertRow(db, "channels", { ...row, is_default: 0 });
+            channels.added += 1;
+        }
+        else if (local.is_default === 1 &&
+            row.is_default === 1 &&
+            local.version === 1 &&
+            local.brand_json === "{}" &&
+            local.series_brief === "" &&
+            !(row.version === 1 && row.brand_json === "{}" && row.series_brief === "")) {
+            const columns = Object.keys(row).filter((column) => column !== "id" && column !== "is_default");
+            db.prepare(`UPDATE channels SET ${columns.map((column) => `${column}=?`).join(",")} WHERE id=?`).run(...columns.map((column) => row[column] ?? null), id);
+            channels.added += 1;
+        }
+        else
+            channels.skipped += 1;
+    }
+    for (const image of images) {
+        const path = join(work, "images", image.sha256);
+        if (!existsSync(path))
+            continue;
+        db.prepare("INSERT INTO image_blobs(sha256,mime,bytes,created_at) VALUES (?,?,?,?) ON CONFLICT(sha256) DO NOTHING").run(image.sha256, image.mime, readFileSync(path), now);
+    }
+    const cast = { added: 0, renamed: 0, skipped: 0 };
+    for (const row of rowsOf(scratch, "SELECT * FROM cast_members ORDER BY rowid")) {
+        if (has("SELECT 1 FROM cast_members WHERE id=?", String(row.id)))
+            cast.skipped += 1;
+        else {
+            insertRow(db, "cast_members", row);
+            cast.added += 1;
+        }
+    }
+    for (const row of rowsOf(scratch, "SELECT * FROM cast_images ORDER BY rowid"))
+        if (!has("SELECT 1 FROM cast_images WHERE id=?", String(row.id)) &&
+            has("SELECT 1 FROM cast_members WHERE id=?", String(row.member_id)) &&
+            (row.sha256 === null || has("SELECT 1 FROM image_blobs WHERE sha256=?", String(row.sha256))))
+            // A picture the other install was still drawing never finishes here.
+            insertRow(db, "cast_images", row.state === "generating"
+                ? { ...row, state: "failed", error: "Stopped by the backup. Make it again." }
+                : row);
+    const episodeMemories = { added: 0, renamed: 0, skipped: 0 };
+    for (const row of rowsOf(scratch, "SELECT * FROM episode_memories ORDER BY rowid")) {
+        if (has("SELECT 1 FROM episode_memories WHERE id=?", String(row.id)) ||
+            has("SELECT 1 FROM episode_memories WHERE project_id=?", String(row.project_id)))
+            episodeMemories.skipped += 1;
+        else {
+            insertRow(db, "episode_memories", row);
+            episodeMemories.added += 1;
+        }
+    }
+    const channelVideos = { added: 0, renamed: 0, skipped: 0 };
+    for (const row of rowsOf(scratch, "SELECT * FROM channel_videos ORDER BY rowid")) {
+        const changes = has("SELECT 1 FROM channel_videos WHERE id=?", String(row.id))
+            ? 0
+            : insertRow(db, "channel_videos", row, "INSERT OR IGNORE");
+        if (changes > 0)
+            channelVideos.added += 1;
+        else
+            channelVideos.skipped += 1;
+    }
+    return { channels, cast, episodeMemories, channelVideos };
+}
+function counts(value) {
+    return { added: value.added, renamed: value.renamed, skipped: value.skipped };
 }
 export function importedName(name, max, taken) {
     for (let n = 1;; n += 1) {

package/dist/slices/storage/delete-project.js

@@ -1,13 +1,16 @@
 import { rmSync } from "node:fs";
 import { derive } from "../../kernel/runner/graph.js";
-import { projectExists, stagesOf } from "../admission/repo.js";
+import { stagesOf } from "../admission/repo.js";
 import { projectDir } from "./layout.js";
+// A run in flight: a call the runner holds, or a stage running or waiting out a retry.
+export function projectBusy(deps, projectId) {
+    return (deps.hasInflight?.(projectId) === true || derive(stagesOf(deps.db, projectId)) === "running");
+}
 export function deleteProject(deps, projectId) {
-    if (!projectExists(deps.db, projectId)) {
+    if (deps.db.prepare("SELECT 1 FROM projects WHERE id = ?").get(projectId) === undefined) {
         return { ok: false, reason: "no-project" };
     }
-    if (deps.hasInflight?.(projectId) === true ||
-        derive(stagesOf(deps.db, projectId)) === "running") {
+    if (projectBusy(deps, projectId)) {
         return { ok: false, reason: "running" };
     }
     // Files first, rows second. A folder that would not go leaves the project listed; rows

package/dist/slices/storage/documents.js

@@ -0,0 +1,87 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, posix, relative, resolve, win32 } from "node:path";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+const execBytes = async (command, args) => (await execute(command, [...args], { timeout: 10_000, windowsHide: true, encoding: "buffer" }))
+    .stdout;
+// Output is always decoded as UTF-8: the PowerShell command below switches its own output to
+// UTF-8 first, so a Documents folder named with non-ASCII letters (a Cyrillic or accented
+// OneDrive path) survives instead of arriving in the console codepage.
+export function nodeDocumentsHost(exec = execBytes) {
+    return {
+        platform: process.platform,
+        env: process.env,
+        home: homedir(),
+        run: async (command, args) => new TextDecoder("utf-8").decode(await exec(command, args)),
+        read: (path) => readFile(path, "utf8").catch(() => undefined),
+    };
+}
+// Forces PowerShell's stdout to UTF-8 before printing: by default it writes in the console's
+// codepage (437, 850, 1252...), which mangles every non-ASCII letter in the path.
+export const WINDOWS_DOCUMENTS_COMMAND = "[Console]::OutputEncoding = [Text.Encoding]::UTF8; [Environment]::GetFolderPath('MyDocuments')";
+// The user's own Documents folder, the way the system itself names it: Windows asks for the
+// known folder (which follows OneDrive and a folder moved in its Properties), Linux asks
+// xdg-user-dir and then reads user-dirs.dirs, macOS has no setting for it. Never throws: the
+// fallback is <home>/Documents. It isn't created here.
+export async function documentsDir(host) {
+    if (host.platform === "win32") {
+        const known = await host
+            .run("powershell.exe", [
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            WINDOWS_DOCUMENTS_COMMAND,
+        ])
+            .then((out) => out.trim())
+            .catch(() => "");
+        if (usable(known, host.home, true))
+            return known;
+        return win32.join(host.env.USERPROFILE?.trim() || host.home, "Documents");
+    }
+    const fallback = posix.join(host.home, "Documents");
+    if (host.platform === "darwin")
+        return fallback;
+    const asked = await host
+        .run("xdg-user-dir", ["DOCUMENTS"])
+        .then((out) => out.trim())
+        .catch(() => "");
+    if (usable(asked, host.home))
+        return resolve(asked);
+    const configHome = host.env.XDG_CONFIG_HOME?.trim() || join(host.home, ".config");
+    const configured = userDirsDocuments((await host.read(join(configHome, "user-dirs.dirs"))) ?? "", host.home);
+    if (configured !== undefined && usable(configured, host.home))
+        return resolve(configured);
+    return fallback;
+}
+// XDG_DOCUMENTS_DIR from a user-dirs.dirs file: `XDG_DOCUMENTS_DIR="$HOME/Documents"`. The
+// format allows only $HOME at the start or an absolute path.
+export function userDirsDocuments(text, home) {
+    for (const line of text.split(/\r?\n/)) {
+        const match = /^\s*XDG_DOCUMENTS_DIR\s*=\s*"([^"]*)"\s*$/.exec(line);
+        if (match === null)
+            continue;
+        const value = match[1] ?? "";
+        if (value === "$HOME" || value.startsWith("$HOME/"))
+            return join(home, value.slice("$HOME".length));
+        if (isAbsolute(value))
+            return value;
+        return undefined;
+    }
+    return undefined;
+}
+// xdg-user-dir answers with the home folder itself when Documents isn't set (the spec's "not
+// configured" value); a Documents folder that is the home folder would mix Slopify's folder
+// with everything else, so that counts as unset too.
+function usable(path, home, windows = false) {
+    if (path === "")
+        return false;
+    if (!windows && !isAbsolute(path))
+        return false;
+    if (windows && !/^(?:[a-zA-Z]:[\\/]|\\\\)/.test(path))
+        return false;
+    if (windows)
+        return win32.relative(win32.resolve(home), win32.resolve(path)) !== "";
+    return relative(resolve(home), resolve(path)) !== "";
+}

package/dist/slices/storage/downloads.js

@@ -1,6 +1,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { extname } from "node:path";
 import { zipSync } from "fflate";
+import { effectiveDescription } from "../youtube/edits-repo.js";
 import { assetOf } from "./asset-name.js";
 import { outputPath } from "./layout.js";
 import { outputsOf, projectTitle } from "./repo.js";
@@ -57,16 +58,47 @@ export function findDownload(deps, projectId, asset) {
     if (stats === undefined) {
         return { ok: false, reason: "missing-file" };
     }
+    const shown = output.role === "youtube_description" || output.role === "youtube_tags"
+        ? shownYoutubeText(deps, projectId, output.role)
+        : undefined;
     return {
         ok: true,
         download: {
             path,
             filename: downloadName(slugOf(title), output),
-            bytes: stats,
+            bytes: shown?.byteLength ?? stats,
             contentType: contentTypeOf(path),
+            ...(shown === undefined ? {} : { text: shown }),
         },
     };
 }
+// The description and tags download as the project page shows and copies them, and as Prepare
+// upload hands them on: the user's hand edits over the written text, chapters fitted, and the
+// channel's and project's links filled in (`youtube/edits-repo.ts`). The file on disk stays
+// the generated text, so regeneration can tell the user's edits from its own.
+function shownYoutubeText(deps, projectId, role) {
+    const outputs = outputsOf(deps.db, projectId);
+    const read = (wanted) => {
+        const output = outputs.find((candidate) => candidate.role === wanted);
+        if (output === undefined)
+            return undefined;
+        const path = outputPath(deps.paths, projectId, output.path);
+        return sizeOf(path) === undefined ? undefined : readFileSync(path, "utf8").trim();
+    };
+    const description = read("youtube_description");
+    if (description === undefined)
+        return undefined;
+    const video = outputs.find((output) => output.role === "video");
+    const shown = effectiveDescription(deps.db, projectId, {
+        description,
+        tags: read("youtube_tags") ?? "",
+        durationSeconds: video?.durationMs === null || video?.durationMs === undefined
+            ? undefined
+            : video.durationMs / 1000,
+    });
+    const text = role === "youtube_description" ? shown.description : shown.tags;
+    return new TextEncoder().encode(`${text}\n`);
+}
 // "download all" images as `<title-slug>-images.zip`, thumbnail included.
 export function imagesZip(deps, projectId) {
     const title = projectTitle(deps.db, projectId);