niceeval 0.15.1-canary.76 → 0.16.1

package/dist/inspection/project-result.d.cts

@@ -0,0 +1,1264 @@
+import { Schema } from "effect";
+export declare const InspectionProjectGapReasonSchema: Schema.Literals<readonly ["no-result", "pending", "not-published", "identity-mismatch", "outcome-ineligible", "score-incomplete", "evidence-unavailable", "timeout-exceeded", "adoption-unproven"]>;
+export declare const InspectionProjectSlotSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly state: Schema.Literal<"reuse">;
+    readonly sourceRunId: Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>;
+    readonly locator: Schema.String;
+    readonly relation: Schema.Literals<readonly ["origin", "reference"]>;
+    readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
+    readonly experimentId: Schema.Codec<import("../record/model/identifiers.cjs").ExperimentId, string, never, never>;
+    readonly evalId: Schema.Codec<import("../record/model/identifiers.cjs").EvalId, string, never, never>;
+    readonly attemptOrdinal: Schema.Number;
+}>, Schema.Struct<{
+    readonly state: Schema.Literal<"gap">;
+    readonly reason: Schema.Literals<readonly ["no-result", "pending", "not-published", "identity-mismatch", "outcome-ineligible", "score-incomplete", "evidence-unavailable", "timeout-exceeded", "adoption-unproven"]>;
+    readonly issues: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly sourceRunId: Schema.NullOr<Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>>;
+    readonly previous: Schema.NullOr<Schema.Struct<{
+        readonly sourceRunId: Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>;
+        readonly locator: Schema.String;
+    }>>;
+    readonly experimentId: Schema.Codec<import("../record/model/identifiers.cjs").ExperimentId, string, never, never>;
+    readonly evalId: Schema.Codec<import("../record/model/identifiers.cjs").EvalId, string, never, never>;
+    readonly attemptOrdinal: Schema.Number;
+}>]>;
+/** Current quality metrics retain the aggregate shapes owned by Inspection. */
+export declare const InspectionProjectResultSchema: Schema.Struct<{
+    readonly history: Schema.$Array<Schema.Struct<{
+        readonly sourceRunId: Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>;
+        readonly locator: Schema.NullOr<Schema.String>;
+        readonly experimentId: Schema.Codec<import("../record/model/identifiers.cjs").ExperimentId, string, never, never>;
+        readonly evalId: Schema.Codec<import("../record/model/identifiers.cjs").EvalId, string, never, never>;
+        readonly attemptOrdinal: Schema.Number;
+    }>>;
+    readonly totals: Schema.Struct<{
+        readonly evaluationKind: Schema.Literals<readonly ["pass", "points", "mixed"]>;
+        readonly denominator: Schema.Struct<{
+            readonly expected: Schema.Number;
+            readonly observed: Schema.Number;
+            readonly classified: Schema.Number;
+            readonly missing: Schema.Number;
+        }>;
+        readonly verdict: Schema.Struct<{
+            readonly tally: Schema.Struct<{
+                readonly passed: Schema.Number;
+                readonly failed: Schema.Number;
+                readonly errored: Schema.Number;
+                readonly skipped: Schema.Number;
+            }>;
+            readonly passRate: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+        }>;
+        readonly score: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly costUSD: Schema.Struct<{
+            readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly durationMs: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly tokens: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly coverage: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly kind: Schema.Literal<"attempt">;
+                readonly locator: Schema.String;
+            }>;
+            readonly state: Schema.Literals<readonly ["not-recorded", "unsupported", "failed"]>;
+        }>, Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly kind: Schema.Literal<"attempt">;
+                readonly locator: Schema.String;
+            }>;
+            readonly entryId: Schema.String;
+            readonly groupPath: Schema.$Array<Schema.String>;
+            readonly state: Schema.Literals<readonly ["complete", "partial", "unavailable", "not-applicable"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["sampled", "truncated", "redacted", "provider-limited", "capacity-limited", "not-collected", "source-unavailable", "producer-failed", "optional-material", "unsupported-subject"]>>;
+            readonly limitations: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"redacted">;
+                readonly fieldCount: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sampled">;
+                readonly captured: Schema.Number;
+                readonly knownTotal: Schema.optional<Schema.Number>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"truncated">;
+                readonly omittedBytes: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"provider-limited">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"capacity-limited">;
+                readonly capturedItems: Schema.Number;
+                readonly knownTotalItems: Schema.Number;
+                readonly omittedBytes: Schema.NullOr<Schema.Number>;
+            }>]>>;
+        }>]>>;
+        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+            readonly locator: Schema.String;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+            readonly runId: Schema.String;
+            readonly slotId: Schema.String;
+            readonly evalId: Schema.String;
+            readonly attemptOrdinal: Schema.Number;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literal<"score-contribution-unavailable">;
+            readonly locator: Schema.String;
+            readonly entryId: Schema.String;
+            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literal<"score-partial">;
+            readonly locator: Schema.NullOr<Schema.String>;
+        }>]>>;
+    }>;
+    readonly experiments: Schema.$Array<Schema.Struct<{
+        readonly evaluationKind: Schema.Literals<readonly ["pass", "points", "mixed"]>;
+        readonly denominator: Schema.Struct<{
+            readonly expected: Schema.Number;
+            readonly observed: Schema.Number;
+            readonly classified: Schema.Number;
+            readonly missing: Schema.Number;
+        }>;
+        readonly verdict: Schema.Struct<{
+            readonly tally: Schema.Struct<{
+                readonly passed: Schema.Number;
+                readonly failed: Schema.Number;
+                readonly errored: Schema.Number;
+                readonly skipped: Schema.Number;
+            }>;
+            readonly passRate: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+        }>;
+        readonly score: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly costUSD: Schema.Struct<{
+            readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly durationMs: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly tokens: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly coverage: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly kind: Schema.Literal<"attempt">;
+                readonly locator: Schema.String;
+            }>;
+            readonly state: Schema.Literals<readonly ["not-recorded", "unsupported", "failed"]>;
+        }>, Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly kind: Schema.Literal<"attempt">;
+                readonly locator: Schema.String;
+            }>;
+            readonly entryId: Schema.String;
+            readonly groupPath: Schema.$Array<Schema.String>;
+            readonly state: Schema.Literals<readonly ["complete", "partial", "unavailable", "not-applicable"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["sampled", "truncated", "redacted", "provider-limited", "capacity-limited", "not-collected", "source-unavailable", "producer-failed", "optional-material", "unsupported-subject"]>>;
+            readonly limitations: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"redacted">;
+                readonly fieldCount: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sampled">;
+                readonly captured: Schema.Number;
+                readonly knownTotal: Schema.optional<Schema.Number>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"truncated">;
+                readonly omittedBytes: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"provider-limited">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"capacity-limited">;
+                readonly capturedItems: Schema.Number;
+                readonly knownTotalItems: Schema.Number;
+                readonly omittedBytes: Schema.NullOr<Schema.Number>;
+            }>]>>;
+        }>]>>;
+        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+            readonly locator: Schema.String;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+            readonly runId: Schema.String;
+            readonly slotId: Schema.String;
+            readonly evalId: Schema.String;
+            readonly attemptOrdinal: Schema.Number;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literal<"score-contribution-unavailable">;
+            readonly locator: Schema.String;
+            readonly entryId: Schema.String;
+            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literal<"score-partial">;
+            readonly locator: Schema.NullOr<Schema.String>;
+        }>]>>;
+        readonly experimentId: Schema.String;
+        readonly adapter: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"available">;
+            readonly value: Schema.Codec<import("../types.cjs").AdapterIdentity, import("../types.cjs").AdapterIdentity, never, never>;
+        }>, Schema.Struct<{
+            readonly state: Schema.Literal<"mixed">;
+        }>]>;
+        readonly model: Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"available">;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly state: Schema.Literal<"mixed">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Literal<"unavailable">;
+        }>]>;
+        readonly labels: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly state: Schema.Literal<"available">;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly state: Schema.Literal<"mixed">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Literal<"unavailable">;
+        }>]>>;
+        readonly groups: Schema.$Array<Schema.Struct<{
+            readonly evaluationKind: Schema.Literals<readonly ["pass", "points", "mixed"]>;
+            readonly denominator: Schema.Struct<{
+                readonly expected: Schema.Number;
+                readonly observed: Schema.Number;
+                readonly classified: Schema.Number;
+                readonly missing: Schema.Number;
+            }>;
+            readonly verdict: Schema.Struct<{
+                readonly tally: Schema.Struct<{
+                    readonly passed: Schema.Number;
+                    readonly failed: Schema.Number;
+                    readonly errored: Schema.Number;
+                    readonly skipped: Schema.Number;
+                }>;
+                readonly passRate: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                    readonly value: Schema.NullOr<Schema.Number>;
+                    readonly samples: Schema.Number;
+                    readonly total: Schema.Number;
+                    readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly locator: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                        readonly runId: Schema.String;
+                        readonly slotId: Schema.String;
+                        readonly evalId: Schema.String;
+                        readonly attemptOrdinal: Schema.Number;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-contribution-unavailable">;
+                        readonly locator: Schema.String;
+                        readonly entryId: Schema.String;
+                        readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-partial">;
+                        readonly locator: Schema.NullOr<Schema.String>;
+                    }>]>>;
+                    readonly refs: Schema.$Array<Schema.Struct<{
+                        readonly identity: Schema.Struct<{
+                            readonly kind: Schema.Literal<"attempt">;
+                            readonly locator: Schema.String;
+                        }>;
+                    }>>;
+                    readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                    readonly bounds: Schema.optional<Schema.Struct<{
+                        readonly min: Schema.Number;
+                        readonly max: Schema.Number;
+                    }>>;
+                }>;
+            }>;
+            readonly score: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+            readonly costUSD: Schema.Struct<{
+                readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+            readonly durationMs: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+            readonly tokens: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+            readonly coverage: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+                readonly state: Schema.Literals<readonly ["not-recorded", "unsupported", "failed"]>;
+            }>, Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+                readonly entryId: Schema.String;
+                readonly groupPath: Schema.$Array<Schema.String>;
+                readonly state: Schema.Literals<readonly ["complete", "partial", "unavailable", "not-applicable"]>;
+                readonly reason: Schema.optional<Schema.Literals<readonly ["sampled", "truncated", "redacted", "provider-limited", "capacity-limited", "not-collected", "source-unavailable", "producer-failed", "optional-material", "unsupported-subject"]>>;
+                readonly limitations: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"redacted">;
+                    readonly fieldCount: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"sampled">;
+                    readonly captured: Schema.Number;
+                    readonly knownTotal: Schema.optional<Schema.Number>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"truncated">;
+                    readonly omittedBytes: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"provider-limited">;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"capacity-limited">;
+                    readonly capturedItems: Schema.Number;
+                    readonly knownTotalItems: Schema.Number;
+                    readonly omittedBytes: Schema.NullOr<Schema.Number>;
+                }>]>>;
+            }>]>>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly groupPath: Schema.$Array<Schema.String>;
+        }>>;
+    }>>;
+    readonly cells: Schema.$Array<Schema.Struct<{
+        readonly evaluationKind: Schema.Literals<readonly ["pass", "points", "mixed"]>;
+        readonly denominator: Schema.Struct<{
+            readonly expected: Schema.Number;
+            readonly observed: Schema.Number;
+            readonly classified: Schema.Number;
+            readonly missing: Schema.Number;
+        }>;
+        readonly verdict: Schema.Struct<{
+            readonly tally: Schema.Struct<{
+                readonly passed: Schema.Number;
+                readonly failed: Schema.Number;
+                readonly errored: Schema.Number;
+                readonly skipped: Schema.Number;
+            }>;
+            readonly passRate: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                readonly value: Schema.NullOr<Schema.Number>;
+                readonly samples: Schema.Number;
+                readonly total: Schema.Number;
+                readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                    readonly locator: Schema.String;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                    readonly runId: Schema.String;
+                    readonly slotId: Schema.String;
+                    readonly evalId: Schema.String;
+                    readonly attemptOrdinal: Schema.Number;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                    readonly locator: Schema.String;
+                    readonly entryId: Schema.String;
+                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                }>, Schema.Struct<{
+                    readonly code: Schema.Literal<"score-partial">;
+                    readonly locator: Schema.NullOr<Schema.String>;
+                }>]>>;
+                readonly refs: Schema.$Array<Schema.Struct<{
+                    readonly identity: Schema.Struct<{
+                        readonly kind: Schema.Literal<"attempt">;
+                        readonly locator: Schema.String;
+                    }>;
+                }>>;
+                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                readonly bounds: Schema.optional<Schema.Struct<{
+                    readonly min: Schema.Number;
+                    readonly max: Schema.Number;
+                }>>;
+            }>;
+        }>;
+        readonly score: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly costUSD: Schema.Struct<{
+            readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly durationMs: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly tokens: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+            readonly value: Schema.NullOr<Schema.Number>;
+            readonly samples: Schema.Number;
+            readonly total: Schema.Number;
+            readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                readonly locator: Schema.String;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                readonly runId: Schema.String;
+                readonly slotId: Schema.String;
+                readonly evalId: Schema.String;
+                readonly attemptOrdinal: Schema.Number;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                readonly locator: Schema.String;
+                readonly entryId: Schema.String;
+                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+            }>, Schema.Struct<{
+                readonly code: Schema.Literal<"score-partial">;
+                readonly locator: Schema.NullOr<Schema.String>;
+            }>]>>;
+            readonly refs: Schema.$Array<Schema.Struct<{
+                readonly identity: Schema.Struct<{
+                    readonly kind: Schema.Literal<"attempt">;
+                    readonly locator: Schema.String;
+                }>;
+            }>>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+            readonly bounds: Schema.optional<Schema.Struct<{
+                readonly min: Schema.Number;
+                readonly max: Schema.Number;
+            }>>;
+        }>;
+        readonly coverage: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly kind: Schema.Literal<"attempt">;
+                readonly locator: Schema.String;
+            }>;
+            readonly state: Schema.Literals<readonly ["not-recorded", "unsupported", "failed"]>;
+        }>, Schema.Struct<{
+            readonly identity: Schema.Struct<{
+                readonly kind: Schema.Literal<"attempt">;
+                readonly locator: Schema.String;
+            }>;
+            readonly entryId: Schema.String;
+            readonly groupPath: Schema.$Array<Schema.String>;
+            readonly state: Schema.Literals<readonly ["complete", "partial", "unavailable", "not-applicable"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["sampled", "truncated", "redacted", "provider-limited", "capacity-limited", "not-collected", "source-unavailable", "producer-failed", "optional-material", "unsupported-subject"]>>;
+            readonly limitations: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"redacted">;
+                readonly fieldCount: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"sampled">;
+                readonly captured: Schema.Number;
+                readonly knownTotal: Schema.optional<Schema.Number>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"truncated">;
+                readonly omittedBytes: Schema.Number;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"provider-limited">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"capacity-limited">;
+                readonly capturedItems: Schema.Number;
+                readonly knownTotalItems: Schema.Number;
+                readonly omittedBytes: Schema.NullOr<Schema.Number>;
+            }>]>>;
+        }>]>>;
+        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+            readonly locator: Schema.String;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+            readonly runId: Schema.String;
+            readonly slotId: Schema.String;
+            readonly evalId: Schema.String;
+            readonly attemptOrdinal: Schema.Number;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literal<"score-contribution-unavailable">;
+            readonly locator: Schema.String;
+            readonly entryId: Schema.String;
+            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+        }>, Schema.Struct<{
+            readonly code: Schema.Literal<"score-partial">;
+            readonly locator: Schema.NullOr<Schema.String>;
+        }>]>>;
+        readonly experimentId: Schema.String;
+        readonly evalId: Schema.String;
+        readonly groupPath: Schema.$Array<Schema.String>;
+        readonly members: Schema.$Array<Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly slotId: Schema.String;
+            readonly evalId: Schema.String;
+            readonly attemptOrdinal: Schema.Number;
+            readonly labels: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"available">;
+                readonly value: Schema.String;
+            }>, Schema.Struct<{
+                readonly state: Schema.Literal<"mixed">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Literal<"unavailable">;
+            }>]>>;
+            readonly publication: Schema.Union<readonly [Schema.Struct<{
+                readonly state: Schema.Literal<"pending">;
+            }>, Schema.Struct<{
+                readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
+                readonly score: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                    readonly value: Schema.NullOr<Schema.Number>;
+                    readonly samples: Schema.Number;
+                    readonly total: Schema.Number;
+                    readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly locator: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                        readonly runId: Schema.String;
+                        readonly slotId: Schema.String;
+                        readonly evalId: Schema.String;
+                        readonly attemptOrdinal: Schema.Number;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-contribution-unavailable">;
+                        readonly locator: Schema.String;
+                        readonly entryId: Schema.String;
+                        readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-partial">;
+                        readonly locator: Schema.NullOr<Schema.String>;
+                    }>]>>;
+                    readonly refs: Schema.$Array<Schema.Struct<{
+                        readonly identity: Schema.Struct<{
+                            readonly kind: Schema.Literal<"attempt">;
+                            readonly locator: Schema.String;
+                        }>;
+                    }>>;
+                    readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                    readonly bounds: Schema.optional<Schema.Struct<{
+                        readonly min: Schema.Number;
+                        readonly max: Schema.Number;
+                    }>>;
+                }>;
+                readonly costUSD: Schema.Struct<{
+                    readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+                    readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                    readonly value: Schema.NullOr<Schema.Number>;
+                    readonly samples: Schema.Number;
+                    readonly total: Schema.Number;
+                    readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly locator: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                        readonly runId: Schema.String;
+                        readonly slotId: Schema.String;
+                        readonly evalId: Schema.String;
+                        readonly attemptOrdinal: Schema.Number;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-contribution-unavailable">;
+                        readonly locator: Schema.String;
+                        readonly entryId: Schema.String;
+                        readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-partial">;
+                        readonly locator: Schema.NullOr<Schema.String>;
+                    }>]>>;
+                    readonly refs: Schema.$Array<Schema.Struct<{
+                        readonly identity: Schema.Struct<{
+                            readonly kind: Schema.Literal<"attempt">;
+                            readonly locator: Schema.String;
+                        }>;
+                    }>>;
+                    readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                    readonly bounds: Schema.optional<Schema.Struct<{
+                        readonly min: Schema.Number;
+                        readonly max: Schema.Number;
+                    }>>;
+                }>;
+                readonly durationMs: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                    readonly value: Schema.NullOr<Schema.Number>;
+                    readonly samples: Schema.Number;
+                    readonly total: Schema.Number;
+                    readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly locator: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                        readonly runId: Schema.String;
+                        readonly slotId: Schema.String;
+                        readonly evalId: Schema.String;
+                        readonly attemptOrdinal: Schema.Number;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-contribution-unavailable">;
+                        readonly locator: Schema.String;
+                        readonly entryId: Schema.String;
+                        readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-partial">;
+                        readonly locator: Schema.NullOr<Schema.String>;
+                    }>]>>;
+                    readonly refs: Schema.$Array<Schema.Struct<{
+                        readonly identity: Schema.Struct<{
+                            readonly kind: Schema.Literal<"attempt">;
+                            readonly locator: Schema.String;
+                        }>;
+                    }>>;
+                    readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                    readonly bounds: Schema.optional<Schema.Struct<{
+                        readonly min: Schema.Number;
+                        readonly max: Schema.Number;
+                    }>>;
+                }>;
+                readonly tokens: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                    readonly value: Schema.NullOr<Schema.Number>;
+                    readonly samples: Schema.Number;
+                    readonly total: Schema.Number;
+                    readonly basis: Schema.Literals<readonly ["slot", "eval"]>;
+                    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly locator: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                        readonly runId: Schema.String;
+                        readonly slotId: Schema.String;
+                        readonly evalId: Schema.String;
+                        readonly attemptOrdinal: Schema.Number;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-contribution-unavailable">;
+                        readonly locator: Schema.String;
+                        readonly entryId: Schema.String;
+                        readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                    }>, Schema.Struct<{
+                        readonly code: Schema.Literal<"score-partial">;
+                        readonly locator: Schema.NullOr<Schema.String>;
+                    }>]>>;
+                    readonly refs: Schema.$Array<Schema.Struct<{
+                        readonly identity: Schema.Struct<{
+                            readonly kind: Schema.Literal<"attempt">;
+                            readonly locator: Schema.String;
+                        }>;
+                    }>>;
+                    readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                    readonly bounds: Schema.optional<Schema.Struct<{
+                        readonly min: Schema.Number;
+                        readonly max: Schema.Number;
+                    }>>;
+                }>;
+                readonly state: Schema.Literal<"published">;
+                readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
+                readonly attemptId: Schema.String;
+                readonly attemptLocator: Schema.String;
+                readonly originRunId: Schema.String;
+                readonly originSlotId: Schema.String;
+            }>, Schema.Struct<{
+                readonly state: Schema.Literal<"absent">;
+                readonly reason: Schema.Literals<readonly ["early-exit-satisfied", "budget-exhausted", "stopped-by-failure", "interrupted-before-publication", "dispatch-failed"]>;
+            }>]>;
+        }>>;
+    }>>;
+    readonly targetIdentity: Schema.NonEmptyString;
+    readonly coverage: Schema.Struct<{
+        readonly expected: Schema.Number;
+        readonly covered: Schema.Number;
+        readonly gaps: Schema.Number;
+    }>;
+    readonly slots: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"reuse">;
+        readonly sourceRunId: Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>;
+        readonly locator: Schema.String;
+        readonly relation: Schema.Literals<readonly ["origin", "reference"]>;
+        readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
+        readonly experimentId: Schema.Codec<import("../record/model/identifiers.cjs").ExperimentId, string, never, never>;
+        readonly evalId: Schema.Codec<import("../record/model/identifiers.cjs").EvalId, string, never, never>;
+        readonly attemptOrdinal: Schema.Number;
+    }>, Schema.Struct<{
+        readonly state: Schema.Literal<"gap">;
+        readonly reason: Schema.Literals<readonly ["no-result", "pending", "not-published", "identity-mismatch", "outcome-ineligible", "score-incomplete", "evidence-unavailable", "timeout-exceeded", "adoption-unproven"]>;
+        readonly issues: Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly sourceRunId: Schema.NullOr<Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>>;
+        readonly previous: Schema.NullOr<Schema.Struct<{
+            readonly sourceRunId: Schema.Codec<import("../record/model/identifiers.cjs").RunId, string, never, never>;
+            readonly locator: Schema.String;
+        }>>;
+        readonly experimentId: Schema.Codec<import("../record/model/identifiers.cjs").ExperimentId, string, never, never>;
+        readonly evalId: Schema.Codec<import("../record/model/identifiers.cjs").EvalId, string, never, never>;
+        readonly attemptOrdinal: Schema.Number;
+    }>]>>;
+}>;
+export type InspectionProjectResult = Schema.Schema.Type<typeof InspectionProjectResultSchema>;
+export type InspectionProjectSlot = Schema.Schema.Type<typeof InspectionProjectSlotSchema>;