modelrig 0.0.1 → 0.2.0

package/dist/registry/seed.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Candidate seeding — the "what should serve this route?" answer, from the
+ * registry rather than from taste. Shared by `modelrig init` (WS2) and the
+ * oracle's `create_route` (WS1), so a drafted route looks the same however
+ * it was drafted.
+ *
+ * The rule: the INCUMBENT leads. The model you already call goes first, so
+ * the drafted route reproduces today's behavior on its first run; the
+ * cheapest probed models that satisfy the inferred capability needs follow
+ * as challengers a bake-off can put to the test. We never silently promote
+ * a cheaper model into first position — that decision belongs to evidence
+ * and a human.
+ */
+import type { CapabilityPredicate, ModelSelectRow } from "./select";
+import type { DraftCandidate } from "../routes/draft";
+export interface SeedCandidatesInput {
+    readonly capabilities: readonly CapabilityPredicate[];
+    /** "provider/model" the caller uses today, if known. */
+    readonly incumbent: string | null;
+    readonly maxInputUsdPerMtok: number | null;
+    /** Caller-supplied candidates short-circuit seeding entirely. */
+    readonly explicit: ReadonlyArray<{
+        readonly provider: string;
+        readonly model: string;
+    }> | null;
+    /** How many challengers to add behind the incumbent. */
+    readonly challengerCount?: number;
+}
+export interface SeededCandidates {
+    readonly candidates: readonly DraftCandidate[];
+    readonly incumbent: {
+        readonly provider: string;
+        readonly model: string;
+    } | null;
+    /** Human-readable account of why this list looks like it does. */
+    readonly reasoning: readonly string[];
+}
+export declare function splitModelKey(modelKey: string): {
+    provider: string;
+    model: string;
+} | null;
+export declare function seedCandidates(rows: readonly ModelSelectRow[], input: SeedCandidatesInput): SeededCandidates;
+//# sourceMappingURL=seed.d.ts.map

package/dist/registry/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../src/registry/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACtD,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IAC/F,wDAAwD;IACxD,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACjF,kEAAkE;IAClE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAI1F;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,cAAc,EAAE,EAC/B,KAAK,EAAE,mBAAmB,GACzB,gBAAgB,CAqFlB"}

package/dist/registry/seed.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Candidate seeding — the "what should serve this route?" answer, from the
+ * registry rather than from taste. Shared by `modelrig init` (WS2) and the
+ * oracle's `create_route` (WS1), so a drafted route looks the same however
+ * it was drafted.
+ *
+ * The rule: the INCUMBENT leads. The model you already call goes first, so
+ * the drafted route reproduces today's behavior on its first run; the
+ * cheapest probed models that satisfy the inferred capability needs follow
+ * as challengers a bake-off can put to the test. We never silently promote
+ * a cheaper model into first position — that decision belongs to evidence
+ * and a human.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitModelKey = splitModelKey;
+exports.seedCandidates = seedCandidates;
+const select_1 = require("./select");
+function splitModelKey(modelKey) {
+    const slash = modelKey.indexOf("/");
+    if (slash <= 0 || slash === modelKey.length - 1)
+        return null;
+    return { provider: modelKey.slice(0, slash), model: modelKey.slice(slash + 1) };
+}
+function seedCandidates(rows, input) {
+    if (input.explicit !== null && input.explicit.length > 0) {
+        return {
+            candidates: input.explicit.map((c) => ({ ...c })),
+            incumbent: input.explicit[0] ?? null,
+            reasoning: ["Candidates were given explicitly — the registry was not consulted."],
+        };
+    }
+    const reasoning = [];
+    const candidates = [];
+    let incumbent = null;
+    if (input.incumbent !== null && input.incumbent !== "") {
+        const parsed = splitModelKey(input.incumbent);
+        if (parsed === null) {
+            reasoning.push(`Could not read "${input.incumbent}" as an incumbent — model keys are "provider/model". ` +
+                "Drafted without one, so review the ordering before you run it.");
+        }
+        else {
+            incumbent = parsed;
+            const known = rows.some((r) => r.key === input.incumbent);
+            candidates.push({
+                ...parsed,
+                note: known
+                    ? "incumbent — your current model, listed first so behavior is unchanged on the first run"
+                    : "incumbent — your current model (not in our probed registry, so unmeasured here)",
+            });
+            reasoning.push(`Incumbent ${input.incumbent} leads: the drafted route reproduces what you do today.`);
+        }
+    }
+    else {
+        reasoning.push("No incumbent was identified, so the cheapest probed model that meets the requirements " +
+            "leads. If you already use a specific model, put it first before running this.");
+    }
+    const challengerCount = input.challengerCount ?? 2;
+    const wanted = challengerCount + (incumbent === null ? 0 : 1);
+    const hits = (0, select_1.selectModels)(rows, {
+        caps: input.capabilities,
+        maxInputUsdPerMtok: input.maxInputUsdPerMtok,
+        limit: challengerCount + 1,
+    });
+    for (const row of hits) {
+        if (candidates.length >= wanted)
+            break;
+        if (incumbent !== null && row.key === `${incumbent.provider}/${incumbent.model}`)
+            continue;
+        const parsed = splitModelKey(row.key);
+        if (parsed === null)
+            continue;
+        const effective = row.effectiveUsdPer1k;
+        candidates.push({
+            ...parsed,
+            note: effective === null
+                ? "probed, but no effective-cost figure yet"
+                : `probed: $${effective.toFixed(4)} per 1k conformant outputs`,
+        });
+    }
+    if (input.capabilities.length > 0) {
+        reasoning.push(`Challengers had to satisfy every requirement asked for (${input.capabilities.join(", ")}) ` +
+            "in probing — declared support alone was not enough.");
+    }
+    if (input.maxInputUsdPerMtok !== null) {
+        reasoning.push(`Challengers were capped at $${input.maxInputUsdPerMtok}/M input tokens.`);
+    }
+    if (candidates.length === 0) {
+        reasoning.push("No probed model satisfied the requirements, so this draft has no candidates and will not " +
+            "load — name a model explicitly, or loosen the requirements.");
+    }
+    else {
+        reasoning.push("Challengers are ranked by effective cost of conformance, not list price. Nothing switches " +
+            "to them without a bake-off and an explicit approval.");
+    }
+    return { candidates, incumbent, reasoning };
+}

package/dist/registry/select.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Model selection — the capability-first question, answered once.
+ *
+ * "Which models can serve strict JSON under $1/M?" is asked in three places:
+ * the console's query box, the MCP oracle's `query_registry` tool, and the
+ * docs. Phase 5 plan §10 names the risk by name — oracle answers drifting
+ * from console answers — so the grammar and the predicates live HERE and
+ * both surfaces call in. If this file changes, every surface changes.
+ *
+ * Dependency-free on purpose: the console imports this source directly (its
+ * tsconfig path alias) and must not drag SQLite or the adapters into a
+ * browser bundle.
+ *
+ * Bars are the registry's own, not new judgments: 0.9 conformance (the
+ * discrepancy detector's bar) and 0.5 grounding (facts.ts's GROUNDED_BAR).
+ */
+/** The capability predicates a question can carry. Deliberately the probed
+ * dimensions only — we answer from measurement, not from provider claims. */
+export type CapabilityPredicate = "structured-native" | "structured-coached" | "grounding" | "caching";
+export declare const ALL_CAPABILITY_PREDICATES: readonly CapabilityPredicate[];
+/** Plain-language gloss per predicate — the explainability layer travels
+ * WITH the answer (console-explainability.md §1), it is not a separate doc. */
+export declare const PREDICATE_GLOSS: Readonly<Record<CapabilityPredicate, string>>;
+/** The row shape selection needs. A projection, not the registry entry —
+ * console (Supabase mirror) and oracle (registry.json) both flatten into it. */
+export interface ModelSelectRow {
+    readonly key: string;
+    readonly provider: string;
+    readonly inputUsdPerMtok: number | null;
+    readonly outputUsdPerMtok: number | null;
+    readonly conformRate: number | null;
+    readonly nativeRungRate: number | null;
+    readonly groundedRate: number | null;
+    readonly cacheHitRate: number | null;
+    readonly effectiveUsdPer1k: number | null;
+    readonly discrepancies: number;
+    readonly probedAsOf: string | null;
+}
+export declare function hasCapability(row: ModelSelectRow, cap: CapabilityPredicate): boolean;
+export interface ParsedQuery {
+    readonly caps: readonly CapabilityPredicate[];
+    readonly maxInputUsdPerMtok: number | null;
+    /** Leftover words — substring-matched against the model key. */
+    readonly text: readonly string[];
+}
+/** The tiny grammar behind the query box and the oracle's free-text input:
+ * capability words + an "under $N/M" price cap; everything else is a
+ * substring match on the model key. Small on purpose — a question we cannot
+ * parse should fall through to text, not guess. */
+export declare function parseCapabilityQuery(query: string): ParsedQuery;
+export interface SelectCriteria {
+    /** Capability predicates ANDed together — every one must hold. */
+    readonly caps?: readonly CapabilityPredicate[];
+    readonly maxInputUsdPerMtok?: number | null;
+    readonly provider?: string | null;
+    readonly discrepanciesOnly?: boolean;
+    /** Substring terms ANDed against the model key. */
+    readonly text?: readonly string[];
+    /** Sort by effective cost of conformance ascending (default true) — the
+     * only ranking that answers "cheapest that actually works". */
+    readonly sortByEffectiveCost?: boolean;
+    readonly limit?: number;
+}
+export declare function selectModels(rows: readonly ModelSelectRow[], criteria?: SelectCriteria): ModelSelectRow[];
+/** Why a question found nothing — the difference between "no such model" and
+ * "we have not probed one yet" is the whole point of the demand meter. */
+export declare function explainEmptySelection(criteria: SelectCriteria): string;
+//# sourceMappingURL=select.d.ts.map

package/dist/registry/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/registry/select.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;6EAC6E;AAC7E,MAAM,MAAM,mBAAmB,GAC3B,mBAAmB,GACnB,oBAAoB,GACpB,WAAW,GACX,SAAS,CAAC;AAEd,eAAO,MAAM,yBAAyB,EAAE,SAAS,mBAAmB,EAKnE,CAAC;AAEF;+EAC+E;AAC/E,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAQzE,CAAC;AAEF;gFACgF;AAChF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAKD,wBAAgB,aAAa,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAWpF;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AA0BD;;;mDAGmD;AACnD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAkB/D;AAED,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC/C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,mDAAmD;IACnD,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;mEAC+D;IAC/D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,cAAc,EAAE,EAC/B,QAAQ,GAAE,cAAmB,GAC5B,cAAc,EAAE,CA6BlB;AAED;0EAC0E;AAC1E,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAatE"}

package/dist/registry/select.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Model selection — the capability-first question, answered once.
+ *
+ * "Which models can serve strict JSON under $1/M?" is asked in three places:
+ * the console's query box, the MCP oracle's `query_registry` tool, and the
+ * docs. Phase 5 plan §10 names the risk by name — oracle answers drifting
+ * from console answers — so the grammar and the predicates live HERE and
+ * both surfaces call in. If this file changes, every surface changes.
+ *
+ * Dependency-free on purpose: the console imports this source directly (its
+ * tsconfig path alias) and must not drag SQLite or the adapters into a
+ * browser bundle.
+ *
+ * Bars are the registry's own, not new judgments: 0.9 conformance (the
+ * discrepancy detector's bar) and 0.5 grounding (facts.ts's GROUNDED_BAR).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREDICATE_GLOSS = exports.ALL_CAPABILITY_PREDICATES = void 0;
+exports.hasCapability = hasCapability;
+exports.parseCapabilityQuery = parseCapabilityQuery;
+exports.selectModels = selectModels;
+exports.explainEmptySelection = explainEmptySelection;
+exports.ALL_CAPABILITY_PREDICATES = [
+    "structured-native",
+    "structured-coached",
+    "grounding",
+    "caching",
+];
+/** Plain-language gloss per predicate — the explainability layer travels
+ * WITH the answer (console-explainability.md §1), it is not a separate doc. */
+exports.PREDICATE_GLOSS = {
+    "structured-native": "the provider enforces your JSON Schema on its side — probed native rung rate above zero",
+    "structured-coached": "output matched the schema at least 90% of probed samples, whether or not the provider enforced it natively",
+    grounding: "at least half of probed answers cited real retrieved sources rather than answering from memory",
+    caching: "repeat calls actually reported cached input tokens — a measured discount, not a claim",
+};
+const CONFORMANCE_BAR = 0.9;
+const GROUNDED_BAR = 0.5;
+function hasCapability(row, cap) {
+    switch (cap) {
+        case "structured-native":
+            return (row.nativeRungRate ?? 0) > 0;
+        case "structured-coached":
+            return (row.conformRate ?? 0) >= CONFORMANCE_BAR;
+        case "grounding":
+            return (row.groundedRate ?? 0) >= GROUNDED_BAR;
+        case "caching":
+            return (row.cacheHitRate ?? 0) > 0;
+    }
+}
+/** Question scaffolding. A search box gets keywords; the MCP oracle gets a
+ * whole sentence ("which models can serve strict JSON under $1/M?"), and
+ * without this every one of those words would become a substring filter on
+ * the model key and match nothing. Dropping them is strictly safer than
+ * matching them: no model key contains "which". */
+const STOP_WORDS = new Set([
+    "a", "about", "an", "and", "any", "are", "avail", "available", "be", "best", "can", "cheapest", "do",
+    "does", "find", "for", "give", "has", "have", "how", "i", "is", "it", "list", "me", "model",
+    "models", "need", "of", "or", "provider", "providers", "serve", "serves", "show", "some",
+    "support", "supports", "that", "the", "their", "them", "there", "these", "they", "this",
+    "those", "to", "use", "using", "want", "what", "whats", "which", "who", "will", "with",
+]);
+/** Punctuation a question drags in — stripped so "json?" is still "json". */
+function normalizeWord(word) {
+    return word.replace(/^[^a-z0-9./_-]+|[^a-z0-9./_-]+$/g, "");
+}
+const CAP_WORDS = [
+    [["json", "strict", "structured", "schema"], "structured-native"],
+    [["grounded", "grounding", "search", "web"], "grounding"],
+    [["cache", "caching", "cached"], "caching"],
+];
+/** The tiny grammar behind the query box and the oracle's free-text input:
+ * capability words + an "under $N/M" price cap; everything else is a
+ * substring match on the model key. Small on purpose — a question we cannot
+ * parse should fall through to text, not guess. */
+function parseCapabilityQuery(query) {
+    const caps = [];
+    const text = [];
+    const priceMatch = query.match(/under\s+\$?(\d+(?:\.\d+)?)\s*\/?\s*m/i);
+    const maxInputUsdPerMtok = priceMatch ? Number(priceMatch[1]) : null;
+    const cleaned = query.replace(/under\s+\$?\d+(?:\.\d+)?\s*\/?\s*m\w*/i, "");
+    for (const raw of cleaned.toLowerCase().split(/\s+/)) {
+        const word = normalizeWord(raw);
+        if (word === "" || STOP_WORDS.has(word))
+            continue;
+        const match = CAP_WORDS.find(([words]) => words.includes(word));
+        if (match === undefined) {
+            text.push(word);
+            continue;
+        }
+        if (!caps.includes(match[1]))
+            caps.push(match[1]);
+    }
+    return { caps, maxInputUsdPerMtok, text };
+}
+function selectModels(rows, criteria = {}) {
+    const caps = criteria.caps ?? [];
+    const text = criteria.text ?? [];
+    let out = rows.filter((row) => {
+        if (criteria.provider != null && criteria.provider !== "" && row.provider !== criteria.provider) {
+            return false;
+        }
+        if (criteria.discrepanciesOnly === true && row.discrepancies === 0)
+            return false;
+        if (caps.some((cap) => !hasCapability(row, cap)))
+            return false;
+        if (criteria.maxInputUsdPerMtok != null) {
+            // A model with no published input price cannot be proven under a cap —
+            // absence is not "cheap enough".
+            if (row.inputUsdPerMtok === null || row.inputUsdPerMtok > criteria.maxInputUsdPerMtok) {
+                return false;
+            }
+        }
+        if (text.length > 0 && !text.every((w) => row.key.toLowerCase().includes(w)))
+            return false;
+        return true;
+    });
+    if (criteria.sortByEffectiveCost !== false) {
+        out = [...out].sort((a, b) => (a.effectiveUsdPer1k ?? Number.POSITIVE_INFINITY) -
+            (b.effectiveUsdPer1k ?? Number.POSITIVE_INFINITY));
+    }
+    if (criteria.limit !== undefined && criteria.limit > 0)
+        out = out.slice(0, criteria.limit);
+    return out;
+}
+/** Why a question found nothing — the difference between "no such model" and
+ * "we have not probed one yet" is the whole point of the demand meter. */
+function explainEmptySelection(criteria) {
+    const parts = [];
+    for (const cap of criteria.caps ?? [])
+        parts.push(exports.PREDICATE_GLOSS[cap]);
+    if (criteria.maxInputUsdPerMtok != null) {
+        parts.push(`input price at or under $${criteria.maxInputUsdPerMtok}/M tokens`);
+    }
+    const asked = parts.length > 0 ? parts.join("; and ") : "the requested filters";
+    return (`No probed model in the registry satisfies ${asked}. ` +
+        "This means no model we have MEASURED qualifies — not that none exists. " +
+        "Unprobed models are absent from these answers by design; open a probe request " +
+        "if you need a specific model covered.");
+}

package/dist/registry/staleness.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Probe-data freshness — addendum A2 (TrustedRouter pattern 3): never serve
+ * stale-as-fresh. The SLO is 7-day-on-change / monthly; without per-entry
+ * change-detection timestamps the enforceable bound is the monthly one, so
+ * staleness = newest probed as_of older than 31 days. Stale data stays
+ * visible — bannered and dated, never hidden.
+ */
+export declare const PROBE_FRESHNESS_SLO_DAYS = 31;
+export interface ProbeFreshness {
+    readonly stale: boolean;
+    /** Newest probed as_of across the corpus — the banner's date. */
+    readonly newestAsOf: string | null;
+    readonly daysOld: number | null;
+}
+export declare function probeFreshness(asOfDates: ReadonlyArray<string | null | undefined>, now?: Date): ProbeFreshness;
+/** The banner sentence (brand guide §7: plain, dated, never hidden). */
+export declare function stalenessSentence(freshness: ProbeFreshness): string;
+//# sourceMappingURL=staleness.d.ts.map

package/dist/registry/staleness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staleness.d.ts","sourceRoot":"","sources":["../../src/registry/staleness.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EACnD,GAAG,GAAE,IAAiB,GACrB,cAAc,CAgBhB;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,CASnE"}

package/dist/registry/staleness.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Probe-data freshness — addendum A2 (TrustedRouter pattern 3): never serve
+ * stale-as-fresh. The SLO is 7-day-on-change / monthly; without per-entry
+ * change-detection timestamps the enforceable bound is the monthly one, so
+ * staleness = newest probed as_of older than 31 days. Stale data stays
+ * visible — bannered and dated, never hidden.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROBE_FRESHNESS_SLO_DAYS = void 0;
+exports.probeFreshness = probeFreshness;
+exports.stalenessSentence = stalenessSentence;
+exports.PROBE_FRESHNESS_SLO_DAYS = 31;
+function probeFreshness(asOfDates, now = new Date()) {
+    const parsed = asOfDates
+        .filter((d) => typeof d === "string" && d !== "")
+        .map((d) => new Date(d).getTime())
+        .filter((t) => Number.isFinite(t));
+    if (parsed.length === 0) {
+        // No probe data at all is its own kind of stale — banner with no date.
+        return { stale: true, newestAsOf: null, daysOld: null };
+    }
+    const newest = Math.max(...parsed);
+    const daysOld = Math.floor((now.getTime() - newest) / 86400000);
+    return {
+        stale: daysOld > exports.PROBE_FRESHNESS_SLO_DAYS,
+        newestAsOf: new Date(newest).toISOString(),
+        daysOld,
+    };
+}
+/** The banner sentence (brand guide §7: plain, dated, never hidden). */
+function stalenessSentence(freshness) {
+    if (freshness.newestAsOf === null) {
+        return "No probe data yet — nothing on this page has been verified.";
+    }
+    return (`This probe data exceeded its freshness window (${exports.PROBE_FRESHNESS_SLO_DAYS} days): ` +
+        `newest result ${freshness.newestAsOf.slice(0, 10)}, ${freshness.daysOld} days old. ` +
+        "The data below is still shown, clearly dated — a rerun is due.");
+}

package/dist/rigindex/bootstrap.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Hierarchical bootstrap CI — RATIFIED PER THE ERRATUM (stop2-architect-review
+ * §1): per rep, (1) resample fixtures within the subtype with replacement,
+ * then (2) ONE resample of each (model, fixture)'s samples, used consistently
+ * across ALL of that model's comparisons in the rep (NOT per model-pair — the
+ * archived prototype's per-pair form injects extra noise and is superseded).
+ * ≥200 reps; 2.5/97.5 percentiles. RNG is seeded and injectable so a fixed
+ * seed reproduces scores and tiers exactly.
+ *
+ * Any change to the resampling scheme re-opens STOP-2.
+ */
+import type { SubtypeSamples } from "./types";
+export declare const BOOTSTRAP_REPS = 200;
+export declare const CI_LO = 0.025;
+export declare const CI_HI = 0.975;
+/** Deterministic PRNG (mulberry32) — seedable, dependency-free. */
+export declare function mulberry32(seed: number): () => number;
+/**
+ * The per-rep resampling plan, exposed for the determinism test family (f):
+ * one fixture multiset draw + exactly ONE per-(model, fixture) sample
+ * resample, keyed so the same array object serves every comparison the model
+ * enters that rep.
+ */
+export declare function drawRep(samples: SubtypeSamples, fixtures: readonly string[], rng: () => number): {
+    readonly fixtureDraws: readonly string[];
+    readonly resampled: SubtypeSamples;
+};
+/**
+ * Bootstrap CIs for one subtype's anchored scores. Returns modelKey →
+ * [2.5th, 97.5th] percentile of the rep RigIndex distribution. A rep where the
+ * basket cannot anchor (all basket members drew empty) is skipped — with the
+ * probe corpus every model has every fixture, so this is a degenerate-input
+ * guard, not a data path.
+ */
+export declare function bootstrapCis(samples: SubtypeSamples, basket: readonly string[], reps: number, rng: () => number): Record<string, readonly [number, number]>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/rigindex/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/rigindex/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,SAAS,CAAC;AAE5D,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,KAAK,QAAQ,CAAC;AAC3B,eAAO,MAAM,KAAK,QAAQ,CAAC;AAE3B,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CASrD;AAOD;;;;;GAKG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,GAAG,EAAE,MAAM,MAAM,GAChB;IACD,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;CACpC,CAYA;AAWD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAsB3C"}

package/dist/rigindex/bootstrap.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Hierarchical bootstrap CI — RATIFIED PER THE ERRATUM (stop2-architect-review
+ * §1): per rep, (1) resample fixtures within the subtype with replacement,
+ * then (2) ONE resample of each (model, fixture)'s samples, used consistently
+ * across ALL of that model's comparisons in the rep (NOT per model-pair — the
+ * archived prototype's per-pair form injects extra noise and is superseded).
+ * ≥200 reps; 2.5/97.5 percentiles. RNG is seeded and injectable so a fixed
+ * seed reproduces scores and tiers exactly.
+ *
+ * Any change to the resampling scheme re-opens STOP-2.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CI_HI = exports.CI_LO = exports.BOOTSTRAP_REPS = void 0;
+exports.mulberry32 = mulberry32;
+exports.drawRep = drawRep;
+exports.bootstrapCis = bootstrapCis;
+const graph_1 = require("./graph");
+const fit_1 = require("./fit");
+exports.BOOTSTRAP_REPS = 200;
+exports.CI_LO = 0.025;
+exports.CI_HI = 0.975;
+/** Deterministic PRNG (mulberry32) — seedable, dependency-free. */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** One with-replacement resample of `list`, same length. */
+function resample(list, rng) {
+    return list.map(() => list[Math.floor(rng() * list.length)]);
+}
+/**
+ * The per-rep resampling plan, exposed for the determinism test family (f):
+ * one fixture multiset draw + exactly ONE per-(model, fixture) sample
+ * resample, keyed so the same array object serves every comparison the model
+ * enters that rep.
+ */
+function drawRep(samples, fixtures, rng) {
+    const fixtureDraws = resample(fixtures, rng);
+    // ONE resample per (model, fixture) — iterate in stable sorted order so a
+    // fixed seed reproduces the plan exactly.
+    const resampled = {};
+    for (const model of Object.keys(samples).sort()) {
+        resampled[model] = {};
+        for (const fixtureId of Object.keys(samples[model]).sort()) {
+            resampled[model][fixtureId] = resample(samples[model][fixtureId], rng);
+        }
+    }
+    return { fixtureDraws, resampled };
+}
+function percentile(sorted, q) {
+    if (sorted.length === 0)
+        return NaN;
+    const idx = q * (sorted.length - 1);
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    if (lo === hi)
+        return sorted[lo];
+    return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
+}
+/**
+ * Bootstrap CIs for one subtype's anchored scores. Returns modelKey →
+ * [2.5th, 97.5th] percentile of the rep RigIndex distribution. A rep where the
+ * basket cannot anchor (all basket members drew empty) is skipped — with the
+ * probe corpus every model has every fixture, so this is a degenerate-input
+ * guard, not a data path.
+ */
+function bootstrapCis(samples, basket, reps, rng) {
+    const models = Object.keys(samples).sort();
+    const fixtures = [...new Set(models.flatMap((m) => Object.keys(samples[m])))].sort();
+    const draws = Object.fromEntries(models.map((m) => [m, []]));
+    for (let rep = 0; rep < reps; rep += 1) {
+        const { fixtureDraws, resampled } = drawRep(samples, fixtures, rng);
+        const graph = (0, graph_1.buildSubtypeGraph)(resampled, fixtureDraws);
+        const scores = (0, fit_1.anchorScores)((0, fit_1.fitBradleyTerry)(graph), basket);
+        if (scores === null)
+            continue;
+        for (const m of models) {
+            if (scores[m] !== undefined)
+                draws[m].push(scores[m]);
+        }
+    }
+    const out = {};
+    for (const m of models) {
+        const sorted = [...draws[m]].sort((a, b) => a - b);
+        if (sorted.length === 0)
+            continue;
+        out[m] = [percentile(sorted, exports.CI_LO), percentile(sorted, exports.CI_HI)];
+    }
+    return out;
+}

package/dist/rigindex/fit.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bradley-Terry fit + frontier anchor — RATIFIED (stop2-architect-review §1):
+ * Hunter's MM algorithm, 400 iterations or convergence, symmetric 0.01
+ * pseudo-wins per ordered pair (keeps saturated all-tie graphs finite and the
+ * graph connected), geometric-mean-normalized per iteration. Anchor:
+ * RigIndex_i = 100 × p_i / GM(basket strengths) — scores >100 are expected
+ * ("above the frontier average").
+ *
+ * Any change to the solver, regularization, or anchor re-opens STOP-2.
+ */
+import type { SubtypeGraph } from "./types";
+export declare const MM_MAX_ITERS = 400;
+export declare const MM_CONVERGENCE = 1e-10;
+export declare const PSEUDO_WINS = 0.01;
+/** Fit BT strengths over the graph's models. Returns modelKey → p, GM-normalized
+ * to 1. Deterministic — no randomness in the fit. */
+export declare function fitBradleyTerry(graph: SubtypeGraph): Record<string, number>;
+/** Geometric mean of the basket members' strengths, over the members present
+ * in the fit. Null when NO basket member is in the graph — the subtype cannot
+ * be anchored (and must not publish a score). */
+export declare function basketGeometricMean(strengths: Readonly<Record<string, number>>, basket: readonly string[]): number | null;
+/** RigIndex_i = 100 × p_i / GM(basket) (review §1). Null when unanchorable. */
+export declare function anchorScores(strengths: Readonly<Record<string, number>>, basket: readonly string[]): Record<string, number> | null;
+//# sourceMappingURL=fit.d.ts.map

package/dist/rigindex/fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit.d.ts","sourceRoot":"","sources":["../../src/rigindex/fit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC;qDACqD;AACrD,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqC3E;AAED;;iDAEiD;AACjD,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,GAAG,IAAI,CAIf;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAC1B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAM/B"}