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

package/dist/services/basis-onboarding/service.js

@@ -0,0 +1,491 @@
+import { routingBasisApprovalDigestV3, routingContractDigest } from "@velum-labs/routekit-eval-contracts";
+import { Clock, Context, Effect, Layer } from "effect";
+import { BASIS_AUTHOR_INPUT_TOKENS_PER_ATTEMPT, BASIS_AUTHOR_OUTPUT_TOKENS_PER_ATTEMPT, DEFAULT_BASIS_CANDIDATE_RECIPES_V3, splitBasisTasksChronologicallyV3 } from "../../basis-candidates.js";
+import { approveSelectedBasisV3, inspectBasisCandidatesV3, selectValidatedBasisCandidatesV3 } from "../../basis-validation.js";
+import { projectRoutingBasisV3 } from "../../basis-projection.js";
+import { captureFrozenRepositorySnapshotV3 } from "../../adapters/git-basis-snapshot.js";
+import { EVAL_PROJECT_V2_VERSION } from "../../project-contracts.js";
+import { EvalProjectTransitionError } from "../../errors.js";
+import { EvalProjectArtifacts } from "../../project-artifacts.js";
+import { EvalProjectStore } from "../../project-store.js";
+export class BasisOnboarding extends Context.Service()("@velum-labs/routekit-eval-setup/BasisOnboarding") {
+}
+const transitionError = (state, detail) => new EvalProjectTransitionError({ state, detail });
+const sameIds = (left, right) => left.length === right.length &&
+    left.every((value, index) => value === right[index]);
+const sameValue = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const sameValidationResults = (left, right) => left.length === right.length &&
+    left.every((result, index) => {
+        const other = right[index];
+        return (other !== undefined &&
+            result.candidateId === other.candidateId &&
+            result.basisDigest === other.basisDigest &&
+            result.validationDatasetDigest === other.validationDatasetDigest &&
+            result.classifierConfigurationDigest ===
+                other.classifierConfigurationDigest &&
+            routingContractDigest("routekit.basis-validation-result.v1", "result", JSON.parse(JSON.stringify(result))) ===
+                routingContractDigest("routekit.basis-validation-result.v1", "result", JSON.parse(JSON.stringify(other))));
+    });
+const verifyDigest = (domain, field, value, digestField, expected) => {
+    const semantic = { ...value };
+    delete semantic[digestField];
+    return routingContractDigest(domain, field, semantic) === expected;
+};
+const requireV2 = (document) => document === undefined
+    ? Effect.fail(transitionError("missing", "initialize the V3 basis project first"))
+    : document.version === EVAL_PROJECT_V2_VERSION
+        ? Effect.succeed(document)
+        : Effect.fail(transitionError(document.stage, "legacy V1 projects are not implicitly converted to Classification V3"));
+export const makeBasisOnboarding = Effect.gen(function* () {
+    const store = yield* EvalProjectStore;
+    const artifacts = yield* EvalProjectArtifacts;
+    const load = (repositoryRoot) => store.loadDocument(repositoryRoot).pipe(Effect.flatMap((document) => document === undefined
+        ? Effect.void.pipe(Effect.as(undefined))
+        : document.version === EVAL_PROJECT_V2_VERSION
+            ? Effect.succeed(document)
+            : Effect.fail(transitionError(document.stage, "legacy V1 projects are not implicitly converted to Classification V3"))));
+    const now = Clock.currentTimeMillis.pipe(Effect.map((milliseconds) => new Date(milliseconds).toISOString()));
+    const transition = (state, operation) => Effect.try({
+        try: operation,
+        catch: (cause) => transitionError(state, cause instanceof Error ? cause.message : String(cause))
+    });
+    const validatePreparedEvidence = (input) => {
+        const eligibleCandidateIds = input.structureReports
+            .filter((report) => report.eligible)
+            .map((report) => report.candidateId);
+        const datasetCandidateIds = input.datasets.map((dataset) => {
+            const candidate = input.candidates.find((entry) => entry.basisDigest === dataset.basisDigest);
+            if (candidate === undefined) {
+                throw new Error("validation dataset refers to an unknown basis");
+            }
+            if (dataset.splitDigest !== input.state.split.splitDigest ||
+                !sameIds(dataset.tasks.map((task) => task.caseId), input.state.split.validation.map((task) => task.caseId))) {
+                throw new Error(`validation dataset for ${JSON.stringify(candidate.candidateId)} does not use the frozen validation cohort`);
+            }
+            return candidate.candidateId;
+        });
+        if (input.validationPlan.repositoryDigest !==
+            input.state.snapshot.repositoryDigest ||
+            input.validationPlan.splitDigest !== input.state.split.splitDigest ||
+            !verifyDigest("routekit.basis-validation-plan.v1", "plan", input.validationPlan, "planDigest", input.validationPlan.planDigest) ||
+            !sameIds(input.validationPlan.candidateIds, eligibleCandidateIds) ||
+            !sameIds(input.validationPlan.classifierBindings.map((binding) => binding.candidateId), eligibleCandidateIds) ||
+            !sameIds(datasetCandidateIds, eligibleCandidateIds) ||
+            !sameIds(input.validationPlan.datasetDigests, input.datasets.map((dataset) => dataset.datasetDigest))) {
+            throw new Error("validation plan must bind every structurally eligible candidate and dataset");
+        }
+        for (const binding of input.validationPlan.classifierBindings) {
+            const candidate = input.candidates.find((entry) => entry.candidateId === binding.candidateId);
+            if (candidate === undefined ||
+                binding.basisDigest !== candidate.basisDigest) {
+                throw new Error("validation classifier bindings must match each exact candidate basis");
+            }
+        }
+        const plannedPrimaryCalls = input.datasets.reduce((total, dataset) => total + dataset.tasks.length, 0) * input.validationPlan.repetitions;
+        if (input.validationPlan.repetitions < 1 ||
+            input.validationPlan.plannedPrimaryCalls !== plannedPrimaryCalls ||
+            input.validationPlan.maximumAttempts <
+                input.validationPlan.plannedPrimaryCalls ||
+            input.validationPlan.requiredTotalInputTokens < 1 ||
+            input.validationPlan.requiredTotalOutputTokens < 1 ||
+            (input.validationPlan.maximumPricedExposureUsd === undefined &&
+                !input.validationPlan.acknowledgeUnpricedExposure)) {
+            throw new Error("validation requires exact calls and approved attempt/token/pricing ceilings");
+        }
+    };
+    return BasisOnboarding.of({
+        load,
+        initialize: (input) => Effect.gen(function* () {
+            const existing = yield* store.loadDocument(input.repositoryRoot);
+            if (existing !== undefined) {
+                if (existing.version === EVAL_PROJECT_V2_VERSION) {
+                    if (existing.stage === "basis-generation-ready") {
+                        yield* artifacts.saveBasisGenerationV3(input.repositoryRoot, {
+                            version: 1,
+                            sourceInventory: existing.sourceInventory,
+                            snapshot: existing.snapshot,
+                            split: existing.split,
+                            generationPlan: existing.generationPlan,
+                            generationLedger: existing.generationLedger
+                        });
+                    }
+                    return existing;
+                }
+                return yield* transitionError(existing.stage, "legacy V1 projects are not implicitly converted to Classification V3");
+            }
+            const capturedAt = new Date(yield* Clock.currentTimeMillis).toISOString();
+            const captured = yield* captureFrozenRepositorySnapshotV3({
+                repositoryRoot: input.repositoryRoot,
+                requestedRef: input.requestedRef,
+                allowDirty: input.allowDirty,
+                capturedAt
+            });
+            const split = splitBasisTasksChronologicallyV3(input.tasks);
+            const paidRecipes = DEFAULT_BASIS_CANDIDATE_RECIPES_V3.filter((recipe) => !recipe.deterministic);
+            const maximumAttempts = paidRecipes.length * 2;
+            const generationSemantic = {
+                version: 1,
+                repositoryDigest: captured.snapshot.repositoryDigest,
+                splitDigest: split.splitDigest,
+                authorModel: input.configuration.authorModel,
+                recipes: DEFAULT_BASIS_CANDIDATE_RECIPES_V3,
+                plannedPrimaryCalls: paidRecipes.length,
+                maximumAttempts,
+                requiredTotalInputTokens: maximumAttempts *
+                    BASIS_AUTHOR_INPUT_TOKENS_PER_ATTEMPT,
+                requiredTotalOutputTokens: maximumAttempts *
+                    BASIS_AUTHOR_OUTPUT_TOKENS_PER_ATTEMPT
+            };
+            const generationPlan = {
+                ...generationSemantic,
+                planDigest: routingContractDigest("routekit.basis-generation-plan.v1", "plan", generationSemantic)
+            };
+            const ledgerSemantic = {
+                version: 1,
+                planDigest: generationPlan.planDigest,
+                jobs: paidRecipes.map((recipe) => ({
+                    recipeId: recipe.id,
+                    status: "pending",
+                    attemptCount: 0,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    callIds: []
+                }))
+            };
+            const state = {
+                version: EVAL_PROJECT_V2_VERSION,
+                projectId: crypto.randomUUID(),
+                revision: 0,
+                createdAt: capturedAt,
+                updatedAt: capturedAt,
+                sourceInventory: captured.sourceInventory,
+                configuration: input.configuration,
+                stage: "basis-generation-ready",
+                snapshot: captured.snapshot,
+                split,
+                generationPlan,
+                generationLedger: {
+                    ...ledgerSemantic,
+                    ledgerDigest: routingContractDigest("routekit.basis-generation-ledger.v1", "ledger", ledgerSemantic)
+                }
+            };
+            yield* store.saveDocument(input.repositoryRoot, state);
+            yield* artifacts.saveBasisGenerationV3(input.repositoryRoot, {
+                version: 1,
+                sourceInventory: state.sourceInventory,
+                snapshot: state.snapshot,
+                split: state.split,
+                generationPlan: state.generationPlan,
+                generationLedger: state.generationLedger
+            });
+            return state;
+        }),
+        recordCandidates: (input) => Effect.gen(function* () {
+            const state = yield* store
+                .loadDocument(input.repositoryRoot)
+                .pipe(Effect.flatMap(requireV2));
+            if (state.stage !== "basis-generation-ready") {
+                if ("candidates" in state &&
+                    sameValue(state.candidates, input.candidates) &&
+                    sameValue(state.generationLedger, input.generationLedger)) {
+                    return state;
+                }
+                return yield* transitionError(state.stage, "candidate evidence differs from the durable transition");
+            }
+            const structureReports = yield* transition(state.stage, () => {
+                if (input.generationLedger.planDigest !==
+                    state.generationPlan.planDigest ||
+                    !verifyDigest("routekit.basis-generation-ledger.v1", "ledger", input.generationLedger, "ledgerDigest", input.generationLedger.ledgerDigest)) {
+                    throw new Error("generation ledger does not match its immutable plan");
+                }
+                const paidRecipeIds = state.generationPlan.recipes
+                    .filter((recipe) => !recipe.deterministic)
+                    .map((recipe) => recipe.id);
+                if (!sameIds(input.generationLedger.jobs.map((job) => job.recipeId), paidRecipeIds) ||
+                    input.generationLedger.jobs.some((job) => job.status !== "completed" ||
+                        job.candidateId === undefined ||
+                        job.attemptCount < 1 ||
+                        job.attemptCount > 2) ||
+                    input.generationLedger.jobs.reduce((total, job) => total + job.attemptCount, 0) > state.generationPlan.maximumAttempts ||
+                    input.generationLedger.jobs.reduce((total, job) => total + job.inputTokens, 0) > state.generationPlan.requiredTotalInputTokens ||
+                    input.generationLedger.jobs.reduce((total, job) => total + job.outputTokens, 0) > state.generationPlan.requiredTotalOutputTokens) {
+                    throw new Error("all seven bounded authoring jobs must complete");
+                }
+                const recipeIds = state.generationPlan.recipes.map((recipe) => recipe.id);
+                if (!sameIds(input.candidates.map((candidate) => candidate.recipeId), recipeIds) ||
+                    new Set(input.candidates.map((candidate) => candidate.candidateId))
+                        .size !== input.candidates.length) {
+                    throw new Error("candidate portfolio must contain the incumbent and exact seven challengers");
+                }
+                const candidateByRecipe = new Map(input.candidates.map((candidate) => [candidate.recipeId, candidate]));
+                for (const job of input.generationLedger.jobs) {
+                    if (candidateByRecipe.get(job.recipeId)?.candidateId !==
+                        job.candidateId) {
+                        throw new Error(`generation job ${JSON.stringify(job.recipeId)} does not identify its candidate`);
+                    }
+                }
+                for (const candidate of input.candidates) {
+                    if (candidate.basis.repositoryDigest !==
+                        state.snapshot.repositoryDigest ||
+                        candidate.basisDigest !== candidate.basis.basisDigest ||
+                        candidate.candidateId !== candidate.basis.basisId) {
+                        throw new Error(`candidate ${JSON.stringify(candidate.candidateId)} has stale repository or basis identity`);
+                    }
+                }
+                return inspectBasisCandidatesV3(input.candidates);
+            });
+            const updatedAt = yield* now;
+            const next = {
+                ...state,
+                revision: state.revision + 1,
+                updatedAt,
+                stage: "basis-candidates-review",
+                generationLedger: input.generationLedger,
+                candidates: [...input.candidates],
+                structureReports: [...structureReports]
+            };
+            yield* artifacts.saveBasisCandidatesV3(input.repositoryRoot, {
+                version: 1,
+                generationPlanDigest: state.generationPlan.planDigest,
+                generationLedger: input.generationLedger,
+                candidates: input.candidates,
+                structureReports
+            });
+            yield* store.saveDocument(input.repositoryRoot, next);
+            return next;
+        }),
+        prepareValidation: (input) => Effect.gen(function* () {
+            const state = yield* store
+                .loadDocument(input.repositoryRoot)
+                .pipe(Effect.flatMap(requireV2));
+            if (state.stage !== "basis-candidates-review") {
+                if ("validationPlan" in state &&
+                    sameValue(state.datasets, input.datasets) &&
+                    sameValue(state.validationPlan, input.validationPlan)) {
+                    return state;
+                }
+                return yield* transitionError(state.stage, "validation evidence differs from the durable transition");
+            }
+            yield* transition(state.stage, () => validatePreparedEvidence({
+                state,
+                candidates: state.candidates,
+                structureReports: state.structureReports,
+                datasets: input.datasets,
+                validationPlan: input.validationPlan
+            }));
+            const updatedAt = yield* now;
+            const next = {
+                ...state,
+                revision: state.revision + 1,
+                updatedAt,
+                stage: "basis-validation-ready",
+                datasets: [...input.datasets],
+                validationPlan: input.validationPlan
+            };
+            yield* artifacts.saveBasisValidationV3(input.repositoryRoot, {
+                version: 1,
+                generationPlanDigest: state.generationPlan.planDigest,
+                datasets: input.datasets,
+                validationPlan: input.validationPlan
+            });
+            yield* store.saveDocument(input.repositoryRoot, next);
+            return next;
+        }),
+        prepareRepairValidation: (input) => Effect.gen(function* () {
+            const state = yield* store
+                .loadDocument(input.repositoryRoot)
+                .pipe(Effect.flatMap(requireV2));
+            if (state.stage !== "basis-validation-review") {
+                return yield* transitionError(state.stage, "repair validation requires an unapproved validation review");
+            }
+            const source = state.candidates.find((candidate) => candidate.candidateId === state.selection.selectedCandidateId);
+            if (source === undefined ||
+                input.repairCandidate.basis.provenance.origin?.kind !== "repair" ||
+                input.repairCandidate.basis.provenance.origin.sourceBasisId !==
+                    source.basis.basisId ||
+                state.candidates.some((candidate) => candidate.candidateId === input.repairCandidate.candidateId)) {
+                return yield* transitionError(state.stage, "repair candidate does not derive from the selected original");
+            }
+            const candidates = [...state.candidates, input.repairCandidate];
+            const repairStructure = inspectBasisCandidatesV3([
+                input.repairCandidate
+            ])[0];
+            if (!repairStructure.eligible) {
+                return yield* transitionError(state.stage, "repair candidate must pass the same structural and projection gates before validation");
+            }
+            const structureReports = [
+                ...state.structureReports,
+                repairStructure
+            ];
+            yield* transition(state.stage, () => validatePreparedEvidence({
+                state,
+                candidates,
+                structureReports,
+                datasets: input.datasets,
+                validationPlan: input.validationPlan
+            }));
+            const updatedAt = yield* now;
+            const next = {
+                version: state.version,
+                projectId: state.projectId,
+                revision: state.revision + 1,
+                createdAt: state.createdAt,
+                updatedAt,
+                sourceInventory: state.sourceInventory,
+                configuration: state.configuration,
+                stage: "basis-validation-ready",
+                snapshot: state.snapshot,
+                split: state.split,
+                generationPlan: state.generationPlan,
+                generationLedger: state.generationLedger,
+                candidates,
+                structureReports,
+                datasets: [...input.datasets],
+                validationPlan: input.validationPlan
+            };
+            yield* artifacts.saveBasisRepairValidationV3(input.repositoryRoot, {
+                version: 1,
+                generationPlanDigest: state.generationPlan.planDigest,
+                datasets: input.datasets,
+                validationPlan: input.validationPlan
+            });
+            yield* store.saveDocument(input.repositoryRoot, next);
+            return next;
+        }),
+        recordValidation: (input) => Effect.gen(function* () {
+            const state = yield* store
+                .loadDocument(input.repositoryRoot)
+                .pipe(Effect.flatMap(requireV2));
+            if (state.stage !== "basis-validation-ready") {
+                if ((state.stage === "basis-validation-review" ||
+                    state.stage === "basis-qualified") &&
+                    sameValidationResults(state.validationResults, input.validationResults)) {
+                    yield* artifacts.saveBasisValidationResultsV3(input.repositoryRoot, {
+                        version: 1,
+                        validationPlanDigest: state.validationPlan.planDigest,
+                        validationResults: state.validationResults,
+                        selection: state.selection
+                    });
+                    return state;
+                }
+                return yield* transitionError(state.stage, "validation evidence differs from the durable transition");
+            }
+            const selection = yield* transition(state.stage, () => {
+                if (!sameIds(input.validationResults.map((result) => result.candidateId), state.validationPlan.candidateIds) ||
+                    input.validationResults.some((result, index) => result.validationDatasetDigest !==
+                        state.datasets[index]?.datasetDigest ||
+                        result.classifierConfigurationDigest !==
+                            state.validationPlan.classifierBindings[index]
+                                ?.classifierConfigurationDigest)) {
+                    throw new Error("validation results must exactly cover the immutable validation plan");
+                }
+                return selectValidatedBasisCandidatesV3({
+                    repositoryDigest: state.snapshot.repositoryDigest,
+                    validationPlan: state.validationPlan,
+                    candidates: state.candidates,
+                    structureReports: state.structureReports,
+                    validationResults: input.validationResults
+                });
+            });
+            const updatedAt = yield* now;
+            const next = {
+                ...state,
+                revision: state.revision + 1,
+                updatedAt,
+                stage: "basis-validation-review",
+                validationResults: [...input.validationResults],
+                selection
+            };
+            yield* store.saveDocument(input.repositoryRoot, next);
+            const saveResults = state.candidates.some((candidate) => candidate.basis.provenance.origin?.kind === "repair")
+                ? artifacts.saveBasisRepairValidationResultsV3
+                : artifacts.saveBasisValidationResultsV3;
+            yield* saveResults(input.repositoryRoot, {
+                version: 1,
+                validationPlanDigest: state.validationPlan.planDigest,
+                validationResults: input.validationResults,
+                selection
+            });
+            return next;
+        }),
+        qualify: (input) => Effect.gen(function* () {
+            const state = yield* store
+                .loadDocument(input.repositoryRoot)
+                .pipe(Effect.flatMap(requireV2));
+            if (state.stage !== "basis-validation-review") {
+                const sameCandidate = state.stage === "basis-qualified" &&
+                    state.approval.candidateId === input.candidateId &&
+                    state.approval.basisDigest === input.basisDigest;
+                const sameApprover = state.stage === "basis-qualified" &&
+                    state.approval.approvedBy === input.approvedBy;
+                const sameAcknowledgement = state.stage === "basis-qualified" &&
+                    state.approval.provisionalAcknowledgement ===
+                        input.provisionalAcknowledgement;
+                if (state.stage === "basis-qualified" &&
+                    sameCandidate &&
+                    sameApprover &&
+                    sameAcknowledgement) {
+                    yield* artifacts.saveBasisQualificationV3(input.repositoryRoot, {
+                        version: 1,
+                        validationPlanDigest: state.validationPlan.planDigest,
+                        validationResults: state.validationResults,
+                        selection: state.selection,
+                        approval: state.approval,
+                        approvalDigest: routingBasisApprovalDigestV3(state.approval)
+                    });
+                    return state;
+                }
+                return yield* transitionError(state.stage, `approval differs from the durable transition (candidate=${String(sameCandidate)}, approver=${String(sameApprover)}, acknowledgement=${String(sameAcknowledgement)})`);
+            }
+            const selectedCandidate = state.candidates.find((candidate) => candidate.candidateId === state.selection.selectedCandidateId);
+            if (selectedCandidate === undefined ||
+                input.candidateId !== state.selection.selectedCandidateId ||
+                input.basisDigest !== selectedCandidate.basisDigest) {
+                return yield* transitionError(state.stage, "approval must pin the exact selected candidate id and basis digest");
+            }
+            const approvedAt = yield* now;
+            const qualified = yield* transition(state.stage, () => {
+                const structure = state.structureReports.find((report) => report.candidateId === state.selection.selectedCandidateId);
+                const validation = state.validationResults.find((result) => result.candidateId === state.selection.selectedCandidateId);
+                if (structure === undefined ||
+                    validation === undefined) {
+                    throw new Error("selected basis evidence is incomplete");
+                }
+                return approveSelectedBasisV3({
+                    projectId: state.projectId,
+                    approvedBy: input.approvedBy,
+                    approvedAt,
+                    snapshot: state.snapshot,
+                    candidate: selectedCandidate,
+                    structure,
+                    validation,
+                    selection: state.selection,
+                    ...(input.provisionalAcknowledgement === undefined
+                        ? {}
+                        : {
+                            provisionalAcknowledgement: input.provisionalAcknowledgement
+                        })
+                });
+            });
+            const next = {
+                ...state,
+                revision: state.revision + 1,
+                updatedAt: qualified.approval.approvedAt,
+                stage: "basis-qualified",
+                approval: qualified.approval
+            };
+            yield* store.saveDocument(input.repositoryRoot, next);
+            yield* artifacts.saveBasisQualificationV3(input.repositoryRoot, {
+                version: 1,
+                validationPlanDigest: state.validationPlan.planDigest,
+                validationResults: state.validationResults,
+                selection: state.selection,
+                approval: qualified.approval,
+                approvalDigest: qualified.approvalDigest
+            });
+            yield* artifacts.saveBasisEvaluationProjectionV3(input.repositoryRoot, projectRoutingBasisV3(selectedCandidate.basis));
+            return next;
+        })
+    });
+});
+export const BasisOnboardingLive = Layer.effect(BasisOnboarding, makeBasisOnboarding);

package/dist/services/basis-repair/service.d.ts

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer } from "effect";
+import { EvalProjectAuthoringError, EvalProjectTransitionError } from "../../errors.js";
+import { EvalProjectArtifacts } from "../../project-artifacts.js";
+import { EvalAuthoringTransport } from "../../project-authoring.js";
+import type { BasisRepairArtifactsV3, BasisRepairPlanV3, BasisRepairSummaryV3 } from "../../project-contracts.js";
+import { EvalProjectStore } from "../../project-store.js";
+export type BasisRepairShape = {
+    readonly plan: (input: {
+        readonly repositoryRoot: string;
+        readonly sourceCandidateId: string;
+        readonly authorModel: string;
+        readonly summary: BasisRepairSummaryV3;
+    }) => Effect.Effect<BasisRepairPlanV3, EvalProjectTransitionError | import("../../errors.js").EvalProjectStoreError>;
+    readonly execute: (input: {
+        readonly repositoryRoot: string;
+        readonly plan: BasisRepairPlanV3;
+        readonly summary: BasisRepairSummaryV3;
+    }) => Effect.Effect<BasisRepairArtifactsV3, EvalProjectAuthoringError | EvalProjectTransitionError | import("../../errors.js").EvalBasisSnapshotError | import("../../errors.js").EvalProjectArtifactError | import("../../errors.js").EvalProjectStoreError, EvalAuthoringTransport>;
+};
+declare const BasisRepair_base: Context.ServiceClass<BasisRepair, "@velum-labs/routekit-eval-setup/BasisRepair", BasisRepairShape>;
+export declare class BasisRepair extends BasisRepair_base {
+}
+export declare const makeBasisRepair: Effect.Effect<BasisRepairShape, never, EvalProjectArtifacts | EvalProjectStore>;
+export declare const BasisRepairLive: Layer.Layer<BasisRepair, never, EvalProjectArtifacts | EvalProjectStore>;
+export {};