@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/edge/http/channels.js

@@ -0,0 +1,128 @@
+import { randomUUID } from "node:crypto";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { z } from "zod";
+import { deleteCastImage, generateCastImage, uploadCastImage, } from "../../slices/channels/cast-images.js";
+import { castImageMaxBytes } from "../../slices/channels/images.js";
+import { imageBlob } from "../../slices/channels/repo.js";
+import { createCastMember, createChannel, deleteCastMember, deleteChannel, listChannels, moveTemplate, readChannel, setChannelAiDisclosure, updateCastMember, updateChannel, } from "../../slices/channels/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({ id: z.uuid() });
+const memberParam = z.object({ memberId: z.uuid() });
+const imageParam = memberParam.extend({ imageId: z.uuid() });
+const pictureParam = z.object({ sha256: z.string().regex(/^[0-9a-f]{64}$/) });
+const templateParam = z.object({ templateId: z.uuid() });
+// Channels: the channels, their brand kit, series brief and cast, and which channel
+// each template belongs to. The bodies are checked by the slice, so a refusal names the field.
+export function channelRoutes(deps) {
+    const service = {
+        db: deps.db,
+        clock: deps.clock,
+        uuid: randomUUID,
+        generateImage: deps.generateCastImage,
+        log: deps.log,
+    };
+    return (new Hono()
+        .get("/", (c) => c.json({ channels: listChannels(service) }))
+        .post("/", async (c) => {
+        const result = createChannel(service, await body(c));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        // The pictures by content hash: they never change, so the browser may keep them.
+        .get("/pictures/:sha256", zValidator("param", pictureParam, onInvalid), (c) => {
+        const blob = imageBlob(deps.db, c.req.valid("param").sha256);
+        if (blob === undefined)
+            return refused(c, { ok: false, reason: "not-found" });
+        return c.body(new Uint8Array(blob.bytes), 200, {
+            "Content-Type": blob.mime,
+            "Cache-Control": "private, max-age=31536000, immutable",
+            "X-Content-Type-Options": "nosniff",
+        });
+    })
+        .put("/templates/:templateId", zValidator("param", templateParam, onInvalid), async (c) => {
+        const result = moveTemplate(service, c.req.valid("param").templateId, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/cast/:memberId", zValidator("param", memberParam, onInvalid), async (c) => {
+        const result = updateCastMember(service, c.req.valid("param").memberId, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .delete("/cast/:memberId", zValidator("param", memberParam, onInvalid), (c) => {
+        const result = deleteCastMember(service, c.req.valid("param").memberId);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        // The picture's bytes are the body, as the file input read them.
+        .post("/cast/:memberId/images", zValidator("param", memberParam, onInvalid), bodyLimit({
+        maxSize: castImageMaxBytes,
+        onError: (c) => refused(c, {
+            ok: false,
+            reason: "not-an-image",
+            message: `This picture is larger than ${String(castImageMaxBytes / 1024 / 1024)} MB. Save it smaller (for example as a JPEG) and upload it again.`,
+        }),
+    }), async (c) => {
+        const bytes = new Uint8Array(await c.req.arrayBuffer());
+        const result = uploadCastImage(service, c.req.valid("param").memberId, bytes);
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .post("/cast/:memberId/generate", zValidator("param", memberParam, onInvalid), async (c) => {
+        const result = generateCastImage(service, c.req.valid("param").memberId, await body(c));
+        return result.ok ? c.json(result.value, 202) : refused(c, result);
+    })
+        .delete("/cast/:memberId/images/:imageId", zValidator("param", imageParam, onInvalid), (c) => {
+        const { memberId, imageId } = c.req.valid("param");
+        const result = deleteCastImage(service, memberId, imageId);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        .get("/:id", zValidator("param", idParam, onInvalid), (c) => {
+        const result = readChannel(service, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/:id", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = updateChannel(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/:id/ai-disclosure", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = setChannelAiDisclosure(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
+        const result = deleteChannel(service, c.req.valid("param").id);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        .post("/:id/cast", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = createCastMember(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    }));
+}
+async function body(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+const details = {
+    "not-found": "This channel, cast member or picture no longer exists; it may have been deleted in another tab. Go back to Channels.",
+    conflict: "This changed in another tab while you were editing. Reload the page to see the latest, then make your change again.",
+    "invalid-input": "Some of these settings are not valid. Check the highlighted fields and try again.",
+    "default-channel": "The default channel can't be deleted; projects and templates without a channel belong to it. Rename it in its Brand tab instead.",
+    "has-templates": "This channel still has templates. Move them to another channel in its Templates tab, or delete them, then delete the channel.",
+    "not-an-image": "This file is not a PNG or JPEG picture. Upload a PNG or JPEG file.",
+    "too-many-images": "This cast member already has the most pictures it can keep. Delete one first.",
+    "no-image-provider": "Slopify can't make pictures here yet. Set up an image provider in Settings → Providers, or upload a picture instead.",
+};
+function refused(c, result) {
+    const status = result.reason === "not-found"
+        ? 404
+        : result.reason === "conflict" || result.reason === "has-templates"
+            ? 409
+            : 400;
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: result.message ?? details[result.reason],
+        extensions: { reason: result.reason },
+    });
+}

package/dist/edge/http/entries.js

@@ -1,12 +1,14 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { versionsOrCurrent } from "../../slices/library/history.js";
 import { entryCategories, entryModes } from "../../slices/library/model.js";
-import { listEntries } from "../../slices/library/repo.js";
-import { createEntry, removeEntry, updateEntry } from "../../slices/library/save.js";
+import { entryById, listEntries } from "../../slices/library/repo.js";
+import { createEntry, removeEntry, restoreEntry, updateEntry } from "../../slices/library/save.js";
+import { usedBy } from "../../slices/library/used-by.js";
 import { onInvalid } from "./problem.js";
 // One rule set for prompts and entries, so one refusal mapping too.
-import { refused } from "./prompts.js";
+import { refused, versionParam } from "./prompts.js";
 const idParam = z.object({
     id: z
         .string()
@@ -33,6 +35,23 @@ export function entryRoutes(deps) {
         .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", entryBody, onInvalid), (c) => {
         const result = updateEntry(library, c.req.valid("param").id, c.req.valid("json"));
         return result.ok ? c.json(result.value) : refused(c, result, "entry");
+    })
+        .get("/:id/history", zValidator("param", idParam, onInvalid), (c) => {
+        const entry = entryById(deps.db, c.req.valid("param").id);
+        return entry === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "entry")
+            : c.json({ versions: versionsOrCurrent(deps.db, "entry", entry) });
+    })
+        .post("/:id/history/:version/restore", zValidator("param", versionParam, onInvalid), (c) => {
+        const { id, version } = c.req.valid("param");
+        const result = restoreEntry(library, id, version);
+        return result.ok ? c.json(result.value) : refused(c, result, "entry");
+    })
+        .get("/:id/used-by", zValidator("param", idParam, onInvalid), (c) => {
+        const entry = entryById(deps.db, c.req.valid("param").id);
+        return entry === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "entry")
+            : c.json(usedBy(deps.db, { item: "entry", category: entry.category, name: entry.name }));
     })
         .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
         const result = removeEntry(library, c.req.valid("param").id);

package/dist/edge/http/files.js

@@ -60,7 +60,7 @@ function missing(c, reason) {
     const details = {
         "unknown-project": "This project no longer exists. Go back to Projects to pick another.",
         "unknown-asset": "This project has no file by that name. Reload the page to see its current files.",
-        "missing-file": "This file was deleted or moved from the project folder. Use Re-run section on the project page to make it again.",
+        "missing-file": "This file was deleted or moved from the project folder. Use More → make it again in its section on the project page to make it again.",
         "no-images": "This project has no images or thumbnail yet. Wait for the Images step to finish, then try again.",
     };
     return problem(c, { status: 404, title: titleOf(404), detail: details[reason] });

package/dist/edge/http/folder-location.js

@@ -46,7 +46,7 @@ export async function replyForFolder(c, deps, projectId, file) {
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "This output's folder was deleted or moved. Use Re-run section on the project page to make the file again.",
+                detail: "This output's folder was deleted or moved. Use More → make it again in its section on the project page to make the file again.",
             });
         }
     }

package/dist/edge/http/home.js

@@ -0,0 +1,39 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { weekSummary } from "../../slices/run-cost/week.js";
+import { markUploaded } from "../../slices/uploads/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const weekQuery = z.object({
+    since: z.iso.datetime({ offset: true }),
+    channelId: z.string().min(1).max(64).optional(),
+});
+// Home's "This week": videos made, spend and the API equivalent since `since` (the browser's
+// own Monday), for one channel or all of them, and where each CLI plan's windows stand.
+export function homeRoutes(deps) {
+    return new Hono().get("/week", zValidator("query", weekQuery, onInvalid), (c) => {
+        const { since, channelId } = c.req.valid("query");
+        return c.json(weekSummary(deps.db, new Date(since).toISOString(), channelId));
+    });
+}
+const idParam = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+// Home's "Mark uploaded" and its undo. Slopify never uploads, so this only records what the
+// person says they did.
+export function uploadedRoutes(deps) {
+    return new Hono().put("/:id/uploaded", zValidator("param", idParam, onInvalid), zValidator("json", z.object({ uploaded: z.boolean() }).strict(), onInvalid), (c) => {
+        const result = markUploaded(deps.db, c.req.valid("param").id, c.req.valid("json").uploaded, deps.clock.now().toISOString());
+        if (!result.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This project no longer exists. Go back to Projects to pick another.",
+            });
+        return c.json({ uploadedAt: result.uploadedAt });
+    });
+}

package/dist/edge/http/host-cli.js

@@ -5,7 +5,7 @@ import { stream } from "hono/streaming";
 import { z } from "zod";
 import { sniffImage } from "../../adapters/image/bytes.js";
 import { redact } from "../../kernel/log.js";
-import { bridgeLimits, HostFolderRefused, hostCliIds, hostCliProtocol, hostFrameSchema, hostImageSchema, hostLlmIds, hostLlmSchema, hostModelsSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
+import { bridgeLimits, encodeHostImageReport, HostFolderRefused, hostCliIds, hostCliProtocol, hostDoneFrame, hostFrameSchema, hostFramesHeader, hostImageReportHeader, hostImageSchema, hostLlmIds, hostLlmSchema, hostModelsSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
 import { agentImageTimeoutMs } from "../../kernel/ports/image.js";
 import { isProviderError, providerError } from "../../kernel/ports/model.js";
 export function hostGate() {
@@ -49,7 +49,7 @@ export function hostGate() {
         },
     };
 }
-const unavailable = "The AI command-line tool on your computer stopped before it finished, so this result is uncertain. Check the section's outputs on the project page, then use Retry stage.";
+const unavailable = "The AI command-line tool on your computer stopped before it finished, so this result is uncertain. Check the section's outputs on the project page, then use Try again.";
 function fault(error, token) {
     return {
         type: "error",
@@ -90,7 +90,7 @@ export function hostCliRoutes(options) {
             return c.json({
                 type: "error",
                 kind: "unavailable",
-                message: "The Slopify helper on your computer is busy or restarting. Wait a moment, then use Retry stage.",
+                message: "The Slopify helper on your computer is busy or restarting. Wait a moment, then use Try again.",
             }, 503);
         const outgoing = c.env?.outgoing;
         let responseEnded = !outgoing;
@@ -174,6 +174,8 @@ export function hostCliRoutes(options) {
         const body = hostLlmSchema.safeParse(await json(c.req.raw));
         if (!body.success)
             return invalid(c);
+        // An app that sends no header reads the original frames (version 1).
+        const frames = Number(c.req.header(hostFramesHeader) ?? 1);
         const job = c.get("job");
         job.holdStream();
         const controller = new AbortController();
@@ -191,7 +193,14 @@ export function hostCliRoutes(options) {
                     signal.throwIfAborted();
                     clearTimeout(timer);
                     timer = setTimeout(() => controller.abort(), 120_000);
-                    const parsed = hostFrameSchema.parse(event);
+                    // The cached-token count, the answering model and the plan windows cross only to
+                    // an app that asked for frame version 2; an older app rejects fields it does not
+                    // know. Typed-ahead text stays here: the bridge carries the committed answer only.
+                    const parsed = hostFrameSchema.parse(event.type === "done"
+                        ? hostDoneFrame(event, frames)
+                        : event.type === "partial"
+                            ? { type: "activity" }
+                            : event);
                     if (done || parsed.type === "error")
                         throw new Error("Slopify hit an internal error (the AI tool on your computer sent a reply Slopify could not read). Try again; if it keeps happening, use Download diagnostics in Settings and report it.");
                     const frame = `${JSON.stringify(parsed)}\n`;
@@ -229,7 +238,17 @@ export function hostCliRoutes(options) {
         const signal = AbortSignal.any([job.signal, controller.signal]);
         const timer = setTimeout(() => controller.abort(), agentImageTimeoutMs);
         try {
-            const { reference, thinking, ...rest } = body.data;
+            const { reference, thinking, cast: bridgedCast, ...rest } = body.data;
+            const cast = bridgedCast?.map((member) => ({
+                name: member.name,
+                description: member.description,
+                images: member.images.map((picture) => ({
+                    bytes: new Uint8Array(Buffer.from(picture.base64, "base64")),
+                    mime: picture.mime,
+                })),
+            }));
+            if (cast?.some((member) => member.images.some((picture) => sniffImage(picture.bytes) !== picture.mime)))
+                return invalid(c);
             const image = reference === undefined
                 ? undefined
                 : {
@@ -242,6 +261,7 @@ export function hostCliRoutes(options) {
                 ...rest,
                 ...(thinking === undefined ? {} : { thinking }),
                 ...(image === undefined ? {} : { reference: image }),
+                ...(cast === undefined ? {} : { cast }),
                 signal,
             });
             if (signal.aborted)
@@ -250,6 +270,10 @@ export function hostCliRoutes(options) {
                 throw new Error("Slopify hit an internal error (the image made on your computer was too large or not a valid image). Try again; if it keeps happening, use Download diagnostics in Settings and report it.");
             c.header("Content-Type", result.mime);
             c.header("Content-Length", String(result.bytes.byteLength));
+            // Any app may get this: one from before it ignores headers it does not know.
+            const report = encodeHostImageReport(result);
+            if (report !== undefined)
+                c.header(hostImageReportHeader, report);
             return c.body(new Uint8Array(result.bytes));
         }
         catch (error) {

package/dist/edge/http/narration-peaks.js

@@ -0,0 +1,76 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { narrationAudio } from "../../slices/narration/peaks.js";
+import { assetPath } from "../../slices/revisions/mutation-assets.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
+import { getRevisionView } from "../../slices/revisions/view.js";
+import { outputPath } from "../../slices/storage/layout.js";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const projectParam = z.object({
+    projectId: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+// ceiling: a few projects' worth of pieces. An asset never changes, so a cached row is never
+// stale; the oldest goes first.
+const cachedPieces = 400;
+// The live view's waveform: the peaks of every finished narration piece of the current
+// version, fetched again each time a `narration.piece` event says one landed.
+export function narrationPeakRoutes(deps) {
+    const cache = new Map();
+    return new Hono().get("/:projectId/narration/peaks", zValidator("param", projectParam, onInvalid), async (c) => {
+        const { projectId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This project no longer exists. Go back to Projects to pick another.",
+            });
+        c.header("Cache-Control", "no-store");
+        const revisionId = currentRevisionId(deps.db, projectId);
+        const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
+        if (revisionId === undefined || view === undefined)
+            return c.json({
+                revisionId: null,
+                complete: false,
+                pieces: [],
+            });
+        const decode = deps.decodePeaks;
+        if (decode === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify can't draw the narration waveform because ffmpeg isn't available. Restart Slopify; if it keeps happening, use Download diagnostics in Settings and report it.",
+            });
+        const audio = narrationAudio(view);
+        const pieces = [];
+        for (const piece of audio.pieces) {
+            let peaks = cache.get(piece.assetId);
+            if (peaks === undefined) {
+                try {
+                    peaks = await decode(outputPath(deps.paths, projectId, assetPath(deps, projectId, piece.assetId)), c.req.raw.signal);
+                }
+                catch (error) {
+                    deps.log.write("warn", "narration.peaks", {
+                        projectId,
+                        stage: "audio",
+                        detail: error instanceof Error ? error.message : String(error),
+                    });
+                    continue;
+                }
+                cache.set(piece.assetId, peaks);
+                while (cache.size > cachedPieces) {
+                    const oldest = cache.keys().next().value;
+                    if (oldest !== undefined)
+                        cache.delete(oldest);
+                }
+            }
+            pieces.push({ key: piece.key, seconds: peaks.seconds, peaks: peaks.peaks });
+        }
+        return c.json({ revisionId, complete: audio.complete, pieces });
+    });
+}

package/dist/edge/http/onboarding.js

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { loudnessOfDefault } from "../../slices/loudness/model.js";
+import { firstRunView } from "../../slices/onboarding/first-run.js";
+import { installPack } from "../../slices/onboarding/install.js";
+import { quickShortInputSchema, sampleCopyInputSchema } from "../../slices/onboarding/model.js";
+import { packById, starterSet } from "../../slices/onboarding/packs.js";
+import { planShortProviders, shortDraft } from "../../slices/onboarding/quick-short.js";
+import { copySample, restoreSamples, sampleProjectIds, } from "../../slices/onboarding/sample.js";
+import { dismissFirstRun, recordShortRequest, shortRequestProject, } from "../../slices/onboarding/state.js";
+import { readSettings } from "../../slices/settings/playback.js";
+import { providerStatuses } from "../../slices/settings/readiness.js";
+import { listVoices } from "../../slices/settings/repo.js";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+import { createProject } from "./project-create.js";
+const packParam = z.object({ id: z.string().min(1).max(40) });
+// The first five minutes: the first-run screen's state, starter packs, "Make a 60-second
+// short" and the bundled samples' Restore and Make my own copy.
+export function onboardingRoutes(deps) {
+    const statuses = () => providerStatuses({ db: deps.db, probe: deps.probe, hostCliStatus: deps.hostCliStatus });
+    const templates = { ...deps, uuid: randomUUID };
+    const sample = {
+        db: deps.db,
+        paths: deps.paths,
+        clock: deps.clock,
+        ids: deps.ids,
+        log: deps.log,
+        appVersion: deps.version,
+        hasInflight: deps.runner.hasInflight,
+        ...(deps.sampleArchives === undefined ? {} : { archives: deps.sampleArchives }),
+    };
+    return new Hono()
+        .get("/", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(firstRunView(deps.db, await statuses(), deps.clock.now().toISOString()));
+    })
+        .post("/dismiss", (c) => {
+        dismissFirstRun(deps.db, deps.clock.now().toISOString());
+        return c.json({ dismissed: true });
+    })
+        .post("/packs/:id", zValidator("param", packParam, onInvalid), (c) => {
+        const installed = installPack(templates, c.req.valid("param").id);
+        if (!installed.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
+            });
+        return c.json(installed.value);
+    })
+        .post("/short", zValidator("json", quickShortInputSchema, onInvalid), async (c) => {
+        const input = c.req.valid("json");
+        const earlier = shortRequestProject(deps.db, input.requestId);
+        if (earlier !== undefined && projectTitle(deps.db, earlier) !== undefined)
+            return c.json({ projectId: earlier, replayed: true });
+        const pack = input.packId === undefined ? starterSet : packById(input.packId);
+        if (pack === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
+            });
+        const modelsFor = deps.modelsFor;
+        if (modelsFor === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify can't list the models on this machine right now. Restart Slopify and try again.",
+            });
+        const plan = await planShortProviders({
+            statuses: await statuses(),
+            voices: listVoices(deps.db),
+            modelsFor,
+            suggested: pack.voice,
+        });
+        if (!plan.ok)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: plan.gaps.map((gap) => gap.message).join(" "),
+                extensions: { gaps: plan.gaps },
+            });
+        const installed = installPack(templates, pack.id, { template: false });
+        if (!installed.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
+            });
+        const created = await createProject(deps, shortDraft({
+            topic: input.topic,
+            pack,
+            names: installed.value.prompts,
+            providers: plan.providers,
+            loudness: loudnessOfDefault(readSettings({ db: deps.db, log: deps.log }).loudness),
+        }));
+        if (!created.ok)
+            return problem(c, {
+                status: created.status,
+                title: titleOf(created.status),
+                detail: `${created.detail} ${created.fields.map((field) => field.message).join(" ")}`.trim(),
+                ...(created.fields.length === 0 ? {} : { extensions: { fields: created.fields } }),
+            });
+        recordShortRequest(deps.db, input.requestId, created.project.id);
+        return c.json({ projectId: created.project.id, replayed: false }, 201);
+    })
+        .get("/sample", (c) => {
+        const samples = sampleProjectIds(deps.db);
+        return c.json({ projectId: samples.library, samples });
+    })
+        .post("/sample/restore", async (c) => {
+        const restored = await restoreSamples(sample);
+        if (!restored.ok)
+            return problem(c, {
+                status: restored.status,
+                title: titleOf(restored.status),
+                detail: restored.detail,
+            });
+        return c.json({ projectId: restored.samples.library, samples: restored.samples });
+    })
+        .post("/sample/copy", async (c) => {
+        // Which sample to copy is in the body; without one, the Library of Alexandria.
+        const body = await c.req.json().catch(() => ({}));
+        const input = sampleCopyInputSchema.safeParse(body ?? {});
+        if (!input.success)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "Slopify couldn't tell which sample to copy. Reload the page and try again.",
+            });
+        const catalogue = deps.catalogue;
+        const id = input.data.projectId ?? sampleProjectIds(deps.db).library ?? undefined;
+        if (catalogue === undefined || id === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "The sample project isn't here. Bring it back with Settings → Backup & storage → Restore samples, then press Make my own copy.",
+            });
+        const copied = copySample({ ...sample, catalogue: catalogue.read() }, id);
+        if (!copied.ok)
+            return problem(c, {
+                status: copied.status,
+                title: titleOf(copied.status),
+                detail: copied.detail,
+            });
+        deps.hub.emitGlobal({ type: "project.updated", projectId: copied.projectId });
+        return c.json({ projectId: copied.projectId }, 201);
+    });
+}

package/dist/edge/http/open-folder.js

@@ -41,7 +41,7 @@ export function openFolderRoutes(deps) {
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "This output's file was deleted or moved. Use Re-run section on the project page to make it again.",
+                detail: "This output's file was deleted or moved. Use More → make it again in its section on the project page to make it again.",
             });
         }
         return replyForFolder(c, deps, id, download.download.path);

package/dist/edge/http/patch-notes.js

@@ -0,0 +1,45 @@
+import { Hono } from "hono";
+import { bundledPatchNotesDir, PatchNotesMissing, readPatchNote, } from "../../slices/patch-notes/library.js";
+import { markPatchNotesSeen, readPatchNotes } from "../../slices/patch-notes/seen.js";
+import { problem, titleOf } from "./problem.js";
+// A build without its notes says so in plain words; anything else is the app's error handler's.
+function missing(c, error) {
+    if (!(error instanceof PatchNotesMissing))
+        throw error;
+    return problem(c, { status: 500, title: titleOf(500), detail: error.message });
+}
+// Settings → Patch notes: the list (with which note is due to open by itself), one note's
+// Markdown, and recording that the note that opened by itself was closed.
+// Preserve Hono's inferred route types for the web client.
+export function patchNotesRoutes(deps) {
+    const dir = deps.patchNotesDir ?? bundledPatchNotesDir();
+    return new Hono()
+        .get("/", async (c) => {
+        try {
+            return c.json(await readPatchNotes(deps.db, dir, deps.version));
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+    })
+        .post("/seen", (c) => {
+        markPatchNotesSeen(deps.db, deps.version);
+        return c.json({ seen: true });
+    })
+        .get("/:id", async (c) => {
+        let markdown;
+        try {
+            markdown = await readPatchNote(dir, c.req.param("id"));
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+        if (markdown === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "These patch notes are not in this version of Slopify. Open Settings → Patch notes and pick one from the list.",
+            });
+        return c.body(markdown, 200, { "content-type": "text/markdown; charset=utf-8" });
+    });
+}

package/dist/edge/http/planning.js

@@ -5,6 +5,7 @@ import { modelFields } from "../../catalog/validate.js";
 import { runDraftSchema } from "../../slices/admission/repo.js";
 import { admit } from "../../slices/admission/rules.js";
 import { batchExists, enqueueBatch, pumpQueue, queueEntries } from "../../slices/batch/index.js";
+import { castVoicedRun } from "../../slices/channels/runs.js";
 import { estimateRun } from "../../slices/estimate/index.js";
 import { resolveFont } from "../../slices/fonts/index.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
@@ -32,8 +33,9 @@ export function planningRoutes(deps) {
             title: item.title,
             values: { ...input.draft.values, ...item.values },
         })) ?? [input.draft];
-        return drafts.map((draft, index) => {
-            const picked = pickTemplates(deps.db, draft);
+        return drafts.map((sent, index) => {
+            // Cast speakers take the cast's voices as they are now, as a run started from Play does.
+            const picked = pickTemplates(deps.db, castVoicedRun(deps.db, sent));
             const admitted = admit({
                 draft: picked.draft,
                 staged: stagedFiles(deps.db),