@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/edge/http/actions.js

@@ -17,21 +17,12 @@ import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { allowsCustomModel } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { outputsOf } from "../../slices/storage/repo.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
-const idParam = z.object({
-    id: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
-});
+import { idParam, idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { revisionRequired } from "./refusal.js";
 const stageParam = idParam.extend({ kind: z.enum(stageKinds) });
 const imageParam = idParam.extend({
-    outputId: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
+    outputId: idString,
 });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
@@ -105,11 +96,10 @@ 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 Choose what to remake (in the project's More menu) to see what will be regenerated and what it costs.",
+            "rebuild-required": "This change needs some outputs to be made again. Use Choose what to make again (in the project's More menu) to see what will be made again and what it costs.",
         };
         return problem(c, {
             status: codes[result.reason],
-            title: titleOf(codes[result.reason]),
             detail: messages[result.reason],
             extensions: {
                 reason: result.reason,
@@ -122,7 +112,6 @@ export function actionRoutes(deps) {
         if (deps.rebuild === undefined)
             return problem(c, {
                 status: 503,
-                title: titleOf(503),
                 detail: "Resume and retry are not ready yet because Slopify is still starting. Wait a moment, reload the page and try again.",
             });
         const result = recoveryResultSchema.parse(await recoverProject(deps.rebuild, id, { ...input, action }));
@@ -138,13 +127,13 @@ export function actionRoutes(deps) {
             "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 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.",
+            "invalid-edit": "This section has settings that need fixing first. Correct this section in Edit settings, then try 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 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).",
+            "invalid-selection": "This section has nothing generated to make again because its content was supplied by you. To change it, use Edit settings.",
+            "review-required": "Content you supplied or captions you edited by hand would be replaced. Change them in Edit settings, or use Choose what to make again (in the project's More menu) to confirm the replacement.",
+            "cost-ack-required": "Making this again needs you to review its cost first. Use Choose what to make again (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.",
+            running: "This section is still running. Wait for it to finish, or Pause the project, before making it again.",
             "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.",
         };
@@ -154,12 +143,11 @@ export function actionRoutes(deps) {
             ...(result.intentRevisionId === undefined
                 ? []
                 : [
-                    "Your re-run request was saved. Use Continue the run to continue it instead of re-running again.",
+                    "Your request to make it again was saved. Use Continue the run to go on with it instead of asking again.",
                 ]),
         ].join(" ");
         return problem(c, {
             status,
-            title: titleOf(status),
             detail,
             extensions: {
                 reason: result.reason,
@@ -222,7 +210,6 @@ export function actionRoutes(deps) {
         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" },
             });
@@ -243,11 +230,3 @@ export function actionRoutes(deps) {
         .delete("/:id/images/:outputId", 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 Choose what to remake (in the project's More menu).",
-        extensions: { reason: "revision-required" },
-    });
-}

package/dist/edge/http/actor.js

@@ -2,9 +2,11 @@
 // No network request can set them (the Node server passes its own `{ incoming, outgoing }`),
 // which is how a route knows an agent asked, not the person.
 export const agentBindings = { actor: "agent" };
+// The in-app assistant's calls, through its own MCP endpoint (`/mcp/assistant`).
+export const assistantBindings = { actor: "assistant" };
 export function actorOf(c) {
     const env = c.env;
-    return typeof env === "object" && env !== null && "actor" in env && env.actor === "agent"
-        ? "agent"
-        : "person";
+    if (typeof env !== "object" || env === null || !("actor" in env))
+        return "person";
+    return env.actor === "agent" || env.actor === "assistant" ? env.actor : "person";
 }

package/dist/edge/http/app.js

@@ -4,9 +4,12 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { mcpPath } from "../../slices/agents/model.js";
 import { isSampleProject } from "../../slices/onboarding/sample.js";
+import { sampleOwner } from "../../slices/template-studio/repo.js";
+import { assistantMcpPath, assistantMcpRoutes, runAllowedCall } from "../mcp/assistant.js";
 import { mcpRoutes } from "../mcp/http.js";
 import { actionRoutes } from "./actions.js";
-import { agentBindings } from "./actor.js";
+import { agentBindings, assistantBindings } from "./actor.js";
+import { assistantRoutes } from "./assistant.js";
 import { audioPreviewRoutes } from "./audio-preview.js";
 import { auditionRoutes } from "./auditions.js";
 import { autostartRoutes } from "./autostart.js";
@@ -14,6 +17,8 @@ import { backupRoutes } from "./backups.js";
 import { channelMemoryRoutes } from "./channel-memory.js";
 import { channelRoutes } from "./channels.js";
 import { checkpointRoutes } from "./checkpoints.js";
+import { designTemplateRoutes } from "./design-templates.js";
+import { designRoutes } from "./designs.js";
 import { diagnosticsRoutes } from "./diagnostics.js";
 import { documentThemeRoutes } from "./document-themes.js";
 import { draftRoutes } from "./drafts.js";
@@ -22,24 +27,31 @@ import { externalReviewRoutes } from "./external-reviews.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
 import { homeRoutes, uploadedRoutes } from "./home.js";
+import { keywordRoutes } from "./keywords.js";
+import { modelCheckRoutes, providerCheckRoutes } from "./model-checks.js";
 import { narrationPeakRoutes } from "./narration-peaks.js";
 import { onboardingRoutes } from "./onboarding.js";
 import { openFolderRoutes } from "./open-folder.js";
 import { outputRoutes } from "./outputs.js";
 import { patchNotesRoutes } from "./patch-notes.js";
 import { planningRoutes } from "./planning.js";
-import { problem, problemFromError, titleOf } from "./problem.js";
+import { problem, problemFromError } from "./problem.js";
 import { projectTemplateRoutes } from "./project-templates.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
 import { pronunciationRoutes } from "./pronunciations.js";
 import { providerRoutes } from "./providers.js";
+import { remoteAccessRoutes } from "./remote-access.js";
+import { remoteGuard } from "./remote-guard.js";
+import { requestGuard } from "./request-guard.js";
 import { reviewRoutes } from "./reviews.js";
 import { revisionFileRoutes, revisionFolderRoutes } from "./revision-files.js";
 import { revisionRoutes } from "./revisions.js";
 import { runCostRoutes } from "./run-cost.js";
+import { viaFunnel } from "./same-page.js";
 import { calendarRoutes, scheduleRoutes } from "./schedules.js";
 import { settingsRoutes } from "./settings.js";
+import { socialRoutes } from "./social.js";
 import { stagingRoutes } from "./staging.js";
 import { startRecorder } from "./starts.js";
 import { storageRoutes } from "./storage.js";
@@ -48,6 +60,7 @@ import { studioRoutes } from "./studio.js";
 import { stylePreviewRoutes } from "./style-preview.js";
 import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.js";
+import { templateStudioRoutes } from "./template-studio.js";
 import { trashRoutes } from "./trash.js";
 import { tutorialRoutes } from "./tutorial.js";
 import { tutorialPagesRoutes } from "./tutorials.js";
@@ -57,7 +70,7 @@ 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) {
+function apiRoutes(deps, startedAt, runAllowed) {
     return (new Hono()
         .get("/health", (c) => c.json({
         status: "ok",
@@ -72,9 +85,12 @@ function apiRoutes(deps, startedAt) {
         .route("/drafts", draftRoutes(deps.drafts))
         .route("/diagnostics", diagnosticsRoutes(deps))
         .route("/project-templates", projectTemplateRoutes(deps.drafts))
+        .route("/template-studio", templateStudioRoutes(deps))
         .route("/schedules", scheduleRoutes(deps.schedules))
         .route("/channels", channelRoutes(deps))
         .route("/channels", channelMemoryRoutes(deps))
+        .route("/designs", designRoutes(deps.designs))
+        .route("/design-templates", designTemplateRoutes(deps.designTemplates))
         .route("/calendar", calendarRoutes(deps.schedules))
         .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
@@ -98,6 +114,7 @@ function apiRoutes(deps, startedAt) {
         .route("/projects", youtubeEditRoutes(deps))
         .route("/fonts", fontsRoutes(deps))
         .route("/prompts", promptRoutes(deps))
+        .route("/keywords", keywordRoutes(deps))
         .route("/entries", entryRoutes(deps))
         .route("/document-themes", documentThemeRoutes(deps))
         .route("/pronunciations", pronunciationRoutes(deps))
@@ -105,19 +122,51 @@ function apiRoutes(deps, startedAt) {
         .route("/telemetry", telemetryRoutes(deps))
         .route("/usage", usageRoutes(deps))
         .route("/settings/autostart", autostartRoutes(deps.autostart))
+        .route("/settings/remote-access", remoteAccessRoutes(deps.remoteAccess))
         .route("/settings", settingsRoutes(deps))
         .route("/studio", studioRoutes(deps))
+        .route("/social", socialRoutes(deps))
         .route("/style-preview", stylePreviewRoutes(deps))
         .route("/tutorial", tutorialRoutes(deps))
         .route("/whats-new", whatsNewRoutes(deps))
         .route("/patch-notes", patchNotesRoutes(deps))
         .route("/tutorials", tutorialPagesRoutes(deps))
+        .route("/providers", providerCheckRoutes(deps))
         .route("/providers", providerRoutes(deps))
-        .route("/onboarding", onboardingRoutes(deps)));
+        .route("/model-checks", modelCheckRoutes(deps))
+        .route("/onboarding", onboardingRoutes(deps))
+        .route("/assistant", assistantRoutes(deps, runAllowed)));
 }
 export function createApp(deps) {
     const startedAt = deps.clock.now().getTime();
+    // An Allow's call goes through the API in-process as the assistant, like its MCP calls.
+    const runAllowed = (call) => runAllowedCall({
+        db: deps.db,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        api: async (request) => app.request(request, undefined, assistantBindings),
+    }, call);
     const app = new Hono()
+        // Slopify has no login, so it never answers the public internet. Tailscale marks every
+        // request that came through Funnel; Slopify never turns Funnel on, and this holds even if
+        // someone else does.
+        .use("*", async (c, next) => {
+        if (!viaFunnel(c.req.raw.headers))
+            return next();
+        return problem(c, {
+            status: 403,
+            detail: "Slopify doesn't answer the public internet: this request came through Tailscale Funnel. On the computer Slopify runs on, run tailscale funnel status to see which port has Funnel, turn it off with tailscale funnel --https=<that port> off, and open Slopify on your other devices through Settings → Remote access instead.",
+        });
+    })
+        // Only Slopify's own names, and changes only from its own page (`request-guard.ts`).
+        .use("*", requestGuard({
+        listenHost: deps.host,
+        remoteHost: deps.remoteAccess?.remoteHost,
+        extraHosts: deps.allowedHosts ?? [],
+    }))
+        // Over remote access: only the account that turned it on, and no host setup.
+        .use("*", remoteGuard(deps.remoteAccess))
         .use("*", async (c, next) => {
         // A provisional candidate must not trigger the stale-tab Reload dialog.
         if (!deps.updater?.locked())
@@ -130,14 +179,12 @@ export function createApp(deps) {
         if (deps.installationPending?.() && new URL(c.req.url).pathname !== "/api/update/activate")
             return problem(c, {
                 status: 503,
-                title: titleOf(503),
                 detail: "Slopify is still finishing its Docker setup. Wait for the launcher to finish, then try again.",
             });
         const releaseRequest = deps.mutations?.begin();
         if (deps.mutations !== undefined && releaseRequest === undefined)
             return problem(c, {
                 status: 503,
-                title: titleOf(503),
                 detail: "Slopify is shutting down, so changes cannot be saved right now. Start it again, reload the page and try again.",
             });
         const updateRoute = [
@@ -151,7 +198,6 @@ export function createApp(deps) {
             releaseRequest?.();
             return problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: "Slopify is updating. Wait for it to restart, reload the page and try again.",
             });
         }
@@ -176,15 +222,28 @@ export function createApp(deps) {
             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.",
+            detail: "This is a sample project, which is read-only so trying things on it never spends anything. Press Make my own copy at the top right of its page, then change and make the copy again.",
             extensions: { reason: "sample-read-only" },
         });
+    })
+        // A template's studio sample is changed only through its studio (`slices/template-studio`),
+        // whose runner reaches the project's slices directly: no project route may change it.
+        .use("/api/projects/:id/*", async (c, next) => {
+        if (["GET", "HEAD", "OPTIONS"].includes(c.req.method))
+            return next();
+        const owner = sampleOwner(deps.db, c.req.param("id"));
+        if (owner === undefined)
+            return next();
+        return problem(c, {
+            status: 409,
+            detail: `This is the sample project of the template ${owner.name}. Change the template in Edit template instead: Templates → ${owner.name} → Edit template.`,
+            extensions: { reason: "template-sample" },
+        });
     })
         .use("/api/*", startRecorder(deps))
         .onError((error, c) => problemFromError(c, error, deps))
         .notFound(missing)
-        .route("/api", apiRoutes(deps, startedAt))
+        .route("/api", apiRoutes(deps, startedAt, runAllowed))
         .get("/api/events/global", (c) => streamSSE(c, (stream) => deps.hub.subscribeGlobal(stream, c.req.raw.signal)))
         .get("/api/events/projects/:id", (c) => streamSSE(c, (stream) => deps.hub.subscribe(c.req.param("id"), stream, c.req.raw.signal)))
         // Files are served by URL, not through the API.
@@ -193,6 +252,23 @@ export function createApp(deps) {
         // The API answers for its whole prefix, so an unknown endpoint is a problem+json 404
         // rather than the SPA's index.html with a 200.
         .all("/api/*", missing);
+    const mcpDeps = {
+        db: deps.db,
+        paths: deps.paths,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        version: deps.version,
+        host: deps.host,
+        ...(deps.measureAudio === undefined ? {} : { measureAudio: deps.measureAudio }),
+    };
+    // The in-app assistant reaches it the same way, as the assistant, with its turn's token.
+    // Mounted first: `/mcp` must never answer for it.
+    app.route(assistantMcpPath, assistantMcpRoutes({
+        ...mcpDeps,
+        turns: deps.assistant?.tokens ?? deps.assistantTurns,
+        api: async (request) => app.request(request, undefined, assistantBindings),
+    }));
     // Agents reach the same API in-process, as the agent (`actor.ts`): every tool validates,
     // refuses and answers exactly like the page's own request.
     app.route(mcpPath, mcpRoutes({
@@ -225,7 +301,6 @@ const sampleReadOnlyExempt = /\/(revisions\/prepare|rebuild\/preview|open-folder
 function missing(c) {
     return problem(c, {
         status: 404,
-        title: titleOf(404),
         detail: `${c.req.method} ${c.req.path} is not a route of this API.`,
     });
 }

package/dist/edge/http/assistant.js

@@ -0,0 +1,129 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { assistantCliPreferences, assistantScreenSchema, assistantTextMax, } from "../../slices/assistant/model.js";
+import { setCliPreference } from "../../slices/assistant/repo.js";
+import { actorOf } from "./actor.js";
+import { idParam } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { hostOnlySentence } from "./remote-guard.js";
+import { viaProxy } from "./same-page.js";
+// The assistant panel's chat. The person's own: an agent or the assistant itself is refused
+// here, so nothing but a press in the page answers an ask.
+const messageBody = z
+    .object({
+    text: z
+        .string()
+        .trim()
+        .min(1, "Write a message first.")
+        .max(assistantTextMax, `Keep a message to ${String(assistantTextMax)} characters.`),
+    screen: assistantScreenSchema.optional(),
+})
+    .strict();
+const answerBody = z.object({ answer: z.enum(["allow", "deny"]) }).strict();
+const cliBody = z.object({ preference: z.enum(assistantCliPreferences) }).strict();
+const notWired = "This copy of Slopify was started without the assistant. Restart Slopify, then open the assistant again.";
+function personOnly(c) {
+    return actorOf(c) === "person"
+        ? undefined
+        : problem(c, {
+            status: 403,
+            detail: "The assistant's chat is the person's: only a press in Slopify's page sends a message or answers an ask.",
+        });
+}
+export function assistantRoutes(deps, 
+// On Allow, the asked call is made by Slopify itself (`edge/mcp/assistant.ts`).
+runAllowed) {
+    const assistant = deps.assistant;
+    const wired = (c) => personOnly(c) ?? assistant ?? problem(c, { status: 503, detail: notWired });
+    return new Hono()
+        .get("/", async (c) => {
+        const refused = personOnly(c);
+        if (refused !== undefined)
+            return refused;
+        if (assistant === undefined)
+            return c.json({
+                available: false,
+                cli: null,
+                reason: notWired,
+                fix: null,
+                preference: "auto",
+                ready: [],
+                session: null,
+            });
+        const { choice, preference, ready } = await assistant.status();
+        return c.json({
+            available: choice.ok,
+            cli: choice.ok ? choice.cli : null,
+            reason: choice.ok ? null : choice.reason,
+            fix: choice.ok ? null : choice.fix,
+            preference,
+            ready,
+            session: assistant.session() ?? null,
+        });
+    })
+        .post("/sessions", (c) => {
+        const service = wired(c);
+        if (service instanceof Response)
+            return service;
+        const id = service.newSession();
+        return c.json({ session: service.session(id) }, 201);
+    })
+        .post("/sessions/:id/messages", zValidator("param", idParam, onInvalid), zValidator("json", messageBody, onInvalid), (c) => {
+        const service = wired(c);
+        if (service instanceof Response)
+            return service;
+        const { text, screen } = c.req.valid("json");
+        const sent = service.send(c.req.valid("param").id, text, screen);
+        if (sent.ok)
+            return c.json({ turnId: sent.turnId }, 202);
+        return problem(c, {
+            status: sent.reason === "unknown-session" ? 404 : 409,
+            detail: sent.reason === "unknown-session"
+                ? "This chat no longer exists. Press New chat and send your message again."
+                : sent.reason === "busy"
+                    ? "The assistant is still answering in this chat. Wait for it, or press Stop, then send your message."
+                    : "Two assistant chats are answering already. Wait for one to finish, or press Stop in it, then send your message.",
+            extensions: { reason: sent.reason },
+        });
+    })
+        .post("/sessions/:id/stop", zValidator("param", idParam, onInvalid), (c) => {
+        const service = wired(c);
+        if (service instanceof Response)
+            return service;
+        return c.json({ stopped: service.stop(c.req.valid("param").id) });
+    })
+        .post("/asks/:id", zValidator("param", idParam, onInvalid), zValidator("json", answerBody, onInvalid), (c) => {
+        // An Allow starts paid or removing work: it is pressed on this computer, or on the
+        // person's own device through remote access, never by another account (`remote-guard.ts`).
+        if (c.req.valid("json").answer === "allow" && viaProxy(c.req.raw.headers))
+            return problem(c, {
+                status: 403,
+                detail: hostOnlySentence("The assistant's Allow is pressed"),
+                extensions: { reason: "host-only" },
+            });
+        const service = wired(c);
+        if (service instanceof Response)
+            return service;
+        const answered = service.answer(c.req.valid("param").id, c.req.valid("json").answer, runAllowed);
+        if (answered.ok)
+            return c.json({ ask: answered.ask });
+        return problem(c, {
+            status: answered.reason === "unknown" ? 404 : 409,
+            detail: answered.reason === "unknown"
+                ? "This ask no longer exists. Ask the assistant again."
+                : answered.reason === "expired"
+                    ? "This ask waited more than 15 minutes, so it expired before your answer. Ask the assistant again, so it can check the cost again."
+                    : "This ask was already answered.",
+            extensions: { reason: answered.reason },
+        });
+    })
+        .put("/cli", zValidator("json", cliBody, onInvalid), (c) => {
+        const refused = personOnly(c);
+        if (refused !== undefined)
+            return refused;
+        const { preference } = c.req.valid("json");
+        setCliPreference(deps.db, preference);
+        return c.json({ preference });
+    });
+}

package/dist/edge/http/audio-preview.js

@@ -4,18 +4,12 @@ import { z } from "zod";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { projectTitle } from "../../slices/storage/repo.js";
 import { currentWorkOrigin } from "../events/visibility.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
-const projectParam = z.object({
-    projectId: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
-});
-const previewParam = projectParam.extend({ previewId: z.uuid() });
+import { projectIdParam } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+const previewParam = projectIdParam.extend({ previewId: z.uuid() });
 export function audioPreviewRoutes(deps) {
     return new Hono()
-        .get("/:projectId/audio-preview", zValidator("param", projectParam, onInvalid), (c) => {
+        .get("/:projectId/audio-preview", zValidator("param", projectIdParam, onInvalid), (c) => {
         const { projectId } = c.req.valid("param");
         if (projectTitle(deps.db, projectId) === undefined)
             return missing(c);
@@ -48,7 +42,6 @@ export function audioPreviewRoutes(deps) {
 function missing(c) {
     return problem(c, {
         status: 404,
-        title: titleOf(404),
         detail: "This live audio preview has ended. Play the finished narration from the project's audio outputs instead.",
     });
 }

package/dist/edge/http/auditions.js

@@ -10,7 +10,7 @@ const line = z.object({
     model: z.string().min(1).max(200),
     text: z.string().trim().min(1).max(auditionLineMax),
 });
-const quoteBody = z.object({
+export const quoteBody = z.object({
     lines: z
         .array(line.extend({ speaker: z.string().max(100) }))
         .min(1)

package/dist/edge/http/autostart.js

@@ -2,7 +2,7 @@ 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";
+import { onInvalid, problem } 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
@@ -12,26 +12,26 @@ export function autostartRoutes(service) {
     return (new Hono()
         .get("/", async (c) => {
         if (service === undefined)
-            return problem(c, { status: 404, title: titleOf(404), detail: unavailable });
+            return problem(c, { status: 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 });
+            return problem(c, { status: 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 });
+            return problem(c, { status: 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 problem(c, { status: 404, detail: unavailable });
         return c.json(await service.answer());
     }));
 }

package/dist/edge/http/backups.js

@@ -2,8 +2,8 @@ import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { backupConfigInputSchema } from "../../slices/backups/model.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
-// Settings → Backups: the schedule, the folder, the last result and Back up now. Writing an
+import { onInvalid, problem } from "./problem.js";
+// Settings → Backup & storage: the schedule, the folder, the last result and Back up now. Writing an
 // archive takes minutes, so Back up now answers at once and the screen polls this view.
 export function backupRoutes(service) {
     const backups = () => {
@@ -21,7 +21,6 @@ export function backupRoutes(service) {
         if (!saved.ok)
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: saved.detail,
                 extensions: { field: "folder" },
             });
@@ -32,7 +31,6 @@ export function backupRoutes(service) {
         if (!started.ok)
             return problem(c, {
                 status: started.status,
-                title: titleOf(started.status),
                 detail: started.detail,
             });
         return c.json(await backups().view(), 202);