assertledger 1.1.1 → 1.2.0

package/dist/contracts/index.d.ts

@@ -44,6 +44,11 @@ export declare const NodeTestAdapterSchema: z.ZodObject<{
     baseTestFiles: z.ZodArray<z.ZodString>;
     extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
+export declare const BunTestAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"bun-test">;
+    executable: z.ZodString;
+    baseTestFiles: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
 export declare const StructuredCommandAdapterSchema: z.ZodObject<{
     kind: z.ZodLiteral<"testforge-command">;
     executable: z.ZodString;
@@ -61,6 +66,21 @@ export declare const AdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     arguments: z.ZodArray<z.ZodString>;
     protocolVersion: z.ZodLiteral<"1.0.0">;
 }, z.core.$strict>], "kind">;
+export declare const AdapterV3Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"node-test">;
+    executable: z.ZodString;
+    baseTestFiles: z.ZodArray<z.ZodString>;
+    extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"testforge-command">;
+    executable: z.ZodString;
+    arguments: z.ZodArray<z.ZodString>;
+    protocolVersion: z.ZodLiteral<"1.0.0">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"bun-test">;
+    executable: z.ZodString;
+    baseTestFiles: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;
 export declare const StructuredCommandSchema: z.ZodObject<{
     executable: z.ZodString;
     arguments: z.ZodArray<z.ZodString>;
@@ -71,6 +91,7 @@ export declare const TrustedLocalIsolationSchema: z.ZodObject<{
     environmentAllowlist: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export declare const VERIFICATION_SCHEMA_VERSION_V2: "2.0.0";
+export declare const VERIFICATION_SCHEMA_VERSION_V3: "3.0.0";
 export declare const ContainerImageReferenceSchema: z.ZodString;
 export declare const ContainerLimitsSchema: z.ZodObject<{
     memoryBytes: z.ZodInt;
@@ -254,6 +275,88 @@ export declare const VerificationRequestV2Schema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>;
+export declare const VerificationRequestV3Schema: z.ZodObject<{
+    repository: z.ZodObject<{
+        root: z.ZodString;
+        exclude: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    candidateRoots: z.ZodArray<z.ZodString>;
+    budgets: z.ZodObject<{
+        maximumCandidates: z.ZodInt;
+        maximumWorlds: z.ZodInt;
+        maximumExecutions: z.ZodInt;
+        maximumRepositoryFiles: z.ZodInt;
+        maximumRepositoryBytes: z.ZodInt;
+        maximumWorldOverlayBytes: z.ZodInt;
+        maximumCandidateBytes: z.ZodInt;
+        maximumTotalCandidateBytes: z.ZodInt;
+        timeoutMsPerExecution: z.ZodInt;
+        maximumOutputBytes: z.ZodInt;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        policyVersion: z.ZodLiteral<"1.0.0">;
+        requiredAttempts: z.ZodInt;
+        minimumTargetWeightPermille: z.ZodInt;
+        maximumSelectedCandidates: z.ZodInt;
+        acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+    }, z.core.$strict>;
+    worlds: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            NEUTRAL: "NEUTRAL";
+            REFERENCE: "REFERENCE";
+            TARGET: "TARGET";
+        }>;
+        required: z.ZodBoolean;
+        weight: z.ZodInt;
+        provenance: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    isolation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"trusted-local">;
+        acknowledgedUnsafeExecution: z.ZodBoolean;
+        environmentAllowlist: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"container">;
+        image: z.ZodString;
+        environment: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+        limits: z.ZodObject<{
+            memoryBytes: z.ZodInt;
+            cpuMillicores: z.ZodInt;
+            pids: z.ZodInt;
+            temporaryDirectoryBytes: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">;
+    schemaVersion: z.ZodLiteral<"3.0.0">;
+    adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node-test">;
+        executable: z.ZodString;
+        baseTestFiles: z.ZodArray<z.ZodString>;
+        extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"testforge-command">;
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"bun-test">;
+        executable: z.ZodString;
+        baseTestFiles: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
 export declare const RepositoryAnalysisSchema: z.ZodObject<{
     root: z.ZodString;
     fileCount: z.ZodInt;
@@ -590,6 +693,209 @@ export declare const RepositoryInitResultSchema: z.ZodObject<{
         arguments: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const REPOSITORY_INIT_SCHEMA_VERSION_V2: "2.0.0";
+export declare const RepositoryInitDetectionsV2Schema: z.ZodObject<{
+    packageManager: z.ZodNullable<z.ZodEnum<{
+        bun: "bun";
+        npm: "npm";
+        pip: "pip";
+        pnpm: "pnpm";
+        poetry: "poetry";
+        uv: "uv";
+        yarn: "yarn";
+    }>>;
+    framework: z.ZodNullable<z.ZodEnum<{
+        "bun:test": "bun:test";
+        jest: "jest";
+        "node:test": "node:test";
+        pytest: "pytest";
+        vitest: "vitest";
+    }>>;
+    testCommand: z.ZodNullable<z.ZodObject<{
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    ciProviders: z.ZodArray<z.ZodEnum<{
+        "azure-pipelines": "azure-pipelines";
+        circleci: "circleci";
+        "github-actions": "github-actions";
+        "gitlab-ci": "gitlab-ci";
+    }>>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    adapterRecommendation: z.ZodEnum<{
+        "bun-test": "bun-test";
+        "node-test": "node-test";
+        "operator-supplied": "operator-supplied";
+        unavailable: "unavailable";
+    }>;
+}, z.core.$strict>;
+export declare const RepositoryInitConfigV2Schema: z.ZodObject<{
+    repository: z.ZodObject<{
+        root: z.ZodLiteral<".">;
+        exclude: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    packageManager: z.ZodEnum<{
+        bun: "bun";
+        npm: "npm";
+        pip: "pip";
+        pnpm: "pnpm";
+        poetry: "poetry";
+        uv: "uv";
+        yarn: "yarn";
+    }>;
+    framework: z.ZodEnum<{
+        "bun:test": "bun:test";
+        jest: "jest";
+        "node:test": "node:test";
+        pytest: "pytest";
+        vitest: "vitest";
+    }>;
+    testCommand: z.ZodObject<{
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    candidateRoots: z.ZodArray<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node-test">;
+        executable: z.ZodString;
+        baseTestFiles: z.ZodArray<z.ZodString>;
+        extraArguments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"testforge-command">;
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"bun-test">;
+        executable: z.ZodString;
+        baseTestFiles: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const RepositoryInitLockV2Schema: z.ZodObject<{
+    configDigest: z.ZodString;
+    evidence: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        kind: z.ZodEnum<{
+            ADAPTER_CONFIG: "ADAPTER_CONFIG";
+            CI_CONFIG: "CI_CONFIG";
+            LOCKFILE: "LOCKFILE";
+            PACKAGE_MANIFEST: "PACKAGE_MANIFEST";
+            TEST_SOURCE: "TEST_SOURCE";
+        }>;
+    }, z.core.$strict>>;
+    lockDigest: z.ZodString;
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    detector: z.ZodObject<{
+        name: z.ZodLiteral<"assertledger-init">;
+        version: z.ZodLiteral<"2.0.0">;
+    }, z.core.$strict>;
+    detections: z.ZodObject<{
+        packageManager: z.ZodNullable<z.ZodEnum<{
+            bun: "bun";
+            npm: "npm";
+            pip: "pip";
+            pnpm: "pnpm";
+            poetry: "poetry";
+            uv: "uv";
+            yarn: "yarn";
+        }>>;
+        framework: z.ZodNullable<z.ZodEnum<{
+            "bun:test": "bun:test";
+            jest: "jest";
+            "node:test": "node:test";
+            pytest: "pytest";
+            vitest: "vitest";
+        }>>;
+        testCommand: z.ZodNullable<z.ZodObject<{
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        ciProviders: z.ZodArray<z.ZodEnum<{
+            "azure-pipelines": "azure-pipelines";
+            circleci: "circleci";
+            "github-actions": "github-actions";
+            "gitlab-ci": "gitlab-ci";
+        }>>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+        adapterRecommendation: z.ZodEnum<{
+            "bun-test": "bun-test";
+            "node-test": "node-test";
+            "operator-supplied": "operator-supplied";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const RepositoryInitResultV2Schema: z.ZodObject<{
+    status: z.ZodEnum<{
+        BLOCKED: "BLOCKED";
+        CONFLICT: "CONFLICT";
+        CREATED: "CREATED";
+        UNCHANGED: "UNCHANGED";
+        WOULD_CREATE: "WOULD_CREATE";
+    }>;
+    reasonCodes: z.ZodArray<z.ZodString>;
+    actions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            CREATE: "CREATE";
+            REGENERATE: "REGENERATE";
+        }>;
+        path: z.ZodEnum<{
+            "assertledger.config.json": "assertledger.config.json";
+            "assertledger.lock.json": "assertledger.lock.json";
+        }>;
+    }, z.core.$strict>>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodEnum<{
+            "assertledger.config.json": "assertledger.config.json";
+            "assertledger.lock.json": "assertledger.lock.json";
+        }>;
+        digest: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+    requiredOperatorInputs: z.ZodTuple<[z.ZodLiteral<"worlds">, z.ZodLiteral<"candidates">], null>;
+    nextCommands: z.ZodArray<z.ZodObject<{
+        executable: z.ZodString;
+        arguments: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<"2.0.0">;
+    detections: z.ZodObject<{
+        packageManager: z.ZodNullable<z.ZodEnum<{
+            bun: "bun";
+            npm: "npm";
+            pip: "pip";
+            pnpm: "pnpm";
+            poetry: "poetry";
+            uv: "uv";
+            yarn: "yarn";
+        }>>;
+        framework: z.ZodNullable<z.ZodEnum<{
+            "bun:test": "bun:test";
+            jest: "jest";
+            "node:test": "node:test";
+            pytest: "pytest";
+            vitest: "vitest";
+        }>>;
+        testCommand: z.ZodNullable<z.ZodObject<{
+            executable: z.ZodString;
+            arguments: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        ciProviders: z.ZodArray<z.ZodEnum<{
+            "azure-pipelines": "azure-pipelines";
+            circleci: "circleci";
+            "github-actions": "github-actions";
+            "gitlab-ci": "gitlab-ci";
+        }>>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+        adapterRecommendation: z.ZodEnum<{
+            "bun-test": "bun-test";
+            "node-test": "node-test";
+            "operator-supplied": "operator-supplied";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const GateResultSchema: z.ZodObject<{
     name: z.ZodEnum<{
         COMPLETENESS: "COMPLETENESS";
@@ -1006,6 +1312,182 @@ export declare const EvidenceManifestV2Schema: z.ZodObject<{
         runtimeCommand: z.ZodArray<z.ZodString>;
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>;
+export declare const EvidenceManifestV3Schema: z.ZodObject<{
+    repositoryDigest: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"invalid">]>;
+    policy: z.ZodUnion<readonly [z.ZodObject<{
+        policyVersion: z.ZodLiteral<"1.0.0">;
+        requiredAttempts: z.ZodInt;
+        minimumTargetWeightPermille: z.ZodInt;
+        maximumSelectedCandidates: z.ZodInt;
+        acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+    }, z.core.$strict>, z.ZodObject<{
+        policyVersion: z.ZodLiteral<"invalid">;
+        requiredAttempts: z.ZodLiteral<1>;
+        minimumTargetWeightPermille: z.ZodLiteral<1000>;
+        maximumSelectedCandidates: z.ZodLiteral<0>;
+        acceptedTargetOutcomes: z.ZodArray<z.ZodLiteral<"ASSERTION_FAILURE">>;
+    }, z.core.$strict>]>;
+    worlds: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            NEUTRAL: "NEUTRAL";
+            REFERENCE: "REFERENCE";
+            TARGET: "TARGET";
+        }>;
+        required: z.ZodBoolean;
+        weight: z.ZodInt;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        sizeBytes: z.ZodInt;
+        status: z.ZodEnum<{
+            ELIGIBLE: "ELIGIBLE";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            INVALID: "INVALID";
+            UNSTABLE: "UNSTABLE";
+            WEAK_ORACLE: "WEAK_ORACLE";
+        }>;
+        killedTargetIds: z.ZodArray<z.ZodString>;
+        targetWeightKilled: z.ZodInt;
+        gates: z.ZodArray<z.ZodObject<{
+            name: z.ZodEnum<{
+                COMPLETENESS: "COMPLETENESS";
+                DISCOVERY: "DISCOVERY";
+                NEUTRAL: "NEUTRAL";
+                REFERENCE: "REFERENCE";
+                STABILITY: "STABILITY";
+                TARGET_STRENGTH: "TARGET_STRENGTH";
+            }>;
+            status: z.ZodEnum<{
+                FAILED: "FAILED";
+                NOT_RUN: "NOT_RUN";
+                PASSED: "PASSED";
+            }>;
+            evidenceRunIds: z.ZodArray<z.ZodString>;
+            reasonCodes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    observations: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        candidateId: z.ZodNullable<z.ZodString>;
+        worldId: z.ZodString;
+        attempt: z.ZodInt;
+        outcome: z.ZodEnum<{
+            ASSERTION_FAILURE: "ASSERTION_FAILURE";
+            COLLECTION_FAILURE: "COLLECTION_FAILURE";
+            COMPILE_FAILURE: "COMPILE_FAILURE";
+            INFRA_ERROR: "INFRA_ERROR";
+            NO_TEST_DISCOVERED: "NO_TEST_DISCOVERED";
+            PASS: "PASS";
+            PROCESS_CRASH: "PROCESS_CRASH";
+            TIMEOUT: "TIMEOUT";
+        }>;
+        testsDiscovered: z.ZodInt;
+        candidateTestsDiscovered: z.ZodInt;
+        attributed: z.ZodBoolean;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        stdoutDigest: z.ZodOptional<z.ZodString>;
+        stderrDigest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    decision: z.ZodObject<{
+        status: z.ZodEnum<{
+            ENGINE_ERROR: "ENGINE_ERROR";
+            INCONCLUSIVE: "INCONCLUSIVE";
+            REJECTED: "REJECTED";
+            VERIFIED: "VERIFIED";
+        }>;
+        selectedCandidateIds: z.ZodArray<z.ZodString>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    decisionDigest: z.ZodString;
+    artifactDigest: z.ZodString;
+    limitations: z.ZodArray<z.ZodString>;
+    evidenceContext: z.ZodObject<{
+        engine: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        adapter: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            configuration: z.ZodJSONSchema;
+        }, z.core.$strict>;
+        worlds: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            provenance: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        execution: z.ZodObject<{
+            isolation: z.ZodString;
+            environmentAllowlist: z.ZodArray<z.ZodString>;
+            budgets: z.ZodJSONSchema;
+            candidateRoots: z.ZodArray<z.ZodString>;
+            backend: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"trusted-local">;
+                level: z.ZodLiteral<"UNSANDBOXED">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"container">;
+                level: z.ZodLiteral<"CONTAINER">;
+                image: z.ZodObject<{
+                    reference: z.ZodString;
+                    id: z.ZodString;
+                    os: z.ZodLiteral<"linux">;
+                    architecture: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodObject<{
+                    clientVersion: z.ZodString;
+                    serverVersion: z.ZodString;
+                    serverOs: z.ZodLiteral<"linux">;
+                    serverArchitecture: z.ZodString;
+                    cgroupVersion: z.ZodString;
+                    securityOptions: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+                controls: z.ZodObject<{
+                    network: z.ZodLiteral<"none">;
+                    rootFilesystem: z.ZodLiteral<"read-only">;
+                    hostMounts: z.ZodLiteral<"none">;
+                    workspace: z.ZodLiteral<"anonymous-volume">;
+                    user: z.ZodLiteral<"65534:65534">;
+                    capabilities: z.ZodLiteral<"none">;
+                    noNewPrivileges: z.ZodLiteral<true>;
+                    imagePull: z.ZodLiteral<"never">;
+                    logDriver: z.ZodLiteral<"none">;
+                    environment: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        value: z.ZodString;
+                    }, z.core.$strict>>;
+                    limits: z.ZodObject<{
+                        memoryBytes: z.ZodInt;
+                        cpuMillicores: z.ZodInt;
+                        pids: z.ZodInt;
+                        temporaryDirectoryBytes: z.ZodInt;
+                    }, z.core.$strict>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    isolation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"trusted-local">;
+        level: z.ZodLiteral<"UNSANDBOXED">;
+        acknowledgedUnsafeExecution: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"container">;
+        level: z.ZodLiteral<"CONTAINER">;
+        runtimeCommand: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+    schemaVersion: z.ZodLiteral<"3.0.0">;
+    adapter: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"node-test">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"bun-test">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"testforge-command">;
+        protocolVersion: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
 export declare const ReplayResultSchema: z.ZodObject<{
     valid: z.ZodBoolean;
     schemaValid: z.ZodBoolean;
@@ -4703,18 +5185,25 @@ export type World = z.infer<typeof WorldSchema>;
 export type Candidate = z.infer<typeof CandidateSchema>;
 export type VerificationRequest = z.infer<typeof VerificationRequestSchema>;
 export type VerificationRequestV2 = z.infer<typeof VerificationRequestV2Schema>;
+export type VerificationRequestV3 = z.infer<typeof VerificationRequestV3Schema>;
 export type ContainerIsolation = z.infer<typeof ContainerIsolationSchema>;
 export type ContainerLimits = z.infer<typeof ContainerLimitsSchema>;
 export type NodeTestAdapter = z.infer<typeof NodeTestAdapterSchema>;
+export type BunTestAdapter = z.infer<typeof BunTestAdapterSchema>;
 export type StructuredCommandAdapter = z.infer<typeof StructuredCommandAdapterSchema>;
 export type RepositoryAnalysis = z.infer<typeof RepositoryAnalysisSchema>;
 export type RepositoryAudit = z.infer<typeof RepositoryAuditSchema>;
 export type RepositoryInitConfig = z.infer<typeof RepositoryInitConfigSchema>;
+export type RepositoryInitConfigV2 = z.infer<typeof RepositoryInitConfigV2Schema>;
 export type RepositoryInitLock = z.infer<typeof RepositoryInitLockSchema>;
+export type RepositoryInitLockV2 = z.infer<typeof RepositoryInitLockV2Schema>;
 export type RepositoryInitResult = z.infer<typeof RepositoryInitResultSchema>;
+export type RepositoryInitResultV2 = z.infer<typeof RepositoryInitResultV2Schema>;
 export type RepositoryInitDetections = z.infer<typeof RepositoryInitDetectionsSchema>;
+export type RepositoryInitDetectionsV2 = z.infer<typeof RepositoryInitDetectionsV2Schema>;
 export type EvidenceManifestContract = z.infer<typeof EvidenceManifestSchema>;
 export type EvidenceManifestV2Contract = z.infer<typeof EvidenceManifestV2Schema>;
+export type EvidenceManifestV3Contract = z.infer<typeof EvidenceManifestV3Schema>;
 export type ExecutionBackendRecord = z.infer<typeof ExecutionBackendRecordSchema>;
 export type ReplayResult = z.infer<typeof ReplayResultSchema>;
 export type AgenticProfilePolicy = z.infer<typeof AgenticProfilePolicySchema>;
@@ -4760,21 +5249,33 @@ export declare class ContractError extends Error {
     constructor(code: string, detail?: string);
 }
 export declare function parseVerificationRequest(value: unknown): VerificationRequest;
-/** Parses either the frozen v1 request or the v2 request that adds container isolation. */
-export declare function parseVersionedVerificationRequest(value: unknown): VerificationRequest | VerificationRequestV2;
+/** Parses a frozen v1/v2 request or a v3 request that adds the Bun adapter. */
+export declare function parseVersionedVerificationRequest(value: unknown): VerificationRequest | VerificationRequestV2 | VerificationRequestV3;
+export declare function parseVerificationRequestV3(value: unknown): VerificationRequestV3;
 /** Parses only the v2 request, which adds container isolation to the frozen v1 request. */
 export declare function parseVerificationRequestV2(value: unknown): VerificationRequestV2;
 export declare function parseRepositoryAnalysis(value: unknown): RepositoryAnalysis;
 export declare function parseRepositoryAudit(value: unknown): RepositoryAudit;
+/** A declared exclusion names one entry and removes it at any depth, as inventories match names. */
+export declare function isRepositoryExcludeName(value: string): boolean;
 export declare function parseRepositoryInitConfig(value: unknown): RepositoryInitConfig;
+export declare function parseRepositoryInitConfigV2(value: unknown): RepositoryInitConfigV2;
+export declare function parseVersionedRepositoryInitConfig(value: unknown): RepositoryInitConfig | RepositoryInitConfigV2;
 export declare function repositoryInitConfigDigest(config: RepositoryInitConfig): string;
+export declare function repositoryInitConfigV2Digest(config: RepositoryInitConfigV2): string;
 export declare function repositoryInitLockDigest(lock: Omit<RepositoryInitLock, "lockDigest">): string;
+export declare function repositoryInitLockV2Digest(lock: Omit<RepositoryInitLockV2, "lockDigest">): string;
 export declare function parseRepositoryInitLock(value: unknown): RepositoryInitLock;
+export declare function parseRepositoryInitLockV2(value: unknown): RepositoryInitLockV2;
+export declare function parseVersionedRepositoryInitLock(value: unknown): RepositoryInitLock | RepositoryInitLockV2;
 export declare function parseRepositoryInitResult(value: unknown): RepositoryInitResult;
+export declare function parseRepositoryInitResultV2(value: unknown): RepositoryInitResultV2;
+export declare function parseVersionedRepositoryInitResult(value: unknown): RepositoryInitResult | RepositoryInitResultV2;
 export declare function parseEvidenceManifest(value: unknown): EvidenceManifestContract;
 export declare function parseEvidenceManifestV2(value: unknown): EvidenceManifestV2Contract;
-/** Parses either a frozen v1 manifest or a v2 manifest with an execution backend record. */
-export declare function parseVersionedEvidenceManifest(value: unknown): EvidenceManifestContract | EvidenceManifestV2Contract;
+export declare function parseEvidenceManifestV3(value: unknown): EvidenceManifestV3Contract;
+/** Parses a frozen v1/v2 manifest or a v3 manifest with the Bun adapter. */
+export declare function parseVersionedEvidenceManifest(value: unknown): EvidenceManifestContract | EvidenceManifestV2Contract | EvidenceManifestV3Contract;
 export declare function parseReplayResult(value: unknown): ReplayResult;
 export declare function parseAgenticProfileRequest(value: unknown): AgenticProfileRequest;
 export declare function parseAgenticProfileReport(value: unknown): AgenticProfileReport;
@@ -4814,9 +5315,14 @@ export declare function repositoryAuditJsonSchema(): Record<string, unknown>;
 export declare function repositoryInitConfigJsonSchema(): Record<string, unknown>;
 export declare function repositoryInitLockJsonSchema(): Record<string, unknown>;
 export declare function repositoryInitResultJsonSchema(): Record<string, unknown>;
+export declare function repositoryInitConfigV2JsonSchema(): Record<string, unknown>;
+export declare function repositoryInitLockV2JsonSchema(): Record<string, unknown>;
+export declare function repositoryInitResultV2JsonSchema(): Record<string, unknown>;
 export declare function evidenceManifestJsonSchema(): Record<string, unknown>;
 export declare function verificationRequestV2JsonSchema(): Record<string, unknown>;
 export declare function evidenceManifestV2JsonSchema(): Record<string, unknown>;
+export declare function verificationRequestV3JsonSchema(): Record<string, unknown>;
+export declare function evidenceManifestV3JsonSchema(): Record<string, unknown>;
 export declare function replayResultJsonSchema(): Record<string, unknown>;
 export declare function agenticProfileRequestJsonSchema(): Record<string, unknown>;
 export declare function agenticProfileReportJsonSchema(): Record<string, unknown>;