@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/narration/pronunciation.js

@@ -4,6 +4,10 @@ import remarkGfm from "remark-gfm";
 // https://docs.inworld.ai/tts/capabilities/custom-pronunciation
 const ipaAtom = "[ˈˌ]?[abdefghijklmnoprstuvwxzæðŋθɑɒɔəɚɛɜɝɡɪɹʃʊʌʒʔɫɾ][\\u0303\\u031a\\u0325\\u0329\\u032a\\u032c\\u032f\\u035c\\u0361ʰʲʷ]*[ːˑ]?";
 const ipaSymbols = new RegExp(`^(?:${ipaAtom})+(?:\\.(?:${ipaAtom})+)*$`, "u");
+// Another language's glossary needs that language's sounds: the full IPA consonant and vowel
+// charts (ç, ʁ, ø, y, ɲ, ʎ, x, β, …) and its diacritics, still never ARPAbet or tags.
+const worldAtom = "[ˈˌ]?[a-zæçðøħŋœɐɑɒɓɔɕɖɗɘəɚɛɜɝɞɟɠɡɢɣɤɥɦɧɨɪɫɬɭɮɯɰɱɲɳɴɵɶɸɹɺɻɽɾʀʁʂʃʄʈʉʊʋʌʍʎʏʐʑʒʔʕʙʛʜʝʟʡʢβθχ][\\u0300-\\u036fʰʱʲʷʼˠˤ˞]*[ːˑ]?";
+const worldSymbols = new RegExp(`^(?:${worldAtom})+(?:\\.(?:${worldAtom})+)*$`, "u");
 function textOf(node) {
     if (node.type === "break")
         return "\n";
@@ -18,7 +22,12 @@ function rowsOf(node) {
         const rows = node.children ?? [];
         return rows.slice(1).map((row) => {
             const cells = row.children ?? [];
-            return cells.length >= 2 ? cells.slice(0, 2).map(textOf).join(": ") : textOf(row);
+            if (cells.length < 2)
+                return textOf(row);
+            const [term, ipa] = cells.slice(0, 2).map((cell) => textOf(cell).trim());
+            // A table's IPA column is often written without the slashes ("| Tiamat | ˈtiːəmɑːt |");
+            // the column already says what the cell is, so a bare cell reads as one /…/ pronunciation.
+            return `${term}: ${ipa !== undefined && ipa !== "" && !ipa.includes("/") ? `/${ipa}/` : ipa}`;
         });
     }
     if (node.type === "paragraph")
@@ -27,16 +36,6 @@ function rowsOf(node) {
         return (node.children ?? []).flatMap(rowsOf);
     return ["(unsupported glossary block)"];
 }
-function refused(row, reason) {
-    return {
-        ok: false,
-        reason: "Pronunciation Glossary entry " +
-            row +
-            ": " +
-            reason +
-            ". Edit the glossary or turn off Use Pronunciation Glossary.",
-    };
-}
 function termIdentity(term) {
     return Array.from(term, (character) => {
         const lower = character.toLowerCase();
@@ -48,10 +47,19 @@ function termIdentity(term) {
         return match.test(folded) ? folded : match.test(lower) ? lower : character;
     }).join("");
 }
-export function parsePronunciationGlossary(markdown) {
+// `language` is the project's (`kernel/ports/languages.ts`): absent or English accepts the
+// standard-English IPA Inworld asks for, as it always did; any other accepts full IPA.
+export function parsePronunciationGlossary(markdown, language) {
+    const english = language === undefined || language === "en";
+    const symbols = english ? ipaSymbols : worldSymbols;
+    const kind = english ? "standard-English IPA" : "IPA";
     const rows = rowsOf(remark().use(remarkGfm).parse(markdown));
     const entries = new Map();
+    const skipped = [];
     for (const [index, row] of rows.entries()) {
+        const skip = (reason) => {
+            skipped.push({ row: index + 1, reason });
+        };
         const trimmed = row.trim();
         if (trimmed === "" || /^pronunciation glossary:?\s*$/iu.test(trimmed))
             continue;
@@ -61,24 +69,63 @@ export function parsePronunciationGlossary(markdown) {
         if (term === undefined ||
             pronunciation === undefined ||
             !/[\p{L}\p{N}]/u.test(term) ||
-            /[/[\]<>\p{Cc}]/u.test(term))
-            return refused(index + 1, "use Term: /IPA/ or a Term | IPA table");
+            /[/[\]<>\p{Cc}]/u.test(term)) {
+            skip("use Term: /IPA/ or a Term | IPA table");
+            continue;
+        }
         const notation = /^(\/[^/]+\/(?:\s+\/[^/]+\/)*)(?:\s+[^/]+)?$/u.exec(pronunciation);
-        if (notation?.[1] === undefined)
-            return refused(index + 1, "use slash-delimited standard-English IPA");
+        if (notation?.[1] === undefined) {
+            skip(`use slash-delimited ${kind}`);
+            continue;
+        }
         const ipa = Array.from(notation[1].matchAll(/\/([^/]+)\//gu)).flatMap((match) => (match[1] ?? "").trim().split(/\s+/u));
-        if (ipa.length === 0 || ipa.some((word) => !ipaSymbols.test(word)))
-            return refused(index + 1, "use standard-English IPA, not ARPAbet or delivery tags");
-        if (term.split(" ").length !== ipa.length)
-            return refused(index + 1, "supply one IPA word for each written word");
+        if (ipa.length === 0 || ipa.some((word) => !symbols.test(word))) {
+            skip(english
+                ? "use standard-English IPA only, not ARPAbet, delivery tags or non-English sounds; give a foreign name an English approximation"
+                : "use IPA, not ARPAbet or delivery tags");
+            continue;
+        }
+        if (term.split(" ").length !== ipa.length) {
+            skip("supply one IPA word for each written word");
+            continue;
+        }
         const key = termIdentity(term);
         const previous = entries.get(key);
-        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" "))
-            return refused(index + 1, "conflicting pronunciations were supplied for the same term");
+        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" ")) {
+            skip("an earlier entry already gives this term a different pronunciation");
+            continue;
+        }
         if (previous === undefined)
             entries.set(key, { term, ipa });
     }
-    return { ok: true, entries: [...entries.values()] };
+    return skipped.length === 0
+        ? { ok: true, entries: [...entries.values()] }
+        : { ok: true, entries: [...entries.values()], skipped };
+}
+// What a person reads about the skipped rows: where they are and why, never their text.
+export function skippedGlossaryNotice(skipped) {
+    if (skipped.length === 0)
+        return null;
+    const rows = skipped.map((one) => `entry ${one.row}: ${one.reason}`).join("; ");
+    return (`Pronunciation Glossary: ${skipped.length === 1 ? "1 entry is" : `${skipped.length} entries are`} ` +
+        `skipped and read as ordinary text (${rows}). The rest of the glossary is used. ` +
+        "To use them, fix those entries in the Pronunciation Glossary at the end of the article in Edit project → Article.");
+}
+export function skippedSpeakerPronunciations(speakers, language) {
+    return speakers.flatMap((speaker) => {
+        if (!speaker.pronunciations?.trim())
+            return [];
+        const parsed = parsePronunciationGlossary(speaker.pronunciations, language);
+        const skipped = parsed.ok ? (parsed.skipped ?? []) : [];
+        return skipped.length === 0 ? [] : [{ speaker: speaker.name.trim() || "A speaker", skipped }];
+    });
+}
+export function skippedSpeakerPronunciationsNotice(rows) {
+    if (rows.length === 0)
+        return null;
+    const parts = rows.map((row) => `${row.speaker}: ${row.skipped.map((one) => `entry ${one.row}: ${one.reason}`).join("; ")}`);
+    return (`Speaker pronunciations: some entries are skipped and read as ordinary text (${parts.join(". ")}). ` +
+        "The rest are used. To use them, fix those entries under Speakers → Pronunciations for that speaker (Play → Audio, or Edit project → Providers).");
 }
 export function pronunciationMatches(source, entries) {
     if (entries.length === 0)
@@ -105,7 +152,7 @@ export function pronunciationMatches(source, entries) {
             continue;
         const entry = ordered.find((_, index) => match[index + 1] !== undefined);
         if (entry === undefined)
-            throw new Error("Slopify hit an internal error (a pronunciation glossary term has no pronunciation). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a pronunciation glossary term has no pronunciation). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         matches.push({ start: match.index, end, entry });
     }
     return matches;
@@ -117,7 +164,7 @@ export function pronunciationSpans(source, entries) {
         for (const [index, word] of Array.from(words).entries()) {
             const ipa = match.entry.ipa[index];
             if (ipa === undefined)
-                throw new Error("Slopify hit an internal error (a pronunciation glossary term is missing a word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a pronunciation glossary term is missing a word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             const start = match.start + word.index;
             spans.push({ start, end: start + word[0].length, text: `/${ipa}/` });
         }

package/dist/slices/narration/run.js

@@ -14,7 +14,7 @@ import { planLegacyNarration } from "./legacy-plan.js";
 import { observeNarration } from "./live.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
-export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Retry stage.";
+export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Try again.";
 // What a chunk piece carries between runs: the text that was sent, and the file it came
 // back as once the provider answered. That is the whole of the resume.
 const chunkPayload = z.object({ text: z.string(), file: z.string().optional() });
@@ -41,7 +41,7 @@ export async function runNarration(deps, context, providers) {
     if (choice === undefined) {
         // Admission refuses a run whose audio is Generate without a provider and a voice, so
         // reaching here is a bug in admission rather than something the user did.
-        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Retry stage.");
+        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Try again.");
     }
     // Read once, before anything is written: the segment steps below ask it what a previous
     // run already stored, and the body step is the only thing that adds to it.
@@ -168,7 +168,7 @@ async function speakSegments(deps, context, providers, choice, outputs) {
         if (text === "") {
             // The same rule, applied to a segment: there is nothing to say, and silently
             // dropping an intro the user picked would lose it without telling anyone.
-            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Retry stage.`);
+            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Try again.`);
         }
         const spoken = await providers.forPiece(piece.id).tts({
             provider: choice.provider,
@@ -200,7 +200,7 @@ function segmentPieces(deps, projectId) {
     if (article === undefined) {
         // Admission writes all six stage rows with the project, so a project without an article
         // stage is a bug rather than a run the user configured.
-        throw new Error("Slopify hit an internal error (the project has no article stage). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project has no article stage). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return piecesOf(deps.db, article.id, "segment");
 }
@@ -257,13 +257,13 @@ function store(deps, projectId, role, path, durationMs, choice) {
 }
 function chunkOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return chunkPayload.parse(JSON.parse(piece.payload));
 }
 function segmentOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return segmentPayload.parse(JSON.parse(piece.payload));
 }

package/dist/slices/narration/shared-glossary.js

@@ -22,7 +22,7 @@ export function collectSharedGlossary(deps, exceptProjectId) {
             continue;
         }
         const parsed = parsePronunciationGlossary(text);
-        // A glossary that doesn't parse can't be trusted in someone else's narration either.
+        // Rows it had to skip are left out; a glossary that does not parse at all shares nothing.
         if (!parsed.ok)
             continue;
         for (const entry of parsed.entries) {

package/dist/slices/narration/steering.js

@@ -9,21 +9,32 @@ function atoms(source, from, to, spans) {
         const span = spans.get(at);
         if (span !== undefined) {
             if (span.end > to || span.end <= at)
-                throw new Error("Slopify hit an internal error (a pronunciation fix spans more than one word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a pronunciation fix spans more than one word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             result.push({ text: span.text, spokenText: source.slice(at, span.end) });
             at = span.end;
         }
         else {
             const point = source.codePointAt(at);
             if (point === undefined)
-                throw new Error("Slopify hit an internal error (a narration position is outside the article text). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a narration position is outside the article text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             const text = String.fromCodePoint(point);
-            result.push({ text, spokenText: text });
+            // An empty span is a later word of a multi-word alias (its spoken form sits on the first
+            // word), so the whitespace in front of it would leave two spaces where one word was.
+            // It stays in the spoken (transcript) text, which the captions are aligned against.
+            result.push({ text: silencedBefore(source, at, spans) ? "" : text, spokenText: text });
             at += text.length;
         }
     }
     return result;
 }
+function silencedBefore(source, at, spans) {
+    if (!/\s/u.test(source[at] ?? ""))
+        return false;
+    let next = at;
+    while (next < source.length && /\s/u.test(source[next] ?? ""))
+        next += 1;
+    return spans.get(next)?.text === "";
+}
 function checkedSpans(source, pronunciation) {
     const spans = new Map();
     let end = 0;
@@ -34,7 +45,7 @@ function checkedSpans(source, pronunciation) {
             span.end <= span.start ||
             span.end > source.length ||
             !/^[^\s\uD800-\uDFFF]+$/u.test(source.slice(span.start, span.end)))
-            throw new Error("Slopify hit an internal error (pronunciation fixes overlap or split a word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (pronunciation fixes overlap or split a word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         spans.set(span.start, span);
         end = span.end;
     }

package/dist/slices/notifications/notifier.js

@@ -1,5 +1,5 @@
 import { redact } from "../../kernel/log.js";
-import { noticeOf, noticeText, webhookBody } from "./rules.js";
+import { noticeOf, noticeText, topicsNoticeText, webhookBody } from "./rules.js";
 import { sendFailureText } from "./send.js";
 export function createRunNotifier(deps) {
     // ceiling: one entry per project seen since boot, a few dozen bytes each.
@@ -15,19 +15,22 @@ export function createRunNotifier(deps) {
         if (subject === undefined)
             return;
         const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
+        post(url, text, kind, { projectId });
+    };
+    const post = (url, text, kind, about) => {
         const body = redact(webhookBody(text));
         const sending = deps
             .send(url, body)
             .then((result) => {
             if (!result.ok)
                 deps.log.write("warn", "notification.failed", {
-                    projectId,
+                    ...about,
                     detail: `${kind} notification not delivered: ${sendFailureText(result)}`,
                 });
         })
             .catch((error) => {
             deps.log.write("warn", "notification.failed", {
-                projectId,
+                ...about,
                 detail: `${kind} notification not delivered: ${error instanceof Error ? error.message : String(error)}`,
             });
         })
@@ -65,6 +68,21 @@ export function createRunNotifier(deps) {
                 });
             }
         },
+        observeTopics: (event) => {
+            if (closed || event.added === 0)
+                return;
+            try {
+                const url = deps.url();
+                if (url === null)
+                    return;
+                post(url, topicsNoticeText(event), "topics", {});
+            }
+            catch (error) {
+                deps.log.write("warn", "notification.failed", {
+                    detail: `topics notification skipped: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
         close: () => {
             closed = true;
         },

package/dist/slices/notifications/rules.js

@@ -8,6 +8,8 @@ export function noticeOf(previous, next) {
     switch (next) {
         case "done":
             return "ready";
+        case "partial":
+            return "partial";
         case "failed":
             return "failed";
         case "pending":
@@ -34,6 +36,16 @@ export function noticeText(kind, subject) {
             return subject.makesVideo
                 ? { headline: `Video ready: ${title}`, detail: "Open the project to watch it." }
                 : { headline: `Run finished: ${title}`, detail: "Open the project to see its files." };
+        case "partial": {
+            const reason = shortReason(subject.reason);
+            const made = subject.makesVideo
+                ? `Video ready with problems: ${title}`
+                : `Run finished with problems: ${title}`;
+            return {
+                headline: reason === undefined ? made : `${made} — ${reason}`,
+                detail: "Open the project to see which step failed and the button that fixes it.",
+            };
+        }
         case "failed": {
             const reason = shortReason(subject.reason);
             return {
@@ -44,10 +56,19 @@ export function noticeText(kind, subject) {
         case "waiting":
             return {
                 headline: `Waiting for you: ${title}`,
-                detail: "Open the project to review the held step or press Resume.",
+                detail: "Open the project to review the held step or press Continue the run.",
             };
     }
 }
+export function topicsNoticeText(subject) {
+    const name = subject.scheduleName.trim() === "" ? "Untitled schedule" : subject.scheduleName.trim();
+    const count = subject.added;
+    const total = subject.waiting > count ? ` ${String(subject.waiting)} are waiting in all.` : "";
+    return {
+        headline: `${String(count)} new ${count === 1 ? "topic is" : "topics are"} waiting for you`,
+        detail: `Open Calendar → Suggested topics → ${name} to queue or reject ${count === 1 ? "it" : "them"}.${total}`,
+    };
+}
 export const testNotice = {
     headline: "Slopify test notification",
     detail: "Notifications work. You'll get one when a run finishes, fails or waits for you.",

package/dist/slices/onboarding/copy.js

@@ -0,0 +1,143 @@
+import { copyFileSync, lstatSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { transact } from "../../kernel/db/tx.js";
+import { executionPlan } from "../rebuild/runtime-plan.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { projectRows } from "../storage/backup-export.js";
+import { projectTables } from "../storage/backup-format.js";
+import { projectDir } from "../storage/layout.js";
+// ceiling: one pass per layer of the step graph (text, narration, timing, picks, prompts,
+// images, renders); far more than any plan has.
+const rebindPasses = 40;
+export function copyProject(deps, sourceId, title) {
+    const source = projectDir(deps.paths, sourceId);
+    const tables = projectTables.map((table) => [table, projectRows(deps.db, table, sourceId)]);
+    const ids = new Map([[sourceId, deps.ids.next()]]);
+    for (const [, rows] of tables)
+        for (const row of rows)
+            for (const [column, value] of Object.entries(row))
+                if ((column === "id" || column === "publication_id" || column === "admission_id") &&
+                    typeof value === "string" &&
+                    // ceiling: every id Slopify makes is a 26-character ULID or a 36-character UUID; a
+                    // shorter value could match inside unrelated text.
+                    value.length >= 16 &&
+                    !ids.has(value))
+                    ids.set(value, deps.ids.next());
+    const pattern = new RegExp([...ids.keys()]
+        .toSorted((left, right) => right.length - left.length)
+        .map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join("|"), "g");
+    const remap = (text) => text.replace(pattern, (id) => ids.get(id) ?? id);
+    const projectId = ids.get(sourceId) ?? sourceId;
+    const target = projectDir(deps.paths, projectId);
+    const at = deps.clock.now().toISOString();
+    try {
+        for (const file of listFiles(source)) {
+            const to = join(target, remap(file));
+            mkdirSync(dirname(to), { recursive: true, mode: 0o700 });
+            copyFileSync(join(source, file), to);
+        }
+        transact(deps.db, () => {
+            deps.db.exec("PRAGMA defer_foreign_keys = ON");
+            for (const [table, rows] of tables)
+                for (const row of rows) {
+                    const copied = Object.fromEntries(Object.entries(row).map(([column, value]) => [
+                        column,
+                        typeof value === "string" ? remap(value) : value,
+                    ]));
+                    insert(deps.db, table, table === "projects" ? { ...copied, title, created_at: at, updated_at: at } : copied);
+                }
+            rebind(deps, projectId);
+        });
+    }
+    catch (error) {
+        rmSync(target, { recursive: true, force: true });
+        throw error;
+    }
+    return { projectId };
+}
+// Re-stamps the copy's finished steps with the fingerprints its own ids give them.
+function rebind(deps, projectId) {
+    const revisionId = currentRevisionId(deps.db, projectId);
+    if (revisionId === undefined)
+        return;
+    for (let pass = 0; pass < rebindPasses; pass++) {
+        const view = getRevisionView(deps, projectId, revisionId);
+        if (view === undefined)
+            return;
+        const plan = executionPlan(deps, view, deps.catalogue);
+        const changes = new Map();
+        for (const change of plan.changedInputs)
+            if (change.before !== null && change.after !== null && change.before !== change.after)
+                changes.set(change.before, change.after);
+        // A finished piece also records the request it answered, which covers the same ids.
+        for (const recipe of plan.recipes)
+            for (const piece of view.pieces)
+                if (piece.selected && piece.key === recipe.key && piece.piece.payload !== null) {
+                    const request = requestOf(piece.piece.payload);
+                    if (request !== undefined &&
+                        recipe.requestFingerprint !== null &&
+                        request !== recipe.requestFingerprint)
+                        changes.set(request, recipe.requestFingerprint);
+                }
+        if (changes.size === 0) {
+            deps.db
+                .prepare("UPDATE project_revisions SET fingerprints=? WHERE id=?")
+                .run(JSON.stringify(Object.fromEntries(plan.recipes.map((row) => [row.key, row.fingerprint]))), revisionId);
+            return;
+        }
+        for (const [before, after] of changes)
+            for (const [table, column] of [
+                ["revision_outputs", "fingerprint"],
+                ["revision_pieces", "fingerprint"],
+                ["revision_outputs", "descriptor"],
+                ["revision_pieces", "descriptor"],
+                ["project_revisions", "content"],
+            ])
+                deps.db
+                    .prepare(`UPDATE ${table} SET ${column}=replace(${column},?,?) WHERE project_id=? AND instr(${column},?)>0`)
+                    .run(before, after, projectId, before);
+    }
+    throw new Error("Slopify hit an internal error (the copy of the sample kept changing while its steps were matched up). Delete the copy and try Make my own copy again; if it happens again, use Download diagnostics in Settings and report it.");
+}
+function requestOf(payload) {
+    try {
+        const value = JSON.parse(payload);
+        return typeof value === "object" &&
+            value !== null &&
+            "requestFingerprint" in value &&
+            typeof value.requestFingerprint === "string"
+            ? value.requestFingerprint
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function listFiles(root) {
+    const out = [];
+    const walk = (directory) => {
+        let names;
+        try {
+            names = readdirSync(directory);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const path = join(directory, name);
+            const stat = lstatSync(path);
+            if (stat.isDirectory())
+                walk(path);
+            else if (stat.isFile())
+                out.push(relative(root, path).split(sep).join("/"));
+        }
+    };
+    walk(root);
+    return out;
+}
+function insert(db, table, row) {
+    const columns = Object.keys(row);
+    db.prepare(`INSERT INTO ${table} (${columns.join(",")}) VALUES (${columns.map(() => "?").join(",")})`).run(...columns.map((column) => row[column] ?? null));
+}

package/dist/slices/onboarding/first-run.js

@@ -0,0 +1,46 @@
+import { starterPacks } from "./packs.js";
+import { sampleProjectIds } from "./sample.js";
+import { dismissFirstRun, firstRunDismissed, readPackRecords } from "./state.js";
+// The first-run screen shows on a fresh install and never again once it is skipped or a real
+// project (anything but the samples) exists. A real project also dismisses it for good, so
+// deleting every project later does not bring it back.
+export function firstRunView(db, statuses, at) {
+    const samples = sampleProjectIds(db);
+    const real = db
+        .prepare("SELECT 1 FROM projects WHERE id IS NOT ? AND id IS NOT ? AND id IS NOT ? LIMIT 1")
+        .get(samples.library, samples.audiobook, samples.podcast) !== undefined;
+    if (real)
+        dismissFirstRun(db, at);
+    const packs = readPackRecords(db);
+    return {
+        show: !real && !firstRunDismissed(db),
+        sampleProjectId: samples.library,
+        samples,
+        clis: detectedClis(statuses),
+        packs: starterPacks.map((pack) => ({
+            id: pack.id,
+            name: pack.name,
+            summary: pack.summary,
+            installed: packs[pack.id] !== undefined,
+            templateId: packs[pack.id]?.template ?? null,
+        })),
+    };
+}
+// What this machine can make without a key: each agent CLI Slopify found, and whether it
+// answers (installed, a supported version, signed in as far as the probe can tell).
+export function detectedClis(statuses) {
+    return ["claude-code", "codex", "gemini"].map((id) => {
+        const status = statuses.find((row) => row.id === id);
+        const readiness = status?.readiness;
+        const cli = readiness?.kind === "cli" ? readiness : undefined;
+        return {
+            id,
+            name: status?.displayName ?? id,
+            installed: cli?.installed === true,
+            ready: cli?.installed === true && cli.issue === undefined,
+            version: cli?.version ?? null,
+            issue: cli?.issue ?? null,
+            draws: id === "codex",
+        };
+    });
+}