@trazum/core 1.8.0

package/dist/glob.js

@@ -0,0 +1,154 @@
+/**
+ * A small, bounded glob matcher.
+ *
+ * Trazum has zero runtime dependencies and that is a security property, not a
+ * preference: a prompt optimiser reads your prompts, and every dependency is
+ * someone else's code doing that too. So the config file's budget patterns are
+ * matched here rather than by pulling in a glob library.
+ *
+ * **It is deliberately not a regex translation.** Turning `**` into
+ * `(?:[^/]*\/)*` produces exactly the nested-quantifier shape that makes a
+ * pattern take exponential time on the wrong input, and these patterns come
+ * from a file in a repository — which on a pull request means from whoever
+ * opened it. A segment-wise dynamic program has no such shape: it is O(pattern
+ * segments x path segments), and each segment match is O(pattern chars x path
+ * chars) with no backtracking beyond a single remembered star.
+ *
+ * Supported, and nothing else:
+ *   `*`   any run of characters within one path segment
+ *   `**`  any number of whole path segments, including none
+ *   `?`   exactly one character within one path segment
+ */
+/**
+ * Longest pattern and path this will consider.
+ *
+ * The matcher is quadratic in both, so a pattern nobody would write by hand is
+ * declined rather than allowed to spend the CI runner's afternoon. Both limits
+ * are far above any real prompt path.
+ */
+const MAX_PATTERN_LENGTH = 1024;
+const MAX_PATH_LENGTH = 4096;
+/** Normalises separators and strips the noise a hand-written path collects. */
+function toSegments(value) {
+    return value
+        .replace(/\\/g, '/')
+        .split('/')
+        .filter((segment) => segment.length > 0 && segment !== '.');
+}
+/**
+ * Matches one path segment against one pattern segment (`*` and `?` only).
+ *
+ * Linear-with-backtracking over a single remembered star, which is the classic
+ * bounded algorithm: on a mismatch it retreats to the last star and advances
+ * the input by one, so the work is O(pattern x input) and never exponential.
+ */
+function matchSegment(pattern, value) {
+    let p = 0;
+    let v = 0;
+    let star = -1;
+    let mark = 0;
+    while (v < value.length) {
+        if (p < pattern.length && (pattern[p] === '?' || pattern[p] === value[v])) {
+            p++;
+            v++;
+        }
+        else if (p < pattern.length && pattern[p] === '*') {
+            star = p++;
+            mark = v;
+        }
+        else if (star >= 0) {
+            p = star + 1;
+            v = ++mark;
+        }
+        else {
+            return false;
+        }
+    }
+    while (p < pattern.length && pattern[p] === '*')
+        p++;
+    return p === pattern.length;
+}
+/**
+ * True when `path` matches `pattern`.
+ *
+ * Both sides are treated as relative paths with `/` separators; a leading `./`
+ * and duplicate separators are ignored, and backslashes are read as separators
+ * so a Windows-shaped path still matches a pattern written with slashes.
+ */
+export function matchGlob(pattern, path) {
+    if (pattern.length > MAX_PATTERN_LENGTH || path.length > MAX_PATH_LENGTH)
+        return false;
+    const p = toSegments(pattern);
+    const s = toSegments(path);
+    // reachable[j] === true means "the first j pattern segments can consume the
+    // path segments seen so far". Walking the path once and updating this row is
+    // the whole algorithm; `**` is the only segment that can stay put.
+    let reachable = new Array(p.length + 1).fill(false);
+    reachable[0] = true;
+    // Leading `**` segments match nothing at all, so they are reachable up front.
+    for (let j = 0; j < p.length && p[j] === '**'; j++)
+        reachable[j + 1] = true;
+    for (const segment of s) {
+        const next = new Array(p.length + 1).fill(false);
+        for (let j = 0; j < p.length; j++) {
+            if (!reachable[j] && !(p[j] === '**' && next[j]))
+                continue;
+            if (p[j] === '**') {
+                // Consume this segment and stay on the same `**`, or step past it.
+                next[j] = true;
+                next[j + 1] = true;
+            }
+            else if (matchSegment(p[j], segment)) {
+                next[j + 1] = true;
+            }
+        }
+        // A `**` that has just been stepped past may be followed by another one,
+        // which can also match nothing. Propagate that before moving on.
+        for (let j = 0; j < p.length; j++) {
+            if (next[j] && p[j] === '**')
+                next[j + 1] = true;
+        }
+        reachable = next;
+    }
+    return reachable[p.length] === true;
+}
+/**
+ * How specific a pattern is, for deciding which of two matching patterns wins.
+ *
+ * "Most specific" needs a definition that is stated rather than felt, because
+ * a budget silently resolved from the wrong pattern is a budget nobody can
+ * debug. The rule: **more literal characters wins**, and a longer pattern
+ * breaks a tie. So `prompts/system.txt` beats `prompts/*.txt`, which beats
+ * `prompts/**`, which beats `**`.
+ */
+export function specificity(pattern) {
+    const literals = pattern.replace(/[*?]/g, '').length;
+    // The multiplier has to exceed every possible tie-breaker value, or the
+    // primary rule stops holding: at a multiplier of 1,000 a pattern with one
+    // literal and 1,024 characters scores the same as one with two literals and
+    // 24, and the stated "more literals wins" quietly becomes a coin toss.
+    return literals * (MAX_PATTERN_LENGTH + 1) + pattern.length;
+}
+/**
+ * The most specific pattern in `patterns` that matches `path`, or null.
+ *
+ * Ties on specificity are broken by lexical order rather than by insertion
+ * order: object key order is easy to reorder by accident, and a budget that
+ * changes because two keys swapped places is the kind of bug that gets blamed
+ * on the tool.
+ */
+export function mostSpecificMatch(patterns, path) {
+    let best = null;
+    let bestScore = -1;
+    for (const pattern of patterns) {
+        if (!matchGlob(pattern, path))
+            continue;
+        const score = specificity(pattern);
+        if (score > bestScore || (score === bestScore && best !== null && pattern < best)) {
+            best = pattern;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=glob.js.map

package/dist/glob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.js","sourceRoot":"","sources":["../src/glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;GAMG;AACH,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAChC,MAAM,eAAe,GAAG,IAAI,CAAC;AAE7B,+EAA+E;AAC/E,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,KAAK;SACT,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;SACnB,KAAK,CAAC,GAAG,CAAC;SACV,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,KAAK,GAAG,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,OAAe,EAAE,KAAa;IAClD,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;IACd,IAAI,IAAI,GAAG,CAAC,CAAC;IAEb,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;QACN,CAAC;aAAM,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YACpD,IAAI,GAAG,CAAC,EAAE,CAAC;YACX,IAAI,GAAG,CAAC,CAAC;QACX,CAAC;aAAM,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;YACrB,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;YACb,CAAC,GAAG,EAAE,IAAI,CAAC;QACb,CAAC;aAAM,CAAC;YACN,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG;QAAE,CAAC,EAAE,CAAC;IACrD,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC;AAC9B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,IAAY;IACrD,IAAI,OAAO,CAAC,MAAM,GAAG,kBAAkB,IAAI,IAAI,CAAC,MAAM,GAAG,eAAe;QAAE,OAAO,KAAK,CAAC;IAEvF,MAAM,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;IAC9B,MAAM,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAE3B,4EAA4E;IAC5E,6EAA6E;IAC7E,mEAAmE;IACnE,IAAI,SAAS,GAAG,IAAI,KAAK,CAAU,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7D,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACpB,8EAA8E;IAC9E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE;QAAE,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;IAE5E,KAAK,MAAM,OAAO,IAAI,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,IAAI,KAAK,CAAU,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAClC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;gBAAE,SAAS;YAC3D,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;gBAClB,mEAAmE;gBACnE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;gBACf,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;YACrB,CAAC;iBAAM,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAE,EAAE,OAAO,CAAC,EAAE,CAAC;gBACxC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;YACrB,CAAC;QACH,CAAC;QACD,yEAAyE;QACzE,iEAAiE;QACjE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAClC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;gBAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;QACnD,CAAC;QACD,SAAS,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,OAAO,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;AACtC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC;IACrD,wEAAwE;IACxE,0EAA0E;IAC1E,4EAA4E;IAC5E,uEAAuE;IACvE,OAAO,QAAQ,GAAG,CAAC,kBAAkB,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;AAC9D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,QAA2B,EAC3B,IAAY;IAEZ,IAAI,IAAI,GAAkB,IAAI,CAAC;IAC/B,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC;IAEnB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC;YAAE,SAAS;QACxC,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,KAAK,GAAG,SAAS,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;YAClF,IAAI,GAAG,OAAO,CAAC;YACf,SAAS,GAAG,KAAK,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/host.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which tool Trazum is running inside.
+ *
+ * On the Node entry point rather than the browser-safe one, because it reads the
+ * process environment. Nothing about the optimisation changes with the answer —
+ * the same prompt optimises the same way everywhere, as it must, and that is a
+ * standing constraint rather than a coincidence.
+ *
+ * What the answer earns is the right to stop quoting a monthly dollar saving to
+ * somebody on a flat-rate plan. Inside Cursor or a Claude Code subscription the
+ * per-call saving is real arithmetic about tokens and **not money anybody gets
+ * back**, and "$184/month" is wrong in the direction that matters most.
+ */
+export interface HostEnvironment {
+    id: string;
+    displayName: string;
+    /**
+     * How the host bills.
+     *
+     * `unknown` is honest rather than lazy: a VS Code terminal says nothing about
+     * whether the prompts written in it go to a metered API or a subscription, and
+     * guessing either way would be worse than saying so.
+     */
+    billing: 'per-token' | 'subscription' | 'unknown';
+    /** The variable that gave it away, so the answer is checkable rather than magic. */
+    evidence: string | null;
+}
+/** The host, or a plain terminal when nothing identifies itself. */
+export declare function detectHost(env?: NodeJS.ProcessEnv): HostEnvironment;
+//# sourceMappingURL=host.d.ts.map

package/dist/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,OAAO,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,CAAC;IAClD,oFAAoF;IACpF,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAqDD,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,eAAe,CAQhF"}

package/dist/host.js

@@ -0,0 +1,69 @@
+/**
+ * Which tool Trazum is running inside.
+ *
+ * On the Node entry point rather than the browser-safe one, because it reads the
+ * process environment. Nothing about the optimisation changes with the answer —
+ * the same prompt optimises the same way everywhere, as it must, and that is a
+ * standing constraint rather than a coincidence.
+ *
+ * What the answer earns is the right to stop quoting a monthly dollar saving to
+ * somebody on a flat-rate plan. Inside Cursor or a Claude Code subscription the
+ * per-call saving is real arithmetic about tokens and **not money anybody gets
+ * back**, and "$184/month" is wrong in the direction that matters most.
+ */
+/**
+ * Hosts recognised by an environment variable they set.
+ *
+ * A miss is harmless: it falls through to `terminal` and nothing changes. That
+ * asymmetry is why the list can include entries verified only by documentation
+ * rather than by running under them — the cost of a wrong row is a detection
+ * that never fires, not a wrong report.
+ *
+ * Ordered most-specific first. Cursor is a VS Code fork and sets
+ * `TERM_PROGRAM=vscode` as well, so a VS Code row above it would swallow every
+ * Cursor session.
+ */
+const HOSTS = [
+    {
+        id: 'claude-code',
+        displayName: 'Claude Code',
+        billing: 'subscription',
+        test: (e) => (e.CLAUDECODE ? 'CLAUDECODE' : null),
+    },
+    {
+        id: 'codex',
+        displayName: 'Codex',
+        billing: 'subscription',
+        test: (e) => (e.CODEX_SANDBOX ? 'CODEX_SANDBOX' : e.CODEX_HOME ? 'CODEX_HOME' : null),
+    },
+    {
+        id: 'cursor',
+        displayName: 'Cursor',
+        billing: 'subscription',
+        test: (e) => (e.CURSOR_TRACE_ID ? 'CURSOR_TRACE_ID' : null),
+    },
+    {
+        id: 'github-actions',
+        displayName: 'GitHub Actions',
+        billing: 'per-token',
+        test: (e) => (e.GITHUB_ACTIONS ? 'GITHUB_ACTIONS' : null),
+    },
+    { id: 'ci', displayName: 'CI', billing: 'per-token', test: (e) => (e.CI ? 'CI' : null) },
+    {
+        id: 'vscode',
+        displayName: 'VS Code',
+        billing: 'unknown',
+        test: (e) => (e.TERM_PROGRAM === 'vscode' ? 'TERM_PROGRAM' : null),
+    },
+];
+/** The host, or a plain terminal when nothing identifies itself. */
+export function detectHost(env = process.env) {
+    for (const host of HOSTS) {
+        const evidence = host.test(env);
+        if (evidence !== null) {
+            return { id: host.id, displayName: host.displayName, billing: host.billing, evidence };
+        }
+    }
+    return { id: 'terminal', displayName: 'terminal', billing: 'unknown', evidence: null };
+}
+//# sourceMappingURL=host.js.map

package/dist/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAiBH;;;;;;;;;;;GAWG;AACH,MAAM,KAAK,GAKN;IACH;QACE,EAAE,EAAE,aAAa;QACjB,WAAW,EAAE,aAAa;QAC1B,OAAO,EAAE,cAAc;QACvB,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;KAClD;IACD;QACE,EAAE,EAAE,OAAO;QACX,WAAW,EAAE,OAAO;QACpB,OAAO,EAAE,cAAc;QACvB,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;KACtF;IACD;QACE,EAAE,EAAE,QAAQ;QACZ,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,cAAc;QACvB,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC;KAC5D;IACD;QACE,EAAE,EAAE,gBAAgB;QACpB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,WAAW;QACpB,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC;KAC1D;IACD,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE;IACxF;QACE,EAAE,EAAE,QAAQ;QACZ,WAAW,EAAE,SAAS;QACtB,OAAO,EAAE,SAAS;QAClB,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC;KACnE;CACF,CAAC;AAEF,oEAAoE;AACpE,MAAM,UAAU,UAAU,CAAC,GAAG,GAAsB,OAAO,CAAC,GAAG;IAC7D,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACtB,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;QACzF,CAAC;IACH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AACzF,CAAC"}

package/dist/i18n/en.d.ts

@@ -0,0 +1,4 @@
+import type { CoreMessages } from './types.js';
+/** English catalogue. This is the source of truth every other locale mirrors. */
+export declare const en: CoreMessages;
+//# sourceMappingURL=en.d.ts.map

package/dist/i18n/en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/i18n/en.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,iFAAiF;AACjF,eAAO,MAAM,EAAE,EAAE,YAsOhB,CAAC"}

package/dist/i18n/en.js

@@ -0,0 +1,168 @@
+const n = (value) => value.toLocaleString('en-US');
+/** English catalogue. This is the source of truth every other locale mirrors. */
+export const en = {
+    locale: 'en',
+    numberLocale: 'en-US',
+    rules: {
+        'duplicate-blocks': {
+            title: 'Repeated paragraphs',
+            rationale: 'Removes whole paragraphs that already appear earlier in the prompt. Common when prompts are assembled by concatenating templates: the same block of instructions goes in twice and is paid for twice.',
+        },
+        'near-duplicate-blocks': {
+            title: 'Near-identical paragraphs',
+            rationale: 'Removes paragraphs sharing 92% or more of their words with an earlier one, catching instructions reworded to say the same thing twice. Aggressive level: read the diff, because the 8% that differs may be exactly the nuance you cared about.',
+        },
+        'duplicate-lines': {
+            title: 'Repeated lines',
+            rationale: 'Removes lines identical to one that appeared earlier, ignoring case, accents and punctuation. Only touches lines of 25 characters or more, so bullets and legitimate separators survive.',
+        },
+        'verbose-phrases': {
+            title: 'Wordy phrasing',
+            rationale: 'Replaces long constructions with their short equivalent ("in order to" → "to", "con el fin de" → "para"). The meaning is identical; only the token count changes.',
+        },
+        politeness: {
+            title: 'Politeness formulas',
+            rationale: 'Strips "please", "thank you", "kindly", "por favor"... The model does not answer better for being asked nicely, and every formula is paid for on every call.',
+        },
+        filler: {
+            title: 'Filler and throat-clearing',
+            rationale: 'Removes empty openers such as "basically", "it is important to note that" or "cabe destacar que", which carry no instruction.',
+        },
+        hedges: {
+            title: 'Hedging',
+            rationale: 'Removes "I think", "in my opinion", "creo que". Inside an instruction they weaken the request without adding information.',
+        },
+        intensifiers: {
+            title: 'Intensifiers',
+            rationale: 'Strips "very", "really", "extremely", "muy"... They rarely change the task. Aggressive level because in a specific prompt the nuance can matter.',
+        },
+        'self-check': {
+            title: 'Self-verification instructions',
+            rationale: 'Removes "double-check your work", "verifica tu respuesta". Current models already verify their own output; asking explicitly triggers extra steps paid for in output tokens. Disable this rule if your workflow depends on that verification.',
+        },
+        emphasis: {
+            title: 'Shouted emphasis',
+            rationale: 'Lowercases shouted words (MUST, NEVER, CRITICAL) and drops prefixes like "IMPORTANT:". Uppercase splits into more tokens than lowercase, and on current models excessive emphasis makes the instruction over-trigger.',
+        },
+        decoration: {
+            title: 'Decorative separators',
+            rationale: 'Removes lines made only of repeated characters (====, ----, ****) and runs of exclamation marks. They add no structure the model uses and cost tokens on every call.',
+        },
+        whitespace: {
+            title: 'Stray whitespace',
+            rationale: 'Trims trailing spaces, collapses repeated spaces inside a line and reduces consecutive blank lines to one. Leading indentation is preserved so lists and nested markdown keep working.',
+        },
+    },
+    llm: {
+        emptyResponse: () => 'The model returned an empty response.',
+        protectedContentAltered: (count) => `The model altered ${count} protected fragment(s) (code, URL or template placeholder). Discarded so the prompt is not broken.`,
+        notShorter: (after, before) => `The result is not shorter (${after} vs ${before} tokens). Keeping the deterministic version.`,
+        suspiciousShrink: (retainedPct) => `The result keeps only ${retainedPct}% of the tokens. That looks like a summary rather than compression: review it by hand before using it.`,
+    },
+    suggest: {
+        'not-found': () => 'the quoted phrase is not in the prompt — the model paraphrased what it was copying',
+        'touches-protected': () => 'it would edit code, a URL, a placeholder or a tag, which are copied verbatim',
+        'introduces-protected': () => 'the replacement adds a placeholder or URL that was not there',
+        'no-saving': () => 'it is no shorter than what it replaces',
+        overlaps: () => 'it shares text with a suggestion already accepted',
+    },
+    advisories: {
+        contextOverflow: ({ tokens, modelName, contextWindow }) => ({
+            title: 'The prompt does not fit in the context window',
+            detail: `The optimised prompt is ~${n(tokens)} tokens and ${modelName} accepts ${n(contextWindow)}. The call will fail: split the content or move to a model with a larger window.`,
+        }),
+        promptCaching: ({ placeholder, prefixTokens, totalTokens, minTokens, modelName, hitRatePct, readPct, writePct, explicit, }) => {
+            const scope = placeholder
+                ? `The stable prefix — everything before the first placeholder ${placeholder} — is ~${n(prefixTokens)} of the prompt's ${n(totalTokens)} tokens, and clears ${modelName}'s ${n(minTokens)}-token cacheable minimum.`
+                : `The prompt has no variable placeholders, so the whole thing is a cacheable prefix and it clears ${modelName}'s ${n(minTokens)}-token minimum.`;
+            const how = explicit
+                ? 'Put the cache marker at the end of the stable prefix: any byte that changes before the cut invalidates everything after it.'
+                : `${modelName} caches automatically above its minimum, so there is nothing to set — but the same rule applies: any byte that changes before the cut invalidates everything after it.`;
+            return {
+                title: 'Turn on prompt caching for the stable prefix',
+                detail: `${scope} At a ${hitRatePct}% hit rate, a cache read costs ${readPct}% of the input price and a write costs ${writePct}%. ${how}`,
+            };
+        },
+        promptCachingNotWorthIt: () => ({
+            title: 'At that hit rate, caching does not pay off',
+            detail: 'A cache write costs 125% of the input price and a read costs 10%. Below roughly a 28% hit rate you pay more than you save. Either raise prefix reuse or leave caching off.',
+        }),
+        belowCacheMinimum: ({ modelName, minTokens, placeholder, prefixTokens, totalTokens, mentionLowerMinimum, }) => {
+            const reason = placeholder
+                ? `here the first variable placeholder (${placeholder}) shows up at ~${n(prefixTokens)} tokens and only what precedes it can be cached`
+                : `this prompt has ~${n(totalTokens)}`;
+            return {
+                title: 'Below the cacheable minimum',
+                detail: `${modelName} needs at least ${n(minTokens)} prefix tokens to cache; ${reason}. Setting cache_control will not error, it simply will not cache.` +
+                    (mentionLowerMinimum
+                        ? ' Claude Opus 5 lowers that minimum to 512 tokens, so short prompts that miss here would cache there.'
+                        : ''),
+            };
+        },
+        cachePrefixReorder: ({ staticTokensAfter, sharePct, placeholder }) => ({
+            title: 'Move the stable instructions ahead of the first placeholder',
+            detail: `About ~${n(staticTokensAfter)} tokens of stable content (${sharePct}% of the prompt) sit after the first variable placeholder ${placeholder}, so today they never get cached. Reorder the template — fixed instructions and context first, placeholders last — and that content starts being read from cache at 10% of the price. Check that reordering does not change what the prompt asks for.`,
+        }),
+        batchApi: () => ({
+            title: 'If the work tolerates latency, use the Batch API',
+            detail: 'The Batch API applies a 50% discount on both input and output. Most batches finish in under an hour, with a 24-hour maximum. It fits bulk classification, data enrichment or evaluations: anything that is not answering a user in real time.',
+        }),
+        modelDowngrade: ({ modelName, tier, candidateName, currentUsd, candidateUsd }) => ({
+            title: `This task may not need ${modelName}`,
+            detail: `By length and vocabulary the prompt looks like "${tier}" complexity. On ${candidateName} you would go from ${currentUsd} to ${candidateUsd} per month. This is a keyword heuristic, not a judgement about answer quality: measure the difference with your own evaluations before switching in production.`,
+        }),
+        outputDominated: ({ outputUsd, inputUsd }) => ({
+            title: 'Your cost is in the output, not the prompt',
+            detail: `Output accounts for ${outputUsd} per month against ${inputUsd} of input. Shortening the prompt has a low ceiling here. The two controls that move the needle are the effort parameter (lower it when the task is not reasoning-heavy) and explicitly asking for concise answers.`,
+        }),
+        promoPricing: ({ modelName, promoInput, promoOutput, until, listInput, listOutput }) => ({
+            title: 'You are costing this with promotional pricing',
+            detail: `${modelName} has introductory pricing of ${promoInput}/${promoOutput} per million tokens until ${until}. After that date it moves to ${listInput}/${listOutput}: your bill goes up even if you change nothing.`,
+        }),
+        contradictoryInstructions: ({ axis, firstValue, firstSnippet, secondValue, secondSnippet, otherCount, }) => ({
+            title: `Two instructions disagree about ${axis}`,
+            detail: `One says ${firstValue} ("${firstSnippet}") and another says ${secondValue} ("${secondSnippet}"). ` +
+                'The model has to pick one, and which one it picks can change between calls — so this is a correctness problem before it is a cost one. ' +
+                'Deleting the instruction you did not mean also shortens the prompt.' +
+                (otherCount > 0
+                    ? ` ${otherCount} other ${otherCount === 1 ? 'pair' : 'pairs'} of instructions disagree too.`
+                    : ''),
+        }),
+        redundantExamples: ({ redundantCount, totalCount, redundantTokens, topSimilarityPct }) => ({
+            title: `${redundantCount} of ${totalCount} examples repeat an earlier one`,
+            detail: `They share ${topSimilarityPct}% or more of their wording with an example that comes before them, and account for about ${n(redundantTokens)} tokens paid for on every call. ` +
+                'Few-shot examples earn their cost by teaching something new; two that demonstrate the same pattern teach it once. ' +
+                'Read them before deleting: an example that looks redundant may be showing a boundary case on purpose.',
+        }),
+        movableSchema: ({ blocks, tokens, keyList, cue }) => ({
+            title: 'The output schema could travel in the request instead of the prompt',
+            detail: `${blocks === 1 ? 'A schema block' : `${blocks} schema blocks`} introduced by "${cue}" defines ${keyList}, costing about ${n(tokens)} tokens on every call. ` +
+                'Every major API now takes a response schema as a request parameter — output_config.format, response_format, responseSchema — and moving it there is the rare change that is both cheaper and stricter: prose asks the model to comply, a parameter makes the decoder comply. ' +
+                'Trazum cannot make this edit, because it changes the call rather than the prompt, and it does not check whether your provider offers the parameter — if it does not, this is not available to you.',
+        }),
+        restatedOutputFormat: ({ restatedCount, totalCount, restatedTokens, keyList }) => ({
+            title: 'The output format is specified twice',
+            detail: `The prose describes ${restatedCount} of the ${totalCount} fields your schema already defines (${keyList}), costing about ${n(restatedTokens)} tokens on every call. ` +
+                'The code block is the version worth keeping: it is unambiguous, and Trazum never edits it. ' +
+                'Check the two agree before deleting either — when a prompt says one thing in prose and another in its schema, the prose is usually the one that went stale.',
+        }),
+    },
+    contradictionAxes: {
+        'response-language': 'the language of the answer',
+        'output-format': 'the output format',
+        'response-length': 'how long the answer should be',
+        'reasoning-visibility': 'whether to show the reasoning',
+    },
+    contradictionValues: {
+        'fixed-language': 'always the same language',
+        'mirror-language': "the reader's own language",
+        'format-json': 'JSON',
+        'format-markdown': 'Markdown',
+        'format-plain-text': 'plain text',
+        'length-brief': 'keep it brief',
+        'length-detailed': 'go into detail',
+        'reasoning-shown': 'show the reasoning',
+        'reasoning-hidden': 'hide the reasoning',
+    },
+};
+//# sourceMappingURL=en.js.map

package/dist/i18n/en.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.js","sourceRoot":"","sources":["../../src/i18n/en.ts"],"names":[],"mappings":"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"}

package/dist/i18n/es.d.ts

@@ -0,0 +1,4 @@
+import type { CoreMessages } from './types.js';
+/** Spanish catalogue. Mirrors `en.ts`, which is the source of truth. */
+export declare const es: CoreMessages;
+//# sourceMappingURL=es.d.ts.map

package/dist/i18n/es.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"es.d.ts","sourceRoot":"","sources":["../../src/i18n/es.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,wEAAwE;AACxE,eAAO,MAAM,EAAE,EAAE,YAsOhB,CAAC"}