@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/edge/http/drafts.js

@@ -11,9 +11,9 @@ import { draftFileRoutes } from "./draft-files.js";
 import { draftProblem } from "./draft-problem.js";
 import { onInvalid } from "./problem.js";
 const idParam = z.object({ id: z.uuid() });
-const versionBody = discardDraftInputSchema.unwrap().omit({ id: true });
-const saveBody = saveDraftInputSchema.unwrap().omit({ id: true });
-const startBody = versionBody.extend({ reviewId: z.uuid() }).strict();
+export const versionBody = discardDraftInputSchema.unwrap().omit({ id: true });
+export const saveBody = saveDraftInputSchema.unwrap().omit({ id: true });
+export const startBody = versionBody.extend({ reviewId: z.uuid() }).strict();
 const summariesSchema = z
     .object({
     drafts: z.array(z

package/dist/edge/http/entries.js

@@ -7,30 +7,27 @@ import { formerNames } from "../../slices/library/rename.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 { idParam } from "./ids.js";
 import { onInvalid } from "./problem.js";
 // One rule set for prompts and entries, so one refusal mapping too.
 import { refused, versionParam } from "./prompts.js";
-const idParam = z.object({
-    id: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
-});
 const entryBody = z.object({
     category: z.enum(entryCategories),
     mode: z.enum(entryModes),
     name: z.string(),
     body: z.string(),
 });
+// Duplicate names the entry it copies, whose old keyword names the copy may keep.
+const entryCreateBody = entryBody.extend({ copyOf: z.string().min(1).max(100).optional() });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function entryRoutes(deps) {
     const library = { db: deps.db, ids: deps.ids, clock: deps.clock };
     return new Hono()
         .get("/", (c) => c.json({ entries: listEntries(deps.db) }))
-        .post("/", zValidator("json", entryBody, onInvalid), (c) => {
-        const result = createEntry(library, c.req.valid("json"));
+        .post("/", zValidator("json", entryCreateBody, onInvalid), (c) => {
+        const { copyOf, ...draft } = c.req.valid("json");
+        const result = createEntry(library, draft, copyOf);
         return result.ok ? c.json(result.value, 201) : refused(c, result, "entry");
     })
         .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", entryBody, onInvalid), (c) => {

package/dist/edge/http/extension-auth.js

@@ -0,0 +1,27 @@
+import { bearerToken, isExtensionOrigin, studioPairing, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { problem } from "./problem.js";
+// The paired Slopify Studio extension's access to the `/ext` routes: every request carries the
+// pairing token, and the CORS headers name the paired extension's origin, never a web page's
+// and never `*`.
+export function extensionAuth(db) {
+    const allowOrigin = (c, pairing) => {
+        const origin = c.req.header("origin");
+        const paired = studioPairing(db).origin;
+        c.header("Vary", "Origin");
+        if (!isExtensionOrigin(origin))
+            return;
+        if (origin === paired || pairing) {
+            c.header("Access-Control-Allow-Origin", origin);
+            c.header("Access-Control-Allow-Headers", "authorization, content-type");
+            c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+            c.header("Access-Control-Max-Age", "600");
+        }
+    };
+    const allowed = (c) => studioRequestAllowed(db, bearerToken(c.req.header("authorization")), c.req.header("origin"));
+    const refused = (c) => problem(c, {
+        status: 401,
+        title: "Unauthorized",
+        detail: "The Slopify Studio extension isn't paired with this Slopify. Copy the pairing token from Slopify's Settings → YouTube Studio into the extension's options and press Pair.",
+    });
+    return { allowOrigin, allowed, refused };
+}

package/dist/edge/http/external-reviews.js

@@ -7,12 +7,9 @@ import { closedReviewSentences } from "../../slices/reviews/external-model.js";
 import { answerExternalReview } from "../../slices/reviews/external-repo.js";
 import { verdictAnswerSchema, verdictIssue } from "../../slices/reviews/verdict.js";
 import { actorOf } from "./actor.js";
-import { onInvalid, problem, problemFromError, titleOf } from "./problem.js";
-const id = z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(/^[0-9A-Za-z_-]+$/);
+import { idString } from "./ids.js";
+import { onInvalid, problem, problemFromError } from "./problem.js";
+const id = idString;
 const reviewParam = z.object({ id, reviewId: id });
 // A verdict that wasn't saved, what was wrong with it, and the tool and body to send instead.
 // Said before the review is looked up, so it claims nothing about the review: a fixed verdict
@@ -20,7 +17,6 @@ const reviewParam = z.object({ id, reviewId: id });
 function notSaved(c, why) {
     return problem(c, {
         status: 400,
-        title: titleOf(400),
         detail: `The verdict wasn't saved${why}. Call submit_review_verdict again with body {verdict: "pass" | "fail", reasons: ["one short sentence per problem"]} and that fixed; a pass may send reasons: [].`,
         extensions: { reason: "invalid-verdict" },
     });
@@ -30,7 +26,6 @@ function notSaved(c, why) {
 function noVerdict(c) {
     return problem(c, {
         status: 400,
-        title: titleOf(400),
         detail: 'The verdict wasn\'t saved: no verdict came with it. Call submit_review_verdict again with body {verdict: "pass" | "fail", reasons: ["one short sentence per problem"]}; a pass may send reasons: [].',
         extensions: { reason: "invalid-verdict" },
     });
@@ -59,24 +54,30 @@ export function externalReviewRoutes(deps) {
         .post("/:id/external-reviews/:reviewId/verdict", zValidator("param", reviewParam, onInvalid), zValidator("json", verdictAnswerSchema, verdictRefused), async (c) => {
         const { id: projectId, reviewId } = c.req.valid("param");
         const answer = c.req.valid("json");
+        const by = actorOf(c);
+        // The in-app assistant has no review tool; this holds even if one were called.
+        if (by === "assistant")
+            return problem(c, {
+                status: 403,
+                detail: "The assistant can't answer this review: it waits for the agent you connected in Settings → Connections → Agents (MCP). Answer it from that agent, or it passes on its own 2 hours after it began waiting.",
+                extensions: { reason: "assistant" },
+            });
         const result = answerExternalReview(deps.db, {
             projectId,
             id: reviewId,
             verdict: { passed: answer.verdict === "pass", reasons: answer.reasons },
-            by: actorOf(c),
+            by,
             at: deps.clock.now().toISOString(),
         });
         if (!result.ok)
             return result.reason === "not-found"
                 ? problem(c, {
                     status: 404,
-                    title: titleOf(404),
                     detail: "This review doesn't exist: the project may have been deleted. Call needs_attention to see what is waiting now.",
                     extensions: { reason: "not-found" },
                 })
                 : problem(c, {
                     status: 409,
-                    title: titleOf(409),
                     detail: `The verdict wasn't saved. ${closedReviewSentences[result.reason]}`,
                     extensions: { reason: result.reason },
                 });

package/dist/edge/http/files.js

@@ -3,19 +3,13 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { findDownload, imagesZip } from "../../slices/storage/downloads.js";
 import { fileResponse } from "./byte-range.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { projectIdParam } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
 import { waveformAnswer } from "./waveform.js";
-const projectParam = z.object({
-    projectId: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
-});
-const setParam = projectParam.extend({
+const setParam = projectIdParam.extend({
     set: z.enum(["images.zip", "thumbnails.zip", "shorts.zip"]),
 });
-const assetParam = projectParam.extend({
+const assetParam = projectIdParam.extend({
     asset: z
         .string()
         .min(1)
@@ -79,5 +73,5 @@ function missing(c, reason) {
         "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] });
+    return problem(c, { status: 404, detail: details[reason] });
 }

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

@@ -1,7 +1,7 @@
 import { lstat } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { folderReplySchema } from "./folder-location-schema.js";
-import { problem, titleOf } from "./problem.js";
+import { problem } from "./problem.js";
 export async function replyForFolder(c, deps, projectId, file) {
     c.header("Cache-Control", "no-store");
     if (deps.folderLocation?.container) {
@@ -9,7 +9,6 @@ export async function replyForFolder(c, deps, projectId, file) {
         if (!host)
             return problem(c, {
                 status: 503,
-                title: titleOf(503),
                 detail: "Slopify cannot show where this file is on your computer because its Docker project folder was not set up. You can still use the download buttons, or run the Slopify Docker launcher again to set up the folder.",
             });
         try {
@@ -45,7 +44,6 @@ 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 More → make it again in its section on the project page to make the file again.",
             });
         }
@@ -63,7 +61,6 @@ export async function replyForFolder(c, deps, projectId, file) {
         });
         return problem(c, {
             status: 503,
-            title: titleOf(503),
             detail: "Slopify could not open a file manager window on the computer it runs on. Make sure you are signed in to that computer's desktop, or use the download buttons instead.",
         });
     }

package/dist/edge/http/fonts.js

@@ -16,14 +16,12 @@ export function fontsRoutes(deps) {
         if (contentType === undefined || !contentType.toLowerCase().startsWith("multipart/form-data"))
             return problem(c, {
                 status: 415,
-                title: titleOf(415),
                 detail: "The font was not sent as a file. Reload the page and choose a .ttf or .otf file again.",
             });
         const body = c.req.raw.body;
         if (body === null)
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: "No font file arrived. Choose a .ttf or .otf file and try again.",
             });
         const part = await readUpload(contentType, body);
@@ -46,7 +44,6 @@ export function fontsRoutes(deps) {
         if (!result.success)
             return problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This font no longer exists; it may have been deleted. Reload the page to see your current fonts.",
             });
         return undefined;
@@ -64,7 +61,6 @@ export function fontsRoutes(deps) {
                 throw error;
             return problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This font no longer exists; it may have been deleted. Reload the page to see your current fonts.",
             });
         }
@@ -140,19 +136,16 @@ function failure(reason) {
         case "unsupported-format":
             return {
                 status: 415,
-                title: titleOf(415),
                 detail: "Slopify only accepts .ttf or .otf font files. Choose a file with one of those endings.",
             };
         case "unsafe-filename":
             return {
                 status: 400,
-                title: titleOf(400),
                 detail: "The font's file name contains characters Slopify cannot use. Rename the file on your computer, then upload it again.",
             };
         case "invalid-font":
             return {
                 status: 400,
-                title: titleOf(400),
                 detail: "This file is not a valid TrueType (.ttf) or OpenType (.otf) font; it may be damaged. Download the font again or choose another.",
             };
     }

package/dist/edge/http/home.js

@@ -1,28 +1,55 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { snoozeDays } from "../../slices/autopilot/model.js";
+import { setWeeklyNotify, snoozeWarning, weeklyNotifyOf } from "../../slices/autopilot/repo.js";
+import { autopilotView } from "../../slices/autopilot/signals.js";
 import { weekSummary } from "../../slices/run-cost/week.js";
+import { notReadySentence, runnableTemplate } from "../../slices/template-studio/schedule-gate.js";
 import { markUploaded, setAside } from "../../slices/uploads/repo.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { idParam, idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
 const weekQuery = z.object({
     since: z.iso.datetime({ offset: true }),
-    channelId: z.string().min(1).max(64).optional(),
+    channelId: idString.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 catalogue = deps.catalogue;
+    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));
-    });
+    })
+        // How far ahead the content is and what may stop the schedules, from the database now
+        // and the hourly check's last answers: it never asks a CLI or waits for one.
+        .get("/autopilot", zValidator("query", channelQuery, onInvalid), (c) => c.json(autopilotView({
+        db: deps.db,
+        clock: deps.clock,
+        // What the schedules actually run (`template-studio/schedule-gate.ts`).
+        template: (id) => runnableTemplate(deps.db, id),
+        notReady: (id) => notReadySentence(deps.db, id),
+        ...(catalogue === undefined ? {} : { catalogue: () => catalogue.read() }),
+    }, deps.autopilot?.latest(), c.req.valid("query").channelId)))
+        // Hide: the warning stays hidden for a week, or until it changes.
+        .post("/autopilot/snooze", zValidator("json", snoozeBody, onInvalid), (c) => {
+        const { key } = c.req.valid("json");
+        const until = new Date(deps.clock.now().valueOf() + snoozeDays * 24 * 60 * 60_000);
+        snoozeWarning(deps.db, key, until);
+        return c.json({ key, until: until.toISOString() });
+    })
+        // Settings → Notifications' Weekly report.
+        .get("/autopilot/weekly", (c) => c.json({ enabled: weeklyNotifyOf(deps.db) }))
+        .put("/autopilot/weekly", zValidator("json", weeklyBody, onInvalid), (c) => {
+        const { enabled } = c.req.valid("json");
+        setWeeklyNotify(deps.db, enabled);
+        return c.json({ enabled });
+    }));
 }
-const idParam = z.object({
-    id: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
-});
+const channelQuery = z.object({ channelId: idString.optional() });
+const snoozeBody = z.object({ key: z.string().min(1).max(300) }).strict();
+const weeklyBody = z.object({ enabled: z.boolean() }).strict();
 // Home's "Mark uploaded" and its undo. Slopify never uploads, so this only records what the
 // person says they did.
 export function uploadedRoutes(deps) {
@@ -33,7 +60,6 @@ export function uploadedRoutes(deps) {
         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({ setAside: c.req.valid("json").setAside });
@@ -43,7 +69,6 @@ export function uploadedRoutes(deps) {
         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

@@ -4,6 +4,7 @@ import { bodyLimit } from "hono/body-limit";
 import { stream } from "hono/streaming";
 import { z } from "zod";
 import { sniffImage } from "../../adapters/image/bytes.js";
+import { internalError } from "../../kernel/errors.js";
 import { redact } from "../../kernel/log.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";
@@ -137,7 +138,7 @@ export function hostCliRoutes(options) {
         onError: (c) => c.json({
             type: "error",
             kind: "unavailable",
-            message: "Slopify hit an internal error (a request to the helper on your computer was too large). Try again; if it keeps happening, use Download diagnostics in Settings and report it.",
+            message: internalError("a request to the helper on your computer was too large"),
         }, 413),
     }));
     app.get("/v1/status/:provider", async (c) => {
@@ -149,7 +150,7 @@ export function hostCliRoutes(options) {
         if (Buffer.byteLength(text) > bridgeLimits.status)
             throw providerError({
                 kind: "unavailable",
-                message: "Slopify hit an internal error (the helper on your computer sent a status report that was too large). Try again; if it keeps happening, use Download diagnostics in Settings and report it.",
+                message: internalError("the helper on your computer sent a status report that was too large"),
             });
         return c.json(status);
     });
@@ -163,7 +164,7 @@ export function hostCliRoutes(options) {
         if (Buffer.byteLength(JSON.stringify(result)) > bridgeLimits.models)
             throw providerError({
                 kind: "unavailable",
-                message: "Slopify hit an internal error (the helper on your computer sent a model list that was too large). Try again; if it keeps happening, use Download diagnostics in Settings and report it.",
+                message: internalError("the helper on your computer sent a model list that was too large"),
             });
         return c.json(result);
     });
@@ -202,11 +203,11 @@ export function hostCliRoutes(options) {
                             ? { 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.");
+                        throw new Error(internalError("the AI tool on your computer sent a reply Slopify could not read"));
                     const frame = `${JSON.stringify(parsed)}\n`;
                     total += Buffer.byteLength(frame);
                     if (Buffer.byteLength(frame) > bridgeLimits.frame || total > bridgeLimits.stream)
-                        throw new Error("Slopify hit an internal error (the AI tool on your computer sent a reply that was too large). Try again; if it keeps happening, use Download diagnostics in Settings and report it.");
+                        throw new Error(internalError("the AI tool on your computer sent a reply that was too large"));
                     await output.write(frame);
                     signal.throwIfAborted();
                     done = parsed.type === "done";
@@ -238,7 +239,7 @@ export function hostCliRoutes(options) {
         const signal = AbortSignal.any([job.signal, controller.signal]);
         const timer = setTimeout(() => controller.abort(), agentImageTimeoutMs);
         try {
-            const { reference, thinking, cast: bridgedCast, ...rest } = body.data;
+            const { reference, thinking, cast: bridgedCast, edit: bridgedEdit, ...rest } = body.data;
             const cast = bridgedCast?.map((member) => ({
                 name: member.name,
                 description: member.description,
@@ -257,17 +258,26 @@ export function hostCliRoutes(options) {
                 };
             if (image !== undefined && sniffImage(image.bytes) !== image.mime)
                 return invalid(c);
+            const source = bridgedEdit === undefined
+                ? undefined
+                : {
+                    bytes: new Uint8Array(Buffer.from(bridgedEdit.source.base64, "base64")),
+                    mime: bridgedEdit.source.mime,
+                };
+            if (source !== undefined && sniffImage(source.bytes) !== source.mime)
+                return invalid(c);
             const result = await ports.image.generate({
                 ...rest,
                 ...(thinking === undefined ? {} : { thinking }),
                 ...(image === undefined ? {} : { reference: image }),
                 ...(cast === undefined ? {} : { cast }),
+                ...(source === undefined ? {} : { edit: { source } }),
                 signal,
             });
             if (signal.aborted)
                 throw providerError({ kind: "unavailable", message: unavailable });
             if (result.bytes.byteLength > bridgeLimits.image || sniffImage(result.bytes) !== result.mime)
-                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.");
+                throw new Error(internalError("the image made on your computer was too large or not a valid image"));
             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.
@@ -328,6 +338,6 @@ function invalid(c) {
     return c.json({
         type: "error",
         kind: "unavailable",
-        message: "Slopify hit an internal error (the helper on your computer received a request it could not read). Try again; if it keeps happening, use Download diagnostics in Settings and report it.",
+        message: internalError("the helper on your computer received a request it could not read"),
     }, 400);
 }

package/dist/edge/http/ids.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const idString = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+export const idParam = z.object({ id: idString });
+export const projectIdParam = z.object({ projectId: idString });

package/dist/edge/http/keywords.js

@@ -0,0 +1,35 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { projectById, projectTrashed } from "../../slices/admission/repo.js";
+import { projectChannelId } from "../../slices/channels/repo.js";
+import { keywordFactsFor } from "../../slices/keywords/facts.js";
+import { costLabel, placeLabels } from "../../slices/keywords/model.js";
+import { keywordSpecs } from "../../slices/keywords/specs.js";
+import { projectIdParam } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+// The keywords Slopify fills, as the editor's Insert bar and agents read them, and a project's
+// facts copied again for Edit project's Refresh keyword facts.
+export function keywordRoutes(deps) {
+    return new Hono()
+        .get("/", (c) => c.json({
+        keywords: keywordSpecs.map((spec) => ({
+            ...spec,
+            cost: { kind: spec.cost, label: costLabel(spec.cost) },
+            places: spec.places.map((place) => ({ place, label: placeLabels[place] })),
+        })),
+    }))
+        .get("/facts/:projectId", zValidator("param", projectIdParam, onInvalid), (c) => {
+        const { projectId } = c.req.valid("param");
+        const project = projectById(deps.db, projectId);
+        if (project === undefined)
+            return problem(c, {
+                status: 404,
+                detail: projectTrashed(deps.db, projectId)
+                    ? "This project is in the trash. Restore it in Settings → Trash, then refresh its keyword facts."
+                    : "This project no longer exists. Go back to Projects to pick another.",
+            });
+        return c.json({
+            keywordFacts: keywordFactsFor(deps, { ...project.config, channelId: projectChannelId(deps.db, projectId) }, deps.clock.now(), projectId),
+        });
+    });
+}

package/dist/edge/http/model-checks.js

@@ -0,0 +1,132 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { errorText } from "../../kernel/errors.js";
+import { providerFamilies } from "../../kernel/ports/model.js";
+import { autoModes } from "../../slices/model-checks/model.js";
+import { accountOf, markNoticesSeen, writeAuto } from "../../slices/model-checks/repo.js";
+import { dollarsText } from "../../slices/model-checks/rules.js";
+import { providerById, providerIds } from "../../slices/settings/model.js";
+import { onInvalid, problem } from "./problem.js";
+const providerParam = z.object({ id: z.enum(providerIds) });
+const modelList = z.string().min(1).max(200);
+const estimateQuery = z.object({ models: z.string().max(10_000).optional() });
+export const checkBody = z
+    .object({
+    models: z.array(modelList).max(300).optional(),
+    confirmedDollars: z.number().finite().nonnegative().optional(),
+})
+    .strict();
+const dismissBody = z
+    .object({
+    keys: z
+        .array(z
+        .object({
+        provider: z.string().min(1).max(64),
+        family: z.enum(providerFamilies),
+        model: modelList,
+    })
+        .strict())
+        .max(500),
+})
+    .strict();
+const autoBody = z.object({ auto: z.enum(autoModes) }).strict();
+const notReady = "Model checks are not ready yet because Slopify is still starting. Wait a moment, reload the page and try again.";
+export function estimateOf(plan) {
+    return {
+        count: plan.targets.length,
+        totalDollars: plan.totalDollars,
+        unpriced: plan.unpriced,
+        planAccounts: plan.planAccounts,
+        text: dollarsText(plan.totalDollars, plan.unpriced),
+        skipped: plan.skipped.map((one) => ({ model: one.model.model, reason: one.reason })),
+    };
+}
+function unavailable(c) {
+    return problem(c, { status: 503, detail: notReady });
+}
+function noAccount(c, id) {
+    const { displayName, auth } = providerById(id);
+    return problem(c, {
+        status: 400,
+        detail: auth === "key"
+            ? `No ${displayName} key is saved, so its models can't be checked. Paste a key in Settings → Providers → ${displayName} and choose Save, then choose Check models in Settings → Models.`
+            : `${displayName} is not set up, so its models can't be checked. Set it up in Settings → Providers, then choose Check models in Settings → Models.`,
+    });
+}
+// The provider-scoped half: its estimate and its Check models button.
+export function providerCheckRoutes(deps) {
+    const checks = () => deps.modelChecks;
+    const models = (raw) => raw === undefined || raw.trim() === ""
+        ? undefined
+        : raw
+            .split(",")
+            .map((one) => one.trim())
+            .filter(Boolean);
+    return new Hono()
+        .get("/:id/models/check/estimate", zValidator("param", providerParam, onInvalid), zValidator("query", estimateQuery, onInvalid), async (c) => {
+        const service = checks();
+        if (service === undefined)
+            return unavailable(c);
+        const { id } = c.req.valid("param");
+        if (accountOf(deps.db, id) === undefined)
+            return noAccount(c, id);
+        c.header("Cache-Control", "no-store");
+        const plan = await service.plan({
+            trigger: "manual",
+            provider: id,
+            models: models(c.req.valid("query").models),
+        });
+        return c.json({ provider: id, ...estimateOf(plan) });
+    })
+        .post("/:id/models/check", zValidator("param", providerParam, onInvalid), zValidator("json", checkBody, onInvalid), async (c) => {
+        const service = checks();
+        if (service === undefined)
+            return unavailable(c);
+        const { id } = c.req.valid("param");
+        if (accountOf(deps.db, id) === undefined)
+            return noAccount(c, id);
+        const body = c.req.valid("json");
+        const name = providerById(id).displayName;
+        const answer = await service.start({ trigger: "manual", provider: id, models: body.models }, body.confirmedDollars);
+        if (!answer.ok && answer.reason === "running")
+            return problem(c, {
+                status: 409,
+                detail: `Slopify is already checking ${name}'s models. Wait for it to finish, then choose Check models again in Settings → Models.`,
+            });
+        if (!answer.ok) {
+            const estimate = estimateOf(answer.plan);
+            return problem(c, {
+                status: 409,
+                detail: `Checking ${String(estimate.count)} ${name} model${estimate.count === 1 ? "" : "s"} costs ${estimate.text} at list price, and nothing was sent yet. Choose Check models in Settings → Models again and confirm the estimate to go ahead.`,
+                extensions: { estimate },
+            });
+        }
+        void answer.done.catch((error) => {
+            deps.log.write("warn", "model-checks", {
+                detail: `${id}: ${errorText(error)}`,
+            });
+        });
+        return c.json({ provider: id, started: true, ...estimateOf(answer.plan) }, 202);
+    });
+}
+// Settings → Models: what each provider's checks found, New for you, and Automatic checks.
+export function modelCheckRoutes(deps) {
+    return new Hono()
+        .get("/", (c) => {
+        const service = deps.modelChecks;
+        if (service === undefined)
+            return unavailable(c);
+        c.header("Cache-Control", "no-store");
+        return c.json(service.overview());
+    })
+        .post("/notices/dismiss", zValidator("json", dismissBody, onInvalid), (c) => {
+        markNoticesSeen(deps.db, c.req.valid("json").keys);
+        return c.body(null, 204);
+    })
+        .put("/auto", zValidator("json", autoBody, onInvalid), (c) => {
+        const { auto } = c.req.valid("json");
+        writeAuto(deps.db, auto);
+        return c.json({ auto });
+    });
+}