@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/edge/http/template-studio.js

@@ -0,0 +1,433 @@
+import { statSync } from "node:fs";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { designBudgetRoom } from "../../slices/designs/budget.js";
+import { playDraftDocumentSchema } from "../../slices/play-drafts/schema.js";
+import { templateById } from "../../slices/project-templates/repo.js";
+import { readSettings } from "../../slices/settings/playback.js";
+import { providerStatuses } from "../../slices/settings/readiness.js";
+import { getAnatomy } from "../../slices/template-studio/anatomy-view.js";
+import { bakeoffQuoteSchema, bakeoffStartSchema, bakeoffView, discardBakeoff, quoteBakeoff, startBakeoff, } from "../../slices/template-studio/bakeoff.js";
+import { budgetRoom, readStudioSettings, studioSettingsSchema, systemTimeZone, writeStudioSettings, } from "../../slices/template-studio/budget.js";
+import { makeSamplesForAll, quoteSamplesForAll, samplesForAllSchema, } from "../../slices/template-studio/for-all.js";
+import { createFreeSamples } from "../../slices/template-studio/free.js";
+import { enqueueJob } from "../../slices/template-studio/jobs.js";
+import { templateSections, } from "../../slices/template-studio/model.js";
+import { exportPack, packLimits } from "../../slices/template-studio/pack.js";
+import { importPack } from "../../slices/template-studio/pack-import.js";
+import { packSampleFileOf, packSamples } from "../../slices/template-studio/pack-samples.js";
+import { quoteSample, quoteSave } from "../../slices/template-studio/quote.js";
+import { markReady, markReadySchema } from "../../slices/template-studio/ready.js";
+import { createUnknownAcks, makeSampleSchema, requestSample, saveStudio, saveStudioSchema, } from "../../slices/template-studio/save.js";
+import { pronunciationsOf, quoteSayItAs, sayItAs, sayItAsSchema, } from "../../slices/template-studio/say-it-as.js";
+import { withDependents } from "../../slices/template-studio/sections.js";
+import { createPriceCache, createReadinessCache, getStudio, getStudioChecks, } from "../../slices/template-studio/service.js";
+import { fullScriptSchema, setFullScript, setSampleTopic, topicOf, topicSchema, } from "../../slices/template-studio/topic.js";
+import { fileResponse } from "./byte-range.js";
+import { readMultipart } from "./multipart.js";
+import { onInvalid, problem } from "./problem.js";
+// Library → Templates → Open studio. Not `/api/studio`, which is the YouTube Studio pack.
+const param = z.object({ id: z.uuid() });
+export function refusedStudio(c, result) {
+    const status = result.reason === "not-found" ? 404 : result.reason === "invalid-input" ? 400 : 409;
+    return problem(c, {
+        status,
+        detail: result.message,
+        extensions: { reason: result.reason },
+    });
+}
+// What to price: a Save's document, a new sample topic, or the full script switched.
+const quoteBody = z
+    .object({
+    document: playDraftDocumentSchema.optional(),
+    topic: z.string().trim().min(1).max(300).optional(),
+    fullScript: z.boolean().optional(),
+})
+    .strict()
+    .refine((body) => [body.document, body.topic, body.fullScript].filter((one) => one !== undefined).length === 1, { message: "Send one of document, topic or fullScript." });
+const unpriced = "This Slopify can't price or make paid samples because Play's review isn't available here. Restart Slopify; if it happens again, use Download diagnostics in Settings and report it.";
+// A refusal that carries the new quote (a higher price, unknown prices, past the budget), so the
+// page can show it on the button at once.
+function refusedWithQuote(c, result) {
+    const status = result.reason === "not-found" ? 404 : result.reason === "invalid-input" ? 400 : 409;
+    return problem(c, {
+        status,
+        detail: result.message,
+        extensions: {
+            reason: result.reason,
+            ...(result.quote === undefined ? {} : { quote: result.quote }),
+        },
+    });
+}
+const missingTemplate = "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.";
+function service(deps) {
+    return (deps.templateStudio ?? {
+        free: createFreeSamples({
+            loudnessDefault: () => readSettings({ db: deps.db, log: deps.log }).loudness,
+        }),
+        prices: createPriceCache(),
+        wake: () => undefined,
+    });
+}
+export function studioDeps(deps, studio) {
+    return {
+        db: deps.db,
+        clock: deps.clock,
+        paths: deps.paths,
+        log: deps.log,
+        free: studio.free,
+        prices: studio.prices,
+        // Probing the CLIs takes seconds: the studio's checks share one lookup for half a minute.
+        providerStatuses: createReadinessCache(() => providerStatuses({
+            db: deps.db,
+            probe: deps.probe,
+            hostCliStatus: deps.hostCliStatus,
+            host: deps.speechHost,
+        })),
+    };
+}
+export function templateStudioRoutes(deps) {
+    const studio = service(deps);
+    const read = studioDeps(deps, studio);
+    const review = studio.review ?? deps.drafts;
+    const acks = studio.acks ?? createUnknownAcks();
+    const sayDeps = { db: deps.db, paths: deps.paths, ids: deps.ids, clock: deps.clock };
+    const gone = (c, detail) => problem(c, { status: 404, detail });
+    const settingsView = () => {
+        const now = deps.clock.now();
+        return {
+            ...readStudioSettings(deps.db),
+            today: budgetRoom(deps.db, now),
+            designToday: designBudgetRoom(deps.db, now, systemTimeZone()),
+        };
+    };
+    const media = (c, file, type, detail) => file === undefined
+        ? gone(c, detail)
+        : fileResponse(c, file.path, file.bytes, {
+            "content-type": type,
+            "cache-control": "no-cache",
+            "x-content-type-options": "nosniff",
+        });
+    return (new Hono()
+        // Settings → Template studio: the samples' daily budgets, and what was spent today.
+        .get("/settings", (c) => c.json(settingsView()))
+        .put("/settings", zValidator("json", studioSettingsSchema, onInvalid), (c) => {
+        writeStudioSettings(deps.db, c.req.valid("json"));
+        return c.json(settingsView());
+    })
+        // Settings → Template studio → Make samples for all: the total first, then each sample
+        // that fits today's budget queued at its price, the rest waiting on the budget.
+        .post("/samples-for-all/quote", async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        return c.json(await quoteSamplesForAll({ db: deps.db, clock: deps.clock, review, acks }));
+    })
+        .post("/samples-for-all", zValidator("json", samplesForAllSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const result = await makeSamplesForAll({ db: deps.db, clock: deps.clock, review, acks }, c.req.valid("json"));
+        if (!result.ok)
+            return refusedWithQuote(c, result);
+        studio.wake();
+        for (const templateId of [...result.value.queued, ...result.value.held])
+            deps.hub.emitGlobal({ type: "template.sample", templateId });
+        return c.json(result.value, 202);
+    })
+        // Import pack: a pack someone exported becomes a new, unchecked template. Read whole
+        // (a pack is at most 30 MB), checked, then written in one go.
+        .post("/packs/import", async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        let tooLarge = false;
+        const bytes = await readMultipart(c.req.raw, async (content) => {
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of content) {
+                size += chunk.byteLength;
+                if (size > packLimits.uploadBytes) {
+                    tooLarge = true;
+                    continue;
+                }
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks, Math.min(size, packLimits.uploadBytes));
+        });
+        if (tooLarge)
+            return problem(c, {
+                status: 413,
+                title: "Content Too Large",
+                detail: `This pack is larger than ${String(packLimits.uploadBytes / 1024 / 1024)} MB, more than a template pack ever is. Export it again from the template's studio, or ask whoever made it to.`,
+            });
+        if (bytes === undefined || bytes.byteLength === 0)
+            return problem(c, {
+                status: 400,
+                detail: "No pack arrived with the upload. Choose the pack's .zip file again.",
+            });
+        const result = importPack(review, new Uint8Array(bytes));
+        if (!result.ok)
+            return refusedStudio(c, result);
+        deps.hub.emitGlobal({ type: "template.sample", templateId: result.value.templateId });
+        return c.json(result.value, 201);
+    })
+        .get("/:id", zValidator("param", param, onInvalid), async (c) => {
+        const result = await getStudio(read, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refusedStudio(c, result);
+    })
+        // A section's prompts, each cut into your words, your keywords, Slopify's and settings'.
+        .get("/:id/anatomy", zValidator("param", param, onInvalid), zValidator("query", z.object({ section: z.enum(templateSections), item: z.string().max(200).optional() }), onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const { section, item } = c.req.valid("query");
+        const result = await getAnatomy({ db: deps.db, paths: deps.paths, log: deps.log, review }, c.req.valid("param").id, section, item);
+        return result.ok ? c.json(result.value) : refusedStudio(c, result);
+    })
+        // Mark ready: the newest version, once every check passes and every sample is current,
+        // becomes the one its schedules run. Refused with each thing still to fix.
+        .post("/:id/ready", zValidator("param", param, onInvalid), zValidator("json", markReadySchema, onInvalid), async (c) => {
+        const id = c.req.valid("param").id;
+        const result = await markReady(read, id, c.req.valid("json"));
+        if (!result.ok) {
+            const status = result.reason === "not-found" ? 404 : result.reason === "invalid-input" ? 400 : 409;
+            return problem(c, {
+                status,
+                detail: result.message,
+                extensions: { reason: result.reason, problems: result.problems },
+            });
+        }
+        if (!result.value.replayed)
+            deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json(result.value);
+    })
+        // Voice → Say it as: the names the sample's script says, each with its first line.
+        .get("/:id/pronunciations", zValidator("param", param, onInvalid), (c) => {
+        const id = c.req.valid("param").id;
+        if (templateById(deps.db, id) === undefined)
+            return gone(c, missingTemplate);
+        return c.json(pronunciationsOf(sayDeps, id));
+    })
+        // What voicing the sample's lines that say a word again, the new way, costs.
+        .post("/:id/say-it-as/quote", zValidator("param", param, onInvalid), zValidator("json", sayItAsSchema.unwrap().pick({ written: true, spoken: true }), onInvalid), (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const result = quoteSayItAs({ ...sayDeps, review }, c.req.valid("param").id, c.req.valid("json"));
+        return result.ok ? c.json(result.value) : refusedStudio(c, result);
+    })
+        // Save a "Say it as": the Library alias, and the sample's lines that say it voiced again.
+        .post("/:id/say-it-as", zValidator("param", param, onInvalid), zValidator("json", sayItAsSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const id = c.req.valid("param").id;
+        const result = await sayItAs({ ...sayDeps, review, acks }, id, c.req.valid("json"));
+        if (!result.ok)
+            return refusedWithQuote(c, result);
+        if (result.value.queued)
+            studio.wake();
+        deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json(result.value);
+    })
+        // The free checks, apart from the studio: they wait on the providers' readiness.
+        .get("/:id/checks", zValidator("param", param, onInvalid), async (c) => {
+        const result = await getStudioChecks(read, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refusedStudio(c, result);
+    })
+        // What a Save's sample would cost, before anything is spent. Prices only; nothing changes.
+        .post("/:id/quote", zValidator("param", param, onInvalid), zValidator("json", quoteBody, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const id = c.req.valid("param").id;
+        const body = c.req.valid("json");
+        const quoteDeps = { db: deps.db, clock: deps.clock, review };
+        let result;
+        if (body.document !== undefined)
+            result = await quoteSave(quoteDeps, id, body.document);
+        else if (body.topic !== undefined) {
+            const named = topicOf(deps, id, body.topic);
+            if (!named.ok)
+                return problem(c, {
+                    status: 400,
+                    detail: named.message,
+                    extensions: { reason: "invalid-input" },
+                });
+            result = await quoteSample(quoteDeps, id, { topic: named.topic, sections: "all" });
+        }
+        else
+            result = await quoteSample(quoteDeps, id, {
+                fullScript: body.fullScript,
+                sections: withDependents(["script"]),
+            });
+        return result.ok ? c.json(result.value) : refusedStudio(c, result);
+    })
+        // Save: the template's next version, with its sample queued at the price the person saw,
+        // or without a sample. A higher price, an unaccepted unknown one, or a sample past today's
+        // budget is refused with the new quote.
+        .post("/:id/save", zValidator("param", param, onInvalid), zValidator("json", saveStudioSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const id = c.req.valid("param").id;
+        const result = await saveStudio({ db: deps.db, clock: deps.clock, review, acks }, id, c.req.valid("json"));
+        if (!result.ok)
+            return refusedWithQuote(c, result);
+        if (!result.value.replayed) {
+            studio.wake();
+            deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        }
+        return c.json(result.value);
+    })
+        // The sample's topic: typed, the next one a schedule has queued, or back to the fixed one.
+        .put("/:id/topic", zValidator("param", param, onInvalid), zValidator("json", topicSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const id = c.req.valid("param").id;
+        const result = await setSampleTopic({ db: deps.db, clock: deps.clock, review, acks }, id, c.req.valid("json"));
+        if (!result.ok)
+            return refusedWithQuote(c, result);
+        studio.wake();
+        deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json(result.value);
+    })
+        // The sample's whole script, or back to the outline and first chapter.
+        .post("/:id/full-script", zValidator("param", param, onInvalid), zValidator("json", fullScriptSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const id = c.req.valid("param").id;
+        const result = await setFullScript({ db: deps.db, clock: deps.clock, review, acks }, id, c.req.valid("json"));
+        if (!result.ok)
+            return refusedWithQuote(c, result);
+        studio.wake();
+        deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json(result.value);
+    })
+        // Make sample: the current version's paid sample again, at the price the button showed.
+        .post("/:id/samples/make", zValidator("param", param, onInvalid), zValidator("json", makeSampleSchema, onInvalid), (c) => {
+        const id = c.req.valid("param").id;
+        const result = requestSample({ db: deps.db, clock: deps.clock, acks }, id, c.req.valid("json"));
+        if (!result.ok)
+            return refusedStudio(c, result);
+        studio.wake();
+        deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json({ queued: true, ...result.value }, 202);
+    })
+        // Make samples: the free ones (video, loudness, PDF, the schedule's cost) for the current
+        // version, queued behind any other template's and made in the background.
+        .post("/:id/free-samples", zValidator("param", param, onInvalid), (c) => {
+        const template = templateById(deps.db, c.req.valid("param").id);
+        if (template === undefined)
+            return gone(c, missingTemplate);
+        enqueueJob(deps.db, {
+            templateId: template.id,
+            templateVersion: template.version,
+            ackHigh: 0,
+            kind: "free",
+            requestedAt: deps.clock.now().toISOString(),
+        });
+        studio.wake();
+        deps.hub.emitGlobal({ type: "template.sample", templateId: template.id });
+        return c.json({ queued: true, version: template.version }, 202);
+    })
+        .get("/:id/loudness/:file", zValidator("param", param.extend({ file: z.enum(["before.mp3", "after.mp3"]) }), onInvalid), (c) => {
+        const { id, file } = c.req.valid("param");
+        const template = templateById(deps.db, id);
+        if (template === undefined)
+            return gone(c, missingTemplate);
+        const notMade = "This loudness sample isn't made yet. Open the template's studio and press Make samples.";
+        if (file === "before.mp3") {
+            const source = studio.loudnessSource;
+            const size = source === undefined ? undefined : statSync(source, { throwIfNoEntry: false });
+            return media(c, source === undefined || size === undefined
+                ? undefined
+                : { path: source, bytes: size.size }, "audio/mpeg", notMade);
+        }
+        const hash = studio.free.loudnessHashOf(template.document);
+        return media(c, hash === undefined ? undefined : studio.loudnessFile?.(hash), "audio/mpeg", hash === undefined
+            ? "Level the volume is off for this template, so there is no levelled narration. Turn it on in Voice, then press Save."
+            : notMade);
+    })
+        // Compare models: one section's sample on one or two other models, priced first.
+        .post("/:id/bakeoff/quote", zValidator("param", param, onInvalid), zValidator("json", bakeoffQuoteSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const result = await quoteBakeoff({ db: deps.db, clock: deps.clock, review, paths: deps.paths, log: deps.log }, c.req.valid("param").id, c.req.valid("json"));
+        return result.ok ? c.json(result.value) : refusedStudio(c, result);
+    })
+        .post("/:id/bakeoff", zValidator("param", param, onInvalid), zValidator("json", bakeoffStartSchema, onInvalid), async (c) => {
+        if (review === undefined)
+            return problem(c, { status: 503, detail: unpriced });
+        const id = c.req.valid("param").id;
+        const result = await startBakeoff({
+            db: deps.db,
+            clock: deps.clock,
+            review,
+            paths: deps.paths,
+            log: deps.log,
+            uuid: review.uuid,
+        }, id, c.req.valid("json"));
+        if (!result.ok)
+            return refusedWithQuote(c, result);
+        studio.wake();
+        deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json(result.value, 202);
+    })
+        .get("/:id/bakeoff", zValidator("param", param, onInvalid), (c) => {
+        const id = c.req.valid("param").id;
+        if (templateById(deps.db, id) === undefined)
+            return gone(c, missingTemplate);
+        return c.json({ bakeoff: bakeoffView(deps, id) });
+    })
+        // Discard: the copies and what they made go; today's spend on them still counts.
+        .delete("/:id/bakeoff", zValidator("param", param, onInvalid), (c) => {
+        const id = c.req.valid("param").id;
+        if (templateById(deps.db, id) === undefined)
+            return gone(c, missingTemplate);
+        const result = discardBakeoff(deps, id);
+        if (!result.ok)
+            return refusedStudio(c, result);
+        deps.hub.emitGlobal({ type: "template.sample", templateId: id });
+        return c.json(result.value);
+    })
+        // Export pack: the version marked ready as a zip to share. A file download, like the
+        // project's files: agents read templates with get_template_studio instead.
+        .get("/:id/pack", zValidator("param", param, onInvalid), async (c) => {
+        const result = await exportPack({
+            db: deps.db,
+            paths: deps.paths,
+            log: deps.log,
+            clock: deps.clock,
+            version: deps.version,
+        }, c.req.valid("param").id);
+        if (!result.ok)
+            return refusedStudio(c, result);
+        return c.body(new Uint8Array(result.value.bytes), 200, {
+            "content-type": "application/zip",
+            "content-length": String(result.value.bytes.byteLength),
+            "content-disposition": `attachment; filename="${result.value.filename}"`,
+            "x-content-type-options": "nosniff",
+        });
+    })
+        // The samples an imported pack came with, shown in the studio until it makes its own.
+        .get("/:id/pack-samples", zValidator("param", param, onInvalid), (c) => {
+        const id = c.req.valid("param").id;
+        if (templateById(deps.db, id) === undefined)
+            return gone(c, missingTemplate);
+        return c.json({
+            samples: packSamples(deps.paths, id).map((sample) => ({
+                role: sample.role,
+                name: sample.name,
+                url: `/api/template-studio/${id}/pack-samples/${sample.file}`,
+            })),
+        });
+    })
+        .get("/:id/pack-samples/:file", zValidator("param", param.extend({
+        file: z.string().regex(/^[a-z0-9-]{1,40}\.(png|jpg|jpeg|webp|mp3|m4a|wav)$/),
+    }), onInvalid), (c) => {
+        const { id, file } = c.req.valid("param");
+        const found = packSampleFileOf(deps.paths, id, file);
+        return media(c, found, found?.type ?? "application/octet-stream", "This template has no such sample from a pack. Open its studio to see the samples it has.");
+    })
+        .get("/:id/document.pdf", zValidator("param", param, onInvalid), (c) => {
+        const template = templateById(deps.db, c.req.valid("param").id);
+        if (template === undefined)
+            return gone(c, missingTemplate);
+        return media(c, studio.documentFile?.(studio.free.documentHashOf(template.document)), "application/pdf", "This PDF sample isn't made yet. Open the template's studio and press Make samples.");
+    }));
+}

package/dist/edge/http/trash.js

@@ -4,21 +4,21 @@ import { z } from "zod";
 import { withProjectControl } from "../../slices/control/lock.js";
 import { trashKinds, } from "../../slices/trash/model.js";
 import { deleteNow, listTrash, restoreItem } from "../../slices/trash/service.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { idString } from "./ids.js";
+import { onInvalid } from "./problem.js";
+import { refusal } from "./refusal.js";
 const itemParam = z.object({
     kind: z.enum(trashKinds),
-    id: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
+    id: idString,
 });
 // Settings → Trash's Restore selected / Restore all and Delete selected / Empty trash: the
 // items named, each done on its own so one refusal leaves the rest done.
-const manySchema = z.object({ items: z.array(itemParam).min(1).max(5000) });
+export const manySchema = z.object({ items: z.array(itemParam).min(1).max(5000) });
 // A template comes back before the schedules that run it, so restoring both at once works.
 const restoreOrder = {
     template: 0,
+    "design-template": 0,
+    design: 1,
     prompt: 1,
     entry: 1,
     project: 1,
@@ -47,11 +47,10 @@ function failedItem(kind, id, reason, detail) {
     };
 }
 function refused(c, reason, detail) {
-    return problem(c, {
-        status: status[reason],
-        title: titleOf(status[reason]),
+    return refusal(c, reason, {
+        statuses: status,
+        otherwise: 500,
         detail: detail === undefined ? details[reason] : `${details[reason]} (${detail})`,
-        extensions: { reason },
     });
 }
 // Settings → Trash: the list, Restore and Delete now, one item or many. The daily purge runs from main.ts.

package/dist/edge/http/tutorial.js

@@ -1,7 +1,7 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { readTutorial, resetTutorial, saveTutorial, tutorialWriteSchema, } from "../../slices/settings/tutorial.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { onInvalid, problem } from "./problem.js";
 // Preserve Hono's inferred route types for the web client.
 export function tutorialRoutes(deps) {
     return new Hono()
@@ -11,7 +11,6 @@ export function tutorialRoutes(deps) {
         if (!result.ok)
             return problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: result.reason === "unreadable"
                     ? "Your saved tutorial progress could not be read. Choose Restart tutorial to start it again."
                     : "Your tutorial progress changed in another tab or window. Reload the page, then try again.",

package/dist/edge/http/tutorials.js

@@ -1,13 +1,8 @@
 import { Hono } from "hono";
 import { tutorialPageIdPattern } from "../../slices/tutorials/anchors.js";
 import { bundledTutorialsDir, loadTutorials, searchTutorials, TutorialsMissing, } from "../../slices/tutorials/library.js";
-import { problem, titleOf } from "./problem.js";
-// A build without its tutorials says so in plain words; anything else is the app's error handler's.
-function missing(c, error) {
-    if (!(error instanceof TutorialsMissing))
-        throw error;
-    return problem(c, { status: 500, title: titleOf(500), detail: error.message });
-}
+import { problem } from "./problem.js";
+import { bundleMissing } from "./refusal.js";
 // Help → Tutorials: the sidebar and page list, a search across every page, and one page's
 // Markdown. The pages ship with the app, so they are read once and kept.
 // Preserve Hono's inferred route types for the web client.
@@ -27,7 +22,7 @@ export function tutorialPagesRoutes(deps) {
             return c.json((await read()).index);
         }
         catch (error) {
-            return missing(c, error);
+            return bundleMissing(c, error, TutorialsMissing);
         }
     })
         .get("/search", async (c) => {
@@ -36,7 +31,7 @@ export function tutorialPagesRoutes(deps) {
             return c.json({ hits: searchTutorials(await read(), query) });
         }
         catch (error) {
-            return missing(c, error);
+            return bundleMissing(c, error, TutorialsMissing);
         }
     })
         .get("/:page", async (c) => {
@@ -46,12 +41,11 @@ export function tutorialPagesRoutes(deps) {
             markdown = tutorialPageIdPattern.test(id) ? (await read()).pages.get(id) : undefined;
         }
         catch (error) {
-            return missing(c, error);
+            return bundleMissing(c, error, TutorialsMissing);
         }
         if (markdown === undefined)
             return problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: `There is no tutorial called ${id} in this version of Slopify. Pick one from the list on Help → Tutorials, or search there.`,
             });
         return c.body(markdown, 200, { "content-type": "text/markdown; charset=utf-8" });

package/dist/edge/http/update.js

@@ -1,5 +1,6 @@
 import { Hono } from "hono";
-import { problem, titleOf } from "./problem.js";
+import { problem } from "./problem.js";
+import { fromSlopifyPage } from "./same-page.js";
 export function updateRoutes(deps) {
     const unavailable = {
         currentVersion: deps.version,
@@ -14,16 +15,16 @@ export function updateRoutes(deps) {
         .get("/ready", (c) => {
         c.header("Cache-Control", "no-store");
         if (!deps.updater?.ready(c.req.header("X-Slopify-Update-Token") ?? ""))
-            return problem(c, { status: 403, title: titleOf(403) });
+            return problem(c, { status: 403 });
         return c.json({ status: "ok", version: deps.version });
     })
         .post("/activate", async (c) => {
         c.header("Cache-Control", "no-store");
         const token = c.req.header("X-Slopify-Update-Token") ?? "";
         if (!deps.updater?.ready(token))
-            return problem(c, { status: 403, title: titleOf(403) });
+            return problem(c, { status: 403 });
         if (!(await deps.updater.activate(token)))
-            return problem(c, { status: 409, title: titleOf(409) });
+            return problem(c, { status: 409 });
         return c.json({ status: "ok", version: deps.version });
     })
         .get("/", async (c) => {
@@ -34,33 +35,27 @@ export function updateRoutes(deps) {
     })
         // Drops an update that is waiting for running work to finish.
         .delete("/", async (c) => {
-        const origin = c.req.header("Origin");
-        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+        if (!fromSlopifyPage(c, deps.remoteAccess?.remoteHost))
             return problem(c, {
                 status: 403,
-                title: titleOf(403),
                 detail: "For your safety, updates can only be changed from the Slopify page itself. Open Slopify and try again there.",
             });
         if (deps.updater?.cancelWaiting() !== true)
             return problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: "No update is waiting to install. Reload the page to see the current update status.",
             });
         return c.json(await deps.updater.check());
     })
         .post("/", async (c) => {
-        const origin = c.req.header("Origin");
-        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+        if (!fromSlopifyPage(c, deps.remoteAccess?.remoteHost))
             return problem(c, {
                 status: 403,
-                title: titleOf(403),
                 detail: "For your safety, updates can only be started from the Slopify page itself. Open Slopify and try again there.",
             });
         if (deps.updater === undefined)
             return problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: unavailable.blockedReason,
             });
         const result = await deps.updater.start();
@@ -69,7 +64,6 @@ export function updateRoutes(deps) {
         const status = result.code ?? 409;
         return problem(c, {
             status,
-            title: titleOf(status),
             detail: result.info.blockedReason ??
                 result.info.error ??
                 "You already have the latest version of Slopify.",

package/dist/edge/http/waveform.js

@@ -1,4 +1,5 @@
-import { problem, titleOf } from "./problem.js";
+import { errorText } from "../../kernel/errors.js";
+import { problem } from "./problem.js";
 // The audio player's waveform: `?waveform=N` on a file's own URL answers the file's loudness
 // as N bars from 0 to 1, instead of the file. The peaks come from the same ffmpeg decode as the
 // live view's waveform (`slices/narration/peaks.ts`), ten a second, folded to N.
@@ -34,19 +35,16 @@ export function waveformAnswer(decode) {
         if (!Number.isInteger(bars) || bars < 1 || bars > waveformBarsMax)
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: `Ask for a waveform of 1 to ${String(waveformBarsMax)} bars.`,
             });
         if (!file.contentType.startsWith("audio/"))
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: "Only an audio file has a waveform. This file plays without one.",
             });
         if (decode === undefined)
             return problem(c, {
                 status: 503,
-                title: titleOf(503),
                 detail: "Slopify can't draw the waveform because ffmpeg isn't available. The audio still plays. Restart Slopify; if it keeps happening, use Download diagnostics in Settings and report it.",
             });
         const key = `${file.path}\0${String(file.bytes)}`;
@@ -58,8 +56,7 @@ export function waveformAnswer(decode) {
             catch (error) {
                 return problem(c, {
                     status: 500,
-                    title: titleOf(500),
-                    detail: `Slopify couldn't read this audio to draw its waveform (${error instanceof Error ? error.message : String(error)}). The audio still plays.`,
+                    detail: `Slopify couldn't read this audio to draw its waveform (${errorText(error)}). The audio still plays.`,
                 });
             }
             cache.set(key, waveform);