@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/edge/http/project-create.js

@@ -0,0 +1,87 @@
+import { modelFields } from "../../catalog/validate.js";
+import { stagesOf } from "../../slices/admission/repo.js";
+import { admit } from "../../slices/admission/rules.js";
+import { startRun } from "../../slices/admission/start.js";
+import { castVoicedRun } from "../../slices/channels/runs.js";
+import { resolveFont } from "../../slices/fonts/index.js";
+import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
+import { stagedFiles } from "../../slices/storage/repo.js";
+import { record } from "../../slices/telemetry/record.js";
+// Starts a project from a whole draft, the way POST /api/projects always has: the prompt
+// bodies are read now, the draft is admitted, the project and its first work are committed in
+// one transaction, and only then is the runner woken. "Make a 60-second short" starts its
+// project through the same door.
+export async function createProject(deps, sent) {
+    // Cast speakers take the cast's voices as they are now, as a run started from Play does.
+    const draft = castVoicedRun(deps.db, sent);
+    if (draft.checkpoints?.length)
+        return {
+            ok: false,
+            status: 409,
+            detail: "This project has checkpoints turned on, so it must be started from Play with Review and start.",
+            fields: [],
+        };
+    const subtitles = draft.subtitles;
+    if (subtitles !== undefined && subtitles.mode !== "off") {
+        try {
+            await resolveFont(deps.paths, subtitles.fontId);
+        }
+        catch {
+            return {
+                ok: false,
+                status: 400,
+                detail: "The subtitle font you picked is no longer available. Choose another font before starting.",
+                fields: [
+                    {
+                        field: "subtitles.fontId",
+                        message: "This font is no longer available. Choose another or upload it again in Settings.",
+                    },
+                ],
+            };
+        }
+    }
+    // The bodies are read here, at the click, so an edit made since the prompt was selected is
+    // the one that runs.
+    const picked = pickTemplates(deps.db, draft);
+    const admitted = admit({
+        draft: picked.draft,
+        staged: stagedFiles(deps.db),
+        requiredSlots: picked.requiredSlots,
+    });
+    const modelErrors = modelFields(picked.draft, deps.catalogue);
+    if (!admitted.ok || picked.missing.length > 0 || modelErrors.length > 0)
+        return {
+            ok: false,
+            status: 400,
+            detail: "This video cannot start yet. Fix the highlighted fields, then try again.",
+            fields: [...picked.missing, ...modelErrors, ...(admitted.ok ? [] : admitted.fields)],
+        };
+    const storage = {
+        catalogue: deps.catalogue,
+        db: deps.db,
+        paths: deps.paths,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        emit: (event) => {
+            deps.hub.emitGlobal(event);
+        },
+    };
+    // Rendered from the values admit() has trimmed, so the stored text carries no padding the
+    // user did not intend.
+    const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values), false, Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])));
+    const telemetry = {
+        db: deps.db,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        appVersion: deps.version,
+    };
+    // One event per project created. record() swallows its own failures, so a broken telemetry
+    // write cannot cost the user the run.
+    record(telemetry, "project.created", {});
+    deps.flushSoon();
+    // The run starts only once the project is committed.
+    deps.runner.tick(project.id);
+    return { ok: true, project, stages: stagesOf(deps.db, project.id) };
+}

package/dist/edge/http/projects.js

@@ -1,21 +1,19 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
-import { modelFields } from "../../catalog/validate.js";
 import { derive, progressOf } from "../../kernel/runner/graph.js";
-import { listProjects, projectById, runDraftSchema, stageStandingsByProject, stagesOf, } from "../../slices/admission/repo.js";
-import { admit } from "../../slices/admission/rules.js";
-import { startRun } from "../../slices/admission/start.js";
+import { listProjects, projectById, projectTrashed, runDraftSchema, stageStandingsByProject, stagesOf, } from "../../slices/admission/repo.js";
+import { defaultChannelId } from "../../slices/channels/model.js";
+import { projectChannels } from "../../slices/channels/repo.js";
 import { withProjectControl } from "../../slices/control/lock.js";
-import { resolveFont } from "../../slices/fonts/index.js";
-import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
 import { resumable } from "../../slices/rebuild/recovery-repo.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
-import { deleteProject } from "../../slices/storage/delete-project.js";
-import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
-import { record } from "../../slices/telemetry/record.js";
+import { outputsOf } from "../../slices/storage/repo.js";
+import { trashProject } from "../../slices/trash/service.js";
+import { uploadedProjects } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
+import { createProject } from "./project-create.js";
 const idParam = z.object({
     id: z
         .string()
@@ -26,28 +24,11 @@ const idParam = z.object({
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function projectRoutes(deps) {
-    const storage = {
-        catalogue: deps.catalogue,
+    const storageForTrash = {
         db: deps.db,
         paths: deps.paths,
-        ids: deps.ids,
         clock: deps.clock,
         log: deps.log,
-        emit: (event) => {
-            deps.hub.emitGlobal(event);
-        },
-    };
-    const telemetry = {
-        db: deps.db,
-        ids: deps.ids,
-        clock: deps.clock,
-        log: deps.log,
-        appVersion: deps.version,
-    };
-    const storageForDelete = {
-        db: deps.db,
-        paths: deps.paths,
-        log: deps.log,
         hasInflight: deps.runner.hasInflight,
     };
     const summarise = (project) => ({
@@ -56,76 +37,33 @@ export function projectRoutes(deps) {
     });
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
-        if (c.req.valid("json").checkpoints?.length)
-            return problem(c, {
-                status: 409,
-                title: titleOf(409),
-                detail: "This project has checkpoints turned on, so it must be started from Play with Review and start.",
-            });
-        const requestedSubtitles = c.req.valid("json").subtitles;
-        if (requestedSubtitles !== undefined && requestedSubtitles.mode !== "off") {
-            try {
-                await resolveFont(deps.paths, requestedSubtitles.fontId);
-            }
-            catch {
-                return problem(c, {
-                    status: 400,
-                    title: titleOf(400),
-                    detail: "The subtitle font you picked is no longer available. Choose another font before starting.",
-                    extensions: {
-                        fields: [
-                            {
-                                field: "subtitles.fontId",
-                                message: "This font is no longer available. Choose another or upload it again in Settings.",
-                            },
-                        ],
-                    },
-                });
-            }
-        }
-        // The bodies are read here, at the click, so an edit made since the
-        // prompt was selected is the one that runs.
-        const picked = pickTemplates(deps.db, c.req.valid("json"));
-        const admitted = admit({
-            draft: picked.draft,
-            staged: stagedFiles(deps.db),
-            requiredSlots: picked.requiredSlots,
-        });
-        const modelErrors = modelFields(picked.draft, deps.catalogue);
-        if (!admitted.ok || picked.missing.length > 0 || modelErrors.length > 0) {
+        const created = await createProject(deps, c.req.valid("json"));
+        if (!created.ok)
             return problem(c, {
-                status: 400,
-                title: titleOf(400),
-                detail: "This video cannot start yet. Fix the highlighted fields, then try again.",
-                extensions: {
-                    fields: [...picked.missing, ...modelErrors, ...(admitted.ok ? [] : admitted.fields)],
-                },
+                status: created.status,
+                title: titleOf(created.status),
+                detail: created.detail,
+                ...(created.fields.length === 0 ? {} : { extensions: { fields: created.fields } }),
             });
-        }
-        // Rendered from the values admit() has trimmed, so the stored text carries no
-        // padding the user did not intend.
-        const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values), false, Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])));
-        // One event per project created. record() swallows its own
-        // failures, so a broken telemetry write cannot cost the user the run.
-        record(telemetry, "project.created", {});
-        deps.flushSoon();
-        // The run starts only once the project is committed.
-        deps.runner.tick(project.id);
         // Read back after the tick, not from the rows startRun built: the runner has
         // already claimed every eligible stage, and a body that paired status "running"
         // with "video: pending" would contradict itself.
-        return c.json({ project: summarise(project), stages: stagesOf(deps.db, project.id) }, 201);
+        return c.json({ project: summarise(created.project), stages: stagesOf(deps.db, created.project.id) }, 201);
     })
         // One statement for every project's stage standings, not one per row: the list needs
         // a status word and a meter, and both come out of the same five columns.
         .get("/", (c) => {
         const standings = stageStandingsByProject(deps.db);
+        const channels = projectChannels(deps.db);
+        const uploads = uploadedProjects(deps.db);
         const projects = listProjects(deps.db).map((project) => {
             const stages = standings.get(project.id) ?? [];
             return {
                 ...project,
                 status: derive(stages, project.paused),
                 progress: progressOf(stages),
+                channelId: channels.get(project.id) ?? defaultChannelId,
+                uploadedAt: uploads.get(project.id) ?? null,
             };
         });
         return c.json({ projects });
@@ -136,7 +74,9 @@ export function projectRoutes(deps) {
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "This project no longer exists. Go back to Projects to pick another.",
+                detail: projectTrashed(deps.db, c.req.valid("param").id)
+                    ? "This project is in the trash. Restore it in Settings → Trash to open it again."
+                    : "This project no longer exists. Go back to Projects to pick another.",
             });
         }
         if (deps.catalogue !== undefined)
@@ -149,30 +89,22 @@ export function projectRoutes(deps) {
             outputs: outputsOf(deps.db, project.id),
         });
     })
-        // Irreversible, and only from the app: the Projects screen puts a confirmation
-        // dialog in front of it.
+        // Moves the project to the trash (Settings → Trash) for 30 days; removing it for good is
+        // Delete now there, or the daily purge (`slices/trash`).
         .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
         const id = c.req.valid("param").id;
         return withProjectControl(deps.db, id, () => {
-            const result = deleteProject(storageForDelete, id);
+            const result = trashProject(storageForTrash, id);
             if (result.ok)
                 return c.body(null, 204);
+            const status = result.reason === "running" ? 409 : 404;
             return problem(c, {
-                status: deleteStatus[result.reason],
-                title: titleOf(deleteStatus[result.reason]),
-                detail: result.detail ?? deleteDetails[result.reason],
+                status,
+                title: titleOf(status),
+                detail: result.reason === "running"
+                    ? "This project is still running. Use Cancel run on the project page first, then delete it."
+                    : "This project no longer exists. Go back to Projects to pick another.",
             });
         });
     }));
 }
-const deleteStatus = {
-    "no-project": 404,
-    running: 409,
-    files: 500,
-};
-const deleteDetails = {
-    "no-project": "This project no longer exists. Go back to Projects to pick another.",
-    // The run has to be stopped before its files can go.
-    running: "This project is still running. Use Cancel run on the project page first, then delete it.",
-    files: "Some of this project's files could not be removed. Close any program using files in the project folder, then try deleting again.",
-};

package/dist/edge/http/prompts.js

@@ -1,9 +1,12 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { versionsOrCurrent } from "../../slices/library/history.js";
 import { promptKinds } from "../../slices/library/model.js";
-import { listPrompts } from "../../slices/library/repo.js";
-import { createPrompt, removePrompt, updatePrompt } from "../../slices/library/save.js";
+import { setPromptPhotorealistic, withPhotorealistic, } from "../../slices/library/photorealistic.js";
+import { listPrompts, promptById } from "../../slices/library/repo.js";
+import { createPrompt, removePrompt, restorePrompt, updatePrompt, } from "../../slices/library/save.js";
+import { usedBy } from "../../slices/library/used-by.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const idParam = z.object({
     id: z
@@ -12,6 +15,8 @@ const idParam = z.object({
         .max(64)
         .regex(/^[0-9A-Za-z_-]+$/),
 });
+// History's Restore names the version by its number.
+export const versionParam = idParam.extend({ version: z.coerce.number().int().positive() });
 // Shape only. The rules - trimming, emptiness, length, the slot lint - are the slice's,
 // so one set of messages reaches the editor.
 const promptBody = z.object({
@@ -26,7 +31,7 @@ export function promptRoutes(deps) {
     return (new Hono()
         // Every kind in one list: 04 Prompts filters by tab, and Duplicate needs the body it
         // is copying.
-        .get("/", (c) => c.json({ prompts: listPrompts(deps.db) }))
+        .get("/", (c) => c.json({ prompts: withPhotorealistic(deps.db, listPrompts(deps.db)) }))
         .post("/", zValidator("json", promptBody, onInvalid), (c) => {
         const result = createPrompt(library, c.req.valid("json"));
         return result.ok ? c.json(result.value, 201) : refused(c, result, "prompt");
@@ -34,6 +39,38 @@ export function promptRoutes(deps) {
         .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", promptBody, onInvalid), (c) => {
         const result = updatePrompt(library, c.req.valid("param").id, c.req.valid("json"));
         return result.ok ? c.json(result.value) : refused(c, result, "prompt");
+    })
+        // An Image prompt's "Draws photorealistic pictures" tick (`slices/library/photorealistic.ts`).
+        .put("/:id/photorealistic", zValidator("param", idParam, onInvalid), zValidator("json", z.object({ photorealistic: z.boolean() }), onInvalid), (c) => {
+        const result = setPromptPhotorealistic(deps.db, c.req.valid("param").id, c.req.valid("json").photorealistic);
+        if (result.ok)
+            return c.body(null, 204);
+        return result.reason === "not-found"
+            ? refused(c, { ok: false, reason: "not-found" }, "prompt")
+            : problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "Only an Image prompt can be marked photorealistic. Open the prompt from the Image tab in Library → Prompts.",
+            });
+    })
+        // Every saved version, newest first (`slices/library/history.ts`).
+        .get("/:id/history", zValidator("param", idParam, onInvalid), (c) => {
+        const prompt = promptById(deps.db, c.req.valid("param").id);
+        return prompt === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "prompt")
+            : c.json({ versions: versionsOrCurrent(deps.db, "prompt", prompt) });
+    })
+        .post("/:id/history/:version/restore", zValidator("param", versionParam, onInvalid), (c) => {
+        const { id, version } = c.req.valid("param");
+        const result = restorePrompt(library, id, version);
+        return result.ok ? c.json(result.value) : refused(c, result, "prompt");
+    })
+        // The templates, schedules and projects that name it.
+        .get("/:id/used-by", zValidator("param", idParam, onInvalid), (c) => {
+        const prompt = promptById(deps.db, c.req.valid("param").id);
+        return prompt === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "prompt")
+            : c.json(usedBy(deps.db, { item: "prompt", kind: prompt.kind, name: prompt.name }));
     })
         // A project holds its own rendered text, so nothing cascades and a
         // template used by past projects is deleted like any other.

package/dist/edge/http/pronunciations.js

@@ -1,17 +1,36 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { aliasCountMax } from "../../kernel/ports/narration-aliases.js";
+import { listNarrationAliases, saveNarrationAliases, } from "../../slices/narration/aliases-library.js";
 import { collectSharedGlossary } from "../../slices/narration/shared-glossary.js";
-import { onInvalid } from "./problem.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
 // The pronunciations of every project's glossary, merged, for Edit project to copy into a
 // project that shares them. `except` leaves out the project being edited, whose own glossary
-// already comes first.
+// already comes first. Library → Aliases lives here too: the other way to change how a word
+// is said.
 export function pronunciationRoutes(deps) {
-    return new Hono().get("/shared", zValidator("query", z.object({
+    const library = { db: deps.db, ids: deps.ids, clock: deps.clock };
+    return (new Hono()
+        .get("/shared", zValidator("query", z.object({
         except: z
             .string()
             .max(64)
             .regex(/^[0-9A-Za-z_-]*$/)
             .optional(),
-    }), onInvalid), (c) => c.json(collectSharedGlossary(deps, c.req.valid("query").except)));
+    }), onInvalid), (c) => c.json(collectSharedGlossary(deps, c.req.valid("query").except)))
+        .get("/aliases", (c) => c.json({ aliases: listNarrationAliases(deps.db) }))
+        // The editor saves the whole ordered list at once; each row is checked in the slice, so
+        // the editor gets "Alias 3: …" sentences rather than schema paths.
+        .put("/aliases", zValidator("json", z.object({ aliases: z.array(z.unknown()).max(aliasCountMax * 2) }), onInvalid), (c) => {
+        const result = saveNarrationAliases(library, c.req.valid("json").aliases);
+        if (result.ok)
+            return c.json({ aliases: result.aliases });
+        return problem(c, {
+            status: 400,
+            title: titleOf(400),
+            detail: `These aliases can't be saved yet: ${result.fields.map((field) => field.message).join(" ")}`,
+            extensions: { fields: result.fields },
+        });
+    }));
 }

package/dist/edge/http/providers.js

@@ -1,8 +1,16 @@
+import { randomUUID } from "node:crypto";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { keyProbes } from "../../adapters/key-probes.js";
 import { videoModelsOf } from "../../catalog/schema.js";
+import { switchAllRetired, switchRetiredModel } from "../../slices/model-upkeep/switch.js";
+import { retiredModelUsage, usageKinds, usageSlots } from "../../slices/model-upkeep/usage.js";
 import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
+import { dismissFirstRun, firstRunStatus } from "../../slices/settings/first-run.js";
+import { checkProviderHealth } from "../../slices/settings/health.js";
+import { keyGuides } from "../../slices/settings/key-guides.js";
+import { testProviderKey } from "../../slices/settings/key-test.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
 import { isLocalCliProvider, providerById, providerIds } from "../../slices/settings/model.js";
 import { createModelCatalog } from "../../slices/settings/models.js";
@@ -14,6 +22,17 @@ const providerParam = z.object({ id: z.enum(providerIds) });
 // ever issues something longer.
 const pathBody = z.object({ path: z.string().max(cliPathMaxLength) });
 const keyBody = z.object({ key: z.string().min(1).max(4096) });
+const modelId = z.string().min(1).max(200);
+const switchBody = z
+    .object({
+    kind: z.enum(usageKinds),
+    id: z.string().min(1).max(64),
+    slot: z.enum(usageSlots),
+    from: z.object({ provider: z.string().min(1).max(64), model: modelId }).strict(),
+    to: modelId,
+})
+    .strict();
+const noFetch = "Slopify cannot reach the internet from here yet because it is still starting. Wait a moment, reload the page and try again.";
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function providerRoutes(deps) {
@@ -29,7 +48,65 @@ export function providerRoutes(deps) {
         now: () => deps.clock.now().getTime(),
         report: (provider) => deps.log.write("warn", "model-catalog", { detail: `Could not load models for ${provider}` }),
     });
+    const upkeep = () => ({ ...deps, uuid: deps.drafts?.uuid ?? randomUUID });
     return (new Hono()
+        // The step lists Settings → Providers shows beside each key field.
+        .get("/key-guides", (c) => c.json({ guides: keyGuides }))
+        // What the first launch found, and the providers Play picks by default.
+        .get("/first-run", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(await firstRunStatus({ db: deps.db, ...(deps.modelsFor === undefined ? {} : { modelsFor: deps.modelsFor }) }, await providerStatuses(readiness)));
+    })
+        .post("/first-run/dismiss", (c) => {
+        dismissFirstRun(deps.db);
+        return c.body(null, 204);
+    })
+        // "Check all": every CLI signed in, every key valid, every chosen model still offered.
+        .post("/health", async (c) => {
+        if (deps.fetch === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        const catalogue = deps.catalogue;
+        return c.json(await checkProviderHealth({
+            ...readiness,
+            clock: deps.clock,
+            fetch: deps.fetch,
+            probes: keyProbes,
+            ...(catalogue === undefined ? {} : { catalogue: () => catalogue.read() }),
+            ...(deps.modelsFor === undefined ? {} : { modelsFor: deps.modelsFor }),
+            ...(deps.cliLogin === undefined ? {} : { login: deps.cliLogin }),
+        }));
+    })
+        // Checks for new, repriced and retired models now instead of waiting for the daily check.
+        .post("/catalogue/check", async (c) => {
+        if (!deps.catalogue?.sync)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "The model list (models.yaml) is not loaded yet. Wait a moment and reload the page; if it stays like this, restart Slopify.",
+            });
+        await deps.catalogue.sync();
+        return c.json(deps.catalogue.status());
+    })
+        // Every template, schedule, draft and unfinished project still using a retired model.
+        .get("/catalogue/retired", (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json({
+            usages: deps.catalogue === undefined ? [] : retiredModelUsage(deps.db, deps.catalogue.read()),
+        });
+    })
+        .post("/catalogue/retired/switch", zValidator("json", switchBody, onInvalid), async (c) => {
+        if (deps.catalogue === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        const result = await switchRetiredModel(upkeep(), deps.catalogue.read(), c.req.valid("json"));
+        if (!result.ok)
+            return problem(c, { status: 409, title: titleOf(409), detail: result.message });
+        return c.json(result);
+    })
+        .post("/catalogue/retired/switch-all", async (c) => {
+        if (deps.catalogue === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        return c.json(await switchAllRetired(upkeep(), deps.catalogue.read()));
+    })
         .get("/catalogue", (c) => c.json(deps.catalogue?.status() ?? {
         warning: "The model list (models.yaml) is not loaded yet. Wait a moment and reload the page; if it stays like this, restart Slopify.",
     }))
@@ -101,6 +178,15 @@ export function providerRoutes(deps) {
         catalog.invalidate(id);
         // The response says a key is stored and shows the mask, never the value.
         return c.json(keyStatus(keys, id));
+    })
+        // The Test button: the cheapest read the provider offers, answered in plain words.
+        .post("/:id/key/test", zValidator("param", providerParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        if (providerById(id).auth === "cli")
+            return refusal(c, id, "cli-provider");
+        if (deps.fetch === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        return c.json(await testProviderKey({ db: deps.db, clock: deps.clock, fetch: deps.fetch, probes: keyProbes }, id));
     })
         .delete("/:id/key", zValidator("param", providerParam, onInvalid), (c) => {
         const { id } = c.req.valid("param");

package/dist/edge/http/reviews.js

@@ -0,0 +1,121 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { revisionControlSchema } from "../../slices/control/revision-control-schema.js";
+import { recoverProject } from "../../slices/rebuild/recovery.js";
+import { actOnVerdict, listVerdicts, verdictById } from "../../slices/reviews/repo.js";
+import { latestReviews } from "../../slices/reviews/view.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
+import { getRevisionView } from "../../slices/revisions/view.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const projectParam = z.object({ id });
+const verdictParam = projectParam.extend({ verdictId: id });
+// The project page's review column: each reviewed item's latest verdict with its reasons,
+// Overrule to accept a failed item as it is, and Redo to have it made again through the
+// same path as More → make it again in its section.
+export function reviewRoutes(deps) {
+    const gone = (c) => problem(c, {
+        status: 404,
+        title: titleOf(404),
+        detail: "This review no longer exists; the project may have been deleted or restored from a backup. Reload the project page.",
+    });
+    const notify = (projectId) => {
+        try {
+            deps.hub.emit(projectId, { type: "project.updated", projectId });
+        }
+        catch (error) {
+            deps.log.write("error", "review.notify", {
+                projectId,
+                detail: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    return new Hono()
+        .get("/:id/reviews", zValidator("param", projectParam, onInvalid), (c) => {
+        const projectId = c.req.valid("param").id;
+        const head = currentRevisionId(deps.db, projectId);
+        const view = head === undefined ? undefined : getRevisionView(deps, projectId, head);
+        const outputs = (view?.outputs ?? [])
+            .filter((row) => row.selected)
+            .map((row) => ({
+            workKey: row.workKey,
+            fingerprint: row.fingerprint,
+            outputId: row.output.id,
+        }));
+        return c.json({ reviews: latestReviews(listVerdicts(deps.db, projectId), outputs) });
+    })
+        .post("/:id/reviews/:verdictId/overrule", zValidator("param", verdictParam, onInvalid), (c) => {
+        const { id: projectId, verdictId } = c.req.valid("param");
+        const result = actOnVerdict(deps.db, projectId, verdictId, "overruled", deps.clock.now().toISOString());
+        if (!result.ok)
+            return result.reason === "not-found"
+                ? gone(c)
+                : problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: "This verdict can't be overruled: it passed, or Slopify is already making the item again. Reload the project page to see where it is.",
+                    extensions: { reason: "conflict" },
+                });
+        notify(projectId);
+        return c.json({ review: result.value });
+    })
+        .post("/:id/reviews/:verdictId/redo", zValidator("param", verdictParam, onInvalid), zValidator("json", revisionControlSchema, onInvalid), async (c) => {
+        const { id: projectId, verdictId } = c.req.valid("param");
+        const verdict = verdictById(deps.db, projectId, verdictId);
+        if (verdict === undefined)
+            return gone(c);
+        if (deps.rebuild === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Redo is not ready yet because Slopify is still starting. Wait a moment, reload the page and try again.",
+            });
+        if (verdict.redoState === "pending" || verdict.redoState === "started")
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Slopify is already making this item again. Wait for it to land, then reload the project page.",
+                extensions: { reason: "conflict" },
+            });
+        const result = await recoverProject(deps.rebuild, projectId, {
+            ...c.req.valid("json"),
+            action: { kind: "redo", item: verdict.itemKey },
+        });
+        if (!result.ok)
+            return refused(c, result, projectId);
+        actOnVerdict(deps.db, projectId, verdictId, "redone", deps.clock.now().toISOString());
+        notify(projectId);
+        return c.json(result, 202);
+    });
+    function refused(c, result, projectId) {
+        const status = result.reason === "no-project"
+            ? 404
+            : result.reason === "invalid-selection" || result.reason === "invalid-edit"
+                ? 400
+                : 409;
+        const lead = result.reason === "running"
+            ? "This item, or work that depends on it, is still running. Wait for it to finish, or Pause the project, then use Redo again."
+            : result.reason === "readiness"
+                ? "Slopify can't make this item again yet. Fix what is listed in Settings → Providers or Edit project, then use Redo again."
+                : result.reason === "conflict" || result.reason === "control-changed"
+                    ? "This project changed since the page loaded. Reload the project page, then use Redo again."
+                    : result.reason === "invalid-selection"
+                        ? "This item can't be made again."
+                        : "Slopify couldn't make this item again.";
+        return problem(c, {
+            status,
+            title: titleOf(status),
+            detail: [lead, ...(result.fields ?? []).map((row) => row.message)].join(" "),
+            extensions: {
+                reason: result.reason,
+                fields: result.fields ?? [],
+                currentRevisionId: currentRevisionId(deps.db, projectId) ?? null,
+            },
+        });
+    }
+}

package/dist/edge/http/revision-files.js

@@ -65,7 +65,7 @@ function unavailable(c, reason) {
         status: 404,
         title: titleOf(404),
         detail: reason === "missing-file"
-            ? "This file was deleted or moved from the project folder. In the Edit tab, use Rebuild affected outputs to make it again."
+            ? "This file was deleted or moved from the project folder. In the Edit tab, use Choose what to remake (in the project's More menu) to make it again."
             : "This file is no longer part of the project. Reload the page to see its current files.",
         extensions: { reason },
     });

package/dist/edge/http/revisions.js

@@ -37,7 +37,7 @@ const details = {
     conflict: "This project changed while you were editing. Reload the page to see the latest, then make your change again.",
     "idempotency-conflict": "This change was already sent with different details. Reload the page, then try again.",
     "invalid-edit": "Some of your changes are not valid. Fix the highlighted fields and save again.",
-    "stale-preview": "What needs rebuilding changed since you opened this review. Cancel it and open Rebuild affected outputs again to see the latest.",
+    "stale-preview": "What needs rebuilding changed since you opened this review. Cancel it and open Choose what to remake (in the project's More menu) again to see the latest.",
     "invalid-selection": "Some of the outputs you picked can no longer be rebuilt. Reload the page and choose again.",
     "review-required": 'This rebuild touches content you supplied yourself. Tick "Keep the provided content" for each item in the review, then choose Start rebuild.',
     "cost-ack-required": "Some costs for this rebuild are unknown. Tick the box confirming you understand, then choose Start rebuild.",