@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/library/rename.js

@@ -1,8 +1,12 @@
 // Renaming a Library prompt or intro/outro. Everything names the Library by name, so a rename
-// rewrites the name where a future run reads it: each live template's current version (its
-// form and the copy it saved of the Library) and every Play draft still being edited.
-// Schedules run their template as it is now, so they follow. A project revision is the record
-// of what its run used and keeps the old name; "Used by" finds it through `formerNames`.
+// rewrites the name where a future run reads it: every version of every template (its form and
+// the copy it saved of the Library) and every Play draft still being edited. Every version, not
+// only the newest: a gated template's schedules run its newest ready version (`template-studio/
+// gate.ts`), Export pack carries that one, a version's samples stay current only while the
+// versions since differ in what they changed, and a trashed template or an old version can be
+// put back. The name is a pointer, so rewriting it changes nothing a version means. A project
+// revision is the record of what its run used and keeps the old name; "Used by" finds it
+// through `formerNames`.
 import { z } from "zod";
 import { renamedIn } from "./used-by.js";
 const documentRow = z.object({ key: z.string(), version: z.number(), document_json: z.string() });
@@ -56,9 +60,7 @@ export function renameReferences(db, ref, id, to) {
     if (ref.name === to)
         return;
     const templates = db
-        .prepare(`SELECT t.id AS key,r.version,r.document_json FROM project_templates t
-       JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version
-       WHERE t.deleted_at IS NULL`)
+        .prepare("SELECT template_id AS key,version,document_json FROM project_template_revisions")
         .all()
         .map((row) => documentRow.parse(row));
     const updateTemplate = db.prepare("UPDATE project_template_revisions SET document_json=? WHERE template_id=? AND version=?");

package/dist/slices/library/save.js

@@ -8,8 +8,10 @@ import { lintEntry, lintPrompt } from "./lint.js";
 import { entryCategories, promptKinds } from "./model.js";
 import { renameReferences } from "./rename.js";
 import { entryById, insertEntry, insertPrompt, promptById, replaceEntry, replacePrompt, trashEntry, trashPrompt, } from "./repo.js";
-export function createPrompt(deps, draft) {
-    const fields = lintPrompt(draft);
+// Duplicate names the prompt it copies (`copyOf`): a copy of one saved before the `Slopify_`
+// prefix was reserved keeps the names that one already has, as an edit of it would.
+export function createPrompt(deps, draft, copyOf) {
+    const fields = lintPrompt(draft, copyOf === undefined ? [] : (promptById(deps.db, copyOf)?.slots ?? []));
     if (fields.length > 0) {
         return { ok: false, reason: "invalid", fields };
     }
@@ -21,8 +23,10 @@ export function createPrompt(deps, draft) {
     }, prompt);
 }
 // A save replaces the row whole and keeps what was saved as a new version (`history.ts`).
-export function updatePrompt(deps, id, draft, restoredFrom) {
-    const fields = lintPrompt(draft);
+export function updatePrompt(deps, id, draft, restoredFrom, 
+// Slot names a restored version had, which it may keep like the stored prompt's.
+restoredSlots = []) {
+    const fields = lintPrompt(draft, [...(promptById(deps.db, id)?.slots ?? []), ...restoredSlots]);
     if (fields.length > 0) {
         return { ok: false, reason: "invalid", fields };
     }
@@ -47,7 +51,7 @@ export function restorePrompt(deps, id, version) {
     const kind = promptKinds.find((one) => one === saved?.kind);
     if (saved === undefined || kind === undefined || promptById(deps.db, id) === undefined)
         return { ok: false, reason: "not-found" };
-    return updatePrompt(deps, id, { kind, name: saved.name, body: saved.body }, version);
+    return updatePrompt(deps, id, { kind, name: saved.name, body: saved.body }, version, detectSlots(saved.body).names);
 }
 // Delete moves the prompt to the trash with its history; Settings → Trash puts it back or
 // removes it for good (`slices/trash`).
@@ -56,8 +60,8 @@ export function removePrompt(deps, id) {
         ? { ok: true, value: null }
         : { ok: false, reason: "not-found" };
 }
-export function createEntry(deps, draft) {
-    const fields = lintEntry(draft);
+export function createEntry(deps, draft, copyOf) {
+    const fields = lintEntry(draft, copyOf === undefined ? [] : (entryById(deps.db, copyOf)?.slots ?? []));
     if (fields.length > 0) {
         return { ok: false, reason: "invalid", fields };
     }
@@ -68,8 +72,8 @@ export function createEntry(deps, draft) {
         return true;
     }, entry);
 }
-export function updateEntry(deps, id, draft, restoredFrom) {
-    const fields = lintEntry(draft);
+export function updateEntry(deps, id, draft, restoredFrom, restoredSlots = []) {
+    const fields = lintEntry(draft, [...(entryById(deps.db, id)?.slots ?? []), ...restoredSlots]);
     if (fields.length > 0) {
         return { ok: false, reason: "invalid", fields };
     }
@@ -95,7 +99,7 @@ export function restoreEntry(deps, id, version) {
         saved.mode === null ||
         entryById(deps.db, id) === undefined)
         return { ok: false, reason: "not-found" };
-    return updateEntry(deps, id, { category, mode: saved.mode, name: saved.name, body: saved.body }, version);
+    return updateEntry(deps, id, { category, mode: saved.mode, name: saved.name, body: saved.body }, version, detectSlots(saved.body).names);
 }
 export function removeEntry(deps, id) {
     return trashEntry(deps.db, id, deps.clock.now().toISOString())

package/dist/slices/library/slots.js

@@ -4,8 +4,10 @@
 // is the one that runs.
 import { normaliseDraft, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { collectFields, render } from "../admission/substitute.js";
+import { keywordUsesOf, placedProblems, textEntryProblems, } from "../keywords/rules.js";
 import { reviewPromptKey } from "../reviews/model.js";
 import { activeReviewStages } from "../reviews/rules.js";
+import { socialPlatforms } from "../social/model.js";
 import { usesScriptPrompt } from "../voices/model.js";
 import { snapshotEntry, snapshotPrompt } from "./snapshot.js";
 export function pickTemplates(db, input, snapshot) {
@@ -16,40 +18,63 @@ export function pickTemplates(db, input, snapshot) {
     // entries. A prompt left selected on a stage set to Provide asks for no field.
     const text = [];
     const image = [];
+    // Each picked body with the field that picked it and where it runs, for the keyword checks.
+    const placed = [];
+    const body = (kind, name, field, into, key) => {
+        const at = into.length;
+        pickBody(db, kind, name, field, missing, into, key, snapshot);
+        const picked = into[at];
+        if (picked !== undefined)
+            placed.push({ field, place: kind, body: picked.body });
+    };
     if (sources.article === "generate") {
-        body(db, usesScriptPrompt(draft) ? "script" : "article", draft.articlePrompt, "articlePrompt", missing, text, "article", snapshot);
+        body(usesScriptPrompt(draft) ? "script" : "article", draft.articlePrompt, "articlePrompt", text, "article");
     }
     const intro = pickEntry(db, "intro", draft.intro, missing, snapshot);
     if (usesNarrationPreparation(draft))
-        body(db, "narration", draft.narrationPrompt, "narrationPrompt", missing, text, "narration", snapshot);
+        body("narration", draft.narrationPrompt, "narrationPrompt", text, "narration");
     const outro = pickEntry(db, "outro", draft.outro, missing, snapshot);
     push(text, "intro", intro);
     push(text, "outro", outro);
+    if (intro !== undefined)
+        placed.push({ field: "intro", place: "intro", body: intro.body });
+    if (outro !== undefined)
+        placed.push({ field: "outro", place: "outro", body: outro.body });
+    for (const entry of [intro, outro])
+        if (entry?.mode === "text")
+            missing.push(...textEntryProblems(entry.body, entry.category));
     // None picked is the built-in prompt, which asks for no keyword.
     if (usesYoutubeDescription(draft))
-        body(db, "description", draft.descriptionPrompt, "descriptionPrompt", missing, text, "description", snapshot);
+        body("description", draft.descriptionPrompt, "descriptionPrompt", text, "description");
     // The Shorts step's two prompts; none picked is the built-in one, which asks for no keyword.
     if (usesShorts(draft)) {
-        body(db, "shorts", draft.shorts?.prompt, "shorts.prompt", missing, text, "shorts", snapshot);
-        body(db, "image", draft.shorts?.imagePrompt, "shorts.imagePrompt", missing, image, "shortsImage", snapshot);
+        body("shorts", draft.shorts?.prompt, "shorts.prompt", text, "shorts");
+        body("image", draft.shorts?.imagePrompt, "shorts.imagePrompt", image, "shortsImage");
     }
     // Each reviewed stage's Review prompt; none picked is the stage's built-in one.
     for (const stage of activeReviewStages(draft))
-        body(db, "review", draft.reviews?.stages[stage]?.prompt, `reviews.stages.${stage}.prompt`, missing, text, reviewPromptKey(stage), snapshot);
+        body("review", draft.reviews?.stages[stage]?.prompt, `reviews.stages.${stage}.prompt`, text, reviewPromptKey(stage));
+    // Each site's post prompt, for the sites whose post is written by one; none picked is the
+    // built-in one, which asks for no keyword.
+    for (const platform of socialPlatforms) {
+        const choice = draft.social?.[platform];
+        if (choice?.text === "prompt")
+            body("post", choice.prompt, `social.${platform}.prompt`, text, `social.${platform}`);
+    }
     // The establishing image's prompt: an image prompt like the others, its keywords filled the
     // same way.
     if (usesReference(draft) && draft.reference?.source === "prompt")
-        body(db, "image", draft.reference.prompt, "reference.prompt", missing, image, "referencePrompt", snapshot);
+        body("image", draft.reference.prompt, "reference.prompt", image, "referencePrompt");
     if (sources.images === "generate") {
         for (const [index, picked] of draft.imagePrompts.entries()) {
             const field = `imagePrompts.${String(index)}.name`;
-            body(db, "image", picked.name, field, missing, image, `imagePrompts.${String(index)}`, snapshot);
+            body("image", picked.name, field, image, `imagePrompts.${String(index)}`);
         }
     }
     // Both Generate modes read the same thumbnail template; Prompt by LLM sends it as the
     // instruction rather than to the image provider.
     if (sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") {
-        body(db, "thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", missing, image, "thumbnailPrompt", snapshot);
+        body("thumbnail", draft.thumbnailPrompt, "thumbnailPrompt", image, "thumbnailPrompt");
     }
     const fields = collectFields(
     // The title's keywords are asked for like a prompt's: it is filled when the run starts.
@@ -58,7 +83,8 @@ export function pickTemplates(db, input, snapshot) {
         draft: withSavedModes(draft, intro, outro),
         requiredSlots: fields.map((field) => field.name),
         bodies: [...text, ...image],
-        missing,
+        missing: [...missing, ...placedProblems(placed, draft.values)],
+        keywordUses: keywordUsesOf(placed),
     };
 }
 // Every picked body rendered once, with the trimmed values
@@ -70,7 +96,7 @@ export function renderPicked(picked, values) {
     }
     return rendered;
 }
-function body(db, kind, name, field, missing, into, key, snapshot) {
+function pickBody(db, kind, name, field, missing, into, key, snapshot) {
     // An unpicked prompt is admission's rule to state ("Pick an article prompt."), so this
     // says nothing about it and the form marks the field once.
     if (name === undefined || name.trim() === "") {

package/dist/slices/library/transfer.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { errorText } from "../../kernel/errors.js";
 import { documentThemeNameMax } from "../document/model.js";
 import { documentThemeSchema } from "../document/theme-schema.js";
 import { narrationAliasSchema } from "../narration/aliases-schema.js";
@@ -202,7 +203,7 @@ export async function importEach(items, options) {
                     break;
             }
             catch (error) {
-                reason = error instanceof Error ? error.message : String(error);
+                reason = errorText(error);
                 break;
             }
         }

package/dist/slices/library/used-by.js

@@ -5,6 +5,8 @@
 // `snapshot.ts` use.
 import { z } from "zod";
 import { liveProject } from "../admission/repo.js";
+import { runnableVersion } from "../template-studio/gate.js";
+import { gatesOf, notTemplateSample } from "../template-studio/repo.js";
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -40,6 +42,8 @@ function slotsIn(value, ref) {
             return field(shorts, "prompt");
         case "review":
             return Object.values(record(record(value.reviews)?.stages) ?? {}).flatMap((stage) => field(record(stage), "prompt"));
+        case "post":
+            return Object.values(record(value.social) ?? {}).flatMap((one) => field(record(one), "prompt"));
         case "image":
             return [
                 ...(Array.isArray(value.imagePrompts) ? value.imagePrompts : []).flatMap((one) => field(record(one), "name")),
@@ -106,18 +110,28 @@ export function usedBy(db, ref, formerNames = []) {
         const parsed = templateRow.parse(row);
         return matches(formOf(parsed.document_json)) ? [{ id: parsed.id, name: parsed.name }] : [];
     });
-    // A schedule runs its template as it is now (`schedules/scheduler.ts`), so the template's
-    // current version is what it uses.
+    // A schedule runs the version of its template the studio gate lets it run
+    // (`template-studio/schedule-gate.ts`), which can be older than the newest one.
+    const runsOf = new Map();
+    const formRun = (templateId, head) => {
+        if (!runsOf.has(templateId)) {
+            const version = runnableVersion(gatesOf(db, templateId), head) ?? head;
+            const row = db
+                .prepare("SELECT document_json FROM project_template_revisions WHERE template_id=? AND version=?")
+                .get(templateId, version);
+            runsOf.set(templateId, row === undefined ? undefined : formOf(String(row.document_json)));
+        }
+        return runsOf.get(templateId);
+    };
     const schedules = db
-        .prepare(`SELECT s.id,s.name,s.status,r.document_json FROM schedules s
+        .prepare(`SELECT s.id,s.name,s.status,s.template_id,t.head_version FROM schedules s
        JOIN project_templates t ON t.id=s.template_id
-       JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version
-       WHERE s.deleted_at IS NULL AND s.status IN ('active','paused') AND ${mentions("r.document_json")}
+       WHERE s.deleted_at IS NULL AND s.status IN ('active','paused') AND s.template_kind='project'
        ORDER BY lower(s.name),s.id`)
-        .all(...plain)
+        .all()
         .flatMap((row) => {
         const parsed = scheduleRow.parse(row);
-        return matches(formOf(parsed.document_json))
+        return matches(formRun(parsed.template_id, parsed.head_version))
             ? [{ id: parsed.id, name: parsed.name, status: parsed.status }]
             : [];
     });
@@ -126,7 +140,7 @@ export function usedBy(db, ref, formerNames = []) {
         (SELECT count(*) FROM project_revisions x WHERE x.project_id=r.project_id) AS total
        FROM project_revisions r JOIN projects p ON p.id=r.project_id
        LEFT JOIN project_heads h ON h.project_id=r.project_id
-       WHERE ${liveProject("p")} AND ${mentions("r.config")}
+       WHERE ${liveProject("p")} AND ${notTemplateSample("p")} AND ${mentions("r.config")}
        ORDER BY p.created_at DESC,p.id,r.created_at`)
         .all(...plain)
         .map((row) => revisionRow.parse(row));
@@ -146,7 +160,7 @@ export function usedBy(db, ref, formerNames = []) {
     // A project from before revisions existed has none yet; its own config is what it ran with.
     for (const row of db
         .prepare(`SELECT p.id,p.title,p.config FROM projects p
-       WHERE ${liveProject("p")}
+       WHERE ${liveProject("p")} AND ${notTemplateSample("p")}
        AND NOT EXISTS (SELECT 1 FROM project_revisions r WHERE r.project_id=p.id)
        AND ${mentions("p.config")} ORDER BY p.created_at DESC,p.id`)
         .all(...plain)
@@ -167,7 +181,8 @@ const scheduleRow = z.object({
     id: z.string(),
     name: z.string(),
     status: z.string(),
-    document_json: z.string(),
+    template_id: z.string(),
+    head_version: z.number(),
 });
 const revisionRow = z.object({
     project_id: z.string(),

package/dist/slices/loudness/loudnorm.js

@@ -1,4 +1,4 @@
-import { renameSync } from "node:fs";
+import { renameSync, rmSync } from "node:fs";
 import { z } from "zod";
 import { runFfmpeg } from "../video/ffmpeg.js";
 // ceiling: below -70 LUFS (the filter's absolute gate) or under 0.4 s (one measuring block)
@@ -89,6 +89,7 @@ export async function measure(run, input, goal, chain = "") {
         args: measureArgs(input, goal, chain),
         signal: run.signal,
         log: run.log,
+        priority: run.priority,
         onProgress: () => { },
         onStderr: (text) => {
             stderr += text;
@@ -109,8 +110,15 @@ export async function normalizeFile(run, input, output, goal, format) {
     // The channels are set before anything is measured: a stereo file mixed down to mono is
     // louder per channel (the mix keeps its loudness, so each sample is about 3 dB higher), and
     // the gain and the peak ceiling have to hold for what is written.
-    const channels = `aformat=channel_layouts=${format.channels === 1 ? "mono" : "stereo"}`;
-    const measured = await measure(run, ["-i", input], goal, channels);
+    const measured = await measure(run, ["-i", input], goal, channelsOf(format));
+    await writeLevelled(run, input, output, goal, measured, format);
+    return measured;
+}
+function channelsOf(format) {
+    return `aformat=channel_layouts=${format.channels === 1 ? "mono" : "stereo"}`;
+}
+// `input` written to `output` with the gain that takes `measured` to `goal` (`gainFilter`).
+async function writeLevelled(run, input, output, goal, measured, format) {
     await runFfmpeg({
         bin: run.bin,
         args: [
@@ -125,7 +133,7 @@ export async function normalizeFile(run, input, output, goal, format) {
             "-map",
             "0:a:0",
             "-af",
-            `${channels},${gainFilter(goal, measured, format.sampleRate)}`,
+            `${channelsOf(format)},${gainFilter(goal, measured, format.sampleRate)}`,
             "-c:a",
             "pcm_f32le",
             "-f",
@@ -134,23 +142,55 @@ export async function normalizeFile(run, input, output, goal, format) {
         ],
         signal: run.signal,
         log: run.log,
+        priority: run.priority,
         onProgress: () => { },
     });
-    return measured;
 }
 // ceiling: within a fifth of a LU of the level no one hears the difference.
 const correctAbove = 0.2;
-// One file brought to `goal` (`normalizeFile`), measured again, and corrected once when the
-// limiter left it more than a fifth of a LU under the level. Returns the first measurement and
-// the last.
+// ceiling: two corrections land a voice whose peaks stand 17 dB over its loudness (raw TTS)
+// within a few tenths of a LU; a third would only chase the last tenth.
+const corrections = 2;
+// ceiling: the most gain a correction adds over the plain gain. Past it the limiter would
+// flatten the voice; the file lands short instead, and its report says how far.
+const extraGainMax = 6;
+// One file brought to `goal` (`normalizeFile`), measured again, and corrected when the limiter
+// left it more than a fifth of a LU under the level. Each correction writes the input again
+// with more gain (so the limiter holds the peaks once, never twice), the gain found from the
+// levels the earlier gains gave. Returns the first measurement and the last.
 export async function levelFile(run, input, output, goal, format) {
     const before = await normalizeFile(run, input, output, goal, format);
     let after = await measureFile(run, output, goal);
-    if (measurable(after) && Math.abs(after.integrated - goal.lufs) > correctAbove) {
+    if (!measurable(before))
+        return { before, after };
+    const plain = goal.lufs - before.integrated;
+    const tried = [
+        { gain: plain, lufs: after.integrated },
+    ];
+    for (let pass = 0; pass < corrections; pass += 1) {
+        if (!measurable(after) || Math.abs(after.integrated - goal.lufs) <= correctAbove)
+            break;
+        const last = tried[tried.length - 1];
+        const prior = tried[tried.length - 2];
+        if (last === undefined)
+            break;
+        const slope = prior === undefined || last.lufs === prior.lufs
+            ? 1
+            : (last.lufs - prior.lufs) / (last.gain - prior.gain);
+        const gain = Math.min(plain + extraGainMax, last.gain + (goal.lufs - last.lufs) / (slope > 0.05 ? slope : 1));
+        if (Math.abs(gain - last.gain) < 0.05)
+            break;
         const corrected = `${output}.corrected.wav`;
-        await normalizeFile(run, output, corrected, goal, format);
+        await writeLevelled(run, input, corrected, { ...goal, lufs: before.integrated + gain }, before, format);
+        const next = await measureFile(run, corrected, goal);
+        // A correction that landed further off than the file it would replace is dropped.
+        if (Math.abs(next.integrated - goal.lufs) >= Math.abs(after.integrated - goal.lufs)) {
+            rmSync(corrected, { force: true });
+            break;
+        }
         renameSync(corrected, output);
-        after = await measureFile(run, output, goal);
+        after = next;
+        tried.push({ gain, lufs: next.integrated });
     }
     return { before, after };
 }

package/dist/slices/model-checks/cost.js

@@ -0,0 +1,61 @@
+import { isVideoModel } from "../../catalog/schema.js";
+import { priceCall } from "../run-cost/pricing.js";
+import { isLocalCliProvider, systemVoiceProvider } from "../settings/model.js";
+// ceiling: an automatic check may cost at most this much per call (decision 1). Anything
+// dearer - and every image - waits for Check models and a confirmed estimate.
+export const automaticCeilingDollars = 0.001;
+// What a check is assumed to use before it runs: a short prompt and a one-word reply, two
+// characters of speech, one small image.
+const assumed = { tokensIn: 40, tokensOut: 40, characters: 2, images: 1 };
+export function isVideoTarget(catalogue, target) {
+    return (target.family === "image" &&
+        catalogue.image.some((row) => row.provider === target.provider && row.id === target.model && isVideoModel(row)));
+}
+export function costOf(catalogue, target) {
+    if (target.provider === systemVoiceProvider)
+        return { dollars: 0, planUsage: false };
+    if (isLocalCliProvider(target.provider))
+        return { dollars: 0, planUsage: true };
+    return { dollars: priced(catalogue, target, assumed), planUsage: false };
+}
+// What a finished check cost, from what it reported; the estimate when it reported nothing.
+export function spentOn(catalogue, target, use) {
+    if (isLocalCliProvider(target.provider) || target.provider === systemVoiceProvider)
+        return 0;
+    const reported = use === null
+        ? null
+        : priced(catalogue, target, {
+            tokensIn: use.tokensIn ?? assumed.tokensIn,
+            tokensOut: use.tokensOut ?? assumed.tokensOut,
+            characters: use.characters ?? assumed.characters,
+            images: use.images ?? assumed.images,
+        });
+    return reported ?? costOf(catalogue, target).dollars ?? 0;
+}
+function priced(catalogue, target, use) {
+    const call = {
+        kind: target.family,
+        provider: target.provider,
+        model: target.model,
+        wallMs: 0,
+        ...use,
+    };
+    const price = priceCall(call, catalogue);
+    if (price.cost !== null)
+        return price.cost;
+    // A voice priced by the minute: two characters are well under a second.
+    const perMinute = target.family === "tts"
+        ? catalogue.tts.find((row) => row.provider === target.provider && row.id === target.model)
+            ?.pricing.perMinute
+        : undefined;
+    return perMinute === undefined ? null : perMinute / 60;
+}
+// Automatic checks (a key or CLI added, the weekly look) run only what costs nothing, a CLI
+// plan's allowance, or a text or voice call under the ceiling. Images and clips never.
+export function automaticAllowed(catalogue, target, cost) {
+    if (target.family === "image" || isVideoTarget(catalogue, target))
+        return false;
+    if (cost.planUsage)
+        return true;
+    return cost.dollars !== null && cost.dollars < automaticCeilingDollars;
+}

package/dist/slices/model-checks/listing.js

@@ -0,0 +1,124 @@
+import { keyWithShared } from "../settings/keys.js";
+import { providerById } from "../settings/model.js";
+import { probeRead } from "../settings/probe-read.js";
+import { accountOf, writeListed } from "./repo.js";
+// ceiling: a list longer than this many pages is read no further.
+const maxPages = 10;
+async function liveList(deps, probe, key) {
+    const list = probe.list;
+    if (list === undefined)
+        return undefined;
+    const ids = new Set();
+    let page;
+    for (let n = 0; n < maxPages; n += 1) {
+        const answer = await probeRead(deps.fetch, list.url(page), probe.headers(key), true);
+        if (answer === undefined || answer.status < 200 || answer.status >= 300)
+            return undefined;
+        const read = list.read(answer.body);
+        if (read === undefined)
+            return undefined;
+        for (const id of read.ids)
+            ids.add(id);
+        if (read.next === undefined)
+            break;
+        page = read.next;
+    }
+    return ids;
+}
+// One read per model's own page: found, missing, or (no answer) left as it was.
+async function modelPages(deps, probe, key, models) {
+    const found = new Map();
+    const model = probe.model;
+    if (model === undefined)
+        return found;
+    for (const id of models) {
+        const answer = await probeRead(deps.fetch, model.url(id), probe.headers(key), false);
+        if (answer === undefined)
+            continue;
+        if (answer.status >= 200 && answer.status < 300)
+            found.set(id, true);
+        else if (answer.status === 404)
+            found.set(id, false);
+    }
+    return found;
+}
+export async function listedFor(deps, provider) {
+    const { family, auth } = providerById(provider);
+    if (auth === "local")
+        return { kind: "skipped", reason: "no-list" };
+    const account = accountOf(deps.db, provider);
+    if (account === undefined)
+        return { kind: "skipped", reason: "no-key" };
+    let models;
+    if (auth === "cli") {
+        let ids;
+        try {
+            ids = await deps.cliModels(provider, family);
+        }
+        catch {
+            return { kind: "skipped", reason: "unreadable" };
+        }
+        models = new Map(ids.map((id) => [id, true]));
+    }
+    else {
+        const probe = Object.hasOwn(deps.probes, provider) ? deps.probes[provider] : undefined;
+        const key = keyWithShared(deps.db, provider);
+        if (key === undefined)
+            return { kind: "skipped", reason: "no-key" };
+        const known = deps.known(provider, family);
+        if (probe?.list !== undefined) {
+            const live = await liveList(deps, probe, key);
+            if (live === undefined)
+                return { kind: "skipped", reason: "unreadable" };
+            models = new Map(known.map((id) => [id, live.has(id)]));
+        }
+        else if (probe?.model !== undefined && probe.model.lists === undefined) {
+            models = await modelPages(deps, probe, key, known);
+        }
+        else
+            return { kind: "skipped", reason: "no-list" };
+    }
+    writeListed(deps.db, {
+        provider,
+        family,
+        account,
+        at: deps.clock.now().toISOString(),
+        models,
+    });
+    return {
+        kind: "listed",
+        listed: [...models.values()].filter(Boolean).length,
+        of: models.size,
+    };
+}
+// ceiling: a provider's list is read at most this often for the same key or login, however
+// many pickers open; a key saved, a CLI added or Check models forces a new read.
+export const listingFreshMs = 6 * 60 * 60_000;
+export function createListing(deps) {
+    const last = new Map();
+    const running = new Map();
+    return {
+        refresh: (provider, force = false) => {
+            const inFlight = running.get(provider);
+            if (inFlight !== undefined)
+                return inFlight;
+            const account = accountOf(deps.db, provider);
+            const seen = last.get(provider);
+            const now = deps.clock.now().getTime();
+            if (!force &&
+                seen !== undefined &&
+                seen.account === account &&
+                now - seen.at < listingFreshMs)
+                return Promise.resolve(undefined);
+            const started = listedFor(deps, provider)
+                .then((outcome) => {
+                if (account !== undefined)
+                    last.set(provider, { account, at: now });
+                return outcome;
+            })
+                .finally(() => running.delete(provider));
+            running.set(provider, started);
+            return started;
+        },
+    };
+}

package/dist/slices/model-checks/model.js

@@ -0,0 +1,20 @@
+// What Slopify knows about one model for the person's own key or CLI login. Only the pickers
+// read it: a run never asks, so no standing ever changes what a run does.
+// works: a check call or a real run succeeded. listed: the key's or CLI's live list names it.
+// known: only Slopify's model list (models.yaml) names it. no-access: the provider said the
+// account can't use it.
+export const modelStandings = ["works", "listed", "known", "no-access"];
+export const checkTriggers = ["manual", "key-added", "cli-added", "weekly", "run"];
+// failed: the check could not tell (rate limit, network, the provider down); it keeps
+// whatever was known before.
+export const checkVerdicts = ["works", "no-access", "failed"];
+export const verdictSources = ["check", "run"];
+// Settings → Models → Automatic checks. free: only checks that cost nothing or well under a
+// tenth of a cent each; off: only Check models.
+export const autoModes = ["free", "off"];
+export const weeklyAtKey = "model-checks.weekly-at";
+export const autoKey = "model-checks.auto";
+export const baselineKey = "model-checks.baseline-done";
+export function keyOfModel(key) {
+    return `${key.family}:${key.provider}:${key.model}`;
+}

package/dist/slices/model-checks/record.js

@@ -0,0 +1,32 @@
+import { providerIds } from "../settings/model.js";
+import { accountOf, writeVerdict } from "./repo.js";
+function known(provider) {
+    return providerIds.includes(provider);
+}
+// Learn from real runs: a model a run used works, and one the provider refused as not on the
+// plan is marked so, with the provider's sentence, the moment it happens. A call made without
+// a key on file (none to tie the row to) teaches nothing.
+export function accessRecorder(deps) {
+    const write = (use, verdict, sentence) => {
+        if (!known(use.provider))
+            return;
+        const account = accountOf(deps.db, use.provider);
+        if (account === undefined)
+            return;
+        writeVerdict(deps.db, {
+            provider: use.provider,
+            family: use.family,
+            model: use.model,
+            account,
+            verdict,
+            source: "run",
+            sentence,
+            at: deps.clock.now().toISOString(),
+            cost: 0,
+        });
+    };
+    return {
+        worked: (use) => write(use, "works", null),
+        denied: (use) => write(use, "no-access", use.sentence),
+    };
+}