@jinn-network/client 0.1.9 → 0.2.0-canary.0b79cd5d

package/dist/vendor/@jinn-network/sdk/dist/benchmarking.d.ts

@@ -0,0 +1,1621 @@
+import { z } from 'zod/v3';
+export declare const ConfigV1Schema: z.ZodObject<{
+    configId: z.ZodString;
+    solveProfile: z.ZodObject<{
+        harness: z.ZodString;
+        harnessVersionOrDigest: z.ZodString;
+        model: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        harness: string;
+        harnessVersionOrDigest: string;
+        model: string;
+    }, {
+        harness: string;
+        harnessVersionOrDigest: string;
+        model: string;
+    }>;
+    loadout: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"artifact">;
+        ref: z.ZodString;
+        sha256: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "artifact";
+        ref: string;
+        sha256: string;
+    }, {
+        kind: "artifact";
+        ref: string;
+        sha256: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "none";
+    }, {
+        kind: "none";
+    }>]>;
+    envOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    configId: string;
+    solveProfile: {
+        harness: string;
+        harnessVersionOrDigest: string;
+        model: string;
+    };
+    loadout: {
+        kind: "artifact";
+        ref: string;
+        sha256: string;
+    } | {
+        kind: "none";
+    };
+    envOverrides?: Record<string, unknown> | undefined;
+}, {
+    configId: string;
+    solveProfile: {
+        harness: string;
+        harnessVersionOrDigest: string;
+        model: string;
+    };
+    loadout: {
+        kind: "artifact";
+        ref: string;
+        sha256: string;
+    } | {
+        kind: "none";
+    };
+    envOverrides?: Record<string, unknown> | undefined;
+}>;
+export type ConfigV1 = z.infer<typeof ConfigV1Schema>;
+export interface BenchmarkValidationIssue {
+    path: string;
+    message: string;
+}
+export type BenchmarkValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: BenchmarkValidationIssue[];
+};
+export declare function validateConfigV1(value: unknown): BenchmarkValidationResult<ConfigV1>;
+export declare function hashCapsuleSet(input: {
+    capsuleDigests: string[];
+    admissionReceiptRefs: string[];
+}): `sha256:${string}`;
+export declare const BenchmarkRunV1Schema: z.ZodEffects<z.ZodObject<{
+    runId: z.ZodString;
+    consumer: z.ZodString;
+    capsuleSet: z.ZodObject<{
+        capsuleDigests: z.ZodArray<z.ZodString, "many">;
+        admissionReceiptRefs: z.ZodArray<z.ZodString, "many">;
+        setHash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        capsuleDigests: string[];
+        admissionReceiptRefs: string[];
+        setHash: string;
+    }, {
+        capsuleDigests: string[];
+        admissionReceiptRefs: string[];
+        setHash: string;
+    }>;
+    configs: z.ZodArray<z.ZodObject<{
+        configId: z.ZodString;
+        solveProfile: z.ZodObject<{
+            harness: z.ZodString;
+            harnessVersionOrDigest: z.ZodString;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        }, {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        }>;
+        loadout: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"artifact">;
+            ref: z.ZodString;
+            sha256: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        }, {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"none">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "none";
+        }, {
+            kind: "none";
+        }>]>;
+        envOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        configId: string;
+        solveProfile: {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        };
+        loadout: {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        } | {
+            kind: "none";
+        };
+        envOverrides?: Record<string, unknown> | undefined;
+    }, {
+        configId: string;
+        solveProfile: {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        };
+        loadout: {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        } | {
+            kind: "none";
+        };
+        envOverrides?: Record<string, unknown> | undefined;
+    }>, "many">;
+    replicates: z.ZodNumber;
+    policy: z.ZodObject<{
+        completenessFloor: z.ZodNumber;
+        replacementPolicy: z.ZodString;
+        eligibilityExclusions: z.ZodArray<z.ZodString, "many">;
+        cellWindow: z.ZodString;
+        selfEvaluation: z.ZodLiteral<false>;
+    }, "strict", z.ZodTypeAny, {
+        completenessFloor: number;
+        replacementPolicy: string;
+        eligibilityExclusions: string[];
+        cellWindow: string;
+        selfEvaluation: false;
+    }, {
+        completenessFloor: number;
+        replacementPolicy: string;
+        eligibilityExclusions: string[];
+        cellWindow: string;
+        selfEvaluation: false;
+    }>;
+    budget: z.ZodObject<{
+        perCellFees: z.ZodObject<{
+            solveWei: z.ZodString;
+            verdictWei: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            solveWei: string;
+            verdictWei: string;
+        }, {
+            solveWei: string;
+            verdictWei: string;
+        }>;
+        hardCapWei: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        perCellFees: {
+            solveWei: string;
+            verdictWei: string;
+        };
+        hardCapWei: string;
+    }, {
+        perCellFees: {
+            solveWei: string;
+            verdictWei: string;
+        };
+        hardCapWei: string;
+    }>;
+    preRegistrationHash: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    runId: string;
+    consumer: string;
+    capsuleSet: {
+        capsuleDigests: string[];
+        admissionReceiptRefs: string[];
+        setHash: string;
+    };
+    configs: {
+        configId: string;
+        solveProfile: {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        };
+        loadout: {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        } | {
+            kind: "none";
+        };
+        envOverrides?: Record<string, unknown> | undefined;
+    }[];
+    replicates: number;
+    policy: {
+        completenessFloor: number;
+        replacementPolicy: string;
+        eligibilityExclusions: string[];
+        cellWindow: string;
+        selfEvaluation: false;
+    };
+    budget: {
+        perCellFees: {
+            solveWei: string;
+            verdictWei: string;
+        };
+        hardCapWei: string;
+    };
+    preRegistrationHash: string;
+}, {
+    runId: string;
+    consumer: string;
+    capsuleSet: {
+        capsuleDigests: string[];
+        admissionReceiptRefs: string[];
+        setHash: string;
+    };
+    configs: {
+        configId: string;
+        solveProfile: {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        };
+        loadout: {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        } | {
+            kind: "none";
+        };
+        envOverrides?: Record<string, unknown> | undefined;
+    }[];
+    replicates: number;
+    policy: {
+        completenessFloor: number;
+        replacementPolicy: string;
+        eligibilityExclusions: string[];
+        cellWindow: string;
+        selfEvaluation: false;
+    };
+    budget: {
+        perCellFees: {
+            solveWei: string;
+            verdictWei: string;
+        };
+        hardCapWei: string;
+    };
+    preRegistrationHash: string;
+}>, {
+    runId: string;
+    consumer: string;
+    capsuleSet: {
+        capsuleDigests: string[];
+        admissionReceiptRefs: string[];
+        setHash: string;
+    };
+    configs: {
+        configId: string;
+        solveProfile: {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        };
+        loadout: {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        } | {
+            kind: "none";
+        };
+        envOverrides?: Record<string, unknown> | undefined;
+    }[];
+    replicates: number;
+    policy: {
+        completenessFloor: number;
+        replacementPolicy: string;
+        eligibilityExclusions: string[];
+        cellWindow: string;
+        selfEvaluation: false;
+    };
+    budget: {
+        perCellFees: {
+            solveWei: string;
+            verdictWei: string;
+        };
+        hardCapWei: string;
+    };
+    preRegistrationHash: string;
+}, {
+    runId: string;
+    consumer: string;
+    capsuleSet: {
+        capsuleDigests: string[];
+        admissionReceiptRefs: string[];
+        setHash: string;
+    };
+    configs: {
+        configId: string;
+        solveProfile: {
+            harness: string;
+            harnessVersionOrDigest: string;
+            model: string;
+        };
+        loadout: {
+            kind: "artifact";
+            ref: string;
+            sha256: string;
+        } | {
+            kind: "none";
+        };
+        envOverrides?: Record<string, unknown> | undefined;
+    }[];
+    replicates: number;
+    policy: {
+        completenessFloor: number;
+        replacementPolicy: string;
+        eligibilityExclusions: string[];
+        cellWindow: string;
+        selfEvaluation: false;
+    };
+    budget: {
+        perCellFees: {
+            solveWei: string;
+            verdictWei: string;
+        };
+        hardCapWei: string;
+    };
+    preRegistrationHash: string;
+}>;
+export type BenchmarkRunV1 = z.infer<typeof BenchmarkRunV1Schema>;
+export declare function hashBenchmarkRunV1(run: BenchmarkRunV1): `sha256:${string}`;
+/** Documented alias — identical projection/result as preRegistrationHash computation (AC2). */
+export declare const computeRunHash: typeof hashBenchmarkRunV1;
+export declare function validateBenchmarkRunV1(value: unknown): BenchmarkValidationResult<BenchmarkRunV1>;
+export declare const BenchPreregistrationV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn.bench-preregistration.v1">;
+    run: z.ZodEffects<z.ZodObject<{
+        runId: z.ZodString;
+        consumer: z.ZodString;
+        capsuleSet: z.ZodObject<{
+            capsuleDigests: z.ZodArray<z.ZodString, "many">;
+            admissionReceiptRefs: z.ZodArray<z.ZodString, "many">;
+            setHash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        }, {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        }>;
+        configs: z.ZodArray<z.ZodObject<{
+            configId: z.ZodString;
+            solveProfile: z.ZodObject<{
+                harness: z.ZodString;
+                harnessVersionOrDigest: z.ZodString;
+                model: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            }, {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            }>;
+            loadout: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"artifact">;
+                ref: z.ZodString;
+                sha256: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            }, {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"none">;
+            }, "strict", z.ZodTypeAny, {
+                kind: "none";
+            }, {
+                kind: "none";
+            }>]>;
+            envOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strict", z.ZodTypeAny, {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }, {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }>, "many">;
+        replicates: z.ZodNumber;
+        policy: z.ZodObject<{
+            completenessFloor: z.ZodNumber;
+            replacementPolicy: z.ZodString;
+            eligibilityExclusions: z.ZodArray<z.ZodString, "many">;
+            cellWindow: z.ZodString;
+            selfEvaluation: z.ZodLiteral<false>;
+        }, "strict", z.ZodTypeAny, {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        }, {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        }>;
+        budget: z.ZodObject<{
+            perCellFees: z.ZodObject<{
+                solveWei: z.ZodString;
+                verdictWei: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                solveWei: string;
+                verdictWei: string;
+            }, {
+                solveWei: string;
+                verdictWei: string;
+            }>;
+            hardCapWei: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        }, {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        }>;
+        preRegistrationHash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }>, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }>;
+    signature: z.ZodObject<{
+        alg: z.ZodLiteral<"eip-191">;
+        signer: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        value: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    }, "strict", z.ZodTypeAny, {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    }, {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "jinn.bench-preregistration.v1";
+    run: {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    };
+    signature: {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    };
+}, {
+    schemaVersion: "jinn.bench-preregistration.v1";
+    run: {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    };
+    signature: {
+        value: `0x${string}`;
+        alg: "eip-191";
+        signer: `0x${string}`;
+    };
+}>;
+export type BenchPreregistrationV1 = z.infer<typeof BenchPreregistrationV1Schema>;
+export declare function validateBenchPreregistrationV1(value: unknown): BenchmarkValidationResult<BenchPreregistrationV1>;
+export declare const CellV1Schema: z.ZodObject<{
+    cellKey: z.ZodString;
+    capsuleDigest: z.ZodString;
+    configId: z.ZodString;
+    replicate: z.ZodNumber;
+    attemptEnvelopeCid: z.ZodOptional<z.ZodString>;
+    verdictEnvelopeRef: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<["judged", "unscorable", "expired", "invalidated"]>;
+    verification: z.ZodObject<{
+        loadout: z.ZodEnum<["match", "mismatch", "unverifiable"]>;
+        profile: z.ZodEnum<["match", "mismatch", "unverifiable"]>;
+        isolation: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        loadout: "match" | "mismatch" | "unverifiable";
+        profile: "match" | "mismatch" | "unverifiable";
+        isolation: string;
+    }, {
+        loadout: "match" | "mismatch" | "unverifiable";
+        profile: "match" | "mismatch" | "unverifiable";
+        isolation: string;
+    }>;
+    judgeIntegrityTier: z.ZodEnum<["re-derivable", "attested-only"]>;
+    solverId: z.ZodString;
+    evaluatorId: z.ZodString;
+    cost: z.ZodObject<{
+        reported: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        source: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        reported: string | number;
+        source: string;
+    }, {
+        reported: string | number;
+        source: string;
+    }>;
+    latencyMs: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    configId: string;
+    cellKey: string;
+    capsuleDigest: string;
+    replicate: number;
+    outcome: "judged" | "unscorable" | "expired" | "invalidated";
+    verification: {
+        loadout: "match" | "mismatch" | "unverifiable";
+        profile: "match" | "mismatch" | "unverifiable";
+        isolation: string;
+    };
+    judgeIntegrityTier: "re-derivable" | "attested-only";
+    solverId: string;
+    evaluatorId: string;
+    cost: {
+        reported: string | number;
+        source: string;
+    };
+    latencyMs: number;
+    attemptEnvelopeCid?: string | undefined;
+    verdictEnvelopeRef?: string | undefined;
+}, {
+    configId: string;
+    cellKey: string;
+    capsuleDigest: string;
+    replicate: number;
+    outcome: "judged" | "unscorable" | "expired" | "invalidated";
+    verification: {
+        loadout: "match" | "mismatch" | "unverifiable";
+        profile: "match" | "mismatch" | "unverifiable";
+        isolation: string;
+    };
+    judgeIntegrityTier: "re-derivable" | "attested-only";
+    solverId: string;
+    evaluatorId: string;
+    cost: {
+        reported: string | number;
+        source: string;
+    };
+    latencyMs: number;
+    attemptEnvelopeCid?: string | undefined;
+    verdictEnvelopeRef?: string | undefined;
+}>;
+export type CellV1 = z.infer<typeof CellV1Schema>;
+export declare const BenchMatrixV1Schema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn.bench-matrix.v1">;
+    runId: z.ZodString;
+    preRegistration: z.ZodEffects<z.ZodObject<{
+        runId: z.ZodString;
+        consumer: z.ZodString;
+        capsuleSet: z.ZodObject<{
+            capsuleDigests: z.ZodArray<z.ZodString, "many">;
+            admissionReceiptRefs: z.ZodArray<z.ZodString, "many">;
+            setHash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        }, {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        }>;
+        configs: z.ZodArray<z.ZodObject<{
+            configId: z.ZodString;
+            solveProfile: z.ZodObject<{
+                harness: z.ZodString;
+                harnessVersionOrDigest: z.ZodString;
+                model: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            }, {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            }>;
+            loadout: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"artifact">;
+                ref: z.ZodString;
+                sha256: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            }, {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"none">;
+            }, "strict", z.ZodTypeAny, {
+                kind: "none";
+            }, {
+                kind: "none";
+            }>]>;
+            envOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strict", z.ZodTypeAny, {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }, {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }>, "many">;
+        replicates: z.ZodNumber;
+        policy: z.ZodObject<{
+            completenessFloor: z.ZodNumber;
+            replacementPolicy: z.ZodString;
+            eligibilityExclusions: z.ZodArray<z.ZodString, "many">;
+            cellWindow: z.ZodString;
+            selfEvaluation: z.ZodLiteral<false>;
+        }, "strict", z.ZodTypeAny, {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        }, {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        }>;
+        budget: z.ZodObject<{
+            perCellFees: z.ZodObject<{
+                solveWei: z.ZodString;
+                verdictWei: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                solveWei: string;
+                verdictWei: string;
+            }, {
+                solveWei: string;
+                verdictWei: string;
+            }>;
+            hardCapWei: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        }, {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        }>;
+        preRegistrationHash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }>, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }, {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    }>;
+    closeBoundary: z.ZodObject<{
+        blockNumber: z.ZodOptional<z.ZodNumber>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        timestamp: string;
+        blockNumber?: number | undefined;
+    }, {
+        timestamp: string;
+        blockNumber?: number | undefined;
+    }>;
+    cells: z.ZodArray<z.ZodObject<{
+        cellKey: z.ZodString;
+        capsuleDigest: z.ZodString;
+        configId: z.ZodString;
+        replicate: z.ZodNumber;
+        attemptEnvelopeCid: z.ZodOptional<z.ZodString>;
+        verdictEnvelopeRef: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodEnum<["judged", "unscorable", "expired", "invalidated"]>;
+        verification: z.ZodObject<{
+            loadout: z.ZodEnum<["match", "mismatch", "unverifiable"]>;
+            profile: z.ZodEnum<["match", "mismatch", "unverifiable"]>;
+            isolation: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        }, {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        }>;
+        judgeIntegrityTier: z.ZodEnum<["re-derivable", "attested-only"]>;
+        solverId: z.ZodString;
+        evaluatorId: z.ZodString;
+        cost: z.ZodObject<{
+            reported: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+            source: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            reported: string | number;
+            source: string;
+        }, {
+            reported: string | number;
+            source: string;
+        }>;
+        latencyMs: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        configId: string;
+        cellKey: string;
+        capsuleDigest: string;
+        replicate: number;
+        outcome: "judged" | "unscorable" | "expired" | "invalidated";
+        verification: {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        };
+        judgeIntegrityTier: "re-derivable" | "attested-only";
+        solverId: string;
+        evaluatorId: string;
+        cost: {
+            reported: string | number;
+            source: string;
+        };
+        latencyMs: number;
+        attemptEnvelopeCid?: string | undefined;
+        verdictEnvelopeRef?: string | undefined;
+    }, {
+        configId: string;
+        cellKey: string;
+        capsuleDigest: string;
+        replicate: number;
+        outcome: "judged" | "unscorable" | "expired" | "invalidated";
+        verification: {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        };
+        judgeIntegrityTier: "re-derivable" | "attested-only";
+        solverId: string;
+        evaluatorId: string;
+        cost: {
+            reported: string | number;
+            source: string;
+        };
+        latencyMs: number;
+        attemptEnvelopeCid?: string | undefined;
+        verdictEnvelopeRef?: string | undefined;
+    }>, "many">;
+    exclusions: z.ZodArray<z.ZodObject<{
+        cellKey: z.ZodString;
+        reason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        cellKey: string;
+        reason: string;
+    }, {
+        cellKey: string;
+        reason: string;
+    }>, "many">;
+    attrition: z.ZodObject<{
+        perConfig: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        perCapsule: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        asymmetryFlags: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        perConfig: Record<string, number>;
+        perCapsule: Record<string, number>;
+        asymmetryFlags: string[];
+    }, {
+        perConfig: Record<string, number>;
+        perCapsule: Record<string, number>;
+        asymmetryFlags: string[];
+    }>;
+    completeness: z.ZodObject<{
+        achieved: z.ZodNumber;
+        floor: z.ZodNumber;
+        runOutcome: z.ZodEnum<["complete", "partial", "cancelled"]>;
+    }, "strict", z.ZodTypeAny, {
+        achieved: number;
+        floor: number;
+        runOutcome: "complete" | "partial" | "cancelled";
+    }, {
+        achieved: number;
+        floor: number;
+        runOutcome: "complete" | "partial" | "cancelled";
+    }>;
+    matrixHash: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    runId: string;
+    schemaVersion: "jinn.bench-matrix.v1";
+    preRegistration: {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    };
+    closeBoundary: {
+        timestamp: string;
+        blockNumber?: number | undefined;
+    };
+    cells: {
+        configId: string;
+        cellKey: string;
+        capsuleDigest: string;
+        replicate: number;
+        outcome: "judged" | "unscorable" | "expired" | "invalidated";
+        verification: {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        };
+        judgeIntegrityTier: "re-derivable" | "attested-only";
+        solverId: string;
+        evaluatorId: string;
+        cost: {
+            reported: string | number;
+            source: string;
+        };
+        latencyMs: number;
+        attemptEnvelopeCid?: string | undefined;
+        verdictEnvelopeRef?: string | undefined;
+    }[];
+    exclusions: {
+        cellKey: string;
+        reason: string;
+    }[];
+    attrition: {
+        perConfig: Record<string, number>;
+        perCapsule: Record<string, number>;
+        asymmetryFlags: string[];
+    };
+    completeness: {
+        achieved: number;
+        floor: number;
+        runOutcome: "complete" | "partial" | "cancelled";
+    };
+    matrixHash: string;
+}, {
+    runId: string;
+    schemaVersion: "jinn.bench-matrix.v1";
+    preRegistration: {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    };
+    closeBoundary: {
+        timestamp: string;
+        blockNumber?: number | undefined;
+    };
+    cells: {
+        configId: string;
+        cellKey: string;
+        capsuleDigest: string;
+        replicate: number;
+        outcome: "judged" | "unscorable" | "expired" | "invalidated";
+        verification: {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        };
+        judgeIntegrityTier: "re-derivable" | "attested-only";
+        solverId: string;
+        evaluatorId: string;
+        cost: {
+            reported: string | number;
+            source: string;
+        };
+        latencyMs: number;
+        attemptEnvelopeCid?: string | undefined;
+        verdictEnvelopeRef?: string | undefined;
+    }[];
+    exclusions: {
+        cellKey: string;
+        reason: string;
+    }[];
+    attrition: {
+        perConfig: Record<string, number>;
+        perCapsule: Record<string, number>;
+        asymmetryFlags: string[];
+    };
+    completeness: {
+        achieved: number;
+        floor: number;
+        runOutcome: "complete" | "partial" | "cancelled";
+    };
+    matrixHash: string;
+}>, {
+    runId: string;
+    schemaVersion: "jinn.bench-matrix.v1";
+    preRegistration: {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    };
+    closeBoundary: {
+        timestamp: string;
+        blockNumber?: number | undefined;
+    };
+    cells: {
+        configId: string;
+        cellKey: string;
+        capsuleDigest: string;
+        replicate: number;
+        outcome: "judged" | "unscorable" | "expired" | "invalidated";
+        verification: {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        };
+        judgeIntegrityTier: "re-derivable" | "attested-only";
+        solverId: string;
+        evaluatorId: string;
+        cost: {
+            reported: string | number;
+            source: string;
+        };
+        latencyMs: number;
+        attemptEnvelopeCid?: string | undefined;
+        verdictEnvelopeRef?: string | undefined;
+    }[];
+    exclusions: {
+        cellKey: string;
+        reason: string;
+    }[];
+    attrition: {
+        perConfig: Record<string, number>;
+        perCapsule: Record<string, number>;
+        asymmetryFlags: string[];
+    };
+    completeness: {
+        achieved: number;
+        floor: number;
+        runOutcome: "complete" | "partial" | "cancelled";
+    };
+    matrixHash: string;
+}, {
+    runId: string;
+    schemaVersion: "jinn.bench-matrix.v1";
+    preRegistration: {
+        runId: string;
+        consumer: string;
+        capsuleSet: {
+            capsuleDigests: string[];
+            admissionReceiptRefs: string[];
+            setHash: string;
+        };
+        configs: {
+            configId: string;
+            solveProfile: {
+                harness: string;
+                harnessVersionOrDigest: string;
+                model: string;
+            };
+            loadout: {
+                kind: "artifact";
+                ref: string;
+                sha256: string;
+            } | {
+                kind: "none";
+            };
+            envOverrides?: Record<string, unknown> | undefined;
+        }[];
+        replicates: number;
+        policy: {
+            completenessFloor: number;
+            replacementPolicy: string;
+            eligibilityExclusions: string[];
+            cellWindow: string;
+            selfEvaluation: false;
+        };
+        budget: {
+            perCellFees: {
+                solveWei: string;
+                verdictWei: string;
+            };
+            hardCapWei: string;
+        };
+        preRegistrationHash: string;
+    };
+    closeBoundary: {
+        timestamp: string;
+        blockNumber?: number | undefined;
+    };
+    cells: {
+        configId: string;
+        cellKey: string;
+        capsuleDigest: string;
+        replicate: number;
+        outcome: "judged" | "unscorable" | "expired" | "invalidated";
+        verification: {
+            loadout: "match" | "mismatch" | "unverifiable";
+            profile: "match" | "mismatch" | "unverifiable";
+            isolation: string;
+        };
+        judgeIntegrityTier: "re-derivable" | "attested-only";
+        solverId: string;
+        evaluatorId: string;
+        cost: {
+            reported: string | number;
+            source: string;
+        };
+        latencyMs: number;
+        attemptEnvelopeCid?: string | undefined;
+        verdictEnvelopeRef?: string | undefined;
+    }[];
+    exclusions: {
+        cellKey: string;
+        reason: string;
+    }[];
+    attrition: {
+        perConfig: Record<string, number>;
+        perCapsule: Record<string, number>;
+        asymmetryFlags: string[];
+    };
+    completeness: {
+        achieved: number;
+        floor: number;
+        runOutcome: "complete" | "partial" | "cancelled";
+    };
+    matrixHash: string;
+}>;
+export type BenchMatrixV1 = z.infer<typeof BenchMatrixV1Schema>;
+export declare function hashBenchMatrixV1(matrix: BenchMatrixV1): `sha256:${string}`;
+export declare function validateBenchMatrixV1(value: unknown): BenchmarkValidationResult<BenchMatrixV1>;