@velum-labs/routekit-eval-core 1.0.26 → 1.1.0

package/dist/basis-selection.d.ts

@@ -0,0 +1,36 @@
+import type { RoutingBasisV3 } from "@velum-labs/routekit-eval-contracts";
+export type RoutingBasisStructureFindingV3 = Readonly<{
+    severity: "hard" | "warning";
+    code: string;
+    dimensionIds: readonly string[];
+    detail: string;
+}>;
+export type RoutingBasisStructureReportV3 = Readonly<{
+    basisId: string;
+    basisDigest: string;
+    eligible: boolean;
+    dimensionCount: number;
+    definitionBytes: number;
+    findings: readonly RoutingBasisStructureFindingV3[];
+}>;
+export type RoutingBasisCandidateMetricsV3 = Readonly<{
+    basis: RoutingBasisV3;
+    structure: RoutingBasisStructureReportV3;
+    activeMae: number;
+    unknownMae: number;
+    referenceUnknownRate: number;
+    activeF1: number;
+    topDimensionAgreement: number;
+    provisional?: boolean;
+}>;
+export type RoutingBasisCandidateSelectionV3 = Readonly<{
+    ranked: readonly Readonly<RoutingBasisCandidateMetricsV3 & {
+        selectionScore: number;
+        pareto: boolean;
+    }>[];
+    selectedBasisId?: string;
+    paretoBasisIds: readonly string[];
+}>;
+export declare function inspectRoutingBasisStructureV3(basis: RoutingBasisV3, aliasSimilarityThreshold?: number): RoutingBasisStructureReportV3;
+export declare function routingBasisSelectionScoreV3(input: Pick<RoutingBasisCandidateMetricsV3, "activeMae" | "unknownMae" | "referenceUnknownRate">): number;
+export declare function selectRoutingBasisCandidatesV3(candidates: readonly RoutingBasisCandidateMetricsV3[]): RoutingBasisCandidateSelectionV3;

package/dist/basis-selection.js

@@ -0,0 +1,118 @@
+const CATCH_ALL = /\b(other|misc(?:ellaneous)?|general|shared|common|everything else)\b/iu;
+function tokens(dimension) {
+    const text = [dimension.name, dimension.description, ...dimension.inclusions]
+        .join(" ")
+        .toLocaleLowerCase("en-US");
+    return new Set(text.split(/[^a-z0-9]+/u).filter((token) => token.length > 2));
+}
+function jaccard(left, right) {
+    const intersection = [...left].filter((token) => right.has(token)).length;
+    const union = new Set([...left, ...right]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+export function inspectRoutingBasisStructureV3(basis, aliasSimilarityThreshold = 0.58) {
+    const findings = [];
+    for (const dimension of basis.dimensions) {
+        if (CATCH_ALL.test(`${dimension.id} ${dimension.name} ${dimension.description}`))
+            findings.push({
+                severity: "hard",
+                code: "catch_all_dimension",
+                dimensionIds: [dimension.id],
+                detail: "dimension appears to define an open-ended catch-all responsibility"
+            });
+        if (dimension.inclusions.length === 0 ||
+            dimension.exclusions.length === 0 ||
+            dimension.boundaryRules.length === 0)
+            findings.push({
+                severity: "hard",
+                code: "empty_semantics",
+                dimensionIds: [dimension.id],
+                detail: "dimension lacks inclusions, exclusions, or boundary rules"
+            });
+        if (dimension.repositoryFacets.componentIds.length +
+            dimension.repositoryFacets.pathAnchors.length +
+            dimension.repositoryFacets.symbolAnchors.length ===
+            0 &&
+            dimension.codeSummaries.length === 0)
+            findings.push({
+                severity: "hard",
+                code: "unsupported_dimension",
+                dimensionIds: [dimension.id],
+                detail: "dimension has no repository evidence anchors"
+            });
+    }
+    for (let leftIndex = 0; leftIndex < basis.dimensions.length; leftIndex += 1) {
+        const left = basis.dimensions[leftIndex];
+        for (let rightIndex = leftIndex + 1; rightIndex < basis.dimensions.length; rightIndex += 1) {
+            const right = basis.dimensions[rightIndex];
+            if (left.id.startsWith(`${right.id}-`) || right.id.startsWith(`${left.id}-`))
+                findings.push({
+                    severity: "hard",
+                    code: "parent_child_pair",
+                    dimensionIds: [left.id, right.id],
+                    detail: "dimensions mix parent and child responsibilities at one routing level"
+                });
+            if (jaccard(tokens(left), tokens(right)) >= aliasSimilarityThreshold)
+                findings.push({
+                    severity: "hard",
+                    code: "near_alias_dimensions",
+                    dimensionIds: [left.id, right.id],
+                    detail: `semantic-token similarity meets the ${String(aliasSimilarityThreshold)} rejection threshold`
+                });
+        }
+    }
+    return {
+        basisId: basis.basisId,
+        basisDigest: basis.basisDigest,
+        eligible: !findings.some((finding) => finding.severity === "hard"),
+        dimensionCount: basis.dimensions.length,
+        definitionBytes: Buffer.byteLength(JSON.stringify(basis.dimensions), "utf8"),
+        findings
+    };
+}
+export function routingBasisSelectionScoreV3(input) {
+    return input.activeMae + 0.5 * input.unknownMae + 0.15 * input.referenceUnknownRate;
+}
+function dominates(left, right) {
+    const leftValues = [
+        left.activeMae,
+        left.unknownMae,
+        left.structure.dimensionCount,
+        left.structure.definitionBytes
+    ];
+    const rightValues = [
+        right.activeMae,
+        right.unknownMae,
+        right.structure.dimensionCount,
+        right.structure.definitionBytes
+    ];
+    return (leftValues.every((value, index) => value <= rightValues[index]) &&
+        leftValues.some((value, index) => value < rightValues[index]));
+}
+export function selectRoutingBasisCandidatesV3(candidates) {
+    const eligible = candidates.filter((candidate) => candidate.structure.eligible);
+    const pareto = eligible.filter((candidate) => !eligible.some((other) => other !== candidate && dominates(other, candidate)));
+    const paretoIds = new Set(pareto.map((candidate) => candidate.basis.basisId));
+    const ranked = candidates
+        .map((candidate) => ({
+        ...candidate,
+        selectionScore: candidate.structure.eligible
+            ? routingBasisSelectionScoreV3(candidate)
+            : Number.POSITIVE_INFINITY,
+        pareto: paretoIds.has(candidate.basis.basisId)
+    }))
+        .sort((left, right) => left.selectionScore - right.selectionScore ||
+        left.structure.dimensionCount - right.structure.dimensionCount ||
+        left.structure.definitionBytes - right.structure.definitionBytes ||
+        left.basis.basisId.localeCompare(right.basis.basisId));
+    return {
+        ranked,
+        ...(ranked.find((candidate) => Number.isFinite(candidate.selectionScore)) === undefined
+            ? {}
+            : {
+                selectedBasisId: ranked.find((candidate) => Number.isFinite(candidate.selectionScore))
+                    .basis.basisId
+            }),
+        paretoBasisIds: pareto.map((candidate) => candidate.basis.basisId).sort()
+    };
+}

package/dist/classification-metrics.d.ts

@@ -0,0 +1,20 @@
+import type { DimensionScoreLabelV3, DimensionScorePredictionV3 } from "@velum-labs/routekit-eval-contracts";
+export type ClassificationMetricOptionsV3 = Readonly<{
+    activeDimensionThreshold: number;
+    unknownThreshold: number;
+}>;
+export type ClassificationMetricsV3 = Readonly<{
+    caseCount: number;
+    skippedInvalidCount: number;
+    activeMae: number;
+    activeF1: number;
+    topDimensionAgreement: number;
+    unknownMae: number;
+    unknownBrier: number;
+    unknownAccuracy: number;
+    falseUnknownRate: number;
+    missedUnknownRate: number;
+    referenceUnknownRate: number;
+    averageActiveDimensionCount: number;
+}>;
+export declare function evaluateClassificationMetricsV3(labels: readonly DimensionScoreLabelV3[], predictions: readonly DimensionScorePredictionV3[], options: ClassificationMetricOptionsV3): ClassificationMetricsV3;

package/dist/classification-metrics.js

@@ -0,0 +1,83 @@
+function unit(value, label) {
+    if (!Number.isFinite(value) || value < 0 || value > 1)
+        throw new Error(`${label} must be between zero and one`);
+}
+function top(scores) {
+    return [...scores].sort((left, right) => right.score - left.score || left.dimensionId.localeCompare(right.dimensionId))[0]?.dimensionId;
+}
+export function evaluateClassificationMetricsV3(labels, predictions, options) {
+    unit(options.activeDimensionThreshold, "active dimension threshold");
+    unit(options.unknownThreshold, "unknown threshold");
+    const predictionByCase = new Map(predictions.map((prediction) => [prediction.caseId, prediction]));
+    if (predictionByCase.size !== predictions.length)
+        throw new Error("predictions contain duplicate case IDs");
+    let absolute = 0, scoreCount = 0, tp = 0, fp = 0, fn = 0, topAgreement = 0;
+    let unknownAbsolute = 0, unknownSquared = 0, unknownCorrect = 0, falseUnknown = 0, missedUnknown = 0, referenceUnknown = 0, activeCount = 0;
+    for (const label of labels) {
+        const prediction = predictionByCase.get(label.caseId);
+        if (prediction === undefined)
+            throw new Error(`missing prediction for case ${label.caseId}`);
+        if (prediction.basisDigest !== label.basisDigest)
+            throw new Error(`basis digest mismatch for case ${label.caseId}`);
+        const labelIds = label.scores.map((entry) => entry.dimensionId);
+        const predictionIds = prediction.scores.map((entry) => entry.dimensionId);
+        if (labelIds.length !== predictionIds.length ||
+            labelIds.some((id, index) => predictionIds[index] !== id))
+            throw new Error(`dimension mismatch for case ${label.caseId}`);
+        for (let index = 0; index < label.scores.length; index += 1) {
+            const expected = label.scores[index];
+            const actual = prediction.scores[index];
+            unit(expected.score, "reference score");
+            unit(actual.score, "prediction score");
+            absolute += Math.abs(expected.score - actual.score);
+            scoreCount += 1;
+            const expectedActive = expected.score >= options.activeDimensionThreshold;
+            const actualActive = actual.score >= options.activeDimensionThreshold;
+            if (expectedActive && actualActive)
+                tp += 1;
+            else if (!expectedActive && actualActive)
+                fp += 1;
+            else if (expectedActive)
+                fn += 1;
+            if (actualActive)
+                activeCount += 1;
+        }
+        if (top(label.scores) === top(prediction.scores))
+            topAgreement += 1;
+        unit(label.unknownProbability, "reference unknown probability");
+        unit(prediction.unknownProbability, "predicted unknown probability");
+        const delta = prediction.unknownProbability - label.unknownProbability;
+        unknownAbsolute += Math.abs(delta);
+        unknownSquared += delta * delta;
+        const expectedUnknown = label.unknownProbability >= options.unknownThreshold;
+        const actualUnknown = prediction.unknownProbability >= options.unknownThreshold;
+        if (expectedUnknown)
+            referenceUnknown += 1;
+        if (expectedUnknown === actualUnknown)
+            unknownCorrect += 1;
+        else if (actualUnknown)
+            falseUnknown += 1;
+        else
+            missedUnknown += 1;
+    }
+    if (predictionByCase.size !== labels.length)
+        throw new Error("predictions contain cases absent from the reference set");
+    const count = labels.length;
+    if (count === 0 || scoreCount === 0)
+        throw new Error("classification metrics require at least one case and dimension");
+    const f1Denominator = 2 * tp + fp + fn;
+    return {
+        caseCount: count,
+        skippedInvalidCount: 0,
+        activeMae: absolute / scoreCount,
+        activeF1: f1Denominator === 0 ? 1 : (2 * tp) / f1Denominator,
+        topDimensionAgreement: topAgreement / count,
+        unknownMae: unknownAbsolute / count,
+        unknownBrier: unknownSquared / count,
+        unknownAccuracy: unknownCorrect / count,
+        falseUnknownRate: falseUnknown / count,
+        missedUnknownRate: missedUnknown / count,
+        referenceUnknownRate: referenceUnknown / count,
+        averageActiveDimensionCount: activeCount / count
+    };
+}

package/dist/effect-api.d.ts

@@ -1,2 +1,4 @@
 export type { EvalEgressOptions } from "./egress.js";
 export { type RoutingModelAvailability, type RoutingScoreConstraints, type RoutingScoreResult, RoutingScoringError, type RoutingScoringErrorCode, type ScoreRoutingCandidatesInput, scoreRoutingCandidates } from "./routing-score.js";
+export * from "./basis-selection.js";
+export * from "./classification-metrics.js";

package/dist/effect-api.js

@@ -1 +1,3 @@
 export { RoutingScoringError, scoreRoutingCandidates } from "./routing-score.js";
+export * from "./basis-selection.js";
+export * from "./classification-metrics.js";

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export type { EvalEgressOptions } from "./egress.js";
-export { type RoutingModelAvailability, type RoutingScoreConstraints, type RoutingScoreResult, RoutingScoringError, type RoutingScoringErrorCode, type ScoreRoutingCandidatesInput, scoreRoutingCandidates } from "./routing-score.js";
+export { type RoutingModelAvailability, type RoutingScoreConstraints, type RoutingScoreComposition, type RoutingScoreEvidence, type RoutingScoreResult, RoutingScoringError, type RoutingScoringErrorCode, type ScoreRoutingCandidatesInput, scoreRoutingCandidates } from "./routing-score.js";
+export * from "./basis-selection.js";
+export * from "./classification-metrics.js";

package/dist/index.js

@@ -1 +1,3 @@
 export { RoutingScoringError, scoreRoutingCandidates } from "./routing-score.js";
+export * from "./basis-selection.js";
+export * from "./classification-metrics.js";

package/dist/routing-score.d.ts

@@ -1,4 +1,4 @@
-import type { PublishedRoutingActivation, RequestDecomposition, RequestRoutingRequirements, RoutingCandidateDecision, RoutingEndpoint, RoutingObjectivePolicy } from "@velum-labs/routekit-eval-contracts";
+import type { ModelDimensionEvidence, RequestRoutingRequirements, RoutingCandidateDecision, RoutingEndpoint, RoutingObjectivePolicy } from "@velum-labs/routekit-eval-contracts";
 export type RoutingModelAvailability = Readonly<{
     model: string;
     served: boolean;
@@ -14,9 +14,25 @@ export type RoutingScoreConstraints = Readonly<{
     /** Maximum weighted failure rate for a candidate. */
     maximumFailureRate?: number;
 }>;
+/** Version-neutral evidence consumed by deterministic routing. */
+export type RoutingScoreEvidence = Readonly<{
+    basisDigest: string;
+    dimensionIds: readonly string[];
+    candidateModels: readonly string[];
+    evidence: readonly ModelDimensionEvidence[];
+}>;
+/** Version-neutral composition consumed by deterministic routing. */
+export type RoutingScoreComposition = Readonly<{
+    basisDigest: string;
+    weights: readonly Readonly<{
+        dimensionId: string;
+        weight: number;
+    }>[];
+    unassignedWeight: number;
+}>;
 export type ScoreRoutingCandidatesInput = Readonly<{
-    snapshot: PublishedRoutingActivation;
-    decomposition: RequestDecomposition;
+    routingEvidence: RoutingScoreEvidence;
+    composition: RoutingScoreComposition;
     requirements: RequestRoutingRequirements;
     objective: RoutingObjectivePolicy;
     availableModels: readonly RoutingModelAvailability[];

package/dist/routing-score.js

@@ -40,19 +40,19 @@ function compareNumberDescending(left, right) {
     return right - left;
 }
 function activeWeights(input) {
-    if (input.snapshot.basisDigest !== input.decomposition.basisDigest) {
-        invalid("dimension definition digest does not match the routing snapshot");
+    if (input.routingEvidence.basisDigest !== input.composition.basisDigest) {
+        invalid("dimension definition digest does not match the routing evidence");
     }
-    const dimensionIds = input.snapshot.dimensions.map((dimension) => dimension.id);
-    unique(dimensionIds, "snapshot dimension IDs");
-    unique(input.snapshot.candidateModels, "snapshot candidate models");
+    const dimensionIds = input.routingEvidence.dimensionIds;
+    unique(dimensionIds, "routing evidence dimension IDs");
+    unique(input.routingEvidence.candidateModels, "routing evidence candidate models");
     if (dimensionIds.length === 0)
-        invalid("routing snapshot must contain at least one dimension");
-    if (input.snapshot.candidateModels.length === 0) {
-        invalid("routing snapshot must contain at least one candidate model");
+        invalid("routing evidence must contain at least one dimension");
+    if (input.routingEvidence.candidateModels.length === 0) {
+        invalid("routing evidence must contain at least one candidate model");
     }
     const weights = new Map();
-    for (const entry of input.decomposition.weights) {
+    for (const entry of input.composition.weights) {
         finiteUnit(entry.weight, `weight for dimension ${entry.dimensionId}`);
         if (weights.has(entry.dimensionId))
             invalid(`duplicate decomposition dimension: ${entry.dimensionId}`);
@@ -64,10 +64,10 @@ function activeWeights(input) {
         if (!weights.has(dimensionId))
             invalid(`missing decomposition dimension: ${dimensionId}`);
     }
-    finiteUnit(input.decomposition.unknownWeight, "unknown weight");
+    finiteUnit(input.composition.unassignedWeight, "unassigned weight");
     const total = [...weights.values()].reduce((sum, weight) => sum + weight, 0);
-    if (Math.abs(total + input.decomposition.unknownWeight - 1) > VECTOR_TOLERANCE) {
-        invalid("dimension weights and unknown weight must sum to one");
+    if (Math.abs(total + input.composition.unassignedWeight - 1) > VECTOR_TOLERANCE) {
+        invalid("dimension weights and unassigned weight must sum to one");
     }
     if (total <= VECTOR_TOLERANCE)
         invalid("routing requires at least one covered dimension");
@@ -81,7 +81,7 @@ function validateInput(input) {
     const availableIds = input.availableModels.map((model) => model.model);
     unique(availableIds, "available model IDs");
     const floors = input.constraints?.minimumDimensionQuality ?? {};
-    const knownDimensions = new Set(input.snapshot.dimensions.map((dimension) => dimension.id));
+    const knownDimensions = new Set(input.routingEvidence.dimensionIds);
     for (const [dimensionId, floor] of Object.entries(floors)) {
         if (!knownDimensions.has(dimensionId))
             invalid(`quality floor refers to unknown dimension: ${dimensionId}`);
@@ -148,7 +148,7 @@ function capabilityReasons(availability, requirements) {
 function calculateCandidates(input, active) {
     const availability = new Map(input.availableModels.map((model) => [model.model, model]));
     const floors = input.constraints?.minimumDimensionQuality ?? {};
-    return input.snapshot.candidateModels.map((model) => {
+    return input.routingEvidence.candidateModels.map((model) => {
         const reasons = capabilityReasons(availability.get(model), input.requirements);
         let quality = 0;
         let failureRate = 0;
@@ -158,7 +158,7 @@ function calculateCandidates(input, active) {
         let completeDuration = true;
         let completeCost = true;
         for (const { dimensionId, weight } of active) {
-            const cells = input.snapshot.evidence.filter((cell) => cell.model === model && cell.dimensionId === dimensionId);
+            const cells = input.routingEvidence.evidence.filter((cell) => cell.model === model && cell.dimensionId === dimensionId);
             if (cells.length === 0) {
                 reasons.push(`missing_evidence:${dimensionId}`);
                 completeCoreEvidence = false;

package/dist/test/classification-v3.test.d.ts

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

package/dist/test/classification-v3.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { evaluateClassificationMetricsV3, routingBasisSelectionScoreV3 } from "../index.js";
+const digest = "a".repeat(64);
+test("classification metrics use independent score and separate unknown errors", () => {
+    const labels = [
+        {
+            caseId: "one",
+            basisDigest: digest,
+            scores: [
+                { dimensionId: "a", score: 1 },
+                { dimensionId: "b", score: 0 }
+            ],
+            unknownProbability: 0
+        }
+    ];
+    const predictions = [
+        {
+            ...labels[0],
+            classifierConfigurationDigest: "b".repeat(64),
+            scores: [
+                { dimensionId: "a", score: 0.8 },
+                { dimensionId: "b", score: 0.3 }
+            ],
+            unknownProbability: 0.2
+        }
+    ];
+    const metrics = evaluateClassificationMetricsV3(labels, predictions, {
+        activeDimensionThreshold: 0.25,
+        unknownThreshold: 0.3
+    });
+    assert.ok(Math.abs(metrics.activeMae - 0.25) < 1e-12);
+    assert.equal(metrics.activeF1, 2 / 3);
+    assert.equal(metrics.topDimensionAgreement, 1);
+    assert.equal(metrics.unknownMae, 0.2);
+    assert.ok(Math.abs(metrics.unknownBrier - 0.04) < 1e-12);
+});
+test("basis scalar selection score uses the frozen formula", () => {
+    assert.equal(routingBasisSelectionScoreV3({ activeMae: 0.1, unknownMae: 0.2, referenceUnknownRate: 0.4 }), 0.26);
+});

package/dist/test/routing-score.test.js

@@ -62,9 +62,19 @@ function available(model, overrides = {}) {
     };
 }
 function run(evidence, objective = { kind: "highest-quality" }, options = {}) {
+    const routingSnapshot = snapshot(evidence, options.candidateModels);
     return scoreRoutingCandidates({
-        snapshot: snapshot(evidence, options.candidateModels),
-        decomposition: options.requestDecomposition ?? decomposition,
+        routingEvidence: {
+            basisDigest: routingSnapshot.basisDigest,
+            dimensionIds: routingSnapshot.dimensions.map((dimension) => dimension.id),
+            candidateModels: routingSnapshot.candidateModels,
+            evidence: routingSnapshot.evidence
+        },
+        composition: {
+            basisDigest: (options.requestDecomposition ?? decomposition).basisDigest,
+            weights: (options.requestDecomposition ?? decomposition).weights,
+            unassignedWeight: (options.requestDecomposition ?? decomposition).unknownWeight
+        },
         requirements,
         objective,
         availableModels: options.availableModels ?? models.map((model) => available(model))
@@ -99,8 +109,17 @@ test("hard requirements exclude unserved and incapable candidates before scoring
         ]
     });
     const withTools = scoreRoutingCandidates({
-        snapshot: snapshot(completeEvidence),
-        decomposition,
+        routingEvidence: {
+            basisDigest: snapshot(completeEvidence).basisDigest,
+            dimensionIds: snapshot(completeEvidence).dimensions.map((dimension) => dimension.id),
+            candidateModels: snapshot(completeEvidence).candidateModels,
+            evidence: snapshot(completeEvidence).evidence
+        },
+        composition: {
+            basisDigest: decomposition.basisDigest,
+            weights: decomposition.weights,
+            unassignedWeight: decomposition.unknownWeight
+        },
         requirements: { ...requirements, requiresTools: true },
         objective: { kind: "highest-quality" },
         availableModels: [
@@ -128,8 +147,17 @@ test("unknown numeric basis limits do not claim a served model is incapable", ()
 test("missing evidence and per-dimension quality floors fail candidates closed", () => {
     const missingLastCell = completeEvidence.filter((entry) => !(entry.model === models[0] && entry.dimensionId === "docs"));
     const result = scoreRoutingCandidates({
-        snapshot: snapshot(missingLastCell),
-        decomposition,
+        routingEvidence: {
+            basisDigest: snapshot(missingLastCell).basisDigest,
+            dimensionIds: snapshot(missingLastCell).dimensions.map((dimension) => dimension.id),
+            candidateModels: snapshot(missingLastCell).candidateModels,
+            evidence: snapshot(missingLastCell).evidence
+        },
+        composition: {
+            basisDigest: decomposition.basisDigest,
+            weights: decomposition.weights,
+            unassignedWeight: decomposition.unknownWeight
+        },
         requirements,
         objective: { kind: "highest-quality" },
         availableModels: models.map((model) => available(model)),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-eval-core",
   "private": false,
-  "version": "1.0.26",
+  "version": "1.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-eval-contracts": "1.0.26",
-    "@velum-labs/routekit-runtime": "1.0.26"
+    "@velum-labs/routekit-eval-contracts": "1.1.0",
+    "@velum-labs/routekit-runtime": "1.1.0"
   },
   "keywords": [
     "routekit",