@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/kernel/db/migrations/0040-standalone-usage.sql

@@ -0,0 +1,35 @@
+-- What every successful provider call made outside a project used and cost: a schedule's
+-- topic generation, a channel's episode summary and its cast pictures. provider_usage cannot
+-- hold them, since each of its rows belongs to a project. Priced the same way when the call
+-- lands. There is no link to the schedule or channel: deleting one keeps what it cost this
+-- week. `channel_id` is the channel the call was made for, resolved when it landed, for Home's
+-- channel filter. A CLI's plan windows reported around the call ride along (`account`,
+-- `reading_json`), so Home's plan standings read them beside a project's.
+CREATE TABLE standalone_usage (
+ id TEXT PRIMARY KEY,
+ owner_kind TEXT NOT NULL CHECK(owner_kind IN ('schedule','channel')),
+ owner_id TEXT NOT NULL,
+ channel_id TEXT NOT NULL,
+ purpose TEXT NOT NULL,
+ kind TEXT NOT NULL CHECK(kind IN ('llm','tts','image','video')),
+ provider TEXT NOT NULL,
+ model TEXT NOT NULL,
+ tokens_in INTEGER,
+ tokens_out INTEGER,
+ tokens_cached INTEGER,
+ characters INTEGER,
+ images INTEGER,
+ seconds REAL,
+ size TEXT,
+ quality TEXT,
+ wall_ms INTEGER NOT NULL,
+ on_plan INTEGER NOT NULL DEFAULT 0 CHECK(on_plan IN (0,1)),
+ cost REAL,
+ api_model TEXT,
+ api_cost REAL,
+ price_json TEXT CHECK(price_json IS NULL OR json_valid(price_json)),
+ account TEXT,
+ reading_json TEXT CHECK(reading_json IS NULL OR json_valid(reading_json)),
+ created_at TEXT NOT NULL
+);
+CREATE INDEX standalone_usage_created ON standalone_usage(created_at);

package/dist/kernel/db/migrations/0041-cast-hosts.sql

@@ -0,0 +1,3 @@
+-- A channel's hosts: cast members marked as the channel's recurring voices. A new podcast or
+-- interview draft starts with them as its speakers. Every member made before this is not a host.
+ALTER TABLE cast_members ADD COLUMN host INTEGER NOT NULL DEFAULT 0 CHECK (host IN (0, 1));

package/dist/kernel/paths.js

@@ -1,18 +1,38 @@
 import { chmodSync, mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
-export function layout(dataDir) {
+export function layout(dataDir, files) {
     const root = resolve(dataDir);
+    const projects = join(root, "projects");
     return {
         dataDir: root,
         db: join(root, "slopify.db"),
-        projects: join(root, "projects"),
+        projects: files?.projects ?? projects,
+        backups: files?.backups ?? join(projects, "Backups"),
+        exports: files === undefined ? null : files.exports,
         staging: join(root, "staging"),
         logs: join(root, "logs"),
         lock: join(root, ".lock"),
     };
 }
+// Points a running install's Paths at moved files. The one object every slice was handed is
+// changed in place, so the next file each one reads or writes is in the new place.
+export function repoint(paths, files) {
+    Object.assign(paths, {
+        projects: files.projects,
+        backups: files.backups,
+        exports: files.exports,
+    });
+}
 export function ensureDirs(paths, options) {
-    for (const dir of [paths.dataDir, paths.projects, paths.staging, paths.logs]) {
+    ensureDataDirs(paths, options);
+    ensureOwnerOnly([paths.projects], options);
+}
+// The data dir's own folders, before it is known where the user-visible files go.
+export function ensureDataDirs(paths, options) {
+    ensureOwnerOnly([paths.dataDir, paths.staging, paths.logs], options);
+}
+function ensureOwnerOnly(dirs, options) {
+    for (const dir of dirs) {
         mkdirSync(dir, { recursive: true, mode: options.mode });
         // mkdir's mode is masked by the umask and ignored for a directory that already
         // exists; provider keys sit in this tree, so the mode has to be forced.
@@ -20,7 +40,8 @@ export function ensureDirs(paths, options) {
     }
 }
 // The subtitle-timing model's cache. The app readies it at start and every captioned render
-// reads it, so both name it through here.
-export function subtitleModelDir(dataDir) {
-    return join(dataDir, "models", "english-subtitles");
+// reads it, so both name it through here. Other languages use the multilingual model, kept
+// in a folder of its own and downloaded on first use, never at start.
+export function subtitleModelDir(dataDir, language = "en") {
+    return join(dataDir, "models", language === "en" ? "english-subtitles" : "multilingual-subtitles");
 }

package/dist/kernel/pipeline.js

@@ -24,12 +24,15 @@ export const stageStates = [
     "skipped",
 ];
 // A persisted pause overrides the stage-derived status. A completed run need not
-// include a video: all selected stages being satisfied is enough.
+// include a video: all selected stages being satisfied is enough. `partial` is a run whose
+// main output was made while another step failed (the video is there, its thumbnail is
+// not): done with problems, not failed.
 export const projectStates = [
     "running",
     "paused",
     "canceled",
     "failed",
+    "partial",
     "done",
     "pending",
 ];

package/dist/kernel/ports/host-cli.js

@@ -5,7 +5,20 @@ import { llmDocumentsSchema } from "./llm-documents.js";
 import { providerErrorKinds } from "./model.js";
 export const hostLlmIds = ["claude-code", "codex", "gemini"];
 export const hostCliIds = [...hostLlmIds, "codex-image"];
+// The health answer's protocol stays 1: both sides read it as an exact value, so bumping it
+// would lock an older app out of a newer helper and the other way round. Richer stream frames
+// are negotiated per request instead, with `hostFramesHeader`.
 export const hostCliProtocol = 1;
+// Sent by the app on every LLM request: the frame version it can read. A helper puts the
+// cached-token count, the answering model and the plan windows on the `done` frame only when
+// this says 2 or more, because an app from before them rejects any field it does not know.
+// An older helper ignores the header and sends the plain frame, which reads as "not reported".
+export const hostFramesHeader = "x-slopify-frames";
+export const hostFramesVersion = 2;
+// What the Codex CLI reported spending on a bridged image (its tokens and plan windows), as
+// base64url JSON. A header rather than a body change, so an older app just ignores it and a
+// newer app reads a missing one as "not reported".
+export const hostImageReportHeader = "x-slopify-image-report";
 export const bridgeLimits = {
     request: 16 * 1024 * 1024,
     status: 64 * 1024,
@@ -39,6 +52,15 @@ export const hostLlmSchema = z
     webSearch: z.boolean().optional(),
 })
     .strict();
+const bridgedImage = z
+    .object({
+    mime: z.enum(["image/png", "image/jpeg"]),
+    base64: z
+        .string()
+        .max(Math.ceil(bridgeLimits.reference / 3) * 4)
+        .regex(/^[A-Za-z0-9+/]*={0,2}$/),
+})
+    .strict();
 export const hostImageSchema = z
     .object({
     // "codex-imagegen" is the Codex default; any other is one of the Codex CLI's models.
@@ -57,6 +79,18 @@ export const hostImageSchema = z
     })
         .strict()
         .optional(),
+    // The cast members the brief mentions, with their pictures (`ImageRequest.cast`); the
+    // whole request still has to fit `bridgeLimits.request`.
+    cast: z
+        .array(z
+        .object({
+        name: z.string().min(1).max(200),
+        description: z.string().max(2000),
+        images: z.array(bridgedImage).min(1).max(4),
+    })
+        .strict())
+        .max(4)
+        .optional(),
 })
     .strict();
 export const hostOpenFolderSchema = z
@@ -102,25 +136,99 @@ export const hostHealthSchema = z
     accepting: z.boolean(),
 })
     .strict();
-export const hostFaultSchema = z
-    .object({
+// Faults and frames are read leniently: a field this side does not know is dropped, never an
+// error, so a newer helper can add optional fields without breaking this app. (Apps before
+// frame version 2 read them strictly, which is why the helper asks before adding any.)
+export const hostFaultSchema = z.object({
     type: z.literal("error"),
     kind: z.enum(providerErrorKinds),
     message: z.string().max(4096),
-})
-    .strict();
+});
+const limitWindowSchema = z.object({
+    kind: z.enum(["five_hour", "weekly", "other"]),
+    usedPercent: z.number().min(0).max(1_000_000),
+    resetsAt: z.string().max(64).nullable(),
+});
+const limitWindowsSchema = z.array(limitWindowSchema).max(16);
+const planLimitReadingSchema = z.object({
+    before: limitWindowsSchema.optional(),
+    after: limitWindowsSchema.optional(),
+});
+const usageSchema = z.object({
+    inputTokens: z.number().nonnegative(),
+    outputTokens: z.number().nonnegative(),
+    // Frame version 2 on; an older helper never sends them.
+    cachedInputTokens: z.number().nonnegative().optional(),
+    model: short.optional(),
+});
 export const hostFrameSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("delta"), text: z.string().max(bridgeLimits.frame) }).strict(),
-    z.object({ type: z.literal("activity") }).strict(),
-    z
-        .object({
+    z.object({ type: z.literal("delta"), text: z.string().max(bridgeLimits.frame) }),
+    z.object({ type: z.literal("activity") }),
+    z.object({
         type: z.literal("done"),
-        usage: z
-            .object({ inputTokens: z.number().nonnegative(), outputTokens: z.number().nonnegative() })
-            .strict()
-            .nullable(),
+        usage: usageSchema.nullable(),
         finishReason: z.string().max(256).nullable(),
-    })
-        .strict(),
+        // Frame version 2 on.
+        limits: planLimitReadingSchema.optional(),
+    }),
     hostFaultSchema,
 ]);
+// The `done` frame the helper sends to an app that reads frame `version`. Version 1 is the
+// original shape exactly; version 2 adds what the CLI reported, each part kept only when it is
+// well formed so one odd value never costs the answer.
+export function hostDoneFrame(event, version) {
+    const plain = event.usage === null
+        ? null
+        : { inputTokens: event.usage.inputTokens, outputTokens: event.usage.outputTokens };
+    if (!(version >= 2))
+        return { type: "done", usage: plain, finishReason: event.finishReason };
+    const cached = z.number().nonnegative().safeParse(event.usage?.cachedInputTokens);
+    const model = short.safeParse(event.usage?.model);
+    const limits = planLimitReadingSchema.safeParse(event.limits);
+    return {
+        type: "done",
+        usage: plain === null
+            ? null
+            : {
+                ...plain,
+                ...(cached.success ? { cachedInputTokens: cached.data } : {}),
+                ...(model.success ? { model: model.data } : {}),
+            },
+        finishReason: event.finishReason,
+        ...(event.limits !== undefined && limits.success ? { limits: limits.data } : {}),
+    };
+}
+const imageReportSchema = z.object({
+    usage: usageSchema.optional(),
+    limits: planLimitReadingSchema.optional(),
+});
+// The image report header's value, or undefined when there is nothing well formed to report.
+export function encodeHostImageReport(image) {
+    const report = imageReportSchema.safeParse({
+        ...(image.usage === undefined ? {} : { usage: image.usage }),
+        ...(image.limits === undefined ? {} : { limits: image.limits }),
+    });
+    if (!report.success || (report.data.usage === undefined && report.data.limits === undefined))
+        return undefined;
+    const value = Buffer.from(JSON.stringify(report.data)).toString("base64url");
+    // Well inside Node's 16 KB header allowance; a larger report is dropped, never the image.
+    return value.length > 8192 ? undefined : value;
+}
+// The usage and plan windows a helper sent beside an image: empty when it sent none (an older
+// helper) or something unreadable, which only costs the report.
+export function decodeHostImageReport(value) {
+    if (typeof value !== "string" || value.length > 8192)
+        return {};
+    try {
+        const report = imageReportSchema.safeParse(JSON.parse(Buffer.from(value, "base64url").toString("utf8")));
+        if (!report.success)
+            return {};
+        return {
+            ...(report.data.usage === undefined ? {} : { usage: report.data.usage }),
+            ...(report.data.limits === undefined ? {} : { limits: report.data.limits }),
+        };
+    }
+    catch {
+        return {};
+    }
+}

package/dist/kernel/ports/key-probe.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/ports/languages.js

@@ -0,0 +1,157 @@
+import { z } from "zod";
+// The language a project is made in: what the LLM writes, what the voice speaks, how the
+// narration is split into sentences and how the captions are timed. Absent on every run
+// config, draft, template and channel saved before it existed, and absent is English, so
+// nothing about those changes. Only a language other than English is ever stored.
+export const writingSystems = [
+    "latin",
+    "cyrillic",
+    "greek",
+    "arabic",
+    "hebrew",
+    "devanagari",
+    "thai",
+    "cjk",
+    "hangul",
+];
+export const languageList = [
+    { code: "en", name: "English", native: "English", script: "latin", timing: "english" },
+    { code: "es", name: "Spanish", native: "Español", script: "latin", timing: "multilingual" },
+    { code: "de", name: "German", native: "Deutsch", script: "latin", timing: "multilingual" },
+    { code: "fr", name: "French", native: "Français", script: "latin", timing: "multilingual" },
+    { code: "it", name: "Italian", native: "Italiano", script: "latin", timing: "multilingual" },
+    { code: "pt", name: "Portuguese", native: "Português", script: "latin", timing: "multilingual" },
+    { code: "nl", name: "Dutch", native: "Nederlands", script: "latin", timing: "multilingual" },
+    { code: "ca", name: "Catalan", native: "Català", script: "latin", timing: "multilingual" },
+    { code: "pl", name: "Polish", native: "Polski", script: "latin", timing: "multilingual" },
+    { code: "cs", name: "Czech", native: "Čeština", script: "latin", timing: "multilingual" },
+    { code: "ro", name: "Romanian", native: "Română", script: "latin", timing: "sentences" },
+    { code: "sv", name: "Swedish", native: "Svenska", script: "latin", timing: "sentences" },
+    { code: "da", name: "Danish", native: "Dansk", script: "latin", timing: "sentences" },
+    { code: "nb", name: "Norwegian", native: "Norsk bokmål", script: "latin", timing: "sentences" },
+    { code: "fi", name: "Finnish", native: "Suomi", script: "latin", timing: "sentences" },
+    { code: "hu", name: "Hungarian", native: "Magyar", script: "latin", timing: "sentences" },
+    { code: "tr", name: "Turkish", native: "Türkçe", script: "latin", timing: "sentences" },
+    {
+        code: "id",
+        name: "Indonesian",
+        native: "Bahasa Indonesia",
+        script: "latin",
+        timing: "sentences",
+    },
+    { code: "vi", name: "Vietnamese", native: "Tiếng Việt", script: "latin", timing: "sentences" },
+    { code: "el", name: "Greek", native: "Ελληνικά", script: "greek", timing: "sentences" },
+    { code: "ru", name: "Russian", native: "Русский", script: "cyrillic", timing: "sentences" },
+    { code: "uk", name: "Ukrainian", native: "Українська", script: "cyrillic", timing: "sentences" },
+    { code: "ar", name: "Arabic", native: "العربية", script: "arabic", timing: "sentences" },
+    { code: "he", name: "Hebrew", native: "עברית", script: "hebrew", timing: "sentences" },
+    { code: "hi", name: "Hindi", native: "हिन्दी", script: "devanagari", timing: "sentences" },
+    { code: "th", name: "Thai", native: "ไทย", script: "thai", timing: "sentences" },
+    { code: "ja", name: "Japanese", native: "日本語", script: "cjk", timing: "sentences" },
+    { code: "zh", name: "Chinese", native: "中文", script: "cjk", timing: "sentences" },
+    { code: "ko", name: "Korean", native: "한국어", script: "hangul", timing: "sentences" },
+];
+export const languageCodes = languageList.map((language) => language.code);
+export const defaultLanguage = "en";
+export const languageSchema = z.enum(languageCodes);
+export function languageInfo(code) {
+    return (languageList.find((language) => language.code === (code ?? defaultLanguage)) ?? languageList[0]);
+}
+// The project's language; absent is English.
+export function projectLanguage(config) {
+    return config.language ?? defaultLanguage;
+}
+export function isEnglish(config) {
+    return projectLanguage(config) === defaultLanguage;
+}
+// The line added to every prompt that writes for the audience, when the project is not in
+// English. It is the app's own sentence, added after the user's prompt rather than written
+// into it, so the prompt library stays as the user wrote it; an English project gets nothing,
+// and its requests (and their fingerprints) stay exactly as they were.
+export function languageInstruction(language) {
+    if (language === undefined || language === defaultLanguage)
+        return undefined;
+    const { name, native } = languageInfo(language);
+    return `Language: write everything meant for the audience (article, narration, titles, descriptions, chapter names, hashtags and tags) in ${name} (${native}), even where the instructions above are written in English. Keep JSON keys, markup and any heading or label the instructions say to use exactly as given.`;
+}
+// The messages with the language line added: to the system message when there is one, since
+// the last user message is sometimes the source text itself; otherwise to the end of the last
+// user message. English returns the very same messages.
+export function withLanguage(messages, language) {
+    const instruction = languageInstruction(language);
+    if (instruction === undefined)
+        return messages;
+    const system = messages.findIndex((message) => message.role === "system");
+    const target = system !== -1 ? system : messages.findLastIndex((message) => message.role === "user");
+    if (target === -1)
+        return messages;
+    return messages.map((message, index) => index === target ? { ...message, content: `${message.content}\n\n${instruction}` } : message);
+}
+// Why word-by-word features are off in a language timed by sentences, or undefined when they
+// are available. The same sentence is shown beside every control it turns off.
+export function wordTimingUnavailable(code) {
+    const language = languageInfo(code);
+    if (language.timing !== "sentences")
+        return undefined;
+    return `Word timing isn't available for ${language.name} yet, so captions are timed sentence by sentence: each sentence is shown for the part of the narration that reads it. Word-by-word captions and cuts that follow the narration need word timing and are off.`;
+}
+// The letters a caption font needs for a language: its alphabet beyond a–z, or a sample of
+// its script. A font missing any of them draws empty boxes in that language's captions.
+const extraLetters = {
+    es: "áéíóúüñ¿¡",
+    de: "äöüß",
+    fr: "àâæçèéêëîïôœùûüÿ",
+    it: "àèéìíîòóù",
+    pt: "áâãàçéêíóôõú",
+    ca: "àèéíïòóúüç·",
+    nl: "éëïóöü",
+    pl: "ąćęłńóśźż",
+    cs: "áčďéěíňóřšťúůýž",
+    ro: "ăâîșț",
+    sv: "åäö",
+    da: "æøå",
+    nb: "æøå",
+    fi: "äö",
+    hu: "áéíóöőúüű",
+    tr: "çğıöşü",
+    vi: "ăâđêôơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ",
+    el: "αβγδεζηθικλμνξοπρστυφχψωάέήίόύώΑΩ",
+    ru: "абвгдеёжзийклмнопрстуфхцчшщъыьэюяАЯ",
+    uk: "абвгґдеєжзиіїйклмнопрстуфхцчшщьюяАЯ",
+    ar: "ابتثجحخدذرزسشصضطظعغفقكلمنهوي",
+    he: "אבגדהוזחטיכלמנסעפצקרשת",
+    hi: "अआइईउऊएऐओऔकखगघचछजझटठडढणतथदधनपफबभमयरलवशषसह",
+    th: "กขคงจฉชซญดตถทนบปผพฟภมยรลวสหอฮ",
+    ja: "あいうえおかきくけこアイウエオ日本語",
+    zh: "的一是不了人我在有他这中大来上国个到说们为子和你地出道也时年",
+    ko: "가나다라마바사아자차카타파하한국어",
+};
+export function languageLetters(code) {
+    const info = languageInfo(code);
+    const letters = `${info.script === "latin" ? "abcdefghijklmnopqrstuvwxyz" : ""}${extraLetters[info.code] ?? ""}`;
+    return [...new Set(Array.from(letters, (letter) => letter.codePointAt(0) ?? 0))];
+}
+// Whether a codepoint belongs to a writing system; used to decide whether a caption font
+// covers the project's letters without reading the font for every character.
+export function writingSystemOf(codepoint) {
+    const inRange = (from, to) => codepoint >= from && codepoint <= to;
+    if (inRange(0x41, 0x5a) || inRange(0x61, 0x7a) || inRange(0xc0, 0x24f) || inRange(0x1e00, 0x1eff))
+        return "latin";
+    if (inRange(0x370, 0x3ff) || inRange(0x1f00, 0x1fff))
+        return "greek";
+    if (inRange(0x400, 0x52f))
+        return "cyrillic";
+    if (inRange(0x590, 0x5ff))
+        return "hebrew";
+    if (inRange(0x600, 0x6ff) || inRange(0x750, 0x77f) || inRange(0xfb50, 0xfdff))
+        return "arabic";
+    if (inRange(0x900, 0x97f))
+        return "devanagari";
+    if (inRange(0xe00, 0xe7f))
+        return "thai";
+    if (inRange(0x1100, 0x11ff) || inRange(0xac00, 0xd7af))
+        return "hangul";
+    if (inRange(0x3040, 0x30ff) || inRange(0x3400, 0x4dbf) || inRange(0x4e00, 0x9fff))
+        return "cjk";
+    return undefined;
+}

package/dist/kernel/ports/model.js

@@ -2,20 +2,24 @@
 // shape never leaves its adapter.
 export const providerFamilies = ["llm", "tts", "image"];
 export function readinessIsUsable(readiness) {
-    return readiness.kind === "keyed"
-        ? readiness.hasKey
-        : readiness.installed && readiness.issue === undefined;
+    if (readiness.kind === "keyed")
+        return readiness.hasKey;
+    if (readiness.kind === "local")
+        return readiness.available;
+    return readiness.installed && readiness.issue === undefined;
 }
 export const providerErrorKinds = [
+    // A key the provider rejected. Like an absent one it fails at once: no wait fixes it.
     "auth",
-    // Distinct from `auth`, a key the provider rejected: a bad key runs the whole retry
-    // policy, an absent one fails immediately.
     "missing_key",
     "unavailable",
     "rate_limit",
     "refusal",
     "unsupported",
     "timeout",
+    // The connection, the provider's server or the CLI process went away before an answer:
+    // nothing says the request itself was wrong, so it is worth sending again later.
+    "dropped",
     "other",
 ];
 export function providerError(init) {
@@ -23,6 +27,7 @@ export function providerError(init) {
         fault: {
             kind: init.kind,
             ...(init.retryAfterMs === undefined ? {} : { retryAfterMs: init.retryAfterMs }),
+            ...(init.planLimit === undefined ? {} : { planLimit: init.planLimit }),
         },
     });
 }

package/dist/kernel/ports/narration-aliases.js

@@ -0,0 +1,60 @@
+// Narration aliases: a written word or phrase and how the narrator should say it ("Dr." as
+// "Doctor"). They change only what is sent to the voice (and to Narration Preparation);
+// the article, the transcript and the captions keep the written form. The same matcher runs
+// where the text is narrated and where captions are timed against that narration, so both
+// agree on which words were said differently. It lives with the ports because the caption
+// aligner (an adapter, which may import only ports) needs it as much as the recipes do.
+export const aliasWrittenMax = 200;
+export const aliasSpokenMax = 500;
+export const aliasCountMax = 1000;
+const wordCharacter = /[\p{L}\p{M}\p{N}_]/u;
+// Every place an alias applies: leftmost first, the longest written form where two start at
+// the same place, never overlapping.
+export function aliasMatches(text, aliases) {
+    const found = [];
+    for (const alias of aliases) {
+        const written = alias.written.trim();
+        if (written === "")
+            continue;
+        const pattern = written
+            .split(/\s+/u)
+            .map((word) => word.replace(/[|\\{}()[\]^$+*?.]/gu, "\\$&"))
+            .join("\\s+");
+        const expression = new RegExp(pattern, alias.caseSensitive ? "gu" : "giu");
+        const first = Array.from(written)[0] ?? "";
+        const last = Array.from(written).at(-1) ?? "";
+        for (const match of text.matchAll(expression)) {
+            const start = match.index;
+            const end = start + match[0].length;
+            if (alias.wholeWord) {
+                const before = Array.from(text.slice(Math.max(0, start - 2), start)).at(-1) ?? "";
+                const after = Array.from(text.slice(end, end + 2))[0] ?? "";
+                if (wordCharacter.test(first) && wordCharacter.test(before))
+                    continue;
+                if (wordCharacter.test(last) && wordCharacter.test(after))
+                    continue;
+            }
+            found.push({ start, end, spoken: alias.spoken });
+        }
+    }
+    found.sort((a, b) => a.start - b.start || b.end - a.end);
+    const chosen = [];
+    let reached = 0;
+    for (const match of found) {
+        if (match.start < reached)
+            continue;
+        chosen.push(match);
+        reached = match.end;
+    }
+    return chosen;
+}
+// The same text as the narrator should read it.
+export function applyAliases(text, aliases) {
+    let out = "";
+    let at = 0;
+    for (const match of aliasMatches(text, aliases)) {
+        out += text.slice(at, match.start) + match.spoken;
+        at = match.end;
+    }
+    return out + text.slice(at);
+}

package/dist/kernel/ports/plan-limits.js

@@ -0,0 +1,36 @@
+// The plan limits of the command-line agents: Claude Code, Codex and Gemini are billed to
+// the user's subscription, which gives them a share of a 5-hour and a weekly allowance rather
+// than a bill. Only what a CLI reports is ever recorded here; nothing is estimated.
+// The subscription a CLI provider draws on. Codex text and Codex images share one login and
+// so one allowance.
+export const planAccounts = ["claude-code", "codex", "gemini"];
+export function planAccountOf(provider) {
+    if (provider === "claude-code")
+        return "claude-code";
+    if (provider === "codex" || provider === "codex-image")
+        return "codex";
+    if (provider === "gemini")
+        return "gemini";
+    return undefined;
+}
+export const planAccountNames = {
+    "claude-code": "Claude",
+    codex: "Codex",
+    gemini: "Gemini",
+};
+// A window of `minutes` length, named the way the screens name it.
+export function windowKindOf(minutes) {
+    if (minutes === 300)
+        return "five_hour";
+    if (minutes === 10_080)
+        return "weekly";
+    return "other";
+}
+// Epoch seconds or milliseconds to ISO, null for anything that is not a plausible time.
+export function isoOfEpoch(value) {
+    if (value === null || value === undefined || !Number.isFinite(value) || value <= 0)
+        return null;
+    const ms = value < 1e12 ? value * 1000 : value;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}