modelrig 0.0.1 → 0.2.0

package/dist/routes/cache-lint.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Prompt-stability lint — cache-aware-routing WS-C step 4 (spec §5.3,
+ * [Briefing §10]). A prefix cache only pays off when the CACHED PREFIX is
+ * stable across calls. A route template that interpolates a volatile value
+ * (a timestamp, a run id, a random nonce) high in the prompt shifts the prefix
+ * on every call, so the provider caches something that never recurs — the route
+ * pays the write premium forever and never reads a hit ("paying full price and
+ * don't know it", the §5.6 smell, caught statically here instead of after the money).
+ *
+ * v1 is a pure, conservative NAME heuristic over the declared `{{variable}}`
+ * references (the run-loop's stable prefix IS the route template — spec §5.3).
+ * It flags variables whose NAME reads volatile AND that appear before the
+ * template's stable tail. It does NOT inspect rendered values (it can't — the
+ * lint runs at load, before any input) and it never fails the load: a false
+ * positive must not block a legitimate route, so this warns. The prompt compiler
+ * + Prefix Stability Score (real per-token volatility telemetry) is the deferred
+ * successor ([Briefing Phase 5]); this is the cheap static precursor.
+ */
+export interface CacheLintWarning {
+    /** The offending variable name. */
+    readonly variable: string;
+    /** Character offset of the reference in the raw template. */
+    readonly index: number;
+    /** Human-readable, teach-not-scold message. */
+    readonly message: string;
+}
+/**
+ * Lint a route's raw system template for cache-hostile volatile interpolations.
+ * Pure and total. Returns one warning per volatile-named reference that sits
+ * before the stable tail; `[]` for a clean template.
+ *
+ * "Before the stable tail" (v1 approximation): a volatile reference in the first
+ * `headFraction` of the template shifts the cacheable prefix; one at the very
+ * end (after the bulk of the stable instructions) shifts only the tail and is
+ * harmless for prefix caching. We warn only on head references to keep the
+ * signal high — a `{{now}}` in a trailing "as of {{now}}" line is fine.
+ */
+export declare function lintCacheTemplate(template: string, opts?: {
+    readonly headFraction?: number;
+}): CacheLintWarning[];
+//# sourceMappingURL=cache-lint.d.ts.map

package/dist/routes/cache-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-lint.d.ts","sourceRoot":"","sources":["../../src/routes/cache-lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAmCH,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5C,gBAAgB,EAAE,CAmBpB"}

package/dist/routes/cache-lint.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Prompt-stability lint — cache-aware-routing WS-C step 4 (spec §5.3,
+ * [Briefing §10]). A prefix cache only pays off when the CACHED PREFIX is
+ * stable across calls. A route template that interpolates a volatile value
+ * (a timestamp, a run id, a random nonce) high in the prompt shifts the prefix
+ * on every call, so the provider caches something that never recurs — the route
+ * pays the write premium forever and never reads a hit ("paying full price and
+ * don't know it", the §5.6 smell, caught statically here instead of after the money).
+ *
+ * v1 is a pure, conservative NAME heuristic over the declared `{{variable}}`
+ * references (the run-loop's stable prefix IS the route template — spec §5.3).
+ * It flags variables whose NAME reads volatile AND that appear before the
+ * template's stable tail. It does NOT inspect rendered values (it can't — the
+ * lint runs at load, before any input) and it never fails the load: a false
+ * positive must not block a legitimate route, so this warns. The prompt compiler
+ * + Prefix Stability Score (real per-token volatility telemetry) is the deferred
+ * successor ([Briefing Phase 5]); this is the cheap static precursor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintCacheTemplate = lintCacheTemplate;
+/** Variable names that read as per-call-volatile. Deliberately broad on the
+ * volatile side (a warning is cheap; a silently un-cached route is not) but
+ * anchored to whole \b tokens so `updated_at_note` matches yet `runtime` does
+ * not falsely trip on "run". */
+const VOLATILE_NAME = new RegExp([
+    "\\btime(stamp)?\\b",
+    "\\bnow\\b",
+    "\\bdate(time)?\\b",
+    "run[_-]?id",
+    "request[_-]?id",
+    "trace[_-]?id",
+    "session[_-]?id",
+    "correlation[_-]?id",
+    "\\buuid\\b",
+    "\\bguid\\b",
+    "\\bnonce\\b",
+    "\\brandom\\b",
+    "\\brand\\b",
+    "\\bepoch\\b",
+    "\\bcurrent[_-]",
+    "generated[_-]?at",
+    "created[_-]?at",
+    "updated[_-]?at",
+].join("|"), "i");
+/** The `{{var}}` scanner from template.ts, duplicated as a global-match here so
+ * the lint can read each reference's POSITION (scanTemplateVariables dedupes to
+ * names only). Kept in sync with template.ts's VAR_TAG. */
+const VAR_TAG = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+/**
+ * Lint a route's raw system template for cache-hostile volatile interpolations.
+ * Pure and total. Returns one warning per volatile-named reference that sits
+ * before the stable tail; `[]` for a clean template.
+ *
+ * "Before the stable tail" (v1 approximation): a volatile reference in the first
+ * `headFraction` of the template shifts the cacheable prefix; one at the very
+ * end (after the bulk of the stable instructions) shifts only the tail and is
+ * harmless for prefix caching. We warn only on head references to keep the
+ * signal high — a `{{now}}` in a trailing "as of {{now}}" line is fine.
+ */
+function lintCacheTemplate(template, opts = {}) {
+    const headFraction = opts.headFraction ?? 0.75;
+    const headCutoff = Math.floor(template.length * headFraction);
+    const warnings = [];
+    for (const m of template.matchAll(VAR_TAG)) {
+        const name = m[1];
+        const index = m.index;
+        if (index >= headCutoff)
+            continue; // in the stable tail — harmless
+        if (!VOLATILE_NAME.test(name))
+            continue;
+        warnings.push({
+            variable: name,
+            index,
+            message: `route template interpolates \`{{${name}}}\` before the stable prompt tail — a per-call ` +
+                `value here shifts the cacheable prefix and defeats prompt caching (the route would pay ` +
+                `full price every call). Move volatile values to the end of the prompt, or drop them.`,
+        });
+    }
+    return warnings;
+}

package/dist/routes/draft.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Route-bundle drafting — the shared emitter behind BOTH `modelrig init`
+ * (WS2) and the oracle's `create_route` act tool (WS1).
+ *
+ * A route bundle is three files, not one: the YAML, its JSON Schema, and its
+ * system prompt. A "draft" that emitted only the YAML would not load, so
+ * this builds the whole set.
+ *
+ * PURE: it returns file contents and writes nothing. Every caller that
+ * touches the disk does so through `writeRouteDraft`, which refuses to
+ * overwrite — drafts are proposals for a human to read, never edits.
+ *
+ * The YAML is hand-emitted rather than serialized by the `yaml` package on
+ * purpose: drafts are read by humans first, and the comments explaining WHERE
+ * each candidate came from are the most valuable lines in the file.
+ */
+export interface DraftCandidate {
+    readonly provider: string;
+    readonly model: string;
+    /** Why this candidate is here — rendered as a trailing comment. */
+    readonly note?: string;
+}
+export interface RouteDraftSpec {
+    /** Route handle, e.g. "research.growth_scenarios". */
+    readonly route: string;
+    readonly candidates: readonly DraftCandidate[];
+    /** Incumbent first is the caller's job; this records which one it was so
+     * the draft can say so out loud. */
+    readonly incumbent?: {
+        readonly provider: string;
+        readonly model: string;
+    } | null;
+    readonly systemPrompt: string;
+    readonly variables: readonly string[];
+    /** JSON Schema for the output; null drafts an unstructured route. */
+    readonly outputSchema: object | null;
+    readonly require?: readonly string[];
+    readonly prefer?: readonly string[];
+    readonly policy?: {
+        readonly timeoutMs?: number;
+        readonly tier?: string;
+        readonly json?: string;
+        readonly retries?: Readonly<Record<string, number>>;
+    };
+    readonly capture?: boolean;
+    /** Provenance lines rendered as a header comment — "found at src/x.ts:42".
+     * SD8: customer-zero provenance is labeled, never hardcoded behavior. */
+    readonly provenance?: readonly string[];
+}
+export interface DraftFile {
+    /** Path relative to the drafts directory. */
+    readonly path: string;
+    readonly contents: string;
+}
+export interface RouteDraft {
+    readonly route: string;
+    readonly files: readonly DraftFile[];
+}
+export declare function buildRouteDraft(spec: RouteDraftSpec): RouteDraft;
+export interface WriteDraftResult {
+    readonly written: readonly string[];
+    /** Files that already existed and were left alone. */
+    readonly skipped: readonly string[];
+}
+/**
+ * Write a draft into `draftsDir`. Two rules, both deliberate:
+ *  - It writes ONLY under the drafts directory. Nothing here can touch the
+ *    caller's source, their live routes, or the control plane (spec §4:
+ *    drafts-only is permanent this phase).
+ *  - It never overwrites. A second run reports what it skipped instead of
+ *    silently discarding edits a human made to a draft.
+ */
+export declare function writeRouteDraft(draft: RouteDraft, draftsDir: string, fs: {
+    existsSync: (p: string) => boolean;
+    mkdirSync: (p: string, o: {
+        recursive: boolean;
+    }) => void;
+    writeFileSync: (p: string, c: string, e: "utf8") => void;
+}, path: {
+    join: (...parts: string[]) => string;
+    dirname: (p: string) => string;
+}): WriteDraftResult;
+//# sourceMappingURL=draft.d.ts.map

package/dist/routes/draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../../src/routes/draft.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;IAC/C;wCACoC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAClF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KACrD,CAAC;IACF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;6EACyE;IACzE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,SAAS;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;CACtC;AAmBD,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU,CAgGhE;AAMD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE;IACF,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;IACnC,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC1D,aAAa,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1D,EACD,IAAI,EAAE;IAAE,IAAI,EAAE,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CAAE,GAC7E,gBAAgB,CAclB"}

package/dist/routes/draft.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Route-bundle drafting — the shared emitter behind BOTH `modelrig init`
+ * (WS2) and the oracle's `create_route` act tool (WS1).
+ *
+ * A route bundle is three files, not one: the YAML, its JSON Schema, and its
+ * system prompt. A "draft" that emitted only the YAML would not load, so
+ * this builds the whole set.
+ *
+ * PURE: it returns file contents and writes nothing. Every caller that
+ * touches the disk does so through `writeRouteDraft`, which refuses to
+ * overwrite — drafts are proposals for a human to read, never edits.
+ *
+ * The YAML is hand-emitted rather than serialized by the `yaml` package on
+ * purpose: drafts are read by humans first, and the comments explaining WHERE
+ * each candidate came from are the most valuable lines in the file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRouteDraft = buildRouteDraft;
+exports.writeRouteDraft = writeRouteDraft;
+/** YAML string quoting: quote unless the value is unambiguously a plain
+ * scalar. Model ids carry dots, colons and dashes — the cases that bite. */
+function yamlString(value) {
+    if (/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(value))
+        return value;
+    return JSON.stringify(value);
+}
+function slug(route) {
+    return route.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+const DEFAULT_RETRIES = {
+    content_invalid: 2,
+    network: 4,
+    capacity_shed: 3,
+};
+function buildRouteDraft(spec) {
+    if (spec.route.trim() === "")
+        throw new Error("a route draft needs a route name");
+    if (spec.candidates.length === 0) {
+        throw new Error(`route draft "${spec.route}" has no candidates — a route with nothing allowed to serve it ` +
+            "cannot run. Name at least one provider/model.");
+    }
+    const name = slug(spec.route);
+    const files = [];
+    const schemaRef = spec.outputSchema === null ? null : `./schemas/${name}.schema.json`;
+    const promptRef = `./prompts/${name}.system.md`;
+    const lines = [
+        "# ModelRig route bundle — DRAFT. Nothing in your app calls this yet.",
+        "# Read it, edit it, move it up one directory into modelrig/routes/, then",
+        "# switch the call site to rig.run(\"" + spec.route + "\", …).",
+    ];
+    if (spec.provenance !== undefined && spec.provenance.length > 0) {
+        lines.push("#");
+        for (const line of spec.provenance)
+            lines.push(`# ${line}`);
+    }
+    lines.push("#", "# Candidates are ordered incumbent-first: the model you already use leads,", "# so the first run reproduces today's behavior. The cheaper probed", "# alternatives below it are what a bake-off would put to the test.", "#", "# `prefer` is empty ON PURPOSE. Adding `cost` re-sorts these candidates by", "# price, which would hand the first run to the cheapest model rather than", "# to your incumbent — the opposite of a like-for-like migration. Prove a", "# cheaper model with a bake-off, then switch to it deliberately.", `route: ${yamlString(spec.route)}`, "version: 1");
+    if (schemaRef !== null)
+        lines.push(`schema: ${schemaRef}`);
+    lines.push("candidates:");
+    for (const candidate of spec.candidates) {
+        lines.push(`  - provider: ${yamlString(candidate.provider)}`);
+        lines.push(`    model: ${yamlString(candidate.model)}` +
+            (candidate.note !== undefined ? `   # ${candidate.note}` : ""));
+    }
+    const require = spec.require ?? (spec.outputSchema === null ? [] : ["schema_conformant"]);
+    if (require.length > 0) {
+        lines.push("require:");
+        for (const r of require)
+            lines.push(`  - ${yamlString(r)}`);
+    }
+    else {
+        lines.push("require: []");
+    }
+    // Default EMPTY, not [cost]: `prefer: [cost]` re-sorts candidates by price
+    // at resolve time, so the incumbent-first ordering above would be silently
+    // overridden and the first run would NOT reproduce today's behavior.
+    lines.push(`prefer: [${(spec.prefer ?? []).map(yamlString).join(", ")}]`);
+    lines.push("prompt:");
+    lines.push(`  system: ${promptRef}`);
+    lines.push(`  variables: [${spec.variables.map(yamlString).join(", ")}]` +
+        (spec.variables.length === 0 ? "   # no {{variables}} detected — the prompt is static" : ""));
+    const policy = spec.policy ?? {};
+    const retries = policy.retries ?? DEFAULT_RETRIES;
+    lines.push("policy:");
+    lines.push(`  retries: { ${Object.entries(retries)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join(", ")} }`);
+    lines.push(`  timeout_ms: ${policy.timeoutMs ?? 120000}`);
+    lines.push(`  tier: ${yamlString(policy.tier ?? "standard")}`);
+    // json only means something for a schema'd route; the loader defaults it,
+    // so an unstructured draft says nothing rather than saying something wrong.
+    if (spec.outputSchema !== null || policy.json !== undefined) {
+        lines.push(`  json: ${yamlString(policy.json ?? "native")}`);
+    }
+    if (spec.capture === true) {
+        lines.push("# capture: replay inputs are stored LOCALLY only — never exported.");
+        lines.push("capture: true");
+    }
+    files.push({ path: `${name}.yaml`, contents: `${lines.join("\n")}\n` });
+    if (spec.outputSchema !== null) {
+        files.push({
+            path: `schemas/${name}.schema.json`,
+            contents: `${JSON.stringify(spec.outputSchema, null, 2)}\n`,
+        });
+    }
+    files.push({ path: `prompts/${name}.system.md`, contents: ensureTrailingNewline(spec.systemPrompt) });
+    return { route: spec.route, files };
+}
+function ensureTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+/**
+ * Write a draft into `draftsDir`. Two rules, both deliberate:
+ *  - It writes ONLY under the drafts directory. Nothing here can touch the
+ *    caller's source, their live routes, or the control plane (spec §4:
+ *    drafts-only is permanent this phase).
+ *  - It never overwrites. A second run reports what it skipped instead of
+ *    silently discarding edits a human made to a draft.
+ */
+function writeRouteDraft(draft, draftsDir, fs, path) {
+    const written = [];
+    const skipped = [];
+    for (const file of draft.files) {
+        const full = path.join(draftsDir, file.path);
+        if (fs.existsSync(full)) {
+            skipped.push(full);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, file.contents, "utf8");
+        written.push(full);
+    }
+    return { written, skipped };
+}

package/dist/routes/loader.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Routes-as-code loader — spec §3, plan step 3.
+ * Scans a routes directory for *.yaml bundles, validates structurally,
+ * resolves schema/prompt paths relative to the bundle file, freezes.
+ */
+import type { RouteBundle } from "../types/route";
+/**
+ * Structured config error thrown for any invalid bundle (never a raw Error).
+ * Load-time problems are deliberately NOT RigFailures — the failure taxonomy
+ * classifies inference attempts; a malformed bundle means the rig was never
+ * runnable for that route.
+ */
+export declare class RouteConfigError extends Error {
+    readonly file: string | null;
+    readonly problems: readonly string[];
+    constructor(message: string, opts?: {
+        file?: string;
+        problems?: readonly string[];
+    });
+}
+export interface LoadedRoutes {
+    get(route: string): RouteBundle;
+    list(): readonly RouteBundle[];
+}
+/**
+ * Merge two loaded route sets into one store — a UNION, collision is a loud
+ * error. Used to fold a deployment's bundled INTERNAL infra routes (e.g. the
+ * server's run-judge@v1 / analyst-summarize@v1) into the operator's configured
+ * routes without replacing them (index.ts createRig, extraRoutesDir). The
+ * reserved `@v<n>` infra namespace never collides with customer/demo routes;
+ * if it ever did, failing at boot is correct.
+ */
+/**
+ * Load a routes directory and OPTIONALLY union a second (deployment-bundled
+ * infra) directory into it — the one call createRig makes so the extra-routes
+ * merge does not grow index.ts. `extraDir` absent/empty ⇒ exactly loadRoutes.
+ */
+export declare function loadRoutesWithExtra(routesDir: string, extraDir?: string): LoadedRoutes;
+export declare function mergeLoadedRoutes(primary: LoadedRoutes, extra: LoadedRoutes): LoadedRoutes;
+/** One route file's structural-validation outcome (CE-6, spec §1 / walkthrough
+ * §8.7a). `route` is the parsed handle, or null when the bundle failed before a
+ * name could be read. */
+export interface RouteValidation {
+    readonly file: string;
+    readonly route: string | null;
+    readonly ok: boolean;
+    readonly problems: readonly string[];
+}
+/**
+ * Structurally validate every route bundle in a directory WITHOUT requiring any
+ * provider key (CE-6 `modelrig validate`). Unlike {@link loadRoutes}, one bad
+ * bundle does NOT abort the rest — each file is loaded independently and its
+ * outcome collected, so a newbie sees every problem in one pass. Duplicate route
+ * handles across files are reported per the later file. This deliberately does
+ * NOT run the serveable-candidate gate (serveability.ts) — that needs keys and
+ * stays fail-closed for SERVING; validation only checks authoring.
+ *
+ * A missing directory is still a hard error (nothing to validate) — it throws
+ * the same teaching RouteConfigError as loadRoutes.
+ */
+export declare function validateRoutesDir(routesDir: string): RouteValidation[];
+export declare function loadRoutes(routesDir: string): LoadedRoutes;
+//# sourceMappingURL=loader.d.ts.map

package/dist/routes/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/routes/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,KAAK,EAKV,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAMxB;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;gBAEzB,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAO;CAOxF;AAiCD,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC;IAChC,IAAI,IAAI,SAAS,WAAW,EAAE,CAAC;CAChC;AAqZD;;;;;;;GAOG;AACH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAItF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAyB1F;AAED;;yBAEyB;AACzB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CA6CtE;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CA2C1D"}