niceeval 0.13.1 → 0.13.2

package/dist/sample/analysis.cjs

@@ -158,32 +158,252 @@ function decodeSampleSnapshot(value) {
 }
 /** @internal Typed codec branch for host diagnostics. */
 function decodeSampleSnapshotEither(value) {
-    if (!isExactObject(value, ["version", "identity", "selection", "runs", "slots", "coverage"])) {
-        return effect_1.Either.left(codecError([], "must contain exactly version, identity, selection, runs, slots, and coverage"));
-    }
-    if (valueAt(value, "version") !== 1)
-        return effect_1.Either.left(codecError(["version"], "must be 1"));
-    const selection = decodeSelection(valueAt(value, "selection"), ["selection"]);
-    if (effect_1.Either.isLeft(selection))
-        return effect_1.Either.left(selection.left);
-    const runs = decodeRuns(valueAt(value, "runs"), ["runs"]);
-    if (effect_1.Either.isLeft(runs))
-        return effect_1.Either.left(runs.left);
-    const slots = decodeSlots(valueAt(value, "slots"), ["slots"]);
-    if (effect_1.Either.isLeft(slots))
-        return effect_1.Either.left(slots.left);
-    const alignment = validateSlotRunAlignment(runs.right, slots.right);
+    const decoded = effect_1.Schema.decodeUnknownEither(SampleSnapshotWireSchema, SampleSchemaParseOptions)(value);
+    if (effect_1.Either.isLeft(decoded))
+        return effect_1.Either.left(codecErrorFromSchema(decoded.left));
+    const canonical = canonicalizeSnapshotWire(decoded.right);
+    if (effect_1.Either.isLeft(canonical))
+        return effect_1.Either.left(canonical.left);
+    const alignment = validateSlotRunAlignment(canonical.right.runs, canonical.right.slots);
     if (alignment !== undefined)
         return effect_1.Either.left(alignment);
-    const snapshot = makeSnapshot({ selection: selection.right, runs: runs.right, slots: slots.right });
-    if (!sameIdentity(valueAt(value, "identity"), snapshot.identity)) {
+    const snapshot = makeSnapshot(canonical.right);
+    if (decoded.right.identity.kind !== snapshot.identity.kind || decoded.right.identity.id !== snapshot.identity.id) {
         return effect_1.Either.left(codecError(["identity"], "does not match the canonical frozen selection"));
     }
-    if (!sameCoverage(valueAt(value, "coverage"), snapshot.coverage)) {
+    if (!sameCoverage(decoded.right.coverage, snapshot.coverage)) {
         return effect_1.Either.left(codecError(["coverage"], "does not satisfy the canonical coverage equations"));
     }
     return effect_1.Either.right(snapshot);
 }
+const SampleSchemaParseOptions = Object.freeze({
+    errors: "all",
+    exact: true,
+    onExcessProperty: "error",
+});
+const PlainObjectSchema = effect_1.Schema.declare((value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}, { identifier: "SamplePlainObject", description: "a plain object or null-prototype record" });
+const plainStruct = (fields) => effect_1.Schema.compose(effect_1.Schema.Struct(fields), { strict: false })(PlainObjectSchema);
+const AttemptOrdinalSchema = effect_1.Schema.JsonNumber.pipe(effect_1.Schema.filter((value) => Number.isSafeInteger(value) && value >= 0, {
+    identifier: "SampleAttemptOrdinal",
+    description: "a zero-based non-negative safe attempt ordinal",
+}));
+const AttemptLocatorSchema = effect_1.Schema.String.pipe(effect_1.Schema.filter((value) => (0, attempt_locator_ts_1.parseAttemptLocator)(value).valid, { identifier: "SampleAttemptLocator", description: "a canonical Attempt locator" }));
+const JsonValueSchema = effect_1.Schema.suspend(() => effect_1.Schema.Union(effect_1.Schema.Null, effect_1.Schema.Boolean, effect_1.Schema.JsonNumber, effect_1.Schema.String, effect_1.Schema.Array(JsonValueSchema), effect_1.Schema.Record({ key: effect_1.Schema.String, value: JsonValueSchema })));
+const RunContextWireSchema = plainStruct({
+    execution: plainStruct({
+        agentId: effect_1.Schema.String.pipe(effect_1.Schema.minLength(1)),
+        model: effect_1.Schema.NullOr(effect_1.Schema.String),
+        reasoningEffort: effect_1.Schema.NullOr(effect_1.Schema.String),
+        flags: effect_1.Schema.Record({ key: effect_1.Schema.String, value: JsonValueSchema }),
+    }),
+    labels: effect_1.Schema.Record({ key: effect_1.Schema.String, value: effect_1.Schema.String }),
+});
+const SelectionProblemSchema = plainStruct({
+    code: effect_1.Schema.Literal("incomplete-run", "record-core-invalid", "selection-run-missing", "selection-run-unreadable"),
+    runId: identifiers_ts_1.RunIdSchema,
+});
+const SelectionSchema = effect_1.Schema.Union(plainStruct({
+    policy: effect_1.Schema.Literal("explicit-runs"),
+    runIds: effect_1.Schema.Array(identifiers_ts_1.RunIdSchema),
+    selectedRunIds: effect_1.Schema.Array(identifiers_ts_1.RunIdSchema),
+    problems: effect_1.Schema.Array(SelectionProblemSchema),
+}), plainStruct({
+    policy: effect_1.Schema.Literal("project-current"),
+    experimentIds: effect_1.Schema.Union(effect_1.Schema.Literal("all"), effect_1.Schema.Array(identifiers_ts_1.ExperimentIdSchema)),
+    selectedRunIds: effect_1.Schema.Array(identifiers_ts_1.RunIdSchema),
+    problems: effect_1.Schema.Array(SelectionProblemSchema),
+}));
+const RunSchema = plainStruct({
+    runId: identifiers_ts_1.RunIdSchema,
+    experimentId: identifiers_ts_1.ExperimentIdSchema,
+    context: effect_1.Schema.NullOr(RunContextWireSchema),
+    startedAt: identifiers_ts_1.UtcMillisSchema,
+    completedAt: identifiers_ts_1.UtcMillisSchema,
+    expectedSlots: effect_1.Schema.Array(identifiers_ts_1.SlotIdSchema),
+});
+const SlotReferenceFields = {
+    runId: identifiers_ts_1.RunIdSchema,
+    slotId: identifiers_ts_1.SlotIdSchema,
+    experimentId: identifiers_ts_1.ExperimentIdSchema,
+    evalId: identifiers_ts_1.EvalIdSchema,
+    attemptOrdinal: AttemptOrdinalSchema,
+    executionIdentityDigest: identifiers_ts_1.ExecutionIdentityDigestSchema,
+};
+const AttemptEvidenceSchema = plainStruct({
+    kind: effect_1.Schema.Literal("attempt"),
+    locator: AttemptLocatorSchema,
+    originRunId: identifiers_ts_1.RunIdSchema,
+});
+const IssueSchema = plainStruct({
+    code: effect_1.Schema.Literal("missing", "migration-required", "unsupported", "producer-incompatible", "input-invalid", "reduction-failed", "relation-unmatched"),
+    message: effect_1.Schema.String,
+    refs: effect_1.Schema.Array(plainStruct({
+        identity: plainStruct({ kind: effect_1.Schema.Literal("attempt"), locator: AttemptLocatorSchema }),
+    })),
+});
+const ActiveSlotSchema = effect_1.Schema.Union(plainStruct({
+    ...SlotReferenceFields,
+    state: effect_1.Schema.Literal("included"),
+    action: effect_1.Schema.Literal("executed", "carried", "accepted"),
+    relation: effect_1.Schema.Literal("origin", "reference"),
+    attempt: AttemptEvidenceSchema,
+}), plainStruct({
+    ...SlotReferenceFields,
+    state: effect_1.Schema.Literal("not-recorded"),
+    action: effect_1.Schema.Literal("not-dispatched", "interrupted").pipe(effect_1.Schema.NullOr),
+    attempt: effect_1.Schema.Null,
+}), plainStruct({
+    ...SlotReferenceFields,
+    state: effect_1.Schema.Literal("core-invalid"),
+    action: effect_1.Schema.Literal("executed", "carried", "accepted", "not-dispatched", "interrupted").pipe(effect_1.Schema.NullOr),
+    attempt: effect_1.Schema.Null,
+    issues: effect_1.Schema.Array(IssueSchema),
+}));
+const SlotSchemaRaw = effect_1.Schema.suspend(() => effect_1.Schema.Union(ActiveSlotSchema, plainStruct({
+    ...SlotReferenceFields,
+    state: effect_1.Schema.Literal("excluded"),
+    base: ActiveSlotSchema,
+}), plainStruct({
+    ...SlotReferenceFields,
+    state: effect_1.Schema.Literal("excluded"),
+    base: ActiveSlotSchema,
+    reason: effect_1.Schema.Literal("identity-mismatch"),
+})));
+const SlotSchema = SlotSchemaRaw;
+const CoverageWireSchema = plainStruct({
+    frameTotal: effect_1.Schema.JsonNumber,
+    selected: effect_1.Schema.JsonNumber,
+    included: effect_1.Schema.JsonNumber,
+    notRecorded: effect_1.Schema.JsonNumber,
+    coreInvalid: effect_1.Schema.JsonNumber,
+    excluded: effect_1.Schema.JsonNumber,
+});
+const SampleSnapshotWireSchema = plainStruct({
+    version: effect_1.Schema.Literal(1),
+    identity: plainStruct({ kind: effect_1.Schema.Literal("analysis-sample"), id: effect_1.Schema.String }),
+    selection: SelectionSchema,
+    runs: effect_1.Schema.Array(RunSchema).pipe(effect_1.Schema.filter((runs) => runs.length <= MAX_SELECTED_RUNS, { identifier: "SampleSelectedRuns", description: "at most 4096 selected Runs" })),
+    slots: effect_1.Schema.Array(SlotSchema).pipe(effect_1.Schema.filter((slots) => slots.length <= MAX_SLOTS, { identifier: "SampleSlots", description: "at most 250000 Slots" })),
+    coverage: CoverageWireSchema,
+});
+function canonicalizeSnapshotWire(input) {
+    const selection = canonicalizeSelection(input.selection);
+    const runs = [];
+    for (let index = 0; index < input.runs.length; index += 1) {
+        const run = input.runs[index];
+        const context = run.context === null
+            ? null
+            : (0, run_context_ts_1.canonicalizeRunContext)({ experimentId: run.experimentId, ...run.context });
+        if (context !== null && effect_1.Either.isLeft(context)) {
+            return effect_1.Either.left(codecError(["runs", String(index), "context"], "is not a valid closed Run context"));
+        }
+        runs.push(Object.freeze({
+            runId: run.runId,
+            experimentId: run.experimentId,
+            context: context === null ? null : closeRunContext(context.right),
+            startedAt: run.startedAt,
+            completedAt: run.completedAt,
+            expectedSlots: Object.freeze(uniqueSorted(run.expectedSlots)),
+        }));
+    }
+    let canonicalRuns;
+    try {
+        canonicalRuns = uniqueSortedBy(runs, (run) => run.runId);
+    }
+    catch {
+        return effect_1.Either.left(codecError(["runs"], "duplicates a Run identity"));
+    }
+    const identities = new Set();
+    const slots = [];
+    for (let index = 0; index < input.slots.length; index += 1) {
+        const slot = input.slots[index];
+        const key = slotKey(slot.runId, slot.slotId);
+        if (identities.has(key))
+            return effect_1.Either.left(codecError(["slots", String(index)], "duplicates a Run/Slot identity"));
+        identities.add(key);
+        const closed = closeDecodedSlot(slot, ["slots", String(index)]);
+        if (effect_1.Either.isLeft(closed))
+            return effect_1.Either.left(closed.left);
+        slots.push(closed.right);
+    }
+    return effect_1.Either.right(Object.freeze({
+        selection,
+        runs: canonicalRuns,
+        slots: Object.freeze(slots.sort(compareSlots)),
+    }));
+}
+function closeDecodedSlot(slot, path) {
+    if (slot.state === "excluded") {
+        const base = closeDecodedSlot(slot.base, [...path, "base"]);
+        if (effect_1.Either.isLeft(base))
+            return base;
+        if (base.right.state === "excluded") {
+            return effect_1.Either.left(codecError([...path, "base"], "must be an active Slot"));
+        }
+        if (base.right.runId !== slot.runId || base.right.slotId !== slot.slotId ||
+            base.right.experimentId !== slot.experimentId || base.right.evalId !== slot.evalId ||
+            base.right.attemptOrdinal !== slot.attemptOrdinal ||
+            base.right.executionIdentityDigest !== slot.executionIdentityDigest)
+            return effect_1.Either.left(codecError(path, "excluded base must be a matching active Slot"));
+        return effect_1.Either.right(Object.freeze({ ...slot, base: base.right }));
+    }
+    if (slot.state === "included") {
+        return effect_1.Either.right(Object.freeze({ ...slot, attempt: Object.freeze({ ...slot.attempt }) }));
+    }
+    if (slot.state === "not-recorded")
+        return effect_1.Either.right(Object.freeze({ ...slot }));
+    return effect_1.Either.right(Object.freeze({
+        ...slot,
+        issues: Object.freeze(slot.issues.map((issue) => Object.freeze({
+            ...issue,
+            refs: Object.freeze(issue.refs.map((ref) => Object.freeze({
+                identity: Object.freeze({ ...ref.identity }),
+            }))),
+        }))),
+    }));
+}
+function canonicalizeSelection(selection) {
+    const problems = normalizedSelectionProblems(selection.problems);
+    return selection.policy === "explicit-runs"
+        ? Object.freeze({
+            policy: selection.policy,
+            runIds: uniqueSorted(selection.runIds),
+            selectedRunIds: uniqueSorted(selection.selectedRunIds),
+            problems,
+        })
+        : Object.freeze({
+            policy: selection.policy,
+            experimentIds: selection.experimentIds === "all" ? "all" : uniqueSorted(selection.experimentIds),
+            selectedRunIds: uniqueSorted(selection.selectedRunIds),
+            problems,
+        });
+}
+/** A Snapshot Slot is a derived occurrence of exactly one closed AnalysisRun. */
+function validateSlotRunAlignment(runs, slots) {
+    const runsById = new Map(runs.map((run) => [run.runId, run]));
+    for (let index = 0; index < slots.length; index += 1) {
+        const slot = slots[index];
+        const run = runsById.get(slot.runId);
+        if (run === undefined)
+            return codecError(["slots", String(index), "runId"], "does not identify a selected AnalysisRun");
+        if (run.experimentId !== slot.experimentId)
+            return codecError(["slots", String(index), "experimentId"], "does not match the associated AnalysisRun");
+        if (!run.expectedSlots.includes(slot.slotId))
+            return codecError(["slots", String(index), "slotId"], "does not belong to the associated AnalysisRun");
+    }
+    return undefined;
+}
+function codecErrorFromSchema(error) {
+    const issue = effect_1.ParseResult.ArrayFormatter.formatErrorSync(error)[0];
+    if (issue === undefined)
+        return codecError([], "is not a valid Sample snapshot");
+    return codecError(issue.path.map(String), issue.message);
+}
 function expectedSlotsByRun(selection) {
     const result = new Map();
     for (const entry of selection.expectedSlots) {
@@ -212,13 +432,9 @@ function expectedSlotsForRun(ref, facts, fromSelection) {
 }
 function selectionSummary(request, selection) {
     const selectedRunIds = uniqueSorted(selection.runRefs.map((ref) => ref.runId));
-    const problems = normalizedSelectionProblems([
-        ...selection.problems,
-        ...selection.warnings.map((warning) => Object.freeze({
-            code: "incomplete-run",
-            runId: warning.runId,
-        })),
-    ]);
+    // Unpublished Run directories are normal writer residue. Record keeps the
+    // warning for maintenance, but it is not a problem with the selected Sample.
+    const problems = normalizedSelectionProblems(selection.problems);
     if (request.policy === "explicit-runs") {
         return Object.freeze({
             policy: "explicit-runs",
@@ -607,414 +823,6 @@ function issueJson(issue) {
         }))),
     });
 }
-function decodeSelection(value, path) {
-    if (!isPlainObject(value))
-        return effect_1.Either.left(codecError(path, "must be an object"));
-    const policy = valueAt(value, "policy");
-    if (policy === "explicit-runs") {
-        if (!isExactObject(value, ["policy", "runIds", "selectedRunIds", "problems"])) {
-            return effect_1.Either.left(codecError(path, "explicit-runs must contain exactly policy, runIds, selectedRunIds, and problems"));
-        }
-        const runIds = decodeArray(valueAt(value, "runIds"), [...path, "runIds"], decodeRunId);
-        const selectedRunIds = decodeArray(valueAt(value, "selectedRunIds"), [...path, "selectedRunIds"], decodeRunId);
-        const problems = decodeSelectionProblems(valueAt(value, "problems"), [...path, "problems"]);
-        if (effect_1.Either.isLeft(runIds))
-            return effect_1.Either.left(runIds.left);
-        if (effect_1.Either.isLeft(selectedRunIds))
-            return effect_1.Either.left(selectedRunIds.left);
-        if (effect_1.Either.isLeft(problems))
-            return effect_1.Either.left(problems.left);
-        return effect_1.Either.right(Object.freeze({
-            policy: "explicit-runs",
-            runIds: uniqueSorted(runIds.right),
-            selectedRunIds: uniqueSorted(selectedRunIds.right),
-            problems: normalizedSelectionProblems(problems.right),
-        }));
-    }
-    if (policy === "project-current") {
-        if (!isExactObject(value, ["policy", "experimentIds", "selectedRunIds", "problems"])) {
-            return effect_1.Either.left(codecError(path, "project-current must contain exactly policy, experimentIds, selectedRunIds, and problems"));
-        }
-        const experimentIdsValue = valueAt(value, "experimentIds");
-        let experimentIds;
-        if (experimentIdsValue === "all") {
-            experimentIds = "all";
-        }
-        else {
-            const decodedExperimentIds = decodeArray(experimentIdsValue, [...path, "experimentIds"], decodeExperimentId);
-            if (effect_1.Either.isLeft(decodedExperimentIds))
-                return effect_1.Either.left(decodedExperimentIds.left);
-            experimentIds = uniqueSorted(decodedExperimentIds.right);
-        }
-        const selectedRunIds = decodeArray(valueAt(value, "selectedRunIds"), [...path, "selectedRunIds"], decodeRunId);
-        const problems = decodeSelectionProblems(valueAt(value, "problems"), [...path, "problems"]);
-        if (effect_1.Either.isLeft(selectedRunIds))
-            return effect_1.Either.left(selectedRunIds.left);
-        if (effect_1.Either.isLeft(problems))
-            return effect_1.Either.left(problems.left);
-        return effect_1.Either.right(Object.freeze({
-            policy: "project-current",
-            experimentIds,
-            selectedRunIds: uniqueSorted(selectedRunIds.right),
-            problems: normalizedSelectionProblems(problems.right),
-        }));
-    }
-    return effect_1.Either.left(codecError([...path, "policy"], "must be explicit-runs or project-current"));
-}
-function decodeSelectionProblems(value, path) {
-    if (!Array.isArray(value))
-        return effect_1.Either.left(codecError(path, "must be an array"));
-    const problems = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const decoded = decodeSelectionProblem(value[index], [...path, String(index)]);
-        if (effect_1.Either.isLeft(decoded))
-            return effect_1.Either.left(decoded.left);
-        problems.push(decoded.right);
-    }
-    return effect_1.Either.right(Object.freeze(problems));
-}
-function decodeSelectionProblem(value, path) {
-    if (!isExactObject(value, ["code", "runId"]))
-        return effect_1.Either.left(codecError(path, "must contain exactly code and runId"));
-    const code = valueAt(value, "code");
-    if (code !== "incomplete-run" && code !== "record-core-invalid" && code !== "selection-run-missing" && code !== "selection-run-unreadable") {
-        return effect_1.Either.left(codecError([...path, "code"], "is not a known selection problem"));
-    }
-    const runId = decodeRunId(valueAt(value, "runId"), [...path, "runId"]);
-    return effect_1.Either.isLeft(runId) ? effect_1.Either.left(runId.left) : effect_1.Either.right(Object.freeze({ code, runId: runId.right }));
-}
-function decodeRuns(value, path) {
-    if (!Array.isArray(value))
-        return effect_1.Either.left(codecError(path, "must be an array"));
-    if (value.length > MAX_SELECTED_RUNS)
-        return effect_1.Either.left(codecError(path, "exceeds the selected-runs limit"));
-    const runs = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const decoded = decodeRun(value[index], [...path, String(index)]);
-        if (effect_1.Either.isLeft(decoded))
-            return effect_1.Either.left(decoded.left);
-        runs.push(decoded.right);
-    }
-    return effect_1.Either.right(Object.freeze(uniqueSortedBy(runs, (run) => run.runId)));
-}
-function decodeRun(value, path) {
-    if (!isExactObject(value, ["runId", "experimentId", "context", "startedAt", "completedAt", "expectedSlots"])) {
-        return effect_1.Either.left(codecError(path, "contains unsupported fields"));
-    }
-    const runId = decodeRunId(valueAt(value, "runId"), [...path, "runId"]);
-    const experimentId = decodeExperimentId(valueAt(value, "experimentId"), [...path, "experimentId"]);
-    const startedAt = decodeUtcMillis(valueAt(value, "startedAt"), [...path, "startedAt"]);
-    const completedAt = decodeUtcMillis(valueAt(value, "completedAt"), [...path, "completedAt"]);
-    const slots = decodeArray(valueAt(value, "expectedSlots"), [...path, "expectedSlots"], decodeSlotId);
-    if (effect_1.Either.isLeft(runId))
-        return effect_1.Either.left(runId.left);
-    if (effect_1.Either.isLeft(experimentId))
-        return effect_1.Either.left(experimentId.left);
-    const context = decodeRunContext(valueAt(value, "context"), experimentId.right, [...path, "context"]);
-    if (effect_1.Either.isLeft(context))
-        return effect_1.Either.left(context.left);
-    if (effect_1.Either.isLeft(startedAt))
-        return effect_1.Either.left(startedAt.left);
-    if (effect_1.Either.isLeft(completedAt))
-        return effect_1.Either.left(completedAt.left);
-    if (effect_1.Either.isLeft(slots))
-        return effect_1.Either.left(slots.left);
-    return effect_1.Either.right(Object.freeze({
-        runId: runId.right,
-        experimentId: experimentId.right,
-        context: context.right,
-        startedAt: startedAt.right,
-        completedAt: completedAt.right,
-        expectedSlots: Object.freeze(uniqueSorted(slots.right)),
-    }));
-}
-function decodeRunContext(value, experimentId, path) {
-    if (value === null)
-        return effect_1.Either.right(null);
-    if (!isExactObject(value, ["execution", "labels"])) {
-        return effect_1.Either.left(codecError(path, "must contain exactly execution and labels"));
-    }
-    const decoded = (0, run_context_ts_1.canonicalizeRunContext)({
-        experimentId,
-        execution: valueAt(value, "execution"),
-        labels: valueAt(value, "labels"),
-    });
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "is not a valid closed Run context"))
-        : effect_1.Either.right(closeRunContext(decoded.right));
-}
-function decodeSlots(value, path) {
-    if (!Array.isArray(value))
-        return effect_1.Either.left(codecError(path, "must be an array"));
-    if (value.length > MAX_SLOTS)
-        return effect_1.Either.left(codecError(path, "exceeds the Slot limit"));
-    const slots = [];
-    const identities = new Set();
-    for (let index = 0; index < value.length; index += 1) {
-        const decoded = decodeSlot(value[index], [...path, String(index)], false);
-        if (effect_1.Either.isLeft(decoded))
-            return effect_1.Either.left(decoded.left);
-        const key = slotKey(decoded.right.runId, decoded.right.slotId);
-        if (identities.has(key))
-            return effect_1.Either.left(codecError([...path, String(index)], "duplicates a Run/Slot identity"));
-        identities.add(key);
-        slots.push(decoded.right);
-    }
-    return effect_1.Either.right(Object.freeze(slots.sort(compareSlots)));
-}
-/** A Snapshot Slot is a derived occurrence of exactly one closed AnalysisRun. */
-function validateSlotRunAlignment(runs, slots) {
-    const runsById = new Map(runs.map((run) => [run.runId, run]));
-    for (let index = 0; index < slots.length; index += 1) {
-        const slot = slots[index];
-        const run = runsById.get(slot.runId);
-        if (run === undefined) {
-            return codecError(["slots", String(index), "runId"], "does not identify a selected AnalysisRun");
-        }
-        if (run.experimentId !== slot.experimentId) {
-            return codecError(["slots", String(index), "experimentId"], "does not match the associated AnalysisRun");
-        }
-        if (!run.expectedSlots.includes(slot.slotId)) {
-            return codecError(["slots", String(index), "slotId"], "does not belong to the associated AnalysisRun");
-        }
-    }
-    return undefined;
-}
-function decodeSlot(value, path, nested) {
-    if (!isPlainObject(value))
-        return effect_1.Either.left(codecError(path, "must be an object"));
-    const state = valueAt(value, "state");
-    if (state === "excluded") {
-        const hasReason = Object.prototype.hasOwnProperty.call(value, "reason");
-        const expectedKeys = hasReason
-            ? ["runId", "slotId", "experimentId", "evalId", "attemptOrdinal", "executionIdentityDigest", "state", "base", "reason"]
-            : ["runId", "slotId", "experimentId", "evalId", "attemptOrdinal", "executionIdentityDigest", "state", "base"];
-        if (nested || !isExactObject(value, expectedKeys)) {
-            return effect_1.Either.left(codecError(path, "excluded Slots must contain exactly runId, slotId, state, base, and optional reason"));
-        }
-        const runId = decodeRunId(valueAt(value, "runId"), [...path, "runId"]);
-        const slotId = decodeSlotId(valueAt(value, "slotId"), [...path, "slotId"]);
-        const experimentId = decodeExperimentId(valueAt(value, "experimentId"), [...path, "experimentId"]);
-        const evalId = decodeEvalId(valueAt(value, "evalId"), [...path, "evalId"]);
-        const attemptOrdinal = decodeAttemptOrdinal(valueAt(value, "attemptOrdinal"), [...path, "attemptOrdinal"]);
-        const executionIdentityDigest = decodeExecutionIdentityDigest(valueAt(value, "executionIdentityDigest"), [...path, "executionIdentityDigest"]);
-        const base = decodeSlot(valueAt(value, "base"), [...path, "base"], true);
-        if (effect_1.Either.isLeft(runId))
-            return effect_1.Either.left(runId.left);
-        if (effect_1.Either.isLeft(slotId))
-            return effect_1.Either.left(slotId.left);
-        if (effect_1.Either.isLeft(experimentId))
-            return effect_1.Either.left(experimentId.left);
-        if (effect_1.Either.isLeft(evalId))
-            return effect_1.Either.left(evalId.left);
-        if (effect_1.Either.isLeft(attemptOrdinal))
-            return effect_1.Either.left(attemptOrdinal.left);
-        if (effect_1.Either.isLeft(executionIdentityDigest))
-            return effect_1.Either.left(executionIdentityDigest.left);
-        if (effect_1.Either.isLeft(base))
-            return effect_1.Either.left(base.left);
-        if (base.right.state === "excluded"
-            || base.right.runId !== runId.right
-            || base.right.slotId !== slotId.right
-            || base.right.experimentId !== experimentId.right
-            || base.right.evalId !== evalId.right
-            || base.right.attemptOrdinal !== attemptOrdinal.right
-            || base.right.executionIdentityDigest !== executionIdentityDigest.right) {
-            return effect_1.Either.left(codecError(path, "excluded base must be a matching active Slot"));
-        }
-        if (hasReason && valueAt(value, "reason") !== "identity-mismatch") {
-            return effect_1.Either.left(codecError([...path, "reason"], "must be identity-mismatch"));
-        }
-        return effect_1.Either.right(Object.freeze({
-            runId: runId.right,
-            slotId: slotId.right,
-            experimentId: experimentId.right,
-            evalId: evalId.right,
-            attemptOrdinal: attemptOrdinal.right,
-            executionIdentityDigest: executionIdentityDigest.right,
-            state,
-            base: base.right,
-            ...(hasReason ? { reason: "identity-mismatch" } : {}),
-        }));
-    }
-    const runId = decodeRunId(valueAt(value, "runId"), [...path, "runId"]);
-    const slotId = decodeSlotId(valueAt(value, "slotId"), [...path, "slotId"]);
-    const experimentId = decodeExperimentId(valueAt(value, "experimentId"), [...path, "experimentId"]);
-    const evalId = decodeEvalId(valueAt(value, "evalId"), [...path, "evalId"]);
-    const attemptOrdinal = decodeAttemptOrdinal(valueAt(value, "attemptOrdinal"), [...path, "attemptOrdinal"]);
-    const executionIdentityDigest = decodeExecutionIdentityDigest(valueAt(value, "executionIdentityDigest"), [...path, "executionIdentityDigest"]);
-    if (effect_1.Either.isLeft(runId))
-        return effect_1.Either.left(runId.left);
-    if (effect_1.Either.isLeft(slotId))
-        return effect_1.Either.left(slotId.left);
-    if (effect_1.Either.isLeft(experimentId))
-        return effect_1.Either.left(experimentId.left);
-    if (effect_1.Either.isLeft(evalId))
-        return effect_1.Either.left(evalId.left);
-    if (effect_1.Either.isLeft(attemptOrdinal))
-        return effect_1.Either.left(attemptOrdinal.left);
-    if (effect_1.Either.isLeft(executionIdentityDigest))
-        return effect_1.Either.left(executionIdentityDigest.left);
-    if (state === "included") {
-        if (!isExactObject(value, ["runId", "slotId", "experimentId", "evalId", "attemptOrdinal", "executionIdentityDigest", "state", "action", "relation", "attempt"])) {
-            return effect_1.Either.left(codecError(path, "included Slots contain unsupported fields"));
-        }
-        const action = valueAt(value, "action");
-        const relation = valueAt(value, "relation");
-        const attempt = decodeAttemptIdentity(valueAt(value, "attempt"), [...path, "attempt"]);
-        if ((action !== "executed" && action !== "carried" && action !== "accepted") || (relation !== "origin" && relation !== "reference")) {
-            return effect_1.Either.left(codecError(path, "included Slot has an invalid Member action or relation"));
-        }
-        if (effect_1.Either.isLeft(attempt))
-            return effect_1.Either.left(attempt.left);
-        return effect_1.Either.right(Object.freeze({
-            runId: runId.right,
-            slotId: slotId.right,
-            experimentId: experimentId.right,
-            evalId: evalId.right,
-            attemptOrdinal: attemptOrdinal.right,
-            executionIdentityDigest: executionIdentityDigest.right,
-            state,
-            action,
-            relation,
-            attempt: attempt.right,
-        }));
-    }
-    if (state === "not-recorded") {
-        if (!isExactObject(value, ["runId", "slotId", "experimentId", "evalId", "attemptOrdinal", "executionIdentityDigest", "state", "action", "attempt"]) || valueAt(value, "attempt") !== null) {
-            return effect_1.Either.left(codecError(path, "not-recorded Slots must retain a null Attempt"));
-        }
-        const action = valueAt(value, "action");
-        if (action !== null && action !== "not-dispatched" && action !== "interrupted") {
-            return effect_1.Either.left(codecError([...path, "action"], "is not a null Member action"));
-        }
-        return effect_1.Either.right(Object.freeze({
-            runId: runId.right,
-            slotId: slotId.right,
-            experimentId: experimentId.right,
-            evalId: evalId.right,
-            attemptOrdinal: attemptOrdinal.right,
-            executionIdentityDigest: executionIdentityDigest.right,
-            state,
-            action,
-            attempt: null,
-        }));
-    }
-    if (state === "core-invalid") {
-        if (!isExactObject(value, ["runId", "slotId", "experimentId", "evalId", "attemptOrdinal", "executionIdentityDigest", "state", "action", "attempt", "issues"]) || valueAt(value, "attempt") !== null) {
-            return effect_1.Either.left(codecError(path, "core-invalid Slots must contain null Attempt and issues"));
-        }
-        const action = valueAt(value, "action");
-        if (action !== null && action !== "executed" && action !== "carried" && action !== "accepted" && action !== "not-dispatched" && action !== "interrupted") {
-            return effect_1.Either.left(codecError([...path, "action"], "is not a Member action"));
-        }
-        const issues = decodeIssues(valueAt(value, "issues"), [...path, "issues"]);
-        if (effect_1.Either.isLeft(issues))
-            return effect_1.Either.left(issues.left);
-        return effect_1.Either.right(Object.freeze({
-            runId: runId.right,
-            slotId: slotId.right,
-            experimentId: experimentId.right,
-            evalId: evalId.right,
-            attemptOrdinal: attemptOrdinal.right,
-            executionIdentityDigest: executionIdentityDigest.right,
-            state,
-            action,
-            attempt: null,
-            issues: issues.right,
-        }));
-    }
-    return effect_1.Either.left(codecError([...path, "state"], "must be included, not-recorded, core-invalid, or excluded"));
-}
-function decodeAttemptIdentity(value, path) {
-    if (!isExactObject(value, ["kind", "locator", "originRunId"]) || valueAt(value, "kind") !== "attempt") {
-        return effect_1.Either.left(codecError(path, "must contain an Attempt locator identity"));
-    }
-    const locator = valueAt(value, "locator");
-    const originRunId = decodeRunId(valueAt(value, "originRunId"), [...path, "originRunId"]);
-    if (typeof locator !== "string" || !(0, attempt_locator_ts_1.parseAttemptLocator)(locator).valid) {
-        return effect_1.Either.left(codecError([...path, "locator"], "is not a canonical Attempt locator"));
-    }
-    return effect_1.Either.isLeft(originRunId)
-        ? effect_1.Either.left(originRunId.left)
-        : effect_1.Either.right(Object.freeze({ kind: "attempt", locator: locator, originRunId: originRunId.right }));
-}
-function decodeIssues(value, path) {
-    if (!Array.isArray(value))
-        return effect_1.Either.left(codecError(path, "must be an array"));
-    const issues = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const entry = value[index];
-        if (!isExactObject(entry, ["code", "message", "refs"]))
-            return effect_1.Either.left(codecError([...path, String(index)], "has unsupported fields"));
-        const code = valueAt(entry, "code");
-        const message = valueAt(entry, "message");
-        const refs = valueAt(entry, "refs");
-        if ((code !== "missing" && code !== "unsupported" && code !== "producer-incompatible" && code !== "input-invalid" && code !== "reduction-failed" && code !== "relation-unmatched") || typeof message !== "string" || !Array.isArray(refs)) {
-            return effect_1.Either.left(codecError([...path, String(index)], "is not a closed Analysis issue"));
-        }
-        const decodedRefs = [];
-        for (let refIndex = 0; refIndex < refs.length; refIndex += 1) {
-            const ref = refs[refIndex];
-            if (!isExactObject(ref, ["identity"]) || !isExactObject(valueAt(ref, "identity"), ["kind", "locator"])) {
-                return effect_1.Either.left(codecError([...path, String(index), "refs", String(refIndex)], "is not a closed evidence reference"));
-            }
-            const identity = valueAt(ref, "identity");
-            if (!isExactObject(identity, ["kind", "locator"])) {
-                return effect_1.Either.left(codecError([...path, String(index), "refs", String(refIndex)], "is not a closed evidence reference"));
-            }
-            const locator = valueAt(identity, "locator");
-            if (valueAt(identity, "kind") !== "attempt" || typeof locator !== "string" || !(0, attempt_locator_ts_1.parseAttemptLocator)(locator).valid) {
-                return effect_1.Either.left(codecError([...path, String(index), "refs", String(refIndex)], "has an invalid evidence locator"));
-            }
-            decodedRefs.push(Object.freeze({ identity: Object.freeze({ kind: "attempt", locator: locator }) }));
-        }
-        issues.push(Object.freeze({ code, message, refs: Object.freeze(decodedRefs) }));
-    }
-    return effect_1.Either.right(Object.freeze(issues));
-}
-function decodeArray(value, path, decode) {
-    if (!Array.isArray(value))
-        return effect_1.Either.left(codecError(path, "must be an array"));
-    const values = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const decoded = decode(value[index], [...path, String(index)]);
-        if (effect_1.Either.isLeft(decoded))
-            return effect_1.Either.left(decoded.left);
-        values.push(decoded.right);
-    }
-    return effect_1.Either.right(Object.freeze(values));
-}
-function decodeRunId(value, path) {
-    return decodeBrand(identifiers_ts_1.RunIdSchema, value, path, "a RunId");
-}
-function decodeSlotId(value, path) {
-    return decodeBrand(identifiers_ts_1.SlotIdSchema, value, path, "a SlotId");
-}
-function decodeEvalId(value, path) {
-    return decodeBrand(identifiers_ts_1.EvalIdSchema, value, path, "an EvalId");
-}
-function decodeAttemptOrdinal(value, path) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
-        ? effect_1.Either.right(value)
-        : effect_1.Either.left(codecError(path, "must be a zero-based non-negative safe attempt ordinal"));
-}
-function decodeExecutionIdentityDigest(value, path) {
-    return decodeBrand(identifiers_ts_1.ExecutionIdentityDigestSchema, value, path, "an execution identity digest");
-}
-function decodeExperimentId(value, path) {
-    return decodeBrand(identifiers_ts_1.ExperimentIdSchema, value, path, "an ExperimentId");
-}
-function decodeUtcMillis(value, path) {
-    return decodeBrand(identifiers_ts_1.UtcMillisSchema, value, path, "a UTC millisecond value");
-}
-function decodeBrand(schema, value, path, label) {
-    const decoded = effect_1.Schema.decodeUnknownEither(schema)(value);
-    return effect_1.Either.isLeft(decoded) ? effect_1.Either.left(codecError(path, `must be ${label}`)) : effect_1.Either.right(decoded.right);
-}
-function uniqueSorted(values) {
-    return Object.freeze([...new Set(values)].sort(identifiers_ts_2.compareCanonicalIdentity));
-}
 function uniqueSortedBy(values, key) {
     const byKey = new Map();
     for (const value of values) {
@@ -1027,19 +835,16 @@ function uniqueSortedBy(values, key) {
         .sort(([left], [right]) => (0, identifiers_ts_2.compareCanonicalIdentity)(left, right))
         .map(([, value]) => value));
 }
-function sameIdentity(value, expected) {
-    return isExactObject(value, ["kind", "id"])
-        && valueAt(value, "kind") === expected.kind
-        && valueAt(value, "id") === expected.id;
+function uniqueSorted(values) {
+    return Object.freeze([...new Set(values)].sort(identifiers_ts_2.compareCanonicalIdentity));
 }
 function sameCoverage(value, expected) {
-    return isExactObject(value, ["frameTotal", "selected", "included", "notRecorded", "coreInvalid", "excluded"])
-        && valueAt(value, "frameTotal") === expected.frameTotal
-        && valueAt(value, "selected") === expected.selected
-        && valueAt(value, "included") === expected.included
-        && valueAt(value, "notRecorded") === expected.notRecorded
-        && valueAt(value, "coreInvalid") === expected.coreInvalid
-        && valueAt(value, "excluded") === expected.excluded;
+    return value.frameTotal === expected.frameTotal
+        && value.selected === expected.selected
+        && value.included === expected.included
+        && value.notRecorded === expected.notRecorded
+        && value.coreInvalid === expected.coreInvalid
+        && value.excluded === expected.excluded;
 }
 function codecException(error) {
     const exception = new Error(error.reason);
@@ -1056,19 +861,4 @@ function canonicalIdentity(value) {
         throw new Error("Sample identity input must be JSON-serializable");
     return `sample-v1:${encoded}`;
 }
-function isPlainObject(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function isExactObject(value, keys) {
-    if (!isPlainObject(value))
-        return false;
-    const actual = Reflect.ownKeys(value);
-    return actual.length === keys.length && actual.every((key) => typeof key === "string" && keys.includes(key));
-}
-function valueAt(value, key) {
-    return Reflect.get(value, key);
-}
 //# sourceMappingURL=analysis.cjs.map