@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/edge/{docker-projects → docker-install}/volume.js

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { chmod, lchown, lstat, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { chmod, lchown, lstat, mkdir, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isMissing, syncDirectory, treeDigest } from "./tree.js";
@@ -78,10 +78,6 @@ export async function volumeOperation(args) {
         await lchown("/data/home", uid, gid);
         return { ok: true };
     }
-    if (operation === "probe") {
-        await writeFile("/probe/container", "slopify ownership probe", { flag: "wx", mode: 0o600 });
-        return { uid: process.getuid?.(), gid: process.getgid?.() };
-    }
     throw new Error("Unknown fixed Docker volume operation.");
 }
 if (process.argv[1] === fileURLToPath(import.meta.url)) {

package/dist/edge/docker.js

@@ -6,16 +6,21 @@ import { installHostPackage } from "../host-cli/install.js";
 import { ensureBridgeToken, hasCode, prepareHostPaths } from "../host-cli/paths.js";
 import { ensureHostService, privateRead, privateWrite } from "../host-cli/service.js";
 import { hostCommandName, resolveHostCommand } from "../host-cli/status.js";
-import { hostCliProtocol, hostLlmIds } from "../kernel/ports/host-cli.js";
+import { hostLlmIds } from "../kernel/ports/host-cli.js";
 export function assertManagedDockerHost(platform, uid, gid) {
     if (platform !== "linux")
-        throw new Error("The --docker launcher only works on Linux. On this system, run Slopify without Docker (npx @gentbajko/slopify), or start the Slopify Docker image yourself with docker run.");
+        throw new Error("The --docker install only works on Linux. On this system, run Slopify without Docker (npx @gentbajko/slopify), or run the compose.yaml from the Slopify repository yourself (docker compose up -d).");
     if (uid === undefined || gid === undefined || uid === 0)
         throw new Error("Don't run the --docker launcher with sudo or as root. Run it as your normal user, and if Docker then says permission denied, give your user access: sudo usermod -aG docker $USER, then log out and back in.");
 }
-export async function prepareDockerHostCli(options) {
+/**
+ * Decides whether the Docker installation uses this machine's AI CLIs, asking once for consent,
+ * before anything changes. `ensure` then installs or updates the bridge: a private helper, run as
+ * the systemd user service slopify-cli-bridge.service, at the same version as the image.
+ */
+export async function planDockerHostCli(options) {
     if (options.disabled)
-        return {};
+        return { enabled: false };
     let installed = false;
     for (const id of hostLlmIds) {
         try {
@@ -28,7 +33,7 @@ export async function prepareDockerHostCli(options) {
         }
     }
     if (!installed)
-        return {};
+        return { enabled: false };
     if (process.platform !== "linux")
         throw new Error("Using this machine's AI CLIs from Docker needs Linux with systemd. Start with --host-cli=off to use API keys only.");
     const uid = process.getuid?.();
@@ -53,25 +58,12 @@ export async function prepareDockerHostCli(options) {
         if (!approved)
             throw new Error("You declined, so Slopify did not set up your host AI CLIs and nothing was changed. Run the launcher again and answer y to allow it, or add --host-cli=off to start with API keys only.");
     }
-    const inspect = () => options.runner.exec("docker", [
-        "image",
-        "inspect",
-        "--format",
-        '{{index .Config.Labels "io.slopify.host-cli-protocol"}}',
-        options.image,
-    ], options.signal);
-    let image = await inspect();
-    if (image.code !== 0 || image.stdout.trim() !== String(hostCliProtocol)) {
-        const pulled = await options.runner.exec("docker", ["pull", options.image], options.signal);
-        if (pulled.code !== 0)
-            throw new Error(`Could not download the Slopify Docker image ${options.image}. Check your internet connection and that Docker is running (docker info), then try again. Nothing was changed.`);
-        image = await inspect();
-        if (image.code !== 0 || image.stdout.trim() !== String(hostCliProtocol))
-            throw new Error(`The Docker image ${options.image} is too old to use the AI CLIs on this machine. Use the latest image (unset SLOPIFY_DOCKER_IMAGE, or point it to a current release) and try again, or start with --host-cli=off.`);
-    }
     const supported = await options.runner.exec("systemctl", ["--user", "list-units", "--no-legend", "--no-pager", "slopify-cli-bridge.service"], options.signal);
     if (supported.code !== 0)
         throw new Error("Using this machine's AI CLIs from Docker needs systemd user services (systemctl --user), which aren't available here. Start with --host-cli=off to use API keys only, or run Slopify without Docker: npx @gentbajko/slopify.");
+    return { enabled: true, ensure: () => ensureDockerHostCli(options, uid, receiptPath) };
+}
+async function ensureDockerHostCli(options, uid, receiptPath) {
     const paths = await prepareHostPaths(options.root);
     const lock = join(paths.root, "setup.lock");
     const deadline = Date.now() + 30_000;
@@ -107,7 +99,7 @@ export async function prepareDockerHostCli(options) {
             env: options.env,
         });
         await privateWrite(receiptPath, JSON.stringify({ version: 1, automaticStartup: true }));
-        return { directory: paths.share };
+        return paths.share;
     }
     finally {
         await rmdir(lock);

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/host-cli.js

@@ -12,7 +12,7 @@ import { startHostServer } from "../host-cli/server.js";
 import { resolveHostCommand } from "../host-cli/status.js";
 import { readVersion } from "../kernel/version.js";
 import { nodeCliProbe } from "../slices/settings/cli-status.js";
-import { dockerRoot } from "./docker-projects/state.js";
+import { dockerRoot } from "./docker-install/state.js";
 const { values } = parseArgs({ options: { "state-dir": { type: "string" } }, strict: true });
 if (!values["state-dir"])
     throw new Error("A host helper state directory is required.");

package/dist/edge/http/actions.js

@@ -11,6 +11,7 @@ import { revisionControlSchema, } from "../../slices/control/revision-control-sc
 import { recoverProject } from "../../slices/rebuild/recovery.js";
 import { recoveryResultSchema } from "../../slices/rebuild/recovery-model.js";
 import { resumable } from "../../slices/rebuild/recovery-repo.js";
+import { clearSoftening, refusedKeys, requestSoftening } from "../../slices/rebuild/soften.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { allowsCustomModel } from "../../slices/settings/models.js";
@@ -59,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"))),
     };
@@ -99,7 +105,7 @@ export function actionRoutes(deps) {
             "revision-required": "This page is out of date. Reload the page, then try again.",
             conflict: "This project changed since the page loaded. Reload the page to see the latest, then try again.",
             "idempotency-conflict": "This action was already sent with different details. Reload the page, then try again.",
-            "rebuild-required": "This change needs some outputs to be made again. In the Edit tab, use Rebuild affected outputs to see what will be regenerated and what it costs.",
+            "rebuild-required": "This change needs some outputs to be made again. In the Edit tab, use Choose what to remake (in the project's More menu) to see what will be regenerated and what it costs.",
         };
         return problem(c, {
             status: codes[result.reason],
@@ -130,14 +136,14 @@ export function actionRoutes(deps) {
         const messages = {
             "no-project": "This project no longer exists. Go back to Projects to pick another.",
             "no-revision": "The project's saved settings changed since the page loaded. Reload the page, then try again.",
-            conflict: "This project changed since the page loaded. Reload the page to see the latest, then use Resume again.",
+            conflict: "This project changed since the page loaded. Reload the page to see the latest, then use Continue the run again.",
             "idempotency-conflict": "This action was already sent with different details. Reload the page, then try again.",
             "invalid-edit": "This section has settings that need fixing first. Open the Edit tab, choose Edit project and correct this section, then try again.",
-            "stale-preview": "What needs to be made changed since the page loaded. Reload the page, then use Resume again.",
+            "stale-preview": "What needs to be made changed since the page loaded. Reload the page, then use Continue the run again.",
             "invalid-selection": "This section has nothing generated to re-run because its content was supplied by you. To change it, open the Edit tab and choose Edit project.",
-            "review-required": "Content you supplied or captions you edited by hand would be replaced. Change them in the Edit tab with Edit project, or use Rebuild affected outputs to confirm the replacement.",
-            "cost-ack-required": "This re-run needs you to review its cost first. In the Edit tab, use Rebuild affected outputs.",
-            readiness: "Slopify cannot run this yet. Check the provider, model, voice and any files you supplied, then use Resume.",
+            "review-required": "Content you supplied or captions you edited by hand would be replaced. Change them in the Edit tab with Edit project, or use Choose what to remake (in the project's More menu) to confirm the replacement.",
+            "cost-ack-required": "This re-run needs you to review its cost first. In the Edit tab, use Choose what to remake (in the project's More menu).",
+            readiness: "Slopify cannot run this yet. Check the provider, model, voice and any files you supplied, then use Continue the run.",
             running: "This section is still running. Wait for it to finish, or Pause the project, before re-running it.",
             "accepted-job": "This section has a finished provider job that Slopify has not collected yet.",
             "control-changed": "Another action on this project (such as Pause or Cancel) happened at the same time. Reload the page to see its current state, then try again.",
@@ -148,7 +154,7 @@ export function actionRoutes(deps) {
             ...(result.intentRevisionId === undefined
                 ? []
                 : [
-                    "Your re-run request was saved. Use Resume to continue it instead of re-running again.",
+                    "Your re-run request was saved. Use Continue the run to continue it instead of re-running again.",
                 ]),
         ].join(" ");
         return problem(c, {
@@ -184,7 +190,7 @@ export function actionRoutes(deps) {
             ? parsed.data
             : controlled(c, id, { ok: false, reason: "revision-required" });
     };
-    return new Hono()
+    return (new Hono()
         .post("/:id/pause", zValidator("param", idParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
         const input = await controlInput(c, id);
@@ -208,19 +214,40 @@ export function actionRoutes(deps) {
         kind: "retry",
         stage: c.req.valid("param").kind,
     }))
+        // Soften and retry: the refused image prompts of this stage are reworded by the project's
+        // AI model when the retry draws them again (`slices/rebuild/soften.ts`).
+        .post("/:id/stages/:kind/soften", zValidator("param", stageParam, onInvalid), zValidator("json", revisionControlSchema, onInvalid), async (c) => {
+        const { id, kind } = c.req.valid("param");
+        const keys = kind === "images" || kind === "thumbnail" ? refusedKeys(deps.db, id, kind) : [];
+        if (keys.length === 0)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Nothing in this section was refused by a content filter, so there is no prompt to soften. Reload the page; if the section still shows an error, use Try again.",
+                extensions: { reason: "nothing-refused" },
+            });
+        requestSoftening(deps.db, id, keys, deps.clock.now().toISOString());
+        const response = await recovery(c, id, c.req.valid("json"), {
+            kind: "retry",
+            stage: kind,
+        });
+        if (response.status !== 202)
+            clearSoftening(deps.db, id, keys);
+        return response;
+    })
         .post("/:id/stages/:kind/rerun", zValidator("param", stageParam, onInvalid), zValidator("json", revisionControlSchema, onInvalid), (c) => recovery(c, c.req.valid("param").id, c.req.valid("json"), {
         kind: "rerun",
         stage: c.req.valid("param").kind,
     }))
         .put("/:id/article", zValidator("param", idParam, onInvalid), revisionRequired)
         .delete("/:id/images/:outputId", zValidator("param", imageParam, onInvalid), revisionRequired)
-        .post("/:id/images/:outputId/regenerate", zValidator("param", imageParam, onInvalid), revisionRequired);
+        .post("/:id/images/:outputId/regenerate", zValidator("param", imageParam, onInvalid), revisionRequired));
 }
 function revisionRequired(c) {
     return problem(c, {
         status: 409,
         title: titleOf(409),
-        detail: "This change is now made from the Edit tab. Choose Edit project, save your change, then use Rebuild affected outputs.",
+        detail: "This change is now made from the Edit tab. Choose Edit project, save your change, then use Choose what to remake (in the project's More menu).",
         extensions: { reason: "revision-required" },
     });
 }

package/dist/edge/http/app.js

@@ -2,9 +2,14 @@ import { existsSync } from "node:fs";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
+import { isSampleProject } from "../../slices/onboarding/sample.js";
 import { actionRoutes } from "./actions.js";
 import { audioPreviewRoutes } from "./audio-preview.js";
+import { auditionRoutes } from "./auditions.js";
+import { autostartRoutes } from "./autostart.js";
 import { backupRoutes } from "./backups.js";
+import { channelMemoryRoutes } from "./channel-memory.js";
+import { channelRoutes } from "./channels.js";
 import { checkpointRoutes } from "./checkpoints.js";
 import { diagnosticsRoutes } from "./diagnostics.js";
 import { documentThemeRoutes } from "./document-themes.js";
@@ -12,7 +17,11 @@ import { draftRoutes } from "./drafts.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
+import { homeRoutes, uploadedRoutes } from "./home.js";
+import { narrationPeakRoutes } from "./narration-peaks.js";
+import { onboardingRoutes } from "./onboarding.js";
 import { openFolderRoutes } from "./open-folder.js";
+import { patchNotesRoutes } from "./patch-notes.js";
 import { planningRoutes } from "./planning.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectTemplateRoutes } from "./project-templates.js";
@@ -20,17 +29,26 @@ import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
 import { pronunciationRoutes } from "./pronunciations.js";
 import { providerRoutes } from "./providers.js";
+import { reviewRoutes } from "./reviews.js";
 import { revisionFileRoutes, revisionFolderRoutes } from "./revision-files.js";
 import { revisionRoutes } from "./revisions.js";
-import { scheduleRoutes } from "./schedules.js";
+import { runCostRoutes } from "./run-cost.js";
+import { calendarRoutes, scheduleRoutes } from "./schedules.js";
 import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
 import { storageRoutes } from "./storage.js";
+import { filesRoutes } from "./storage-files.js";
+import { studioRoutes } from "./studio.js";
+import { stylePreviewRoutes } from "./style-preview.js";
 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";
+import { youtubeEditRoutes } from "./youtube-edits.js";
 const notBuilt = "The Slopify UI is not built yet. The API is running: try /api/health.\n" +
     "Build the SPA with `npm run build` at the repository root.\n";
 function apiRoutes(deps, startedAt) {
@@ -41,34 +59,53 @@ function apiRoutes(deps, startedAt) {
         uptimeMs: deps.clock.now().getTime() - startedAt,
     }))
         .route("/staging", stagingRoutes(deps))
+        .route("/storage/files", filesRoutes(deps))
         .route("/storage", storageRoutes(deps))
         .route("/backups", backupRoutes(deps.backups))
+        .route("/trash", trashRoutes(deps))
         .route("/drafts", draftRoutes(deps.drafts))
         .route("/diagnostics", diagnosticsRoutes(deps))
         .route("/project-templates", projectTemplateRoutes(deps.drafts))
         .route("/schedules", scheduleRoutes(deps.schedules))
+        .route("/channels", channelRoutes(deps))
+        .route("/channels", channelMemoryRoutes(deps))
+        .route("/calendar", calendarRoutes(deps.schedules))
         .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
         .route("/projects", checkpointRoutes(deps))
+        .route("/projects", reviewRoutes(deps))
         .route("/projects", revisionRoutes(deps))
         .route("/projects", revisionFolderRoutes(deps))
         .route("/projects", openFolderRoutes(deps))
         .route("/projects", audioPreviewRoutes(deps))
+        .route("/projects", narrationPeakRoutes(deps))
+        .route("/projects", runCostRoutes(deps))
+        .route("/projects", uploadedRoutes(deps))
+        .route("/home", homeRoutes(deps))
         .route("/update", updateRoutes(deps))
         // The re-run and cancel actions sit on the same prefix as the project itself; they
         // are their own router because they are their own concern.
         .route("/projects", actionRoutes(deps))
         .route("/projects", subtitleRoutes(deps))
+        .route("/projects", youtubeEditRoutes(deps))
         .route("/fonts", fontsRoutes(deps))
         .route("/prompts", promptRoutes(deps))
         .route("/entries", entryRoutes(deps))
         .route("/document-themes", documentThemeRoutes(deps))
         .route("/pronunciations", pronunciationRoutes(deps))
+        .route("/auditions", auditionRoutes(deps))
         .route("/telemetry", telemetryRoutes(deps))
         .route("/usage", usageRoutes(deps))
+        .route("/settings/autostart", autostartRoutes(deps.autostart))
         .route("/settings", settingsRoutes(deps))
+        .route("/studio", studioRoutes(deps))
+        .route("/style-preview", stylePreviewRoutes(deps))
         .route("/tutorial", tutorialRoutes(deps))
-        .route("/providers", providerRoutes(deps)));
+        .route("/whats-new", whatsNewRoutes(deps))
+        .route("/patch-notes", patchNotesRoutes(deps))
+        .route("/tutorials", tutorialPagesRoutes(deps))
+        .route("/providers", providerRoutes(deps))
+        .route("/onboarding", onboardingRoutes(deps)));
 }
 export function createApp(deps) {
     const startedAt = deps.clock.now().getTime();
@@ -117,6 +154,24 @@ export function createApp(deps) {
             releaseUpdate?.();
             releaseRequest?.();
         }
+    })
+        // The bundled sample is read-only, so exploring it never reaches a paid provider: only
+        // what reads or previews it is let through.
+        .use("/api/projects/:id/*", async (c, next) => {
+        if (["GET", "HEAD", "OPTIONS"].includes(c.req.method))
+            return next();
+        const id = c.req.param("id");
+        // Deleting the sample is allowed: Settings → Restore sample brings it back.
+        if (!isSampleProject(deps.db, id) ||
+            sampleReadOnlyExempt.test(c.req.path) ||
+            c.req.path.replace(/\/$/, "") === `/api/projects/${id}`)
+            return next();
+        return problem(c, {
+            status: 409,
+            title: titleOf(409),
+            detail: "This is the sample project, which is read-only so trying things on it never spends anything. Press Make my own copy at the top of the sample's page, then edit and rebuild the copy.",
+            extensions: { reason: "sample-read-only" },
+        });
     })
         .onError((error, c) => problemFromError(c, error, deps))
         .notFound(missing)
@@ -141,6 +196,9 @@ export function createApp(deps) {
     }
     return app;
 }
+// What the sample's page may still do: prepare its revision view, preview a rebuild (which
+// starts nothing) and open its folder.
+const sampleReadOnlyExempt = /\/(revisions\/prepare|rebuild\/preview|open-folder)\/?$/;
 function missing(c) {
     return problem(c, {
         status: 404,

package/dist/edge/http/auditions.js

@@ -0,0 +1,70 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { isProviderError } from "../../kernel/ports/model.js";
+import { estimateRequests } from "../../slices/estimate/index.js";
+import { auditionLineMax } from "../../slices/voices/audition.js";
+import { onInvalid, problem } from "./problem.js";
+const line = z.object({
+    provider: z.string().min(1).max(100),
+    model: z.string().min(1).max(200),
+    text: z.string().trim().min(1).max(auditionLineMax),
+});
+const quoteBody = z.object({
+    lines: z
+        .array(line.extend({ speaker: z.string().max(100) }))
+        .min(1)
+        .max(10),
+});
+const speakBody = line.extend({
+    voice: z.string().min(1).max(200),
+    // The page sends this only from the Audition button, after showing the price.
+    confirmed: z.literal(true),
+});
+export function auditionRoutes(deps) {
+    return new Hono()
+        .post("/quote", zValidator("json", quoteBody, onInvalid), (c) => {
+        const { lines } = c.req.valid("json");
+        if (deps.catalogue === undefined)
+            return c.json({ estimate: null });
+        const estimate = estimateRequests(lines.map((one) => ({
+            kind: "tts",
+            stage: one.speaker,
+            provider: one.provider,
+            model: one.model,
+            text: one.text,
+        })), deps.catalogue.read());
+        return c.json({ estimate });
+    })
+        .post("/", zValidator("json", speakBody, onInvalid), async (c) => {
+        const body = c.req.valid("json");
+        if (deps.audition === undefined)
+            return problem(c, {
+                status: 500,
+                title: "Internal Server Error",
+                detail: "Voice auditions aren't available in this build. Start the run and listen to the narration in the project instead.",
+            });
+        try {
+            const spoken = await deps.audition({ provider: body.provider, model: body.model, voiceId: body.voice, text: body.text }, c.req.raw.signal);
+            if (!spoken.ok)
+                return problem(c, {
+                    status: 409,
+                    title: "Conflict",
+                    detail: "The audition was held back. Try the Audition button again in a moment.",
+                });
+            return c.body(spoken.value.bytes.slice().buffer, 200, {
+                "content-type": "audio/mpeg",
+                "cache-control": "no-store",
+            });
+        }
+        catch (error) {
+            if (isProviderError(error))
+                return problem(c, {
+                    status: 502,
+                    title: "Bad Gateway",
+                    detail: `The audition couldn't be spoken: ${error.message}`,
+                });
+            throw error;
+        }
+    });
+}

package/dist/edge/http/autostart.js

@@ -0,0 +1,37 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { AutostartRefusal } from "../autostart/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const body = z.object({ enabled: z.boolean() });
+// Settings → General's "Start Slopify when I log in", and the first-run screen's offer of it.
+// In Docker the view says whether Docker starts at login, and turning it on or off is refused
+// with where Docker's own setting is.
+export function autostartRoutes(service) {
+    const unavailable = "Starting at login can't be set from this Slopify. Start it with npx @gentbajko/slopify and try Settings → General again.";
+    return (new Hono()
+        .get("/", async (c) => {
+        if (service === undefined)
+            return problem(c, { status: 404, title: titleOf(404), detail: unavailable });
+        c.header("Cache-Control", "no-store");
+        return c.json(await service.view());
+    })
+        .put("/", zValidator("json", body, onInvalid), async (c) => {
+        if (service === undefined)
+            return problem(c, { status: 404, title: titleOf(404), detail: unavailable });
+        try {
+            return c.json(await service.set(c.req.valid("json").enabled));
+        }
+        catch (error) {
+            if (!(error instanceof AutostartRefusal))
+                throw error;
+            return problem(c, { status: 409, title: titleOf(409), detail: error.message });
+        }
+    })
+        // The first-run screen's No thanks: never offer it there again, change nothing.
+        .post("/answer", async (c) => {
+        if (service === undefined)
+            return problem(c, { status: 404, title: titleOf(404), detail: unavailable });
+        return c.json(await service.answer());
+    }));
+}

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/channel-memory.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { z } from "zod";
+import { clearChannelVideos, deleteChannelVideo, importChannelVideos, listChannelVideos, previewChannelVideos, } from "../../slices/channels/videos.js";
+import { channelEpisodes, deleteMemory, editMemory, setEpisodeMemory, } from "../../slices/episodes/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({ id: z.uuid() });
+const memoryParam = idParam.extend({ memoryId: z.string().min(1).max(100) });
+const videoParam = idParam.extend({ videoId: z.uuid() });
+// A YouTube Studio export of a large channel is a few megabytes.
+const importMaxBytes = 20 * 1024 * 1024;
+// Channel page → Episodes (episode memory: the setting and the summaries) and Existing videos
+// (titles made before Slopify; a CSV is previewed, then its ticked titles are saved). Mounted
+// beside `channelRoutes` under /api/channels.
+export function channelMemoryRoutes(deps) {
+    const service = { db: deps.db, clock: deps.clock, uuid: randomUUID };
+    return new Hono()
+        .get("/:id/episodes", zValidator("param", idParam, onInvalid), (c) => {
+        const result = channelEpisodes(service, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refused(c, result, "episode");
+    })
+        .put("/:id/episodes/setting", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = setEpisodeMemory(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result, "episode");
+    })
+        .put("/:id/episodes/:memoryId", zValidator("param", memoryParam, onInvalid), async (c) => {
+        const { id, memoryId } = c.req.valid("param");
+        const result = editMemory(service, id, memoryId, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result, "episode");
+    })
+        .delete("/:id/episodes/:memoryId", zValidator("param", memoryParam, onInvalid), (c) => {
+        const { id, memoryId } = c.req.valid("param");
+        const result = deleteMemory(service, id, memoryId);
+        return result.ok ? c.body(null, 204) : refused(c, result, "episode");
+    })
+        .get("/:id/videos", zValidator("param", idParam, onInvalid), (c) => {
+        const result = listChannelVideos(service, c.req.valid("param").id);
+        return result.ok ? c.json({ videos: result.value }) : refused(c, result, "video");
+    })
+        .post("/:id/videos/preview", zValidator("param", idParam, onInvalid), importLimit(), async (c) => {
+        const result = previewChannelVideos(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result, "video");
+    })
+        .post("/:id/videos", zValidator("param", idParam, onInvalid), importLimit(), async (c) => {
+        const result = importChannelVideos(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value, 201) : refused(c, result, "video");
+    })
+        .delete("/:id/videos", zValidator("param", idParam, onInvalid), (c) => {
+        const result = clearChannelVideos(service, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refused(c, result, "video");
+    })
+        .delete("/:id/videos/:videoId", zValidator("param", videoParam, onInvalid), (c) => {
+        const { id, videoId } = c.req.valid("param");
+        const result = deleteChannelVideo(service, id, videoId);
+        return result.ok ? c.body(null, 204) : refused(c, result, "video");
+    });
+}
+function importLimit() {
+    return bodyLimit({
+        maxSize: importMaxBytes,
+        onError: (c) => refused(c, {
+            ok: false,
+            reason: "invalid-input",
+            message: "This file is larger than 20 MB. Export fewer videos from YouTube Studio, or paste the titles instead.",
+        }, "video"),
+    });
+}
+async function body(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+function refused(c, result, about) {
+    const status = result.reason === "not-found" ? 404 : 400;
+    const detail = result.message ??
+        (result.reason === "not-found"
+            ? about === "episode"
+                ? "This channel or episode summary no longer exists; it may have been deleted in another tab. Reload the channel's Episodes tab."
+                : "This channel or video title no longer exists; it may have been deleted in another tab. Reload the channel's Existing videos tab."
+            : "This request isn't valid. Reload the page and try again.");
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail,
+        extensions: { reason: result.reason },
+    });
+}