modelrig 0.3.0 → 0.4.0

package/dist/run/rawonly.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * runRaw-only construction — CE-8 (ruling R1,
+ * `docs/ModelRig/customer-efficiency/ce8-runraw-only-rig-spec-plan.md`).
+ *
+ * A Lane-B customer who only calls `rig.runRaw`/`rig.runRawStream` has no routes.
+ * With `routesDir: null`, `createRig` SKIPS route loading, the `rig.yaml`
+ * manifest, and the serveable-candidate gate — so a stray route file (or a route
+ * whose provider key is absent in this deployment) can no longer down a rig that
+ * never serves it. The raw lane is unchanged; every route-dependent surface
+ * (`run`/`runStream`/`runBundle`/`replay`/`bakeoff`/`verifySwap`) fails with a
+ * TERMINAL `invariant_violation` that teaches the fix — Promise surfaces reject,
+ * the two streaming surfaces hand back a handle whose `result`/`events` fail
+ * (never a synchronous throw, matching the real `runStream` contract).
+ *
+ * This module holds the small pieces of that opt-out (the empty store, the
+ * teaching failure, the throwing route methods) so `index.ts` stays under the
+ * 700-LOC cap — `createRig` remains the ONE construction path (a separate
+ * `createRawRig()` factory was considered and REJECTED, spec §2 R1).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAW_ONLY_FIX_HINT = void 0;
+exports.rawOnlyRouteFailure = rawOnlyRouteFailure;
+exports.requireRoutesDir = requireRoutesDir;
+exports.emptyRouteStore = emptyRouteStore;
+exports.loadRoutesOrReport = loadRoutesOrReport;
+exports.rawOnlyRouteMethods = rawOnlyRouteMethods;
+const loader_1 = require("../routes/loader");
+const load_error_report_1 = require("../telemetry/load-error-report");
+const failures_1 = require("../types/failures");
+/** The teaching remediation for a route-lane call on a runRaw-only rig (spec §2
+ * R1). One constant so the failure and the docs stay in lock-step. */
+exports.RAW_ONLY_FIX_HINT = "this rig was constructed runRaw-only (routesDir: null); give createRig a routesDir to serve routes";
+/** Build the TERMINAL failure a route-dependent surface throws when the rig was
+ * constructed runRaw-only. Reuses `invariant_violation` (already TERMINAL + in
+ * the teaching table) — no new FailureClass (spec §3 rationale). */
+function rawOnlyRouteFailure(surface) {
+    return new failures_1.RigFailureError({
+        class: "invariant_violation",
+        message: `${surface} needs routes, but this rig was constructed runRaw-only (routesDir: null)`,
+        fixHint: exports.RAW_ONLY_FIX_HINT,
+    });
+}
+/** A `RunStreamHandle` that fails the runRaw-only way: `result` rejects and the
+ * `events` iterator throws — matching the real `runStream` contract, which NEVER
+ * throws synchronously (a stream surface always hands back a handle, errors ride
+ * `result`/`events`). A synchronous throw here would break the caller's
+ * `const h = rig.runStream(...); await h.result` shape. */
+function rawOnlyStreamHandle(surface) {
+    const err = rawOnlyRouteFailure(surface);
+    const result = Promise.reject(err);
+    // Keep the rejection handled so an unconsumed handle never becomes an
+    // unhandledRejection; the events iterator surfaces the same error.
+    result.catch(() => undefined);
+    const events = {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async *[Symbol.asyncIterator]() {
+            throw err;
+        },
+    };
+    return { events, result };
+}
+/** Narrow a config's `routesDir` to a string for a route-REQUIRED context (the
+ * route-oriented CLI subcommands: bakeoff/watch/swap/init/observe/validate),
+ * throwing the teaching failure if the rig was built runRaw-only.
+ * `loadConfigFromEnv` always yields a string (R2), so this is unreachable for
+ * env-built configs — it guards a hand-built `routesDir: null` reaching a
+ * route-only command, and satisfies the `string | null` type at those seams. */
+function requireRoutesDir(config, surface) {
+    if (config.routesDir === null)
+        throw rawOnlyRouteFailure(surface);
+    return config.routesDir;
+}
+/** The empty route store for a runRaw-only rig: `list()` is `[]` (so
+ * serveability, capture-detection, and the exported route mirror are all no-ops)
+ * and `get()` teaches, though no public surface reaches it — every route method
+ * is overridden by {@link rawOnlyRouteMethods}. */
+function emptyRouteStore() {
+    return {
+        get(route) {
+            throw rawOnlyRouteFailure(`get("${route}")`);
+        },
+        list() {
+            return Object.freeze([]);
+        },
+    };
+}
+/** Load routes from a real (string) `routesDir`, mirroring a malformed-bundle
+ * diagnosis to the console before re-throwing — the byte-for-byte behaviour the
+ * string path had inline in `createRig` before CE-8 extracted it here. */
+function loadRoutesOrReport(config, routesDir) {
+    try {
+        return (0, loader_1.loadRoutesWithExtra)(routesDir, config.extraRoutesDir);
+    }
+    catch (err) {
+        // A malformed bundle is teachable, not just fatal: mirror the diagnosis to
+        // the console before re-throwing (the rig still cannot serve).
+        if (err instanceof loader_1.RouteConfigError)
+            (0, load_error_report_1.reportLoadError)(config, err);
+        throw err;
+    }
+}
+/** The throwing overrides for a runRaw-only rig (spec §2 R1). Each names the
+ * surface + the route/task the caller asked for, so the terminal error points at
+ * exactly the call that needs a `routesDir`. Promise-returning surfaces REJECT
+ * (matching the routed lane, where errors surface as rejections); the two
+ * streaming surfaces return a handle synchronously, so they throw synchronously
+ * — the caller never reaches an event to await. */
+function rawOnlyRouteMethods() {
+    return {
+        run: (route) => Promise.reject(rawOnlyRouteFailure(`run("${route}")`)),
+        runStream: (route) => rawOnlyStreamHandle(`runStream("${route}")`),
+        runBundle: (bundle) => Promise.reject(rawOnlyRouteFailure(`runBundle("${bundle.route}")`)),
+        runBundleStream: (bundle) => rawOnlyStreamHandle(`runBundleStream("${bundle.route}")`),
+        replay: (route) => Promise.reject(rawOnlyRouteFailure(`replay("${route}")`)),
+        bakeoff: (route) => Promise.reject(rawOnlyRouteFailure(`bakeoff("${route}")`)),
+        bakeoffFromEvalCases: (task) => Promise.reject(rawOnlyRouteFailure(`bakeoffFromEvalCases("${task}")`)),
+        verifySwap: (route) => Promise.reject(rawOnlyRouteFailure(`verifySwap("${route}")`)),
+    };
+}

package/dist/run/record-attempt.d.ts

@@ -13,11 +13,17 @@ import type { AttemptTelemetry } from "./dispatch";
 import type { ActiveRunContext } from "../artifacts/run-context";
 import type { RetryLedger } from "./retry";
 import type { RouteBundle, RunOptions, RunTags } from "../types/route";
-import type { TelemetryStore } from "../types/telemetry";
+import type { TelemetryRung, TelemetryStore } from "../types/telemetry";
+import type { LadderKeyMinter } from "./ladder-key";
 export interface RecordAttemptDeps {
     readonly telemetry: TelemetryStore;
     readonly route: RouteBundle;
     readonly ledger: RetryLedger;
+    /** Per-call ladder-key minter (spec §2.1 R0) — every row this recorder writes
+     * is stamped with the call's id, its 1-based attempt_seq, and the current
+     * candidate index. Shared by reference with the run loop, which advances the
+     * candidate index as the iterator moves. */
+    readonly ladder: LadderKeyMinter;
     readonly effectiveTags: RunTags;
     readonly servedVariant: string | null;
     /** Active run context (E2 chunk A) or null when the artifact namespace is off. */
@@ -33,6 +39,13 @@ export interface RecordAttemptDeps {
      * uncached), exactly matching the request builder's suppression. */
     readonly droppedCacheHandle: ReadonlySet<string>;
 }
+/**
+ * Classify a recorded row's ladder rung (R1 review, F1). `primaryDispatched`
+ * carries the candidate indices already given a primary dispatch on this call —
+ * mutated here so the next same-index non-repair dispatch reads `retry`.
+ * Exported for unit tests; the run loop reaches it only through the recorder.
+ */
+export declare function rungOf(attempt: AttemptTelemetry, preDispatch: boolean, candidateIndex: number | null, primaryDispatched: Set<number>): TelemetryRung;
 /** Build the run loop's `recordAttempt(attempt) => inferenceId` over this run's
  * state. Records one inference row and, with an active run context, mirrors it
  * as a ground-truth step (fail-open). */

package/dist/run/record-attempt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record-attempt.d.ts","sourceRoot":"","sources":["../../src/run/record-attempt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIvE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC;;qFAEiF;IACjF,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACrC;;;wEAGoE;IACpE,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClD;AAED;;yCAEyC;AACzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CA6ElG"}
+{"version":3,"file":"record-attempt.d.ts","sourceRoot":"","sources":["../../src/run/record-attempt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAgB,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGtF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B;;;gDAG4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC;;qFAEiF;IACjF,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACrC;;;wEAGoE;IACpE,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClD;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,OAAO,EAAE,gBAAgB,EACzB,WAAW,EAAE,OAAO,EACpB,cAAc,EAAE,MAAM,GAAG,IAAI,EAC7B,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,GAC7B,aAAa,CAUf;AAED;;yCAEyC;AACzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CA+FlG"}

package/dist/run/record-attempt.js

@@ -11,17 +11,45 @@
  * in-flight E4 / capture-write work (plan coordination note).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rungOf = rungOf;
 exports.createRecordAttempt = createRecordAttempt;
 const node_crypto_1 = require("node:crypto");
 const failures_1 = require("../types/failures");
 const cache_stamp_1 = require("./cache-stamp");
 const cache_handle_1 = require("./cache-handle");
+/**
+ * Classify a recorded row's ladder rung (R1 review, F1). `primaryDispatched`
+ * carries the candidate indices already given a primary dispatch on this call —
+ * mutated here so the next same-index non-repair dispatch reads `retry`.
+ * Exported for unit tests; the run loop reaches it only through the recorder.
+ */
+function rungOf(attempt, preDispatch, candidateIndex, primaryDispatched) {
+    if (attempt.rung !== undefined)
+        return attempt.rung; // explicit (tool-call path)
+    if (attempt.repairedBy !== undefined)
+        return "repair";
+    if (preDispatch)
+        return "predispatch_fail";
+    // A real primary/retry candidate dispatch. First time this index is dispatched
+    // ⇒ primary; any later dispatch of the same index ⇒ retry.
+    if (candidateIndex === null)
+        return "primary";
+    if (primaryDispatched.has(candidateIndex))
+        return "retry";
+    primaryDispatched.add(candidateIndex);
+    return "primary";
+}
 /** Build the run loop's `recordAttempt(attempt) => inferenceId` over this run's
  * state. Records one inference row and, with an active run context, mirrors it
  * as a ground-truth step (fail-open). */
 function createRecordAttempt(deps) {
     const { telemetry, route, ledger, effectiveTags, servedVariant, runCtx, autoStepKey } = deps;
-    const { cache, droppedCacheHandle } = deps;
+    const { cache, droppedCacheHandle, ladder } = deps;
+    // The candidate indices for which a real primary dispatch has already been
+    // recorded on THIS call — so the SECOND non-repair dispatch of a candidate
+    // stamps `retry` rather than a second `primary` (R1 review, F1). Held in the
+    // per-call closure (the recorder is built once per invocation).
+    const primaryDispatched = new Set();
     return function recordAttempt(attempt) {
         // Request-path cache substrate (WS-C): derived from the SAME pure gate the
         // dispatcher stamps the request with, so `cache_key`/`prefix_fingerprint` on
@@ -53,6 +81,16 @@ function createRecordAttempt(deps) {
         const dropped = droppedCacheHandle.has(`${attempt.candidate.provider} ${attempt.candidate.model}`);
         const customer = isPrimary && !preDispatch ? (0, cache_handle_1.customerCacheHandle)(cache, attempt.candidate, dropped) : null;
         const cacheKey = customer?.key ?? cacheStamp?.cacheKey ?? null;
+        // Ladder key (spec §2.1 R0): one stamp per row — shared call_id, monotonic
+        // attempt_seq, and the current candidate_index (the candidate being repaired
+        // for a repair row, since the iterator has not advanced during its turn).
+        const ladderKey = ladder.stamp();
+        // Rung tag (R1 review, F1): the row's place on the ladder, so the rollup and
+        // ladder view never guess. Precedence: an explicit hint from the caller
+        // (only the tool-call path sets one) wins; then a repair row, then a
+        // pre-dispatch terminal failure, then primary-vs-retry by whether this
+        // candidate index was already dispatched on this call.
+        const rung = rungOf(attempt, preDispatch, ladderKey.candidateIndex, primaryDispatched);
         const row = {
             id: (0, node_crypto_1.randomUUID)(),
             ts: new Date().toISOString(),
@@ -75,11 +113,14 @@ function createRecordAttempt(deps) {
             ttfbMs: attempt.ttfbMs ?? null,
             failureClass: attempt.failure?.class ?? null,
             attemptsJson: JSON.stringify(ledger.snapshot()),
-            tagsJson: JSON.stringify(effectiveTags),
+            tagsJson: JSON.stringify({ ...effectiveTags, rung }),
             fingerprintCell: route.fingerprintCell,
             servedVariant,
             repairedBy: attempt.repairedBy ?? null,
             pricingMissing: attempt.pricingMissing ?? false,
+            callId: ladderKey.callId,
+            attemptSeq: ladderKey.attemptSeq,
+            candidateIndex: ladderKey.candidateIndex,
         };
         telemetry.record(row);
         // Mirror this inference into a ground-truth step attempt (fail-open — the

package/dist/run/resolve.d.ts

@@ -12,6 +12,10 @@ export type CapabilityLookup = (provider: ProviderId, model: string) => Readonly
 export interface CandidateIterator {
     /** Next eligible candidate, or null when the set is exhausted. */
     next(): CandidateRef | null;
+    /** Position in the EFFECTIVE eligible list of the candidate the most recent
+     * `next()` returned (0 = first eligible; ladder key, spec §2.1). `-1` before
+     * the first `next()`; unchanged by a `next()` that returns null. */
+    readonly index: number;
 }
 /**
  * Request-time candidate filters (G-2) — optional, applied by resolveCandidates

package/dist/run/resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/run/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAElF,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG,CAC7B,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,KACV,WAAW,CAAC,cAAc,CAAC,CAAC;AAEjC,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,IAAI,IAAI,YAAY,GAAG,IAAI,CAAC;CAC7B;AA6CD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACzC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC;;oFAEgF;IAChF,QAAQ,CAAC,uBAAuB,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACzF,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CACjD;AAED;kFACkF;AAClF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtF,QAAQ,CAAC,WAAW,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3F,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,gBAAgB,EAC9B,cAAc,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,EACtE,eAAe,UAAQ,EACvB,MAAM,CAAC,EAAE,eAAe,EACxB,YAAY,CAAC,EAAE,mBAAmB,GACjC,iBAAiB,CAkFnB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,GAAG,WAAW,CAM5F;AAED;mFACmF;AACnF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,GAAG,SAAS,CAUxF;AAED;;gDAEgD;AAChD,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAMtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAElF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE;IAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC9D,YAAY,GAAG,IAAI,CAMrB"}
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/run/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAElF,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG,CAC7B,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,KACV,WAAW,CAAC,cAAc,CAAC,CAAC;AAEjC,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,IAAI,IAAI,YAAY,GAAG,IAAI,CAAC;IAC5B;;wEAEoE;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AA6CD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACzC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC;;oFAEgF;IAChF,QAAQ,CAAC,uBAAuB,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACzF,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CACjD;AAED;kFACkF;AAClF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtF,QAAQ,CAAC,WAAW,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3F,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,gBAAgB,EAC9B,cAAc,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,EACtE,eAAe,UAAQ,EACvB,MAAM,CAAC,EAAE,eAAe,EACxB,YAAY,CAAC,EAAE,mBAAmB,GACjC,iBAAiB,CAwFnB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,GAAG,WAAW,CAM5F;AAED;mFACmF;AACnF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,GAAG,SAAS,CAUxF;AAED;;gDAEgD;AAChD,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAMtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAElF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE;IAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC9D,YAAY,GAAG,IAAI,CAMrB"}

package/dist/run/resolve.js

@@ -124,10 +124,17 @@ function resolveCandidates(route, capabilities, costUsdPerMTok, searchAvailable
     // minted. The cast below is the single sanctioned exception to the
     // "no `as CandidateRef`" grep (scoped to run/resolve.ts in CI).
     const refs = ordered.map((c) => Object.freeze({ provider: c.provider, model: c.model }));
-    let index = 0;
+    let cursor = 0;
+    let lastIndex = -1;
     return {
         next() {
-            return index < refs.length ? refs[index++] : null;
+            if (cursor >= refs.length)
+                return null;
+            lastIndex = cursor;
+            return refs[cursor++];
+        },
+        get index() {
+            return lastIndex;
         },
     };
 }

package/dist/run/routing-docs.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Routing & reliability — the code-anchored boundary and the failure-class
+ * section of https://modelrig.dev/routing-reliability.html.
+ *
+ * ONE table feeds the published page AND the tripwire test, the same way
+ * `RAW_KNOB_SUPPORT` (raw-support.ts) feeds the raw-lane matrix and its runtime
+ * guard. The docs builder (scripts/build-docs-site.ts) injects
+ * `renderRoutingBoundary()` at `<!-- ROUTING_BOUNDARY -->` and
+ * `renderFailureClasses()` at `<!-- FAILURE_CLASSES -->`, and inlines the
+ * boundary into llms.txt. Nothing here is exported from the package root.
+ *
+ * Spec: docs/ModelRig/routing-reliability-overview/spec.md §5–§6.
+ */
+import type { FailureClass } from "../types/failures";
+export type BoundaryStatus = "not_built" | "deferred" | "shadow" | "by_design";
+export interface BoundaryTripwire {
+    /** Path relative to packages/modelrig (the test reads it as text). */
+    readonly file: string;
+    /** Entry is STALE if this matches — the feature appeared. */
+    readonly mustNotMatch?: RegExp;
+    /** Entry is STALE if this stops matching — the no-op marker vanished. */
+    readonly mustMatch?: RegExp;
+}
+export interface BoundaryEntry {
+    /** Stable id (B1…) — becomes the first table column and a citable handle. */
+    readonly id: string;
+    readonly status: BoundaryStatus;
+    /** <= 8 words. */
+    readonly capability: string;
+    /** ONE sentence, present tense: what is true today. */
+    readonly statement: string;
+    /** Repo doc path (or issue) a reader can cite. */
+    readonly tracking: string;
+    readonly tripwire?: BoundaryTripwire | {
+        readonly noImportersOf: string;
+    };
+}
+/** Rendered group headings, in order. */
+export declare const BOUNDARY_STATUS_LABEL: Readonly<Record<BoundaryStatus, string>>;
+/**
+ * The ten boundary entries, transcribed verbatim from spec §5.3. Statuses,
+ * statements, and tripwires are BINDING content — do not add, drop, or reword
+ * an entry without an architect addendum to the spec. Shipping a capability
+ * listed here breaks `routing-docs.test.ts` until the entry is flipped or
+ * removed and the page updated.
+ */
+export declare const ROUTING_BOUNDARY: readonly BoundaryEntry[];
+/**
+ * Markdown (renderer subset only): one `###` per non-empty status group, a pipe
+ * table per group with columns id | capability | what is true today | tracking.
+ * No nested lists, no HTML — the docs-site renderer supports neither.
+ *
+ * `published` (the site's page slugs) is passed by the docs builder so a tracking
+ * cell naming a published page renders as a link; a bare call (the shape/tripwire
+ * tests, which assert the plain table) leaves every cell as plain text.
+ */
+export declare function renderRoutingBoundary(published?: ReadonlySet<string>): string;
+/** The failure classes in taxonomy order (types/failures.ts `FailureClass`
+ * union). FAILURE_TEACHING is keyed in that same order and its completeness is
+ * pinned by failures-teaching.test.ts, so its key order is the canonical walk.
+ * A test in routing-docs.test.ts asserts this equals the union order in
+ * failures.ts, so a taxonomy reorder cannot drift silently. */
+export declare function failureClassOrder(): readonly FailureClass[];
+/**
+ * Markdown: `### <class>` per FailureClass in taxonomy order, then the teaching
+ * `what`, the retry line, the backoff schedule (when any), and the `fixHint`.
+ * Heading text is the bare class name so the docs-site id equals the class
+ * (failures-teaching.ts docsUrl anchors depend on it — spec §6).
+ */
+export declare function renderFailureClasses(): string;
+/** Exposed for the anchor-completeness test: the heading id each class gets. */
+export declare function failureClassAnchor(cls: FailureClass): string;
+//# sourceMappingURL=routing-docs.d.ts.map

package/dist/run/routing-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-docs.d.ts","sourceRoot":"","sources":["../../src/run/routing-docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE/E,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,kBAAkB;IAClB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG;QAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AAED,yCAAyC;AACzC,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAK1E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EA0FpD,CAAC;AAwBF;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAoB7E;AAED;;;;+DAI+D;AAC/D,wBAAgB,iBAAiB,IAAI,SAAS,YAAY,EAAE,CAE3D;AA0BD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAW7C;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAE5D"}

package/dist/run/routing-docs.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Routing & reliability — the code-anchored boundary and the failure-class
+ * section of https://modelrig.dev/routing-reliability.html.
+ *
+ * ONE table feeds the published page AND the tripwire test, the same way
+ * `RAW_KNOB_SUPPORT` (raw-support.ts) feeds the raw-lane matrix and its runtime
+ * guard. The docs builder (scripts/build-docs-site.ts) injects
+ * `renderRoutingBoundary()` at `<!-- ROUTING_BOUNDARY -->` and
+ * `renderFailureClasses()` at `<!-- FAILURE_CLASSES -->`, and inlines the
+ * boundary into llms.txt. Nothing here is exported from the package root.
+ *
+ * Spec: docs/ModelRig/routing-reliability-overview/spec.md §5–§6.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROUTING_BOUNDARY = exports.BOUNDARY_STATUS_LABEL = void 0;
+exports.renderRoutingBoundary = renderRoutingBoundary;
+exports.failureClassOrder = failureClassOrder;
+exports.renderFailureClasses = renderFailureClasses;
+exports.failureClassAnchor = failureClassAnchor;
+const failures_1 = require("../types/failures");
+const failures_teaching_1 = require("../types/failures-teaching");
+/** Rendered group headings, in order. */
+exports.BOUNDARY_STATUS_LABEL = {
+    not_built: "Not built",
+    deferred: "Deferred",
+    shadow: "Built, not actuating",
+    by_design: "By design — will not do",
+};
+/**
+ * The ten boundary entries, transcribed verbatim from spec §5.3. Statuses,
+ * statements, and tripwires are BINDING content — do not add, drop, or reword
+ * an entry without an architect addendum to the spec. Shipping a capability
+ * listed here breaks `routing-docs.test.ts` until the entry is flipped or
+ * removed and the page updated.
+ */
+exports.ROUTING_BOUNDARY = [
+    {
+        id: "B1",
+        status: "not_built",
+        capability: "Quality / value-accuracy gate in the ladder",
+        statement: "Fall-through is triggered by structure and infrastructure only; no builder-defined predicate or judge can reject a schema-valid output at run time — value accuracy exists offline, in bake-offs.",
+        tracking: "customer request on file (2026-08-21); not scheduled",
+        tripwire: { file: "src/types/route.ts", mustNotMatch: /qualityGate|"judged"/ },
+    },
+    {
+        id: "B2",
+        status: "not_built",
+        capability: "Structure on the raw lane",
+        statement: '`runRaw` never validates or repairs; `responseFormat: "json_object"` shapes MIME, not schema, so `meta.validated` stays false (ruled schema-free in CE-2 F4b; re-requested #223 R2).',
+        tracking: "ruled schema-free on the raw lane; re-request on file",
+        tripwire: { file: "src/run/raw.ts", mustNotMatch: /readonly outputSchema\??:/ },
+    },
+    {
+        id: "B3",
+        status: "deferred",
+        capability: "`prefer: latency` / observed-health ordering",
+        statement: "`latency` is accepted and does nothing — declared order stands; observed p50/p90/p99 are aggregated but unused by routing.",
+        tracking: "deferred to the observed-health work (latency signal first)",
+        tripwire: { file: "src/run/resolve.ts", mustMatch: /declared order stands/ },
+    },
+    {
+        id: "B4",
+        status: "shadow",
+        capability: "Cache-aware (warmth) candidate ordering",
+        statement: "The cache-adjusted ranking is computed and logged beside the chosen order but never changes it.",
+        tracking: "cache-aware routing — shadow mode; see caching-lifecycle.md",
+        tripwire: { file: "src/run/resolve.ts", mustMatch: /returns the UNCHANGED list-cost order/ },
+    },
+    {
+        id: "B5",
+        status: "shadow",
+        capability: "Cache-miss streak alert",
+        statement: "A miss-streak detector exists; nothing consumes it yet, so no alert fires.",
+        tracking: "cache-aware routing — monitor wiring pending",
+        tripwire: { noImportersOf: "telemetry/cache-miss-streak" },
+    },
+    {
+        id: "B6",
+        status: "not_built",
+        capability: "Run-level idempotency / dedupe key",
+        statement: "Two identical `rig.run` calls dispatch twice; the only idempotency is the exporter's watermark.",
+        // Spec §5.3 tracking reads "— (record here)": B6 has no external tracking
+        // doc; this generated boundary IS its record, so the rendered cell is "—".
+        tracking: "—",
+        tripwire: { file: "src/types/route.ts", mustNotMatch: /idempotencyKey/ },
+    },
+    {
+        id: "B7",
+        status: "by_design",
+        capability: "Automatic model swap",
+        statement: "Nothing changes what serves a route without a bake-off and an explicit human approval (`modelrig swap execute <id> --approve`).",
+        tracking: "optimization-loop.md — human-approved swaps only",
+        // No file tripwire: the P6 never-silent-swap invariant is covered by its
+        // own dev-rule tests (spec §5.3).
+    },
+    {
+        id: "B8",
+        status: "by_design",
+        capability: "Provider cache resource lifecycle",
+        statement: "ModelRig passes your cache handle through and prices the hits; it never creates, refreshes, or deletes the resource — your heartbeat does.",
+        tracking: "caching-lifecycle.md — who owns what",
+    },
+    {
+        id: "B9",
+        status: "by_design",
+        capability: "Tool execution",
+        statement: "ModelRig normalizes the tool-call protocol and returns `meta.toolCalls`; the caller runs the tool.",
+        tracking: "route-bundles.md — tools are normalized, never executed",
+    },
+    {
+        id: "B10",
+        status: "by_design",
+        capability: "Raw-lane flex → standard degrade",
+        statement: "A flex capacity rejection on `runRaw` surfaces as `capacity_shed` for your own retry ladder; ModelRig does not degrade the tier for you.",
+        tracking: "route-bundles.md — raw-lane serviceTier (customer-side degrade)",
+    },
+];
+const STATUS_ORDER = ["not_built", "deferred", "shadow", "by_design"];
+/** Escape a table cell so a literal `|` in content cannot break the pipe table.
+ * (None of the current statements contain one; this keeps a future edit safe.) */
+function cell(text) {
+    return text.replace(/\|/g, "\\|");
+}
+/**
+ * Turn a `<slug>.md` token in a tracking cell into a markdown link to that
+ * published page (S8) — but ONLY when the slug is one the site actually
+ * publishes, so a stray `.md` reference never becomes a dead link. The URL is
+ * absolute (`modelrig.dev/<slug>.html`) so the same rendered text works on the
+ * page (the docs renderer leaves an already-`.html` href alone) AND inline in
+ * llms.txt, which is plain text and never runs the `.md`→`.html` rewrite.
+ */
+function linkifyTracking(text, published) {
+    return text.replace(/\b([a-z0-9][a-z0-9-]*)\.md\b/gi, (whole, slug) => published.has(slug) ? `[${slug}](https://modelrig.dev/${slug}.html)` : whole);
+}
+/**
+ * Markdown (renderer subset only): one `###` per non-empty status group, a pipe
+ * table per group with columns id | capability | what is true today | tracking.
+ * No nested lists, no HTML — the docs-site renderer supports neither.
+ *
+ * `published` (the site's page slugs) is passed by the docs builder so a tracking
+ * cell naming a published page renders as a link; a bare call (the shape/tripwire
+ * tests, which assert the plain table) leaves every cell as plain text.
+ */
+function renderRoutingBoundary(published) {
+    const blocks = [];
+    for (const status of STATUS_ORDER) {
+        const entries = exports.ROUTING_BOUNDARY.filter((e) => e.status === status);
+        if (entries.length === 0)
+            continue;
+        const rows = entries.map((e) => {
+            const tracking = published ? linkifyTracking(e.tracking, published) : e.tracking;
+            return `| ${e.id} | ${cell(e.capability)} | ${cell(e.statement)} | ${cell(tracking)} |`;
+        });
+        blocks.push([
+            `### ${exports.BOUNDARY_STATUS_LABEL[status]}`,
+            "",
+            "| id | capability | what is true today | tracking |",
+            "|---|---|---|---|",
+            ...rows,
+        ].join("\n"));
+    }
+    return blocks.join("\n\n");
+}
+/** The failure classes in taxonomy order (types/failures.ts `FailureClass`
+ * union). FAILURE_TEACHING is keyed in that same order and its completeness is
+ * pinned by failures-teaching.test.ts, so its key order is the canonical walk.
+ * A test in routing-docs.test.ts asserts this equals the union order in
+ * failures.ts, so a taxonomy reorder cannot drift silently. */
+function failureClassOrder() {
+    return Object.keys(failures_teaching_1.FAILURE_TEACHING);
+}
+/**
+ * Backoff schedule per class, in reader-facing words. The numbers mirror the
+ * (non-exported) constants in run/retry.ts — `CAPACITY_BACKOFF_MS` and the
+ * `NETWORK_BACKOFF_*` pair — and a test in routing-docs.test.ts reads retry.ts
+ * to pin them, so this string cannot drift from the engine (spec §6).
+ */
+function backoffLine(cls) {
+    if (cls === "capacity_shed")
+        return "Backoff between retries: 30 s -> 60 s -> 120 s -> 240 s.";
+    if (cls === "network")
+        return "Backoff between retries: 1 s, doubling each time, capped at 30 s.";
+    // A class that is never retried — terminal, or `config_auth` (straight to the
+    // next candidate) — has no backoff to describe. Every OTHER class is retryable
+    // with a zero delay, so say so: §2 promises "with backoff", and leaving the
+    // remaining classes silent read as "unspecified" rather than "none" (S7).
+    if (failures_1.TERMINAL_CLASSES.has(cls) || cls === "config_auth")
+        return null;
+    return "No backoff between retries (immediate retry).";
+}
+/** The retry disposition sentence for one class (spec §6). */
+function retryLine(cls) {
+    if (failures_1.TERMINAL_CLASSES.has(cls))
+        return "Terminal — never retried; aborts the run.";
+    if (cls === "config_auth")
+        return "Never retried — the run loop advances to the next candidate.";
+    return "Retryable — default budget 0 (declare every budget you want under `policy.retries`).";
+}
+/**
+ * Markdown: `### <class>` per FailureClass in taxonomy order, then the teaching
+ * `what`, the retry line, the backoff schedule (when any), and the `fixHint`.
+ * Heading text is the bare class name so the docs-site id equals the class
+ * (failures-teaching.ts docsUrl anchors depend on it — spec §6).
+ */
+function renderFailureClasses() {
+    const blocks = [];
+    for (const cls of failureClassOrder()) {
+        const teaching = failures_teaching_1.FAILURE_TEACHING[cls];
+        const parts = [`### ${cls}`, "", teaching.what, "", retryLine(cls)];
+        const backoff = backoffLine(cls);
+        if (backoff !== null)
+            parts.push("", backoff);
+        parts.push("", `Fix: ${teaching.fixHint}`);
+        blocks.push(parts.join("\n"));
+    }
+    return blocks.join("\n\n");
+}
+/** Exposed for the anchor-completeness test: the heading id each class gets. */
+function failureClassAnchor(cls) {
+    return cls;
+}

package/dist/run/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/run/run.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrD,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,mBAAmB,CAAC;AAGvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,KAAK,EAAsC,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAQlD,OAAO,KAAK,EAAE,cAAc,EAAoC,MAAM,aAAa,CAAC;AASpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;gDAE4C;IAC5C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACvC;2EACuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC;;0BAEsB;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACxC,qDAAqD;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;mFAG+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,eAAe,CAAC;IACzC;;;;;uDAKmD;IACnD,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACjD;AAsED,wBAAsB,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAoiBhG"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/run/run.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrD,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,mBAAmB,CAAC;AAGvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,KAAK,EAAsC,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAQlD,OAAO,KAAK,EAAE,cAAc,EAAoC,MAAM,aAAa,CAAC;AAUpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAKlD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;gDAE4C;IAC5C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACvC;2EACuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC;;0BAEsB;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACxC,qDAAqD;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;mFAG+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,eAAe,CAAC;IACzC;;;;;uDAKmD;IACnD,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACjD;AAqDD,wBAAsB,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAmjBhG"}