@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/services/quality-gate/service.d.ts

@@ -0,0 +1,233 @@
+import { Context, Effect, Layer } from "effect";
+import type { RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+import type { RepositoryBenchmarkCaseV1, RepositoryCandidateVisibleTaskV1 } from "../../repository-benchmark-protocol.js";
+import type { RepositoryHiddenOracleV1 } from "../../repository-oracle-protocol.js";
+import type { RepositorySpecificationCritiqueV1 } from "../../repository-specification-critique-protocol.js";
+import type { RepositoryTaskFamilyV1 } from "../../repository-task-family-protocol.js";
+import type { RepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import type { RepositoryTrajectoryPolicyV1 } from "../../repository-trajectory-protocol.js";
+export type QualityGateShape = {
+    readonly evaluate: (input: {
+        readonly map: RepositoryBehaviorMapV1;
+        readonly seed: RepositoryTaskSeedV1;
+        readonly family: RepositoryTaskFamilyV1;
+        readonly visible: RepositoryCandidateVisibleTaskV1;
+        readonly hidden: RepositoryHiddenOracleV1;
+        readonly specificationCritique: RepositorySpecificationCritiqueV1;
+        readonly trajectoryPolicy?: RepositoryTrajectoryPolicyV1;
+    }) => Effect.Effect<RepositoryBenchmarkCaseV1>;
+};
+declare const QualityGate_base: Context.ServiceClass<QualityGate, "@velum-labs/routekit-eval-setup/QualityGate", QualityGateShape>;
+export declare class QualityGate extends QualityGate_base {
+}
+export declare const evaluateRepositoryBenchmarkDraftV1: (input: {
+    readonly map: RepositoryBehaviorMapV1;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly family: RepositoryTaskFamilyV1;
+    readonly visible: RepositoryCandidateVisibleTaskV1;
+    readonly hidden: RepositoryHiddenOracleV1;
+    readonly specificationCritique: RepositorySpecificationCritiqueV1;
+    readonly trajectoryPolicy?: RepositoryTrajectoryPolicyV1;
+}) => Effect.Effect<{
+    readonly id: string;
+    readonly version: 1;
+    readonly rejectionReasons: readonly string[];
+    readonly status: "rejected" | "valid-library" | "routing-eligible" | "routing-active";
+    readonly seedId: string;
+    readonly lane: "request" | "repository-agent";
+    readonly qualityFindings: readonly {
+        readonly axis: "coverage" | "stability" | "authenticity" | "specification-sufficiency" | "oracle-adequacy" | "distinctness" | "realism" | "leakage" | "triviality";
+        readonly outcome: "pass" | "fail" | "review-required";
+        readonly detail: string;
+        readonly evidence: readonly {
+            readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+            readonly id: string;
+            readonly path?: string | undefined;
+        }[];
+        readonly evidenceIds: readonly string[];
+    }[];
+    readonly capabilityId: string;
+    readonly familyId: string;
+    readonly visible: {
+        readonly lane: "request";
+        readonly id: string;
+        readonly request: {
+            readonly endpoint: "chat" | "responses" | "anthropic";
+            readonly method: "POST";
+            readonly path: string;
+            readonly headers: readonly {
+                readonly name: string;
+                readonly value: string;
+            }[];
+            readonly bodyJson: string;
+        };
+    } | {
+        readonly lane: "repository-agent";
+        readonly id: string;
+        readonly requestText: string;
+        readonly checkoutCommit: string;
+        readonly allowedTools: readonly ("test" | "read" | "search" | "edit" | "shell")[];
+        readonly constraints: readonly string[];
+    };
+    readonly hidden: {
+        readonly version: 1;
+        readonly fixtures: readonly ({
+            readonly kind: "historical-regression";
+            readonly expectationMode: "changes";
+            readonly id: string;
+            readonly description: string;
+            readonly expectedBehavior: string;
+            readonly source: "historical" | "generated" | "reviewed";
+            readonly testPath: string;
+        } | {
+            readonly kind: "boundary";
+            readonly expectationMode: "changes" | "preserved";
+            readonly id: string;
+            readonly description: string;
+            readonly expectedBehavior: string;
+            readonly source: "historical" | "generated" | "reviewed";
+            readonly testPath: string;
+        } | {
+            readonly kind: "counterfactual";
+            readonly expectationMode: "changes";
+            readonly id: string;
+            readonly description: string;
+            readonly expectedBehavior: string;
+            readonly source: "historical" | "generated" | "reviewed";
+            readonly testPath: string;
+        } | {
+            readonly kind: "metamorphic";
+            readonly expectationMode: "preserved";
+            readonly id: string;
+            readonly description: string;
+            readonly expectedBehavior: string;
+            readonly source: "historical" | "generated" | "reviewed";
+            readonly testPath: string;
+        })[];
+        readonly caseId: string;
+        readonly hardFailurePolicy: "any-critical-hard-clause-fails";
+        readonly clauses: readonly ({
+            readonly kind: "candidate-policy";
+            readonly policyId: string;
+            readonly forbiddenPaths: readonly string[];
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        } | {
+            readonly kind: "test-command";
+            readonly recipeId: string;
+            readonly expectedExitCode: number;
+            readonly fixtureIds: readonly string[];
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        } | {
+            readonly kind: "json-field";
+            readonly id: string;
+            readonly description: string;
+            readonly critical: boolean;
+            readonly operator: "equals" | "present" | "absent";
+            readonly pointer: string;
+            readonly expectedJson?: string | undefined;
+        } | {
+            readonly kind: "ordered-events";
+            readonly id: string;
+            readonly description: string;
+            readonly critical: boolean;
+            readonly eventTypes: readonly string[];
+            readonly terminalEvent?: string | undefined;
+        } | {
+            readonly kind: "property";
+            readonly propertyId: string;
+            readonly fixtureIds: readonly string[];
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        } | {
+            readonly kind: "differential";
+            readonly implementationIds: readonly string[];
+            readonly fixtureIds: readonly string[];
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        } | {
+            readonly kind: "architecture";
+            readonly ruleId: string;
+            readonly expectedPaths: readonly string[];
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        } | {
+            readonly kind: "transformation-completeness";
+            readonly ruleId: string;
+            readonly forbiddenLegacyPaths: readonly string[];
+            readonly requiredNewPaths: readonly string[];
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        } | {
+            readonly kind: "semantic-residual";
+            readonly criterion: string;
+            readonly id: string;
+            readonly critical: boolean;
+            readonly description: string;
+        })[];
+        readonly solutions: readonly {
+            readonly kind: "historical-reference" | "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "historical-defect" | "mutation" | "model-near-miss" | "reward-hacking";
+            readonly id: string;
+            readonly expectedClass: "valid" | "wrong";
+            readonly family: string;
+            readonly commit?: string | undefined;
+        }[];
+        readonly observations: readonly {
+            readonly outcome: "pass" | "fail" | "unknown";
+            readonly solutionId: string;
+            readonly clauseId: string;
+            readonly repetition: number;
+            readonly detail: string;
+            readonly inconclusiveReason?: "unattributed-test-failure" | undefined;
+        }[];
+        readonly knownLimitations: readonly string[];
+        readonly executionBindingDigest?: string | undefined;
+        readonly executionRepetitions?: number | undefined;
+    };
+    readonly adequacy: {
+        readonly version: 1;
+        readonly caseId: string;
+        readonly admitted: boolean;
+        readonly validSolutionCount: number;
+        readonly wrongSolutionCount: number;
+        readonly falseRejectedSolutionIds: readonly string[];
+        readonly falseAcceptedSolutionIds: readonly string[];
+        readonly unstableSolutionIds: readonly string[];
+        readonly unobservedClauseIds: readonly string[];
+        readonly insufficientObservationPairs: readonly string[];
+        readonly mutationFamilyKills: readonly {
+            readonly family: string;
+            readonly killed: number;
+            readonly total: number;
+        }[];
+        readonly rejectionReasons: readonly string[];
+    };
+    readonly behavioralFingerprint: string;
+    readonly trajectoryPolicy?: {
+        readonly version: 1;
+        readonly caseId: string;
+        readonly purpose: "routing-signal";
+        readonly validationRecipeIds: readonly string[];
+        readonly protectedPaths: readonly string[];
+        readonly thresholds: {
+            readonly maximumToolCalls: number;
+            readonly maximumFailedToolCalls: number;
+            readonly maximumRepeatedFailedActions: number;
+        };
+        readonly requirements: {
+            readonly passingValidationAfterLastMutation: boolean;
+            readonly noProtectedPathMutations: boolean;
+        };
+        readonly rationale: string;
+    } | undefined;
+}, never, never>;
+export declare const makeQualityGate: Effect.Effect<QualityGateShape, never, never>;
+export declare const QualityGateLive: Layer.Layer<QualityGate, never, never>;
+export {};

package/dist/services/quality-gate/service.js

@@ -0,0 +1,136 @@
+import { Context, Effect, Layer } from "effect";
+import { admitRepositoryBenchmarkCaseV1, evaluateRepositoryOracleAdequacyV1, repositoryBehavioralFingerprintV1 } from "../../repository-quality-policy.js";
+const finding = (axis, outcome, detail, evidence = [], evidenceIds = []) => ({
+    axis,
+    outcome,
+    detail,
+    evidence,
+    evidenceIds
+});
+const visibleText = (visible) => visible.lane === "repository-agent" ? visible.requestText : visible.request.bodyJson;
+const leakedHiddenValue = (visible, oracle) => {
+    const text = visibleText(visible);
+    return oracle.solutions
+        .flatMap((solution) => [solution.commit, solution.id])
+        .filter((value) => value !== undefined && value.length >= 7)
+        .find((value) => text.includes(value));
+};
+export class QualityGate extends Context.Service()("@velum-labs/routekit-eval-setup/QualityGate") {
+}
+export const evaluateRepositoryBenchmarkDraftV1 = Effect.fn("QualityGate.evaluate")(function* (input) {
+    const adequacy = evaluateRepositoryOracleAdequacyV1(input.hidden);
+    const text = visibleText(input.visible);
+    const leak = leakedHiddenValue(input.visible, input.hidden);
+    const independentValidCount = input.hidden.solutions.filter((solution) => solution.expectedClass === "valid" &&
+        (solution.kind === "independent-valid" || solution.kind === "simplified-valid")).length;
+    const behaviorPreservingValidCount = input.hidden.solutions.filter((solution) => solution.expectedClass === "valid" && solution.kind === "behavior-preserving-valid").length;
+    const wrongSolutions = input.hidden.solutions.filter((solution) => solution.expectedClass === "wrong");
+    const hasHistoricalDefect = wrongSolutions.some((solution) => solution.kind === "historical-defect");
+    const integrationFamily = /(?:integration|cross-file|adapter|schema|protocol|facade|façade|reader|writer|cli|service|removed-path|new-path)/iu;
+    const hasIntegrationAdversary = wrongSolutions.some((solution) => integrationFamily.test(solution.family));
+    const hasSemanticAdversary = wrongSolutions.some((solution) => solution.kind === "mutation" && !integrationFamily.test(solution.family));
+    const hasRewardHackingAdversary = wrongSolutions.some((solution) => solution.kind === "reward-hacking");
+    const hasBoundaryOrCounterfactualFixture = input.hidden.fixtures.some((fixture) => fixture.kind === "boundary" || fixture.kind === "counterfactual");
+    const hasMetamorphicFixture = input.hidden.fixtures.some((fixture) => fixture.kind === "metamorphic");
+    const hasCandidatePolicyClause = input.hidden.clauses.some((clause) => clause.kind === "candidate-policy" && clause.critical);
+    const oraclePopulationGaps = [
+        ...(independentValidCount > 0 ? [] : ["no independently implemented valid alternative"]),
+        ...(behaviorPreservingValidCount > 0 ? [] : ["no behavior-preserving valid transformation"]),
+        ...(hasHistoricalDefect ? [] : ["no historical defect control"]),
+        ...(hasSemanticAdversary ? [] : ["no target-relevant semantic mutation"]),
+        ...(hasIntegrationAdversary ? [] : ["no cross-file or integration adversary"]),
+        ...(hasRewardHackingAdversary ? [] : ["no reward-hacking adversary"]),
+        ...(hasBoundaryOrCounterfactualFixture
+            ? []
+            : ["no boundary or counterfactual hidden fixture"]),
+        ...(hasMetamorphicFixture ? [] : ["no metamorphic hidden fixture"]),
+        ...(hasCandidatePolicyClause ? [] : ["no executable candidate-policy clause"])
+    ];
+    const findings = [
+        finding("authenticity", input.seed.status === "qualified" ? "pass" : "fail", input.seed.status === "qualified"
+            ? "The task is grounded in a replay-qualified repository seed."
+            : "The task seed has not passed replay qualification.", input.seed.capabilityEvidence, [
+            `generation:/qualification/seed/${input.seed.id}`,
+            ...input.seed.capabilityEvidence.map((evidence) => `repository-evidence:${evidence.kind}:${evidence.id}`)
+        ]),
+        finding("specification-sufficiency", input.specificationCritique.caseId === input.visible.id &&
+            input.specificationCritique.outcome === "pass"
+            ? "pass"
+            : input.specificationCritique.outcome === "fail"
+                ? "fail"
+                : "review-required", input.specificationCritique.outcome === "pass"
+            ? `The task passed structured criticism and ${String(input.specificationCritique.independentApprovalCount)} independent sufficiency reviews.`
+            : input.specificationCritique.rejectionReasons.join("; "), [], [
+            `generation:/authored/specificationCritique/${input.specificationCritique.caseId}`,
+            ...input.specificationCritique.reviews.map((review) => `generation:/authored/reviews/${review.reviewerId}`)
+        ]),
+        finding("oracle-adequacy", adequacy.admitted && oraclePopulationGaps.length === 0 ? "pass" : "fail", adequacy.admitted && oraclePopulationGaps.length === 0
+            ? "All required valid controls, mutation populations, hidden fixture classes, and candidate-policy checks passed."
+            : [...adequacy.rejectionReasons, ...oraclePopulationGaps].join("; "), [], [
+            `generation:/benchmarkCase/adequacy/${adequacy.caseId}`,
+            `generation:/benchmarkCase/hidden/clauses`,
+            `generation:/benchmarkCase/hidden/observations`
+        ]),
+        finding("stability", adequacy.unstableSolutionIds.length === 0 ? "pass" : "fail", adequacy.unstableSolutionIds.length === 0
+            ? "Repeated oracle observations are stable."
+            : `Unstable solutions: ${adequacy.unstableSolutionIds.join(", ")}`, [], [
+            `generation:/benchmarkCase/adequacy/${adequacy.caseId}/unstableSolutionIds`,
+            `generation:/benchmarkCase/hidden/observations`
+        ]),
+        finding("distinctness", input.family.seedIds.includes(input.seed.id) ? "pass" : "fail", "The case is bound to its evidence-backed task family.", [], [`generation:/family/${input.family.id}/seedIds/${input.seed.id}`]),
+        finding("realism", input.seed.source.kind === "historical-fix" ||
+            input.seed.source.kind === "historical-feature" ||
+            input.seed.source.kind === "historical-refactor"
+            ? "pass"
+            : "review-required", "Replay-qualified historical work is admitted directly; synthetic coverage gaps require review.", [], [
+            `generation:/qualification/seed/source/${input.seed.source.kind}`,
+            `generation:/qualification/seed/${input.seed.id}`
+        ]),
+        finding("leakage", leak === undefined ? "pass" : "fail", leak === undefined
+            ? "No hidden solution identifier or commit appears in the visible task."
+            : `Visible task leaks hidden value ${JSON.stringify(leak)}.`, [], [
+            `generation:/benchmarkCase/visible`,
+            `generation:/benchmarkCase/hidden/solutions`
+        ]),
+        finding("triviality", text.length >= 100 && !/\breplace\s+[`'"].+[`'"]\s+with\s+[`'"].+[`'"]/iu.test(text)
+            ? "pass"
+            : "fail", "The task is not a direct-copy or explicit string-substitution exercise.", [], [`generation:/benchmarkCase/visible`]),
+        finding("coverage", input.map.workloadSignals.some((signal) => input.seed.source.kind === "historical-fix" ||
+            input.seed.source.kind === "historical-feature" ||
+            input.seed.source.kind === "historical-refactor"
+            ? signal.episodeIds.includes(input.seed.source.changeEpisodeId)
+            : false)
+            ? "pass"
+            : "review-required", "The task contributes to an evidence-backed recurring workload signal.", [], [
+            `generation:/map/workloadSignals`,
+            `generation:/qualification/seed/${input.seed.id}`
+        ])
+    ];
+    const id = input.visible.id;
+    const behavioralFingerprint = repositoryBehavioralFingerprintV1({
+        capabilityId: input.family.capabilityId,
+        familyId: input.family.id,
+        behaviorClauses: input.seed.targetBehavior.map((clause) => clause.description),
+        oracle: input.hidden
+    });
+    return admitRepositoryBenchmarkCaseV1({
+        draft: {
+            version: 1,
+            id,
+            capabilityId: input.family.capabilityId,
+            familyId: input.family.id,
+            seedId: input.seed.id,
+            lane: input.family.lane,
+            visible: input.visible,
+            hidden: input.hidden,
+            ...(input.trajectoryPolicy === undefined
+                ? {}
+                : { trajectoryPolicy: input.trajectoryPolicy }),
+            adequacy,
+            qualityFindings: findings,
+            behavioralFingerprint
+        }
+    });
+});
+export const makeQualityGate = Effect.succeed(QualityGate.of({ evaluate: evaluateRepositoryBenchmarkDraftV1 }));
+export const QualityGateLive = Layer.effect(QualityGate, makeQualityGate);

package/dist/services/repository-bundle/service.d.ts

@@ -0,0 +1,33 @@
+export type PortableRepositoryArtifactV2 = {
+    readonly path: string;
+    readonly kind: "eval-definition" | "public-fixture" | "public-metadata" | "routing-labels";
+    readonly mediaType: "application/json" | "application/yaml" | "text/markdown" | "text/plain" | "text/typescript";
+    readonly content: string;
+};
+export type PortableRepositoryBundleFileV2 = Omit<PortableRepositoryArtifactV2, "content"> & {
+    readonly bytes: number;
+    readonly sha256: string;
+};
+export type PortableRepositoryBundleV2 = {
+    readonly version: 2;
+    readonly sourceCommitSha: string;
+    readonly files: readonly PortableRepositoryBundleFileV2[];
+    readonly totalBytes: number;
+    readonly contentDigest: string;
+};
+export type PortableRepositoryBundleMaterialV2 = Readonly<{
+    readonly bundle: PortableRepositoryBundleV2;
+    readonly files: readonly PortableRepositoryArtifactV2[];
+}>;
+/** Deterministic portable bundle core. */
+export declare const makePortableRepositoryBundleV2: (input: {
+    readonly admitted: true;
+    readonly sourceCommitSha: string;
+    readonly artifacts: readonly PortableRepositoryArtifactV2[];
+}) => PortableRepositoryBundleV2;
+/** Returns the descriptors and the exact bytes that the compiler will publish. */
+export declare const compilePortableRepositoryBundleV2: (input: {
+    readonly admitted: true;
+    readonly sourceCommitSha: string;
+    readonly artifacts: readonly PortableRepositoryArtifactV2[];
+}) => PortableRepositoryBundleMaterialV2;

package/dist/services/repository-bundle/service.js

@@ -0,0 +1,114 @@
+import { createHash } from "node:crypto";
+import { posix } from "node:path";
+const stableJson = (value) => JSON.stringify(value, (_key, entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+        return entry;
+    const record = entry;
+    return Object.fromEntries(Object.keys(record)
+        .sort()
+        .map((key) => [key, record[key]]));
+});
+const digest = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+const credentialPatterns = [
+    /-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/u,
+    /\b(?:authorization|proxy-authorization)\s*:\s*bearer\s+\S+/iu,
+    /\b(?:api[_-]?key|access[_-]?token|client[_-]?secret|password)\s*[:=]\s*["']?[A-Za-z0-9_./+=-]{12,}/iu,
+    /\b(?:ghp|github_pat|sk)-[A-Za-z0-9_-]{16,}\b/u,
+    /\bAKIA[0-9A-Z]{16}\b/u
+];
+const normalizedPath = (path) => {
+    if (path.length === 0 ||
+        path.includes("\0") ||
+        path.includes("\\") ||
+        path.startsWith("/") ||
+        /^[A-Za-z]:/u.test(path)) {
+        throw new Error("repository artifact path must be a relative POSIX path");
+    }
+    const normalized = posix.normalize(path.normalize("NFC"));
+    if (normalized !== path ||
+        normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith("../")) {
+        throw new Error("repository artifact path must be normalized and cannot traverse");
+    }
+    const parts = normalized.split("/");
+    if (parts.some((part) => part.length === 0 || part === "." || part === "..") ||
+        parts.some((part, index) => part.startsWith(".") && !(index === 0 && part === ".routekit")) ||
+        parts[0] !== ".routekit" ||
+        parts[1] !== "evals") {
+        throw new Error("repository artifact path must be a visible .routekit/evals path");
+    }
+    return normalized;
+};
+const artifactKinds = new Set([
+    "eval-definition",
+    "public-fixture",
+    "public-metadata",
+    "routing-labels"
+]);
+const mediaTypes = new Set([
+    "application/json",
+    "application/yaml",
+    "text/markdown",
+    "text/plain",
+    "text/typescript"
+]);
+const assertArtifactSafe = (artifact) => {
+    const path = normalizedPath(artifact.path);
+    if (!artifactKinds.has(artifact.kind) || !mediaTypes.has(artifact.mediaType)) {
+        throw new Error(`repository artifact ${path} has an unsupported public classification`);
+    }
+    const bytes = Buffer.byteLength(artifact.content, "utf8");
+    if (bytes > 1024 * 1024)
+        throw new Error(`repository artifact ${path} exceeds the one MiB file bound`);
+    if (credentialPatterns.some((pattern) => pattern.test(`${path}\n${artifact.content}`))) {
+        throw new Error(`repository artifact ${path} resembles private credential material`);
+    }
+};
+const compileFiles = (artifacts) => {
+    const sortedArtifacts = artifacts
+        .map((artifact) => {
+        assertArtifactSafe(artifact);
+        return { ...artifact, path: normalizedPath(artifact.path) };
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+    if (sortedArtifacts.length === 0)
+        throw new Error("portable repository bundle requires at least one admitted artifact");
+    if (new Set(sortedArtifacts.map(({ path }) => path)).size !== sortedArtifacts.length) {
+        throw new Error("portable repository bundle paths must be unique");
+    }
+    const files = sortedArtifacts.map(({ content, ...artifact }) => ({
+        ...artifact,
+        bytes: Buffer.byteLength(content, "utf8"),
+        sha256: digest(content)
+    }));
+    const totalBytes = files.reduce((total, file) => total + file.bytes, 0);
+    if (totalBytes > 16 * 1024 * 1024)
+        throw new Error("portable repository bundle exceeds the sixteen MiB bundle bound");
+    return { sortedArtifacts, files, totalBytes };
+};
+/** Deterministic portable bundle core. */
+export const makePortableRepositoryBundleV2 = (input) => {
+    if (input.admitted !== true) {
+        throw new Error("portable repository bundle accepts admitted artifacts only");
+    }
+    if (!/^[a-f0-9]{40}$/u.test(input.sourceCommitSha)) {
+        throw new Error("portable repository bundle requires an exact source commit SHA");
+    }
+    const { files, totalBytes } = compileFiles(input.artifacts);
+    return {
+        version: 2,
+        sourceCommitSha: input.sourceCommitSha,
+        files,
+        totalBytes,
+        contentDigest: digest(stableJson(files))
+    };
+};
+/** Returns the descriptors and the exact bytes that the compiler will publish. */
+export const compilePortableRepositoryBundleV2 = (input) => {
+    const bundle = makePortableRepositoryBundleV2(input);
+    const sortedArtifacts = [...input.artifacts]
+        .map((artifact) => ({ ...artifact, path: normalizedPath(artifact.path) }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    return { bundle, files: sortedArtifacts };
+};

package/dist/services/repository-model/service.d.ts

@@ -0,0 +1,105 @@
+import { Context, Effect, Layer } from "effect";
+import type { RepositoryFoundryError } from "../../errors.js";
+import { type RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+export type RepositoryModelShape = {
+    readonly build: (input: {
+        readonly repositoryRoot: string;
+        readonly requestedRef: string;
+        readonly maximumHistoryEpisodes?: number;
+    }) => Effect.Effect<RepositoryBehaviorMapV1, RepositoryFoundryError>;
+};
+declare const RepositoryModel_base: Context.ServiceClass<RepositoryModel, "@velum-labs/routekit-eval-setup/RepositoryModel", RepositoryModelShape>;
+export declare class RepositoryModel extends RepositoryModel_base {
+}
+export declare const buildRepositoryBehaviorMapV1: (input: {
+    readonly repositoryRoot: string;
+    readonly requestedRef: string;
+    readonly maximumHistoryEpisodes?: number;
+}) => Effect.Effect<{
+    readonly version: 1;
+    readonly repository: {
+        readonly root: string;
+        readonly requestedRef: string;
+        readonly commit: string;
+        readonly tree: string;
+    };
+    readonly packages: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly path: string;
+        readonly manifestPath: string;
+        readonly dependencyPackageIds: readonly string[];
+        readonly publicExports: readonly string[];
+    }[];
+    readonly publicSurfaces: readonly {
+        readonly kind: "package-export" | "cli-command" | "http-endpoint" | "documented-example";
+        readonly id: string;
+        readonly path: string;
+        readonly symbols: readonly string[];
+        readonly packageId?: string | undefined;
+    }[];
+    readonly protocols: readonly {
+        readonly id: string;
+        readonly path: string;
+        readonly name: string;
+        readonly kind: "schema" | "wire" | "persistence" | "internal-boundary";
+    }[];
+    readonly commands: readonly {
+        readonly id: string;
+        readonly kind: "schema" | "test" | "build" | "check" | "custom";
+        readonly cwd: string;
+        readonly executable: string;
+        readonly args: readonly string[];
+        readonly timeoutMs: number;
+    }[];
+    readonly tests: readonly {
+        readonly id: string;
+        readonly path: string;
+        readonly names: readonly string[];
+        readonly commandIds: readonly string[];
+    }[];
+    readonly testBindings: readonly {
+        readonly testId: string;
+        readonly targetIds: readonly string[];
+        readonly signals: readonly ("direct-import" | "symbol-reference" | "fixture-reference" | "package-ownership" | "git-cochange" | "coverage" | "reviewed-hypothesis")[];
+        readonly confidence: "high" | "medium" | "hypothesis";
+    }[];
+    readonly historyEpisodes: readonly {
+        readonly id: string;
+        readonly commit: string;
+        readonly changedPaths: readonly {
+            readonly kind: "protocol" | "schema" | "test" | "documentation" | "implementation" | "operational" | "other";
+            readonly path: string;
+            readonly status: "added" | "modified" | "deleted" | "renamed" | "copied";
+            readonly previousPath?: string | undefined;
+        }[];
+        readonly testPaths: readonly string[];
+        readonly implementationPaths: readonly string[];
+        readonly protocolPaths: readonly string[];
+        readonly occurredAt: string;
+        readonly subject: string;
+        readonly body: string;
+        readonly behaviorChanging: boolean;
+        readonly seedEligible: boolean;
+        readonly parentCommit?: string | undefined;
+    }[];
+    readonly workloadSignals: readonly {
+        readonly id: string;
+        readonly kind: "recurring-cochange" | "recurring-behavior-change" | "recurring-command" | "public-contract" | "reviewed-critical";
+        readonly label: string;
+        readonly episodeIds: readonly string[];
+        readonly pathPatterns: readonly string[];
+        readonly frequency: number;
+        readonly importance: "critical" | "high" | "normal";
+        readonly confidence: "high" | "medium" | "review-required";
+    }[];
+    readonly blindSpots: readonly {
+        readonly id: string;
+        readonly kind: "unmapped-test" | "unreconstructible-command" | "unsupported-language" | "external-service" | "history-gap" | "unknown-relationship";
+        readonly detail: string;
+        readonly paths: readonly string[];
+    }[];
+}, RepositoryFoundryError, never>;
+export declare const makeRepositoryModel: Effect.Effect<RepositoryModelShape, never, never>;
+export declare const RepositoryModelLive: Layer.Layer<RepositoryModel, never, never>;
+export {};