@gentbajko/slopify 3.0.0 → 3.0.2

package/dist/catalog/registry.js

@@ -1,6 +1,6 @@
 import { thinkingModes } from "../kernel/ports/llm.js";
 import { providerError } from "../kernel/ports/model.js";
-import { isLocalCliProvider } from "../slices/settings/model.js";
+import { isLocalCliProvider, systemVoiceProvider } from "../slices/settings/model.js";
 import { referenceRefusal, takesReferenceImage } from "./schema.js";
 export function curateRegistry(registry, catalogue) {
     const requireModel = (provider, family, id) => {
@@ -146,6 +146,9 @@ export function curateRegistry(registry, catalogue) {
         },
         tts: (id) => {
             const port = registry.tts(id);
+            // The system voice's models are the speech programs on this computer, not list rows.
+            if (id === systemVoiceProvider)
+                return port;
             return {
                 ...port,
                 models: async () => catalogue.models(id, "tts"),

package/dist/catalog/validate.js

@@ -1,5 +1,5 @@
 import { usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../slices/admission/rules.js";
-import { isLocalCliProvider } from "../slices/settings/model.js";
+import { isLocalCliProvider, isUncataloguedProvider } from "../slices/settings/model.js";
 import { usesAnimation } from "../slices/video/edit-settings.js";
 import { referenceRefusal, takesReferenceImage, videoModelsOf } from "./schema.js";
 export function modelFields(draft, catalogue) {
@@ -32,7 +32,7 @@ export function modelFields(draft, catalogue) {
         },
     ];
     for (const { field, family, choice, needed } of checks) {
-        if (!needed || !choice || isLocalCliProvider(choice.provider))
+        if (!needed || !choice || isUncataloguedProvider(choice.provider))
             continue;
         const model = catalogue.models(choice.provider, family).find((m) => m.id === choice.model);
         if (!model)

package/dist/edge/autostart/docker-record.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { installSchema, readState, writeState } from "../docker-install/state.js";
-import { checkDockerStart, loginStartFile, loginStartReport, loginStartSchema, } from "./docker.js";
+import { inspectDockerStart, loginStartFile, loginStartReport, loginStartSchema, } from "./docker.js";
 import { autostartQuestion } from "./prompt.js";
 /**
  * The --docker installer's part: ask "Start Slopify when you log in?" once (or take
@@ -20,9 +20,9 @@ export async function recordLoginStart(o) {
     const record = {
         version: 1,
         checkedAt: o.now().toISOString(),
-        docker: await checkDockerStart(o.exec, manager),
         manager,
         wanted,
+        ...(await inspectDockerStart({ exec: o.exec, manager, host: o.host })),
     };
     await writeState(path, record);
     o.report(wanted === false

package/dist/edge/autostart/docker.js

@@ -1,3 +1,4 @@
+import { posix, win32 } from "node:path";
 import { z } from "zod";
 // Slopify in Docker restarts with Docker (`restart: unless-stopped` in compose.yaml), so it
 // starts at login exactly when Docker does. Slopify never changes Docker's own setting; the
@@ -15,6 +16,10 @@ export const loginStartSchema = z
     manager: z.enum(["system", "rootless"]),
     // The installer's "Start Slopify when you log in?" answer, or null when it wasn't asked.
     wanted: z.boolean().nullable(),
+    // The system the installer ran on, and whether its Docker is Docker Desktop, which has its
+    // own sign-in setting instead of a systemd service. Absent in records from before 3.0.1.
+    platform: z.enum(["linux", "darwin", "win32", "other"]).optional(),
+    desktop: z.boolean().optional(),
 })
     .strict();
 export function dockerHowTo(manager) {
@@ -22,6 +27,17 @@ export function dockerHowTo(manager) {
         ? "Turn on Docker's start at login in a terminal: systemctl --user enable docker (rootless Docker). Slopify then starts with it."
         : "Turn on Docker's start with the computer in a terminal: sudo systemctl enable docker. Slopify then starts with it.";
 }
+export const dockerDesktopHowTo = "Turn on Docker Desktop → Settings → General → Start Docker Desktop when you sign in to your computer. Slopify then starts with it.";
+// Where to turn Docker's start at login on, for the Docker this installation uses. A record
+// from before the installer noted the system can't tell Docker Desktop from Docker Engine
+// when systemctl didn't answer (macOS and Windows have none), so it names both.
+export function howToFor(record) {
+    if (record.desktop === true)
+        return dockerDesktopHowTo;
+    if (record.platform === undefined && record.docker === "unknown")
+        return desktopHowTo;
+    return dockerHowTo(record.manager);
+}
 export const desktopHowTo = "With Docker Desktop: Docker Desktop → Settings → General → Start Docker Desktop when you sign in. With Docker Engine on Linux: sudo systemctl enable docker. Slopify starts whenever Docker does.";
 /**
  * Reads, never changes, whether Docker starts by itself. `systemctl is-enabled` only reports;
@@ -38,8 +54,60 @@ export async function checkDockerStart(exec, manager) {
         return "no";
     return "unknown";
 }
+// Docker Desktop's settings files, newest name first: settings-store.json in current
+// versions, settings.json before it.
+export function desktopSettingsPaths(host) {
+    const names = ["settings-store.json", "settings.json"];
+    if (host.platform === "win32") {
+        const appData = host.env.APPDATA?.trim() || win32.join(host.home, "AppData", "Roaming");
+        return names.map((name) => win32.join(appData, "Docker", name));
+    }
+    if (host.platform === "darwin")
+        return names.map((name) => posix.join(host.home, "Library", "Group Containers", "group.com.docker", name));
+    return names.map((name) => posix.join(host.home, ".docker", "desktop", name));
+}
+// `AutoStart` in settings-store.json, `autoStart` in the older settings.json: Start Docker
+// Desktop when you sign in to your computer.
+export function desktopAutoStart(text) {
+    try {
+        const value = JSON.parse(text);
+        if (typeof value !== "object" || value === null)
+            return "unknown";
+        const record = value;
+        const start = record.AutoStart ?? record.autoStart;
+        return start === true ? "yes" : start === false ? "no" : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Reads, never changes, whether Docker starts by itself on this machine. macOS and Windows run
+ * Docker Desktop, whose settings file says; on Linux, Docker Desktop's settings file when it
+ * is there, otherwise the system or rootless docker service through systemctl.
+ */
+export async function inspectDockerStart(o) {
+    const platform = o.host.platform === "linux" || o.host.platform === "darwin" || o.host.platform === "win32"
+        ? o.host.platform
+        : "other";
+    for (const path of desktopSettingsPaths(o.host)) {
+        const text = await o.host.read(path);
+        if (text !== undefined)
+            return { docker: desktopAutoStart(text), desktop: true, platform };
+    }
+    if (platform === "darwin" || platform === "win32")
+        return { docker: "unknown", desktop: true, platform };
+    return { docker: await checkDockerStart(o.exec, o.manager), desktop: false, platform };
+}
 // The terminal line the installer prints after its question.
 export function loginStartReport(record) {
+    if (record.desktop === true) {
+        if (record.docker === "yes")
+            return "Slopify starts when you sign in: Docker Desktop starts at sign-in and restarts Slopify.";
+        if (record.docker === "no")
+            return `Docker Desktop doesn't start when you sign in, so neither does Slopify. ${dockerDesktopHowTo}`;
+        return `Slopify couldn't tell whether Docker Desktop starts when you sign in (its settings file didn't say). ${dockerDesktopHowTo}`;
+    }
     if (record.docker === "yes")
         return record.manager === "rootless"
             ? "Slopify starts when you log in: rootless Docker starts with your login and restarts Slopify."

package/dist/edge/autostart/prompt.js

@@ -45,8 +45,14 @@ export async function settleAutostart(options) {
     try {
         let wanted = options.flag;
         if (wanted === undefined) {
-            if (!options.interactive || !(await options.autostart.unanswered()))
+            if (!(await options.autostart.unanswered()))
                 return;
+            // Started without a terminal (a service, a script, a desktop shortcut): nobody can answer
+            // here, so the question stays open for the first-run screen and Settings → General.
+            if (!options.interactive) {
+                options.report("To start Slopify when you log in, turn it on in the app: the first-run screen offers it, or Settings → General → Start Slopify when I log in.");
+                return;
+            }
             wanted = await options.ask(autostartQuestion);
             if (wanted === undefined)
                 return;

package/dist/edge/autostart/service.js

@@ -1,5 +1,5 @@
 import { readSetting, writeSetting } from "../../slices/settings/repo.js";
-import { desktopHowTo, dockerHowTo } from "./docker.js";
+import { desktopHowTo, howToFor } from "./docker.js";
 import { autostartAnsweredKey } from "./model.js";
 export class AutostartRefusal extends Error {
 }
@@ -15,17 +15,19 @@ export function createAutostartService(db, source) {
                 enabled: record === null || record.docker === "unknown" ? null : record.docker === "yes",
                 summary: record === null
                     ? "Slopify runs in Docker and starts whenever Docker starts. From inside the container it can't see whether Docker starts when you log in."
-                    : record.docker === "yes"
-                        ? record.manager === "rootless"
-                            ? "Slopify runs in Docker and starts when you log in: rootless Docker starts with your login and restarts Slopify."
-                            : "Slopify runs in Docker and starts with this computer: Docker starts at boot and restarts Slopify."
-                        : record.docker === "no"
-                            ? "Slopify runs in Docker, and Docker doesn't start by itself on this computer, so Slopify doesn't either."
-                            : "Slopify runs in Docker and starts whenever Docker starts. The installer couldn't tell whether Docker starts by itself here.",
+                    : record.desktop === true
+                        ? desktopSummary(record.docker)
+                        : record.docker === "yes"
+                            ? record.manager === "rootless"
+                                ? "Slopify runs in Docker and starts when you log in: rootless Docker starts with your login and restarts Slopify."
+                                : "Slopify runs in Docker and starts with this computer: Docker starts at boot and restarts Slopify."
+                            : record.docker === "no"
+                                ? "Slopify runs in Docker, and Docker doesn't start by itself on this computer, so Slopify doesn't either."
+                                : "Slopify runs in Docker and starts whenever Docker starts. The installer couldn't tell whether Docker starts by itself here.",
                 where: null,
                 howTo: record === null
                     ? desktopHowTo
-                    : `${dockerHowTo(record.manager)} To check again after changing it, run npx @gentbajko/slopify --docker.`,
+                    : `${howToFor(record)} To check again after changing it, run npx @gentbajko/slopify --docker.`,
                 checkedAt: record?.checkedAt ?? null,
                 offer: false,
             };
@@ -66,6 +68,13 @@ export function createAutostartService(db, source) {
         refresh: () => (source.kind === "native" ? source.native.refresh() : Promise.resolve()),
     };
 }
+function desktopSummary(docker) {
+    return docker === "yes"
+        ? "Slopify runs in Docker Desktop and starts when you sign in: Docker Desktop starts at sign-in and restarts Slopify."
+        : docker === "no"
+            ? "Slopify runs in Docker Desktop, and Docker Desktop doesn't start when you sign in, so Slopify doesn't either."
+            : "Slopify runs in Docker Desktop and starts whenever it does. The installer couldn't read whether Docker Desktop starts when you sign in.";
+}
 // The native steps already speak in sentences; a file error from the disk doesn't.
 function plain(error, enabled) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/edge/cli-args.js

@@ -0,0 +1,71 @@
+import { parseArgs } from "node:util";
+const options = {
+    port: { type: "string" },
+    host: { type: "string" },
+    "data-dir": { type: "string" },
+    "projects-dir": { type: "string" },
+    "no-open": { type: "boolean" },
+    docker: { type: "boolean" },
+    "host-cli": { type: "string" },
+    "accept-host-cli": { type: "boolean" },
+    autostart: { type: "boolean" },
+    "no-autostart": { type: "boolean" },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+};
+function parse(args) {
+    return parseArgs({ args: [...args], allowPositionals: true, options });
+}
+// Node's own wording for a bad flag ("Unknown option '--foo'. To specify a positional argument
+// starting with a '-', place it after '--'") is replaced by one that says where the list is.
+export function parseCli(args) {
+    let parsed;
+    try {
+        parsed = parse(args);
+    }
+    catch (error) {
+        const code = error instanceof Error && "code" in error && typeof error.code === "string"
+            ? error.code
+            : undefined;
+        if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
+            const flag = /'([^']+)'/.exec(error instanceof Error ? error.message : "")?.[1];
+            throw new Error(`Slopify doesn't know the option ${flag ?? "you gave"}. Run npx @gentbajko/slopify --help to see every option.`);
+        }
+        if (code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE")
+            throw new Error(`${error instanceof Error ? error.message : String(error)}. Run npx @gentbajko/slopify --help to see how each option is written.`);
+        throw error;
+    }
+    if (parsed.values.help === true || parsed.positionals[0] === "help")
+        return { kind: "help" };
+    if (parsed.values.version === true)
+        return { kind: "version" };
+    return { kind: "run", values: parsed.values, positionals: parsed.positionals };
+}
+export function helpText(version) {
+    return `Slopify ${version}: makes narrated YouTube videos, Shorts, articles and PDFs from a topic.
+
+Usage
+  npx @gentbajko/slopify [options]            Start Slopify on this machine and open it in the browser
+  npx @gentbajko/slopify --docker [options]   Install (or reinstall) Slopify in Docker (install --docker works too)
+  npx @gentbajko/slopify@latest update        Update Slopify while it runs, or the Docker install (waits for running work first)
+
+Options for starting Slopify
+  --port <number>       The port the web app listens on (default 6969; or SLOPIFY_PORT)
+  --host <address>      The address it listens on (default 127.0.0.1, only this machine; or SLOPIFY_HOST)
+  --data-dir <folder>   Where Slopify keeps its database, settings and logs (default ~/.slopify; or SLOPIFY_DATA_DIR)
+  --no-open             Don't open the browser when Slopify starts (or SLOPIFY_NO_OPEN=1)
+  --autostart           Start Slopify when you log in, without asking
+  --no-autostart        Don't start Slopify when you log in, without asking
+
+Options for the Docker install
+  --docker              Install or update Slopify in Docker instead of running it directly
+  --projects-dir <folder>  The folder on this machine where the Docker version keeps project files
+  --host-cli=off        Use API keys only; don't connect the AI CLIs installed on this machine
+  --accept-host-cli     Connect the AI CLIs installed on this machine without asking
+
+Other
+  -h, --help            Show this list
+  -v, --version         Print the version
+
+More: https://slopify.stream`;
+}

package/dist/edge/cli.js

@@ -1,29 +1,24 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
 import { configFrom } from "../kernel/config/index.js";
 import { readVersion } from "../kernel/version.js";
 import { boot } from "../main.js";
 import { forwardManagedUpdate } from "../updater/forward.js";
 import { askTerminal, autostartFlag, settleAutostart } from "./autostart/prompt.js";
+import { helpText, parseCli } from "./cli-args.js";
 import { openBrowser } from "./open-browser.js";
 import { installSignalShutdown } from "./signal-shutdown.js";
-const { values, positionals } = parseArgs({
-    allowPositionals: true,
-    options: {
-        port: { type: "string" },
-        host: { type: "string" },
-        "data-dir": { type: "string" },
-        "projects-dir": { type: "string" },
-        "no-open": { type: "boolean" },
-        docker: { type: "boolean" },
-        "host-cli": { type: "string" },
-        "accept-host-cli": { type: "boolean" },
-        autostart: { type: "boolean" },
-        "no-autostart": { type: "boolean" },
-    },
-});
 let config;
 try {
+    const parsed = parseCli(process.argv.slice(2));
+    if (parsed.kind === "help") {
+        console.log(helpText(readVersion()));
+        process.exit(0);
+    }
+    if (parsed.kind === "version") {
+        console.log(readVersion());
+        process.exit(0);
+    }
+    const { values, positionals } = parsed;
     const autostart = autostartFlag(values);
     const [action, ...extra] = positionals;
     if (extra.length > 0 || (action !== undefined && action !== "install" && action !== "update"))

package/dist/edge/docker-install/run.js

@@ -1,4 +1,4 @@
-import { access } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -107,6 +107,12 @@ export async function runDockerCommand(command) {
             interactive: process.stdin.isTTY === true,
             ask: askTerminal,
             exec: nodeAutostartExec,
+            host: {
+                platform: process.platform,
+                home,
+                env,
+                read: (path) => readFile(path, "utf8").catch(() => undefined),
+            },
             now: () => new Date(),
             report: (line) => console.log(line),
         }).catch((error) => {

package/dist/edge/events/hub.js

@@ -72,7 +72,9 @@ export function createHub(deps) {
             for (const subscriber of projects.get(projectId) ?? []) {
                 send(subscriber, event);
             }
-            if (event.type === "project.state" || event.type === "project.updated") {
+            if (event.type === "project.state" ||
+                event.type === "project.updated" ||
+                event.type === "review.flagged") {
                 for (const subscriber of globals)
                     send(subscriber, event);
             }

package/dist/edge/http/actions.js

@@ -60,7 +60,12 @@ export function actionRoutes(deps) {
         ...reruns,
         runner: deps.runner,
         emit: (projectId, event) => deps.hub.emit(projectId, event),
-        providers: () => providerStatuses({ db: deps.db, probe: deps.probe, hostCliStatus: deps.hostCliStatus }),
+        providers: () => providerStatuses({
+            db: deps.db,
+            probe: deps.probe,
+            hostCliStatus: deps.hostCliStatus,
+            host: deps.speechHost,
+        }),
         allowsCustomModels: deps.catalogue ? () => false : allowsCustomModel,
         modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
     };

package/dist/edge/http/app.js

@@ -44,6 +44,7 @@ import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.js";
 import { trashRoutes } from "./trash.js";
 import { tutorialRoutes } from "./tutorial.js";
+import { tutorialPagesRoutes } from "./tutorials.js";
 import { updateRoutes } from "./update.js";
 import { usageRoutes } from "./usage.js";
 import { whatsNewRoutes } from "./whats-new.js";
@@ -102,6 +103,7 @@ function apiRoutes(deps, startedAt) {
         .route("/tutorial", tutorialRoutes(deps))
         .route("/whats-new", whatsNewRoutes(deps))
         .route("/patch-notes", patchNotesRoutes(deps))
+        .route("/tutorials", tutorialPagesRoutes(deps))
         .route("/providers", providerRoutes(deps))
         .route("/onboarding", onboardingRoutes(deps)));
 }

package/dist/edge/http/byte-range.js

@@ -0,0 +1,42 @@
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+// One `bytes=` range, as browsers ask for media; anything else is answered with the whole file.
+export function byteRange(header, size) {
+    const matched = /^bytes=(\d*)-(\d*)$/.exec(header?.trim() ?? "");
+    if (matched === null)
+        return undefined;
+    const [, from = "", to = ""] = matched;
+    if (from === "" && to === "")
+        return undefined;
+    if (from === "") {
+        const suffix = Number(to);
+        if (suffix === 0)
+            return "unsatisfiable";
+        return { start: Math.max(0, size - suffix), end: size - 1 };
+    }
+    const start = Number(from);
+    const end = to === "" ? size - 1 : Math.min(Number(to), size - 1);
+    if (start >= size || end < start)
+        return "unsatisfiable";
+    return { start, end };
+}
+// A file on disk as a response that honours one byte range, so an audio or video element
+// can seek: it asks for the bytes at the new time and gets 206 with just that slice. Built
+// with `c.body` so the app's own headers (the version, among others) are still added.
+export function fileResponse(c, path, size, headers) {
+    const base = { ...headers, "accept-ranges": "bytes" };
+    const range = byteRange(c.req.header("range"), size);
+    if (range === "unsatisfiable")
+        return c.body(null, 416, { ...base, "content-range": `bytes */${String(size)}` });
+    if (size === 0)
+        return c.body(null, 200, { ...base, "content-length": "0" });
+    const { start, end } = range ?? { start: 0, end: size - 1 };
+    const body = Readable.toWeb(createReadStream(path, { start, end }));
+    return c.body(body, range === undefined ? 200 : 206, {
+        ...base,
+        "content-length": String(end - start + 1),
+        ...(range === undefined
+            ? {}
+            : { "content-range": `bytes ${String(start)}-${String(end)}/${String(size)}` }),
+    });
+}

package/dist/edge/http/diagnostics.js

@@ -11,6 +11,7 @@ export function diagnosticsRoutes(deps) {
             db: deps.db,
             probe: deps.probe,
             hostCliStatus: deps.hostCliStatus,
+            host: deps.speechHost,
         });
         const projectCount = deps.db.prepare("SELECT count(*) AS count FROM projects").get();
         const schema = deps.db.prepare("SELECT max(version) AS version FROM schema_migrations").get();

package/dist/edge/http/draft-files.js

@@ -1,6 +1,4 @@
-import { createReadStream } from "node:fs";
 import { extname } from "node:path";
-import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
@@ -9,6 +7,7 @@ import { readDraft } from "../../slices/play-drafts/service.js";
 import { uploadDraftAttachment } from "../../slices/play-drafts/uploads.js";
 import { stagingPath } from "../../slices/storage/layout.js";
 import { stagedFileById } from "../../slices/storage/repo.js";
+import { fileResponse } from "./byte-range.js";
 import { draftProblem } from "./draft-problem.js";
 import { readMultipart } from "./multipart.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -59,9 +58,8 @@ export function draftFileRoutes(service) {
                 title: titleOf(404),
                 detail: "This attached file has not finished uploading, so it cannot be previewed yet. Wait a moment or attach it again.",
             });
-        return c.body(Readable.toWeb(createReadStream(stagingPath(deps.paths, staged.path))), 200, {
+        return fileResponse(c, stagingPath(deps.paths, staged.path), staged.bytes, {
             "content-type": contentType,
-            "content-length": String(staged.bytes),
             "x-content-type-options": "nosniff",
             "cache-control": "no-store",
         });

package/dist/edge/http/files.js

@@ -1,9 +1,8 @@
-import { createReadStream } from "node:fs";
-import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
 import { findDownload, imagesZip } from "../../slices/storage/downloads.js";
+import { fileResponse } from "./byte-range.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const projectParam = z.object({
     projectId: z
@@ -42,11 +41,16 @@ export function fileRoutes(deps) {
             return missing(c, result.reason);
         }
         const { download } = result;
-        // ceiling: whole-file responses only. Seeking inside the finished video would
-        // need a Range handler answering 206 with the requested slice.
-        return c.body(Readable.toWeb(createReadStream(download.path)), 200, {
+        // The YouTube description and tags as the page shows them, edits and links in.
+        if (download.text !== undefined)
+            return c.body(download.text, 200, {
+                "content-type": download.contentType,
+                "content-length": String(download.text.byteLength),
+                "content-disposition": disposition(download.filename),
+            });
+        // Byte ranges, so the players can jump to any time in the video or narration.
+        return fileResponse(c, download.path, download.bytes, {
             "content-type": download.contentType,
-            "content-length": String(download.bytes),
             "content-disposition": disposition(download.filename),
         });
     }));

package/dist/edge/http/onboarding.js

@@ -2,17 +2,21 @@ import { randomUUID } from "node:crypto";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { defaultSpeechVoice, detectSpeechCached, primaryLanguage, } from "../../kernel/ports/system-speech.js";
 import { loudnessOfDefault } from "../../slices/loudness/model.js";
 import { firstRunView } from "../../slices/onboarding/first-run.js";
+import { fullVideoDraft } from "../../slices/onboarding/full-video.js";
 import { installPack } from "../../slices/onboarding/install.js";
-import { quickShortInputSchema, sampleCopyInputSchema } from "../../slices/onboarding/model.js";
+import { fullVideoInputSchema, quickShortInputSchema, sampleCopyInputSchema, } from "../../slices/onboarding/model.js";
 import { packById, starterSet } from "../../slices/onboarding/packs.js";
-import { planShortProviders, shortDraft } from "../../slices/onboarding/quick-short.js";
+import { planShortProviders, shortDraft, } from "../../slices/onboarding/quick-short.js";
 import { copySample, restoreSamples, sampleProjectIds, } from "../../slices/onboarding/sample.js";
 import { dismissFirstRun, recordShortRequest, shortRequestProject, } from "../../slices/onboarding/state.js";
+import { systemVoiceProvider } from "../../slices/settings/model.js";
 import { readSettings } from "../../slices/settings/playback.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { listVoices } from "../../slices/settings/repo.js";
+import { addVoice } from "../../slices/settings/voices.js";
 import { projectTitle } from "../../slices/storage/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 import { createProject } from "./project-create.js";
@@ -20,7 +24,21 @@ const packParam = z.object({ id: z.string().min(1).max(40) });
 // The first five minutes: the first-run screen's state, starter packs, "Make a 60-second
 // short" and the bundled samples' Restore and Make my own copy.
 export function onboardingRoutes(deps) {
-    const statuses = () => providerStatuses({ db: deps.db, probe: deps.probe, hostCliStatus: deps.hostCliStatus });
+    const statuses = () => providerStatuses({
+        db: deps.db,
+        probe: deps.probe,
+        hostCliStatus: deps.hostCliStatus,
+        host: deps.speechHost,
+    });
+    const speech = () => detectSpeechCached(deps.probe, deps.speechHost ?? process);
+    // The best speech program found and its English voice, for a short made without a voice key.
+    const systemVoicePick = async () => {
+        const engine = (await speech()).engines[0];
+        const voice = engine === undefined ? undefined : defaultSpeechVoice(engine);
+        return engine === undefined || voice === undefined
+            ? undefined
+            : { model: engine.id, voiceId: voice.id, name: voice.name };
+    };
     const templates = { ...deps, uuid: randomUUID };
     const sample = {
         db: deps.db,
@@ -35,7 +53,7 @@ export function onboardingRoutes(deps) {
     return new Hono()
         .get("/", async (c) => {
         c.header("Cache-Control", "no-store");
-        return c.json(firstRunView(deps.db, await statuses(), deps.clock.now().toISOString()));
+        return c.json(firstRunView(deps.db, await statuses()));
     })
         .post("/dismiss", (c) => {
         dismissFirstRun(deps.db, deps.clock.now().toISOString());
@@ -75,6 +93,7 @@ export function onboardingRoutes(deps) {
             voices: listVoices(deps.db),
             modelsFor,
             suggested: pack.voice,
+            systemVoice: await systemVoicePick(),
         });
         if (!plan.ok)
             return problem(c, {
@@ -90,6 +109,22 @@ export function onboardingRoutes(deps) {
                 title: titleOf(404),
                 detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
             });
+        // The computer's voice is saved like any other, so Play and a later rebuild offer it.
+        const audio = plan.providers.audio;
+        if (plan.systemVoice &&
+            !listVoices(deps.db).some((voice) => voice.provider === audio.provider && voice.voiceId === audio.voice)) {
+            const found = await speech();
+            const spoken = found.engines
+                .flatMap((engine) => engine.voices)
+                .find((voice) => voice.id === audio.voice);
+            const language = spoken === undefined ? undefined : primaryLanguage(spoken);
+            addVoice({ db: deps.db, ids: deps.ids }, {
+                provider: systemVoiceProvider,
+                name: `${spoken?.name ?? audio.voice} (computer voice)`,
+                voiceId: audio.voice,
+                ...(language === undefined ? {} : { languages: [language] }),
+            });
+        }
         const created = await createProject(deps, shortDraft({
             topic: input.topic,
             pack,
@@ -105,7 +140,32 @@ export function onboardingRoutes(deps) {
                 ...(created.fields.length === 0 ? {} : { extensions: { fields: created.fields } }),
             });
         recordShortRequest(deps.db, input.requestId, created.project.id);
+        // A real project now exists, so the first-run screen is done with.
+        dismissFirstRun(deps.db, deps.clock.now().toISOString());
         return c.json({ projectId: created.project.id, replayed: false }, 201);
+    })
+        .post("/full-video", zValidator("json", fullVideoInputSchema, onInvalid), (c) => {
+        const made = fullVideoDraft(templates, c.req.valid("json"));
+        if (made.ok)
+            return c.json(made.value, 201);
+        if (made.reason === "not-found")
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This short or its starter pack is no longer here, so Play couldn't be set up from it. Open Play and pick a template yourself.",
+            });
+        if (made.reason === "not-short")
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "This project is already a long video. Open Play to start another one on a new topic.",
+            });
+        return problem(c, {
+            status: 409,
+            title: titleOf(409),
+            detail: "Slopify couldn't open a Play draft for the full video. Press Make the full video on this topic again; if it keeps failing, open Play and pick the pack's template in Library → Templates.",
+            extensions: { reason: made.reason },
+        });
     })
         .get("/sample", (c) => {
         const samples = sampleProjectIds(deps.db);