@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/channels/schema.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+import { languageSchema } from "../../kernel/ports/languages.js";
+import { aiDisclosureSettings } from "../studio/disclosure.js";
+import { ambientBedProblems } from "../video/ambient-bed.js";
+import { channelAmbientBedSchema } from "../video/ambient-bed-schema.js";
+import { paceSteps } from "../voices/model.js";
+import { castKinds } from "./model.js";
+const id = z.uuid();
+const colour = z
+    .string()
+    .regex(/^#[0-9a-fA-F]{6}$/, "Use a colour like #FFD700.")
+    .transform((value) => value.toUpperCase());
+const optionalText = (max) => z.string().trim().max(max).optional();
+const fontId = z
+    .string()
+    .max(160)
+    .regex(/^[A-Za-z0-9_-]+$/, "Choose a font from the list.")
+    .optional();
+// A blank field is left out rather than kept as "", so it inherits instead of overriding.
+export const brandKitSchema = z
+    .object({
+    captionFontId: fontId,
+    captionColor: colour.optional(),
+    captionOutlineColor: colour.optional(),
+    titleFontId: fontId,
+    titleColor: colour.optional(),
+    intro: optionalText(200),
+    outro: optionalText(200),
+    endScreenText: optionalText(200),
+    documentTheme: optionalText(200),
+    // The built-in beds only; the ranges are `video/ambient-bed.ts`'s, said in its words.
+    ambientBed: channelAmbientBedSchema
+        .superRefine((bed, context) => {
+        for (const problem of ambientBedProblems(bed))
+            context.addIssue({
+                code: "custom",
+                path: [problem.field],
+                message: `${problem.message} Change it under Brand kit → Ambient sound on the channel page.`,
+            });
+    })
+        .optional(),
+    language: languageSchema.optional(),
+})
+    .strict()
+    .transform((kit) => Object.fromEntries(Object.entries(kit).filter(([, value]) => value !== undefined && value !== "")));
+const name = z
+    .string()
+    .trim()
+    .min(1, "Enter a name.")
+    .max(200, "Keep the name to 200 characters or fewer.");
+export const channelCreateSchema = z.object({ id, name }).strict().readonly();
+export const channelUpdateSchema = z
+    .object({
+    name,
+    brand: brandKitSchema,
+    seriesBrief: z.string().max(10000, "Keep the series brief to 10,000 characters or fewer."),
+    baseVersion: z.number().int().positive(),
+})
+    .strict()
+    .readonly();
+// Names and aliases are matched against titles and image briefs as whole words; one of at
+// most 200 characters, and at most 20 aliases, keeps that cheap.
+const term = z
+    .string()
+    .trim()
+    .min(1, "Enter a name, and remove empty aliases.")
+    .max(200, "Keep names and aliases to 200 characters or fewer.");
+// A cast member's voice. The pace is one of the Speakers list's steps; the rest is checked
+// when a run uses it, like every other voice choice.
+export const castVoiceSchema = z
+    .object({
+    provider: z.string().trim().min(1, "Choose a voice provider.").max(100),
+    model: z.string().trim().min(1, "Choose a voice model.").max(200),
+    voice: z.string().trim().min(1, "Choose a voice.").max(200),
+    pace: z
+        .number()
+        .refine((value) => paceSteps.includes(value), "Pick a pace from the list.")
+        .optional(),
+    pronunciations: z
+        .string()
+        .max(20_000, "Keep the pronunciations to 20,000 characters or fewer.")
+        .optional(),
+})
+    .strict();
+export const castMemberInputSchema = z
+    .object({
+    kind: z.enum(castKinds),
+    name: term,
+    aliases: z.array(term).max(20, "Keep to 20 aliases or fewer.").default([]),
+    description: z
+        .string()
+        .trim()
+        .max(2000, "Keep the description to 2,000 characters or fewer.")
+        .default(""),
+    // Absent keeps the saved voice; null removes it.
+    voice: castVoiceSchema.nullable().optional(),
+})
+    .strict();
+export const castMemberCreateSchema = castMemberInputSchema.extend({ id }).strict();
+export const castMemberUpdateSchema = castMemberInputSchema
+    .extend({ baseVersion: z.number().int().positive() })
+    .strict();
+export const castGenerateSchema = z
+    .object({
+    prompt: z
+        .string()
+        .trim()
+        .min(1, "Describe the picture to make.")
+        .max(4000, "Keep the picture's description to 4,000 characters or fewer."),
+    provider: z.string().min(1).max(100),
+    model: z.string().min(1).max(200),
+})
+    .strict();
+export const templateChannelSchema = z.object({ channelId: id }).strict();
+// The channel's YouTube AI disclosure, saved on its own so it never races the Brand form.
+export const channelAiDisclosureSchema = z
+    .object({
+    aiDisclosure: z.enum(aiDisclosureSettings, "Choose Automatic, Always Yes or Always No."),
+})
+    .strict();
+// A cast member as a run's config holds it (`CastSnapshot`).
+export const castSnapshotSchema = z
+    .array(z.object({
+    name: z.string(),
+    aliases: z.array(z.string()).readonly(),
+    description: z.string(),
+    images: z.array(z.string()).readonly(),
+}))
+    .readonly();

package/dist/slices/channels/service.js

@@ -0,0 +1,180 @@
+import { transact } from "../../kernel/db/tx.js";
+import { defaultChannelId } from "./model.js";
+import { castMemberById, castOfChannel, channelById, channelSummaries } from "./repo.js";
+import { castMemberCreateSchema, castMemberUpdateSchema, channelAiDisclosureSchema, channelCreateSchema, channelUpdateSchema, templateChannelSchema, } from "./schema.js";
+export function listChannels(deps) {
+    return channelSummaries(deps.db);
+}
+export function readChannel(deps, id) {
+    const channel = channelById(deps.db, id);
+    if (channel === undefined)
+        return { ok: false, reason: "not-found" };
+    return { ok: true, value: { channel, cast: castOfChannel(deps.db, id) } };
+}
+export function createChannel(deps, input) {
+    const parsed = channelCreateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const { id, name } = parsed.data;
+    return transact(deps.db, () => {
+        const existing = channelById(deps.db, id);
+        // The same create sent twice (a retried request) answers with what the first made.
+        if (existing !== undefined)
+            return existing.name === name
+                ? { ok: true, value: existing }
+                : { ok: false, reason: "conflict" };
+        const at = deps.clock.now().toISOString();
+        // A new channel starts with episode memory on (`slices/episodes`); the column's default
+        // is off only for the channels that existed before it.
+        deps.db
+            .prepare("INSERT INTO channels(id,name,episode_memory,created_at,updated_at) VALUES (?,?,1,?,?)")
+            .run(id, name, at, at);
+        const created = channelById(deps.db, id);
+        if (created === undefined)
+            throw new Error("The new channel could not be read back");
+        return { ok: true, value: created };
+    });
+}
+export function updateChannel(deps, id, input) {
+    const parsed = channelUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: parsed.error.issues[0]?.message,
+        };
+    return transact(deps.db, () => {
+        const previous = channelById(deps.db, id);
+        if (previous === undefined)
+            return { ok: false, reason: "not-found" };
+        if (previous.version !== parsed.data.baseVersion)
+            return { ok: false, reason: "conflict" };
+        const brand = parsed.data.brand;
+        deps.db
+            .prepare("UPDATE channels SET name=?,brand_json=?,series_brief=?,version=version+1,updated_at=? WHERE id=? AND version=?")
+            .run(parsed.data.name, JSON.stringify(brand), parsed.data.seriesBrief, deps.clock.now().toISOString(), id, parsed.data.baseVersion);
+        const saved = channelById(deps.db, id);
+        if (saved === undefined)
+            throw new Error("The saved channel could not be read back");
+        return { ok: true, value: saved };
+    });
+}
+// Automatic, Always Yes or Always No for YouTube's AI disclosure. It leaves the channel's
+// version alone, so a Brand form open in another tab still saves.
+export function setChannelAiDisclosure(deps, id, input) {
+    const parsed = channelAiDisclosureSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input", message: parsed.error.issues[0]?.message };
+    const changed = deps.db
+        .prepare("UPDATE channels SET ai_disclosure=?,updated_at=? WHERE id=?")
+        .run(parsed.data.aiDisclosure, deps.clock.now().toISOString(), id);
+    if (Number(changed.changes) === 0)
+        return { ok: false, reason: "not-found" };
+    const saved = channelById(deps.db, id);
+    if (saved === undefined)
+        throw new Error("The saved channel could not be read back");
+    return { ok: true, value: saved };
+}
+// Its cast goes with it; its projects move to the default channel. A channel with templates
+// is refused, since its schedules would silently change channel.
+export function deleteChannel(deps, id) {
+    return transact(deps.db, () => {
+        const channel = channelById(deps.db, id);
+        if (channel === undefined)
+            return { ok: false, reason: "not-found" };
+        if (channel.isDefault)
+            return { ok: false, reason: "default-channel" };
+        // A template in the trash does not hold its channel: restored, it falls back to the
+        // default channel (`resolveChannelId`).
+        if (deps.db
+            .prepare("SELECT 1 FROM project_templates WHERE channel_id=? AND deleted_at IS NULL LIMIT 1")
+            .get(id))
+            return { ok: false, reason: "has-templates" };
+        deps.db
+            .prepare("UPDATE project_channels SET channel_id=? WHERE channel_id=?")
+            .run(defaultChannelId, id);
+        deps.db.prepare("DELETE FROM channels WHERE id=?").run(id);
+        return { ok: true, value: { deleted: true } };
+    });
+}
+export function moveTemplate(deps, templateId, input) {
+    const parsed = templateChannelSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        if (channelById(deps.db, parsed.data.channelId) === undefined)
+            return { ok: false, reason: "not-found" };
+        const changed = deps.db
+            .prepare("UPDATE project_templates SET channel_id=? WHERE id=?")
+            .run(parsed.data.channelId, templateId);
+        if (Number(changed.changes) === 0)
+            return { ok: false, reason: "not-found" };
+        return { ok: true, value: { templateId, channelId: parsed.data.channelId } };
+    });
+}
+export function createCastMember(deps, channelId, input) {
+    const parsed = castMemberCreateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input", message: parsed.error.issues[0]?.message };
+    const { id, kind, name, aliases, description, voice } = parsed.data;
+    return transact(deps.db, () => {
+        if (channelById(deps.db, channelId) === undefined)
+            return { ok: false, reason: "not-found" };
+        const existing = castMemberById(deps.db, id);
+        if (existing !== undefined)
+            return existing.channelId === channelId && existing.name === name
+                ? { ok: true, value: existing }
+                : { ok: false, reason: "conflict" };
+        const at = deps.clock.now().toISOString();
+        deps.db
+            .prepare("INSERT INTO cast_members(id,channel_id,kind,name,aliases_json,description,voice_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)")
+            .run(id, channelId, kind, name, JSON.stringify(unique(aliases, name)), description, voice === undefined || voice === null ? null : JSON.stringify(voice), at, at);
+        const created = castMemberById(deps.db, id);
+        if (created === undefined)
+            throw new Error("The new cast member could not be read back");
+        return { ok: true, value: created };
+    });
+}
+export function updateCastMember(deps, id, input) {
+    const parsed = castMemberUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input", message: parsed.error.issues[0]?.message };
+    const { kind, name, aliases, description, voice, baseVersion } = parsed.data;
+    return transact(deps.db, () => {
+        const previous = castMemberById(deps.db, id);
+        if (previous === undefined)
+            return { ok: false, reason: "not-found" };
+        if (previous.version !== baseVersion)
+            return { ok: false, reason: "conflict" };
+        deps.db
+            .prepare("UPDATE cast_members SET kind=?,name=?,aliases_json=?,description=?,voice_json=?,version=version+1,updated_at=? WHERE id=? AND version=?")
+            .run(kind, name, JSON.stringify(unique(aliases, name)), description, voice === undefined
+            ? previous.voice === undefined
+                ? null
+                : JSON.stringify(previous.voice)
+            : voice === null
+                ? null
+                : JSON.stringify(voice), deps.clock.now().toISOString(), id, baseVersion);
+        const saved = castMemberById(deps.db, id);
+        if (saved === undefined)
+            throw new Error("The saved cast member could not be read back");
+        return { ok: true, value: saved };
+    });
+}
+export function deleteCastMember(deps, id) {
+    const changed = deps.db.prepare("DELETE FROM cast_members WHERE id=?").run(id);
+    return Number(changed.changes) === 0
+        ? { ok: false, reason: "not-found" }
+        : { ok: true, value: { deleted: true } };
+}
+// Aliases compared without case, the name itself left out: matching ignores case anyway.
+function unique(aliases, name) {
+    const seen = new Set([name.toLowerCase()]);
+    return aliases.filter((alias) => {
+        const key = alias.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/slices/channels/studio-csv.js

@@ -0,0 +1,110 @@
+// The video titles in a CSV file, such as YouTube Studio's Analytics → Content export. Pure.
+//
+// The title column is the one whose header reads "Video title", else "Title", else "Content"
+// (any case); failing that, the first column holding text that is not a number, a date or an id.
+// Quoted fields may hold commas, doubled quotes and line breaks. A leading byte-order mark is
+// dropped, and a file with more semicolons or tabs than commas in its first line is read with
+// that separator. Studio's "Total" row is skipped.
+const titleHeaders = ["video title", "title", "content"];
+export function parseCsv(text) {
+    const source = text.replace(/^/, "");
+    const firstLine = source.slice(0, source.search(/\r?\n|$/));
+    const separator = pickSeparator(firstLine);
+    const rows = [];
+    let row = [];
+    let field = "";
+    let quoted = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (quoted) {
+            if (char === '"') {
+                if (source[index + 1] === '"') {
+                    field += '"';
+                    index += 1;
+                }
+                else
+                    quoted = false;
+            }
+            else
+                field += char;
+            continue;
+        }
+        if (char === '"' && field === "")
+            quoted = true;
+        else if (char === separator) {
+            row.push(field);
+            field = "";
+        }
+        else if (char === "\n" || char === "\r") {
+            if (char === "\r" && source[index + 1] === "\n")
+                index += 1;
+            row.push(field);
+            rows.push(row);
+            row = [];
+            field = "";
+        }
+        else
+            field += char;
+    }
+    if (field !== "" || row.length > 0) {
+        row.push(field);
+        rows.push(row);
+    }
+    return rows.filter((cells) => cells.some((cell) => cell.trim() !== ""));
+}
+function pickSeparator(line) {
+    const count = (char) => line.split(char).length - 1;
+    const candidates = [",", ";", "\t"].map((char) => ({ char, n: count(char) }));
+    return candidates.reduce((best, next) => (next.n > best.n ? next : best)).char;
+}
+export function titlesFromCsv(text) {
+    const rows = parseCsv(text);
+    const header = rows[0];
+    if (header === undefined)
+        return [];
+    // In that order: Studio's export has both "Content" (the video id) and "Video title".
+    const names = header.map((cell) => cell.trim().toLowerCase());
+    const named = titleHeaders.map((name) => names.indexOf(name)).find((index) => index !== -1) ?? -1;
+    const column = named !== -1 ? named : textColumn(rows);
+    if (column === -1)
+        return [];
+    const body = named !== -1 || looksLikeHeader(header, column) ? rows.slice(1) : rows;
+    return body
+        .map((cells) => (cells[column] ?? "").replace(/\s+/g, " ").trim())
+        .filter((title) => title !== "" && title.toLowerCase() !== "total");
+}
+// A cell that is only a number, duration, date or a YouTube video id is no title.
+function plainValue(cell) {
+    const value = cell.trim();
+    return (value === "" ||
+        /^[-+]?[\d.,:%\s]+$/.test(value) ||
+        /^\d{4}-\d{2}-\d{2}/.test(value) ||
+        /^[A-Za-z0-9_-]{11}$/.test(value));
+}
+function textColumn(rows) {
+    const width = Math.max(...rows.map((cells) => cells.length));
+    const sample = rows.slice(1, 21).length > 0 ? rows.slice(1, 21) : rows;
+    const text = (column, cell) => sample.some((cells) => !plainValue(cells[column] ?? "") && cell(cells[column] ?? ""));
+    // Titles are words: a column with spaces in it wins over a column of single tokens (ids,
+    // handles), which is taken only when there is nothing else.
+    for (let column = 0; column < width; column += 1)
+        if (text(column, (value) => /\S\s+\S/.test(value.trim())))
+            return column;
+    for (let column = 0; column < width; column += 1)
+        if (text(column, () => true))
+            return column;
+    return -1;
+}
+// Without a known header name, the first row is a header when the other columns of it are
+// words while the rows below hold numbers there.
+function looksLikeHeader(header, column) {
+    return header.some((cell, index) => index !== column && !plainValue(cell) && cell.trim() !== "");
+}
+// Pasted titles: one per line, blank lines and surrounding spaces dropped.
+export function titlesFromLines(text) {
+    return text
+        .replace(/^/, "")
+        .split(/\r?\n/)
+        .map((line) => line.replace(/\s+/g, " ").trim())
+        .filter((line) => line !== "");
+}

package/dist/slices/channels/videos.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { channelById } from "./repo.js";
+import { titlesFromCsv, titlesFromLines } from "./studio-csv.js";
+export const videoTitleMax = 500;
+// ceiling: a channel with more uploads than this imports the first ones; the topic prompt
+// only lists 5,000 titles anyway.
+export const importMax = 10_000;
+export const importFilterMax = 200;
+const filterKey = (channelId) => `channels.importFilter.${channelId}`;
+const importSchema = z
+    .object({
+    // "lines": one title per line; "csv": a CSV export, the title column found by its header.
+    format: z.enum(["lines", "csv"]),
+    text: z.string().max(20_000_000, "This file is too large. Import at most 20 MB at a time."),
+    // The preview's "Keep only titles containing…" text, remembered for the next import.
+    filter: z
+        .string()
+        .max(importFilterMax, `The filter is too long to remember. Shorten "Keep only titles containing…" on the channel's Existing videos tab to at most ${importFilterMax} characters.`)
+        .optional(),
+})
+    .strict();
+const row = z.object({ id: z.string(), title: z.string(), created_at: z.string() });
+export function channelVideos(db, channelId) {
+    return db
+        .prepare("SELECT id,title,created_at FROM channel_videos WHERE channel_id=? ORDER BY lower(title), id")
+        .all(channelId)
+        .map((value) => {
+        const parsed = row.parse(value);
+        return { id: parsed.id, title: parsed.title, createdAt: parsed.created_at };
+    });
+}
+export function channelVideoTitles(db, channelId) {
+    return channelVideos(db, channelId).map((video) => video.title);
+}
+export function listChannelVideos(deps, channelId) {
+    if (channelById(deps.db, channelId) === undefined)
+        return { ok: false, reason: "not-found" };
+    return { ok: true, value: channelVideos(deps.db, channelId) };
+}
+// The titles an import would add and the channel's last "Keep only titles containing…" text
+// ("" when none); nothing is saved.
+export function previewChannelVideos(deps, channelId, input) {
+    if (channelById(deps.db, channelId) === undefined)
+        return { ok: false, reason: "not-found" };
+    const read = importOf(input);
+    if (!read.ok)
+        return read;
+    const filter = storedFilter(readSetting(deps.db, filterKey(channelId)));
+    return { ok: true, value: { titles: read.value.titles, filter } };
+}
+// Titles already on the channel (any case) and repeats within the import are skipped.
+export function importChannelVideos(deps, channelId, input) {
+    const read = importOf(input);
+    if (!read.ok)
+        return read;
+    const { titles, filter } = read.value;
+    return transact(deps.db, () => {
+        if (channelById(deps.db, channelId) === undefined)
+            return { ok: false, reason: "not-found" };
+        const at = deps.clock.now().toISOString();
+        const insert = deps.db.prepare("INSERT INTO channel_videos(id,channel_id,title,created_at) VALUES (?,?,?,?) ON CONFLICT DO NOTHING");
+        let added = 0;
+        for (const title of titles)
+            added += Number(insert.run(deps.uuid(), channelId, title, at).changes);
+        if (filter !== undefined)
+            writeSetting(deps.db, filterKey(channelId), JSON.stringify(filter.trim()));
+        return { ok: true, value: { added, skipped: titles.length - added } };
+    });
+}
+// Stored as JSON, like every row of the `settings` table a backup carries.
+function storedFilter(stored) {
+    if (stored === undefined)
+        return "";
+    try {
+        const value = JSON.parse(stored);
+        return typeof value === "string" ? value : "";
+    }
+    catch {
+        return "";
+    }
+}
+function importOf(input) {
+    const parsed = importSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input", message: parsed.error.issues[0]?.message };
+    const titles = (parsed.data.format === "csv"
+        ? titlesFromCsv(parsed.data.text)
+        : titlesFromLines(parsed.data.text)).map((title) => title.slice(0, videoTitleMax));
+    if (titles.length === 0)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: parsed.data.format === "csv"
+                ? "No video titles were found in this file. Export it from YouTube Studio → Analytics → Content (Export current view → Comma-separated values), or paste the titles one per line instead."
+                : "Paste at least one video title, one per line.",
+        };
+    if (titles.length > importMax)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: `This holds ${titles.length.toLocaleString("en")} titles; import at most ${importMax.toLocaleString("en")} at a time.`,
+        };
+    return { ok: true, value: { titles, filter: parsed.data.filter } };
+}
+export function deleteChannelVideo(deps, channelId, videoId) {
+    const changed = deps.db
+        .prepare("DELETE FROM channel_videos WHERE id=? AND channel_id=?")
+        .run(videoId, channelId);
+    return Number(changed.changes) === 0
+        ? { ok: false, reason: "not-found" }
+        : { ok: true, value: { deleted: true } };
+}
+export function clearChannelVideos(deps, channelId) {
+    if (channelById(deps.db, channelId) === undefined)
+        return { ok: false, reason: "not-found" };
+    const changed = deps.db.prepare("DELETE FROM channel_videos WHERE channel_id=?").run(channelId);
+    return { ok: true, value: { deleted: Number(changed.changes) } };
+}

package/dist/slices/checkpoints/recovery.js

@@ -107,7 +107,17 @@ export function recoverCheckpointWork(db) {
         AND (p.submitted_at IS NOT NULL OR p.continuation IS NOT NULL OR p.state IN ('running','done')))`)
             .all()
             .map((row) => z.string().parse(row.id));
+        // A step waiting out a rate limit or a timeout keeps its wait across a restart: it was not
+        // running when the process stopped, and the failure that parked it lost no submission.
+        const waiting = db
+            .prepare("SELECT id FROM revision_work WHERE state='pending' AND dispatch_state='allowed' AND retry_at IS NOT NULL")
+            .all()
+            .map((row) => z.string().parse(row.id));
         recoverWork(db);
+        for (const id of waiting) {
+            db.prepare("UPDATE revision_work SET dispatch_state='allowed' WHERE id=? AND state='pending'").run(id);
+            db.prepare("UPDATE revision_work_pieces SET state='pending',dispatch_state='allowed' WHERE work_id=? AND state!='done'").run(id);
+        }
         for (const id of retained) {
             db.prepare("UPDATE revision_work SET dispatch_state='allowed' WHERE id=? AND state='pending'").run(id);
             db.prepare("UPDATE revision_work_pieces SET state='pending',dispatch_state='allowed' WHERE work_id=? AND submitted_at IS NULL AND continuation IS NULL").run(id);

package/dist/slices/control/index.js

@@ -129,7 +129,8 @@ function editable(db, id, runner) {
     const stages = stagesOf(db, id);
     if (stages.some((stage) => stage.state === "running") || runner.hasInflight?.(id))
         return { ok: false, reason: "running" };
-    if (project.paused !== true && derive(stages) !== "failed")
+    const status = derive(stages);
+    if (project.paused !== true && status !== "failed" && status !== "partial")
         return { ok: false, reason: "not-editable" };
     return { ok: true };
 }

package/dist/slices/document/fonts.js

@@ -18,7 +18,7 @@ export function readDocumentAssets() {
         return { cinzel, parchment: new Uint8Array(readFileSync(new URL("background.jpg", assets))) };
     }
     catch (error) {
-        throw new Error(`Slopify couldn't read the fonts and page texture it makes documents with (${error instanceof Error ? error.message : String(error)}). Its installation is incomplete: reinstall or update Slopify, then use Retry stage on Document.`, { cause: error });
+        throw new Error(`Slopify couldn't read the fonts and page texture it makes documents with (${error instanceof Error ? error.message : String(error)}). Its installation is incomplete: reinstall or update Slopify, then use Try again on Document.`, { cause: error });
     }
 }
 export function registerFonts(doc, fonts) {

package/dist/slices/document/render.js

@@ -10,7 +10,7 @@ export function renderDocument(input) {
     const text = documentText(input.articleMarkdown, input.researchNotes);
     const blocks = withoutTitle(text.blocks, input.title);
     if (blocks.length === 0)
-        throw new Error("The article has no text to put in the document. Write or regenerate the article (Edit project → Article), then use Retry stage on Document.");
+        throw new Error("The article has no text to put in the document. Write or regenerate the article (Edit project → Article), then use Try again on Document.");
     const words = blocks
         .map((block) => block.kind === "heading" ? block.text : "runs" in block ? runsText(block.runs) : "")
         .join(" ")