@gentbajko/slopify 0.5.1 → 0.7.0

package/dist/adapters/alignment/runner.js

@@ -0,0 +1,76 @@
+import { fork } from "node:child_process";
+import { workerMessage } from "./protocol.js";
+export async function runAlignmentWorker(input, signal, onProgress, worker = new URL("./worker.js", import.meta.url)) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const options = {
+            stdio: ["ignore", "ignore", "pipe", "ipc"],
+            windowsHide: true,
+            execArgv: [],
+            serialization: "advanced",
+        };
+        const child = fork(worker, [], options);
+        let finishing = false;
+        let failure;
+        let output = [];
+        let stderr = "";
+        const finish = (error, words) => {
+            if (finishing)
+                return;
+            finishing = true;
+            failure = error;
+            output = words ?? [];
+            signal.removeEventListener("abort", abort);
+            child.kill("SIGKILL");
+        };
+        const abort = () => finish(new Error("Subtitle alignment was canceled."));
+        signal.addEventListener("abort", abort, { once: true });
+        child.stderr?.on("data", (data) => {
+            stderr = (stderr + data.toString("utf8")).slice(-2000);
+        });
+        child.on("error", (error) => finish(error));
+        // Wait for close, not only the IPC answer: Windows still owns the decoded audio
+        // handle until the worker has actually exited, so early cleanup can fail with EPERM.
+        child.on("close", (code) => {
+            if (!finishing)
+                finish(new Error(`Local subtitle alignment stopped (exit ${String(code)}). ${stderr}`.trim()));
+            if (failure !== undefined)
+                reject(failure);
+            else
+                resolve(output);
+        });
+        child.on("message", (raw) => {
+            if (finishing)
+                return;
+            const parsed = workerMessage.safeParse(raw);
+            if (!parsed.success) {
+                finish(new Error("The local subtitle worker returned invalid timing data."));
+                return;
+            }
+            const message = parsed.data;
+            if (message.type === "progress") {
+                try {
+                    onProgress?.(message.current, message.total);
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            else if (message.type === "error")
+                finish(new Error(message.message));
+            else
+                finish(undefined, message.words.map(({ confidence, ...word }) => ({
+                    ...word,
+                    ...(confidence === undefined ? {} : { confidence }),
+                })));
+        });
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        child.send(input, (error) => {
+            if (error !== null)
+                finish(error);
+        });
+    });
+}

package/dist/adapters/alignment/text.js

@@ -0,0 +1,61 @@
+import { cardinal, numberForms } from "./numbers.js";
+// Original display words remain intact; only acoustic matching uses normalized English.
+export function speechWords(text, observed = "") {
+    const words = [];
+    for (const textWord of text.trim().split(/\s+/)) {
+        const forms = wordForms(textWord);
+        const spoken = forms.find((form) => form !== "" && ` ${observed} `.includes(` ${form} `)) ?? forms[0] ?? "";
+        if (spoken === "") {
+            const previous = words.at(-1);
+            if (previous !== undefined)
+                previous.text += ` ${textWord}`;
+            continue;
+        }
+        words.push({ text: textWord, spoken });
+    }
+    if (words.length === 0)
+        throw new Error("Local subtitles currently require an English transcript with spoken words.");
+    return words;
+}
+function wordForms(raw) {
+    const plain = raw.normalize("NFKD").replace(/\p{M}/gu, "").replace(/[‘’]/g, "'");
+    if (/\p{L}/u.test(plain.replace(/[A-Za-z]/g, "")))
+        throw new Error("Local subtitles currently support English speech and Latin-script names only.");
+    const core = plain.replace(/^[^\p{L}\p{N}$£€]+|[^\p{L}\p{N}%]+$/gu, "");
+    if (core === "")
+        return [];
+    const currency = core.startsWith("$")
+        ? "DOLLARS"
+        : core.startsWith("£")
+            ? "POUNDS"
+            : core.startsWith("€")
+                ? "EUROS"
+                : "";
+    const percent = core.endsWith("%") ? "PERCENT" : "";
+    const clean = core.replace(/^[$£€]/, "").replace(/%$/, "");
+    let forms;
+    if (/^\d[\d,.]*(?:s|st|nd|rd|th)?$/i.test(clean)) {
+        forms = numberForms(clean);
+    }
+    else {
+        const expanded = clean
+            .replaceAll("&", " AND ")
+            .replaceAll("+", " PLUS ")
+            .replace(/\d+/g, (digits) => numberForms(digits)[0] ?? digits);
+        const normal = expanded
+            .toUpperCase()
+            .replace(/[^A-Z']/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        forms = /^[A-Z]{2,8}$/.test(clean) ? [normal, clean.split("").join(" ")] : [normal];
+    }
+    const result = forms.map((form) => [form, currency, percent].filter(Boolean).join(" "));
+    const money = /^(\d[\d,]*)\.(\d{2})$/.exec(clean);
+    if (currency !== "" && money !== null) {
+        const whole = cardinal(Number((money[1] ?? "").replaceAll(",", "")));
+        const fraction = cardinal(Number(money[2]));
+        const unit = currency === "POUNDS" ? "PENCE" : "CENTS";
+        result.push(`${whole} ${currency} AND ${fraction} ${unit}`, `${whole} ${currency} ${fraction}`, `${whole} ${fraction}`);
+    }
+    return result;
+}

package/dist/adapters/alignment/vocabulary.js

@@ -0,0 +1,69 @@
+// The vocabulary belongs to the pinned wav2vec2-base-960h model.
+export const vocabulary = {
+    "<pad>": 0,
+    "<s>": 1,
+    "</s>": 2,
+    "<unk>": 3,
+    "|": 4,
+    E: 5,
+    T: 6,
+    A: 7,
+    O: 8,
+    N: 9,
+    I: 10,
+    H: 11,
+    S: 12,
+    R: 13,
+    D: 14,
+    L: 15,
+    U: 16,
+    M: 17,
+    W: 18,
+    C: 19,
+    F: 20,
+    G: 21,
+    Y: 22,
+    P: 23,
+    B: 24,
+    V: 25,
+    K: 26,
+    "'": 27,
+    X: 28,
+    J: 29,
+    Q: 30,
+    Z: 31,
+};
+export const letters = [
+    "",
+    "",
+    "",
+    "",
+    " ",
+    "E",
+    "T",
+    "A",
+    "O",
+    "N",
+    "I",
+    "H",
+    "S",
+    "R",
+    "D",
+    "L",
+    "U",
+    "M",
+    "W",
+    "C",
+    "F",
+    "G",
+    "Y",
+    "P",
+    "B",
+    "V",
+    "K",
+    "'",
+    "X",
+    "J",
+    "Q",
+    "Z",
+];

package/dist/adapters/alignment/worker.js

@@ -0,0 +1,163 @@
+import { open, readFile, stat } from "node:fs/promises";
+import * as ort from "onnxruntime-web/wasm";
+import { alignWindow, frameSeconds, mismatch } from "./ctc.js";
+import { workerInput } from "./protocol.js";
+import { agreesWithSpeech } from "./quality.js";
+import { speechWords } from "./text.js";
+import { letters } from "./vocabulary.js";
+const sampleRate = 16000;
+const windowSeconds = 12;
+const overlapSeconds = 2;
+process.once("message", (raw) => {
+    const input = workerInput.safeParse(raw);
+    if (!input.success) {
+        send({ type: "error", message: "The subtitle worker received an invalid request." });
+        return;
+    }
+    run(input.data).then((words) => send({ type: "done", words }), (error) => send({ type: "error", message: error instanceof Error ? error.message : String(error) }));
+});
+function send(message) {
+    process.send?.(message);
+}
+async function run(input) {
+    ort.env.wasm.numThreads = 1;
+    const model = new Uint8Array(await readFile(input.modelPath));
+    const session = await ort.InferenceSession.create(model, { executionProviders: ["wasm"] });
+    const file = await open(input.pcmPath, "r");
+    try {
+        const totalSamples = (await stat(input.pcmPath)).size / 4;
+        if (!Number.isInteger(totalSamples) || totalSamples < sampleRate / 10)
+            throw new Error("The narration is too short to align subtitles.");
+        const source = speechWords(input.text);
+        const output = [];
+        let cursor = 0;
+        let sampleAt = 0;
+        while (sampleAt < totalSamples && cursor < source.length) {
+            const count = Math.min(windowSeconds * sampleRate, totalSamples - sampleAt);
+            const buffer = Buffer.alloc(count * 4);
+            await file.read(buffer, 0, buffer.length, sampleAt * 4);
+            const audio = new Float32Array(buffer.buffer, buffer.byteOffset, count);
+            const normalized = normalize(audio);
+            if (normalized === undefined) {
+                sampleAt += count;
+                continue;
+            }
+            const result = await session.run({
+                input_values: new ort.Tensor("float32", normalized, [1, count]),
+            });
+            const logits = result.logits;
+            if (logits === undefined ||
+                !(logits.data instanceof Float32Array) ||
+                logits.dims.length !== 3 ||
+                logits.dims[2] !== 32)
+                throw new Error("The local subtitle model returned an unsupported result.");
+            const frames = logits.dims[1] ?? 0;
+            const observed = greedy(logits.data, frames);
+            if (observed.replace(/[^A-Z]/g, "").length === 0) {
+                sampleAt += count;
+                for (const tensor of Object.values(result))
+                    tensor.dispose();
+                continue;
+            }
+            const candidate = candidates(source, cursor, observed);
+            const finalWindow = sampleAt + count >= totalSamples;
+            const complete = finalWindow && cursor + candidate.length === source.length;
+            const aligned = alignWindow(logits.data, frames, candidate, complete).words;
+            const cutoff = finalWindow ? count / sampleRate : count / sampleRate - overlapSeconds;
+            const accepted = aligned.filter((word) => word.end <= cutoff);
+            const last = accepted.at(-1);
+            if (last === undefined)
+                throw new Error(mismatch);
+            const heard = greedy(logits.data, Math.min(frames, Math.ceil(last.end / frameSeconds)));
+            if (!agreesWithSpeech(candidate
+                .slice(0, accepted.length)
+                .map((word) => word.spoken)
+                .join(" "), heard))
+                throw new Error(mismatch);
+            const offset = sampleAt / sampleRate;
+            output.push(...accepted.map((word) => ({
+                ...word,
+                start: offset + word.start,
+                end: offset + word.end,
+            })));
+            cursor += accepted.length;
+            send({ type: "progress", current: cursor, total: source.length });
+            // Keep a small leading silence margin but never re-use speech already captioned.
+            sampleAt += Math.max(1, Math.floor(last.end * sampleRate));
+            for (const tensor of Object.values(result))
+                tensor.dispose();
+        }
+        if (cursor !== source.length || output.length === 0)
+            throw new Error(mismatch);
+        // A substantial spoken tail absent from the transcript is a mismatch too.
+        while (sampleAt + sampleRate < totalSamples) {
+            const count = Math.min(windowSeconds * sampleRate, totalSamples - sampleAt);
+            const buffer = Buffer.alloc(count * 4);
+            await file.read(buffer, 0, buffer.length, sampleAt * 4);
+            const audio = normalize(new Float32Array(buffer.buffer, buffer.byteOffset, count));
+            if (audio !== undefined) {
+                const result = await session.run({
+                    input_values: new ort.Tensor("float32", audio, [1, count]),
+                });
+                const logits = result.logits;
+                if (logits !== undefined &&
+                    logits.data instanceof Float32Array &&
+                    greedy(logits.data, logits.dims[1] ?? 0).replace(/[^A-Z]/g, "").length > 8)
+                    throw new Error(mismatch);
+                for (const tensor of Object.values(result))
+                    tensor.dispose();
+            }
+            sampleAt += count;
+        }
+        return output;
+    }
+    finally {
+        await file.close();
+        await session.release();
+    }
+}
+function candidates(source, cursor, observed) {
+    const selected = [];
+    let length = 0;
+    for (let index = cursor; index < source.length; index += 1) {
+        const word = source[index];
+        if (word === undefined)
+            break;
+        const normalized = speechWords(word.text, observed)[0];
+        if (normalized === undefined)
+            continue;
+        if (length + normalized.spoken.length + 1 > 900)
+            break;
+        selected.push(normalized);
+        length += normalized.spoken.length + 1;
+    }
+    return selected;
+}
+function normalize(audio) {
+    let mean = 0;
+    for (const value of audio)
+        mean += value;
+    mean /= audio.length;
+    let variance = 0;
+    for (const value of audio)
+        variance += (value - mean) ** 2;
+    variance /= audio.length;
+    if (variance < 1e-10)
+        return undefined;
+    const divisor = Math.sqrt(variance + 1e-7);
+    return Float32Array.from(audio, (value) => (value - mean) / divisor);
+}
+function greedy(logits, frames) {
+    let previous = -1;
+    let text = "";
+    for (let frame = 0; frame < frames; frame += 1) {
+        let best = 0;
+        for (let label = 1; label < 32; label += 1)
+            if ((logits[frame * 32 + label] ?? -Infinity) > (logits[frame * 32 + best] ?? -Infinity))
+                best = label;
+        if (best !== previous && best !== 0)
+            text += letters[best] ?? "";
+        previous = best;
+    }
+    return text.trim().replace(/\s+/g, " ");
+}

package/dist/adapters/image/google.js

@@ -3,28 +3,21 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { retryAfter } from "../retry-after.js";
 import { describeBytes, sniffImage } from "./bytes.js";
+import { discoverGoogleImages } from "./models.js";
 // The HTTP gateway adapter for Google's own image generation, billed to a Gemini API key
 // rather than to a host reselling the same models. Like the OpenAI one it hands back the
-// bytes with the call, so there is no link to follow; unlike it, the whole interaction is
-// one `input` string and a `response_format`, with no per-model size table to keep.
+// bytes with the call, so there is no link to follow.
 export const googleImagesBase = "https://generativelanguage.googleapis.com/v1beta";
-// The dropdown is filled from what the provider offers, and Google's model list carries every
-// text and embedding model too, so the image shortlist is this adapter's own data. Named as
-// Google markets them: "Nano Banana" is the family, `gemini-*-image` is what the API answers
-// to, and the picker shows the name a user would recognise. Newest first.
-//
-// A Gemini model without the `-image` suffix returns text and cannot be used here, whatever
-// its version number: `gemini-3.8-flash` is newer than all of these and generates no images.
+// Offline choices only; the picker normally loads the provider catalogue.
 export const googleImageModels = [
     { id: "gemini-3.1-flash-image", name: "Nano Banana 2" },
     { id: "gemini-3.1-flash-lite-image", name: "Nano Banana 2 Lite" },
     { id: "gemini-3-pro-image", name: "Nano Banana Pro" },
     { id: "gemini-2.5-flash-image", name: "Nano Banana" },
 ];
-// The API takes the aspect in the run's own words, so the closest supported size is exact
-// and the render crops nothing. `2K` is the middle of the documented ladder: enough to
-// survive the 4x pre-scale the zoom needs without paying for 4K on every slide.
-const imageSize = "2K";
+// 2.5 and Flash Lite cannot generate 2K images. Unknown models keep their own default
+// resolution until their capabilities are known; discovery alone does not describe sizes.
+const highResolutionModel = /^gemini-(?:3(?:\.1)?-pro|3\.1-flash)-image(?:-preview(?:-\d{2}-\d{2})?)?$/;
 // A wire payload is narrowed, never cast. The image arrives as one content part of a
 // `model_output` step, beside any text the model chose to write, so both the step and the
 // part are searched for by type rather than read off a fixed index.
@@ -58,7 +51,7 @@ const refusalWords = /\b(safety|blocked|content polic|prohibited|violat)/i;
 export function googleImage(deps) {
     return {
         id: "google-image",
-        models: () => Promise.resolve(googleImageModels),
+        models: () => discoverGoogleImages(deps),
         generate: async (req) => {
             const response = await deps.fetch(`${googleImagesBase}/interactions`, {
                 method: "POST",
@@ -72,7 +65,11 @@ export function googleImage(deps) {
                     // The stage sends Number as that many independent calls, one piece each, so one
                     // image per request is what it asks for. Nothing about style is set: the stage
                     // asks for the provider's own.
-                    response_format: { type: "image", aspect_ratio: req.aspect, image_size: imageSize },
+                    response_format: {
+                        type: "image",
+                        aspect_ratio: req.aspect,
+                        ...(highResolutionModel.test(req.model) ? { image_size: "2K" } : {}),
+                    },
                 }),
             });
             if (!response.ok) {

package/dist/adapters/image/models.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { providerError } from "../../kernel/ports/model.js";
+const openAiModels = z.object({ data: z.array(z.object({ id: z.string() })) });
+const googleModels = z.object({
+    models: z
+        .array(z.object({
+        name: z.string(),
+        displayName: z.string().optional(),
+        supportedGenerationMethods: z.array(z.string()).optional(),
+    }))
+        .default([]),
+    nextPageToken: z.string().optional(),
+});
+export async function discoverOpenAiImages(deps) {
+    const response = await deps.fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${requireKey(deps)}` },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok)
+        throw unavailable();
+    const parsed = openAiModels.safeParse(await response.json());
+    if (!parsed.success)
+        throw unavailable();
+    return parsed.data.data
+        .filter(({ id }) => id.startsWith("gpt-image-"))
+        .map(({ id }) => ({ id, name: id }));
+}
+export async function discoverGoogleImages(deps) {
+    const headers = { "x-goog-api-key": requireKey(deps) };
+    const signal = AbortSignal.timeout(10_000);
+    const result = [];
+    const tokens = new Set();
+    let page = "";
+    // Bound a malformed provider's pagination while allowing 20,000 model records.
+    for (let count = 0; count < 20; count++) {
+        const url = new URL("https://generativelanguage.googleapis.com/v1beta/models");
+        url.searchParams.set("pageSize", "1000");
+        if (page !== "")
+            url.searchParams.set("pageToken", page);
+        const response = await deps.fetch(url, { headers, signal });
+        if (!response.ok)
+            throw unavailable();
+        const parsed = googleModels.safeParse(await response.json());
+        if (!parsed.success)
+            throw unavailable();
+        for (const model of parsed.data.models) {
+            const id = model.name.replace(/^models\//, "");
+            // Imagen uses a different generation API. Only Gemini image models share this adapter.
+            if (id.startsWith("gemini-") &&
+                /-image(?:-|$)/.test(id) &&
+                model.supportedGenerationMethods?.includes("generateContent") === true) {
+                result.push({ id, name: model.displayName ?? id });
+            }
+        }
+        page = parsed.data.nextPageToken ?? "";
+        if (page === "")
+            return result;
+        if (tokens.has(page))
+            throw unavailable();
+        tokens.add(page);
+    }
+    throw unavailable();
+}
+function requireKey(deps) {
+    const key = deps.key();
+    if (key === undefined || key === "")
+        throw providerError({ kind: "missing_key", message: "Save an API key to load models." });
+    return key;
+}
+function unavailable() {
+    return providerError({ kind: "other", message: "The provider model list could not be loaded." });
+}

package/dist/adapters/image/openai.js

@@ -3,15 +3,13 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { retryAfter } from "../retry-after.js";
 import { describeBytes, sniffImage } from "./bytes.js";
+import { discoverOpenAiImages } from "./models.js";
 // The HTTP gateway adapter for OpenAI's images endpoint: the platform's own `fetch` and
 // nothing else, because the whole call is one request. Unlike fal and Replicate this one
 // hands back the image itself - a GPT image model always answers with base64, never a URL -
 // so there is no link to follow.
 export const openAiImagesBase = "https://api.openai.com/v1";
-// The dropdown is filled from what the provider offers, and `/v1/models`
-// lists every model on the account, chat and embeddings among them, so the image
-// shortlist is this adapter's own data. These are the four GPT image models OpenAI
-// documents; adding the next one is a line here and no code change anywhere else.
+// Offline choices only; the picker normally loads the provider catalogue.
 export const openAiImageModels = [
     { id: "gpt-image-2", name: "GPT Image 2" },
     { id: "gpt-image-1.5", name: "GPT Image 1.5" },
@@ -52,7 +50,7 @@ export function sizeFor(model, aspect) {
 export function openAiImage(deps) {
     return {
         id: "openai-image",
-        models: () => Promise.resolve(openAiImageModels),
+        models: () => discoverOpenAiImages(deps),
         generate: async (req) => {
             const response = await deps.fetch(`${openAiImagesBase}/images/generations`, {
                 method: "POST",

package/dist/adapters/llm/catalogue-files.js

@@ -0,0 +1,23 @@
+import { open } from "node:fs/promises";
+// Bound both the initial read and a file that grows between stat and read. Model
+// metadata is data only: none of the installed CLI's modules are evaluated.
+export async function readCatalogueFile(path, maxBytes) {
+    const file = await open(path, "r");
+    try {
+        const info = await file.stat();
+        if (!info.isFile() || info.size > maxBytes)
+            throw new Error("Invalid model metadata file");
+        const bytes = Buffer.alloc(maxBytes + 1);
+        let size = 0;
+        while (size <= maxBytes) {
+            const chunk = await file.read(bytes, size, bytes.length - size, null);
+            if (chunk.bytesRead === 0)
+                return bytes.toString("utf8", 0, size);
+            size += chunk.bytesRead;
+        }
+        throw new Error("Model metadata file is too large");
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/adapters/llm/claude-code.js

@@ -8,10 +8,9 @@ import { lines } from "./sse-lines.js";
 // may not import `slices/**`, and `slices/settings/cli-status.ts` already probes the binary per
 // request. The registry `main.ts` builds is where this adapter and that probe meet.
 export const claudeCodeBinary = "claude";
-// The CLI takes an alias for the latest model of a family (`claude --help`, 2.1.258).
-// ceiling: a fixed list, because the CLI has no offline command that prints the models an
-// account may use. A user whose plan carries a model not listed here cannot pick it;
-// reading the list off the CLI is the upgrade when it can print one.
+// Official stable family aliases resolve to the latest model available to the
+// installed CLI/account. Full model IDs remain available through custom entry.
+// https://code.claude.com/docs/en/model-config
 export const claudeCodeModels = [
     { id: "fable", name: "Claude Fable (latest)" },
     { id: "opus", name: "Claude Opus (latest)" },
@@ -37,6 +36,7 @@ export function claudeCodeArgs(req) {
         "stream-json",
         // stream-json output is refused without it.
         "--verbose",
+        "--include-partial-messages",
         // `claude --help` 2.1.263: safe mode excludes CLAUDE.md, output styles, skills and
         // hooks while retaining login and managed policy. --bare would discard OAuth.
         "--safe-mode",
@@ -82,6 +82,10 @@ export function claudeCodeLlm(deps) {
                     continue;
                 }
                 const event = cliEvent(binary, line);
+                // Partial text/thinking and tool events are a heartbeat. Full assistant
+                // messages remain the sole prose source so text is never appended twice.
+                yield { type: "activity" };
+                req.signal.throwIfAborted();
                 if (event.type === "assistant") {
                     for (const block of cliShaped(binary, assistantEvent, event.value).message.content) {
                         // A turn also carries `thinking` and `tool_use` blocks; only the prose is the
@@ -133,9 +137,7 @@ export function claudeCodeLlm(deps) {
     }
     return {
         id: "claude-code",
-        // Whole assistant turns rather than token deltas, still enough for the idle timeout to
-        // see life on the stream. ceiling: `--include-partial-messages` would give per-token
-        // deltas for the streamed article; it is the upgrade when the page needs finer text.
+        // Partial messages keep the deadline alive; complete assistant turns supply prose.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
         models: () => Promise.resolve(claudeCodeModels),
         complete,

package/dist/adapters/llm/codex-models.js

@@ -0,0 +1,46 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { readCatalogueFile } from "./catalogue-files.js";
+const safeText = z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .refine((text) => [...text].every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127));
+// Deliberately omit model instructions, capabilities and every authentication
+// file. Visibility refers to the CLI picker, not supported_in_api: some visible
+// CLI-only models cannot be called through the public API.
+const cache = z.object({ models: z.array(z.unknown()).max(1000) });
+const model = z.object({
+    slug: safeText.refine((id) => !/\s/.test(id)),
+    display_name: safeText.optional(),
+    visibility: z.literal("list"),
+    priority: z.number().finite().optional(),
+});
+export async function nodeCodexModels(env = process.env) {
+    try {
+        const directory = env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+        const source = await readCatalogueFile(join(directory, "models_cache.json"), 8 * 1024 * 1024);
+        const parsed = cache.parse(JSON.parse(source));
+        const models = parsed.models
+            .flatMap((entry) => {
+            const parsed = model.safeParse(entry);
+            return parsed.success ? [parsed.data] : [];
+        })
+            .sort((left, right) => (left.priority ?? Infinity) - (right.priority ?? Infinity));
+        const unique = new Map();
+        for (const item of models) {
+            if (!unique.has(item.slug)) {
+                unique.set(item.slug, { id: item.slug, name: item.display_name ?? item.slug });
+            }
+        }
+        if (unique.size === 0)
+            throw new Error("No visible models");
+        return [...unique.values()];
+    }
+    catch {
+        // Do not expose cache contents, home paths or raw JSON errors to the browser.
+        throw new Error("Codex model metadata is unavailable. Open Codex once to refresh its model list, or enter a custom model ID.");
+    }
+}