@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/edge/events/hub.js

@@ -1,3 +1,4 @@
+import { errorText } from "../../kernel/errors.js";
 import { createPreviewCache } from "./preview-cache.js";
 export function createHub(deps) {
     const previews = createPreviewCache();
@@ -20,7 +21,7 @@ export function createHub(deps) {
             .writeSSE({ event: event.type, data: JSON.stringify(event), id: deps.ids.next() })
             .catch((error) => {
             subscriber.drop();
-            deps.log.write("warn", "sse.write", { detail: `${event.type}: ${messageOf(error)}` });
+            deps.log.write("warn", "sse.write", { detail: `${event.type}: ${errorText(error)}` });
         });
     };
     const join = (set, stream, signal, prune) => {
@@ -80,7 +81,7 @@ export function createHub(deps) {
                 // What the AI models are writing right now, so a page opened mid-call shows it.
                 for (const event of previews.snapshotAll()) {
                     const shown = present(event);
-                    if (shown !== undefined)
+                    if (shown !== undefined && deps.quiet?.(shown.projectId) !== true)
                         send(subscriber, shown);
                 }
             }
@@ -96,6 +97,8 @@ export function createHub(deps) {
                 return;
             for (const subscriber of projects.get(projectId) ?? [])
                 send(subscriber, shown);
+            if (deps.quiet?.(projectId) === true)
+                return;
             for (const subscriber of globals)
                 send(subscriber, shown);
         },
@@ -120,6 +123,3 @@ export function observedHub(hub, observe) {
         },
     };
 }
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}

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.
@@ -109,7 +100,6 @@ export function actionRoutes(deps) {
         };
         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 }));
@@ -159,7 +148,6 @@ export function actionRoutes(deps) {
         ].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 → General → 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.",
             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 studio sample of ${owner.name}. Change the template in its studio instead: Library → Templates → ${owner.name} → Open studio.`,
+            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,127 @@
+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",
+                session: null,
+            });
+        const { choice, preference } = 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,
+            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,7 +2,7 @@ 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";
+import { onInvalid, problem } from "./problem.js";
 // Settings → Backups: 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) {
@@ -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);

package/dist/edge/http/channel-memory.js

@@ -5,7 +5,8 @@ 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";
+import { onInvalid } from "./problem.js";
+import { jsonBody, refusal } from "./refusal.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() });
@@ -22,12 +23,12 @@ export function channelMemoryRoutes(deps) {
         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));
+        const result = setEpisodeMemory(service, c.req.valid("param").id, await jsonBody(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));
+        const result = editMemory(service, id, memoryId, await jsonBody(c));
         return result.ok ? c.json(result.value) : refused(c, result, "episode");
     })
         .delete("/:id/episodes/:memoryId", zValidator("param", memoryParam, onInvalid), (c) => {
@@ -40,11 +41,11 @@ export function channelMemoryRoutes(deps) {
         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));
+        const result = previewChannelVideos(service, c.req.valid("param").id, await jsonBody(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));
+        const result = importChannelVideos(service, c.req.valid("param").id, await jsonBody(c));
         return result.ok ? c.json(result.value, 201) : refused(c, result, "video");
     })
         .delete("/:id/videos", zValidator("param", idParam, onInvalid), (c) => {
@@ -67,26 +68,12 @@ function importLimit() {
         }, "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 },
-    });
+    return refusal(c, result.reason, { statuses: { "not-found": 404 }, otherwise: 400, detail });
 }