niceeval 0.12.2-canary.31 → 0.13.0

package/dist/sample/analysis.cjs

@@ -1,1068 +1,1074 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExperimentIdSchema = exports.RecordHandleInvalid = void 0;
-exports.decodeAnalysisSample = decodeAnalysisSample;
-exports.encodeAnalysisSample = encodeAnalysisSample;
-exports.selectAnalysisSample = selectAnalysisSample;
-exports.selectExplicitRuns = selectExplicitRuns;
-exports.selectProjectCurrent = selectProjectCurrent;
-exports.narrowAnalysisSample = narrowAnalysisSample;
-exports.narrowAnalysisSampleHandle = narrowAnalysisSampleHandle;
-exports.resolveAnalysisSampleHandle = resolveAnalysisSampleHandle;
+exports.materializeSampleSnapshot = materializeSampleSnapshot;
+exports.narrowSampleSnapshot = narrowSampleSnapshot;
+exports.narrowSampleSnapshotByCurrentIdentity = narrowSampleSnapshotByCurrentIdentity;
+exports.encodeSampleSnapshot = encodeSampleSnapshot;
+exports.decodeSampleSnapshot = decodeSampleSnapshot;
+exports.decodeSampleSnapshotEither = decodeSampleSnapshotEither;
+exports.closeAnalysisRunExecution = closeAnalysisRunExecution;
 const effect_1 = require("effect");
+const attempt_locator_ts_1 = require("../attempt-locator.cjs");
 const identifiers_ts_1 = require("../record/codec/identifiers.cjs");
-const core_ts_1 = require("../record/codec/core.cjs");
 const identifiers_ts_2 = require("../record/model/identifiers.cjs");
-const record_errors_ts_1 = require("../record/errors/record-errors.cjs");
-const errors_ts_1 = require("../record/reader/errors.cjs");
-const internal_ts_1 = require("../record/reader/internal.cjs");
-const experiment_id_ts_1 = require("../eval/experiment-id.cjs");
-const eligibility_ts_1 = require("../eval/record/eligibility.cjs");
-var errors_ts_2 = require("../record/reader/errors.cjs");
-Object.defineProperty(exports, "RecordHandleInvalid", { enumerable: true, get: function () { return errors_ts_2.RecordHandleInvalid; } });
-var experiment_id_ts_2 = require("../eval/experiment-id.cjs");
-Object.defineProperty(exports, "ExperimentIdSchema", { enumerable: true, get: function () { return experiment_id_ts_2.ExperimentIdSchema; } });
-const analysisSampleHandleTypeId = Symbol("niceeval.analysis-sample-handle");
+const run_context_ts_1 = require("../record/model/run-context.cjs");
 const MAX_SELECTED_RUNS = 4096;
 const MAX_SLOTS = 250000;
-const CURRENT_INPUT_IDENTITY_DOMAIN = "niceeval.input/fingerprint-v1";
-const CURRENT_CONFIG_IDENTITY_DOMAIN = "niceeval.config/identity-v1";
-const handleBindings = new WeakMap();
-/** Exact, portable decode. The result is deeply frozen and canonically ordered. */
-function decodeAnalysisSample(input) {
-    if (!isExactObject(input, ["selection", "runs", "slots", "denominator"])) {
-        return effect_1.Either.left(codecError([], "must contain exactly selection, runs, slots, and denominator"));
+/**
+ * Reads only the selected Core needed to freeze the Sample denominator. Fixed
+ * family payloads, blobs, and physical paths are intentionally not touched.
+ */
+function materializeSampleSnapshot(input) {
+    return effect_1.Effect.gen(function* () {
+        const selection = selectionSummary(input.selectionRequest, input.selection);
+        const selected = [...input.selection.runRefs].sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.runId, right.runId));
+        if (selected.length > MAX_SELECTED_RUNS) {
+            return yield* effect_1.Effect.die(new Error("Sample selection exceeds the maximum selected Run count"));
+        }
+        const expectedByRun = expectedSlotsByRun(input.selection);
+        const factsByRun = runFactsByRun(input.selection);
+        const runs = [];
+        const slots = [];
+        const attemptsBySlot = new Map();
+        const slotIdentitiesBySlot = new Map();
+        for (const ref of selected) {
+            const facts = factsByRun.get(ref);
+            if (facts === undefined) {
+                return yield* effect_1.Effect.die(new Error("Record selection omitted closed facts for a selected Run"));
+            }
+            const expected = expectedSlotsForRun(ref, facts, expectedByRun.get(ref));
+            if (expected.length > MAX_SLOTS - slots.length) {
+                return yield* effect_1.Effect.die(new Error("Sample selection exceeds the maximum Slot count"));
+            }
+            const read = yield* input.reader.readRun(ref);
+            if (read.state !== "available") {
+                runs.push(closeRunFacts(facts));
+                for (const expectedSlot of expected) {
+                    slotIdentitiesBySlot.set(slotKey(ref.runId, expectedSlot.slot.slotId), expectedSlot.slot);
+                    slots.push(coreInvalidSlot(ref.runId, expectedSlot.experimentId, expectedSlot.slot, null, "the selected Run Core is unavailable"));
+                }
+                continue;
+            }
+            const run = read.value;
+            if (run.document.experimentId !== facts.experimentId) {
+                runs.push(closeRunFacts(facts));
+                for (const expectedSlot of expected) {
+                    slotIdentitiesBySlot.set(slotKey(ref.runId, expectedSlot.slot.slotId), expectedSlot.slot);
+                    slots.push(coreInvalidSlot(ref.runId, expectedSlot.experimentId, expectedSlot.slot, null, "the selected Run experimentId does not match its closed selection facts"));
+                }
+                continue;
+            }
+            runs.push(closeRun(run, expected.map((entry) => entry.slot)));
+            const members = membersBySlot(run);
+            for (const expectedSlot of expected) {
+                const slot = expectedSlot.slot;
+                slotIdentitiesBySlot.set(slotKey(ref.runId, slot.slotId), slot);
+                const materialized = materializeSlot({
+                    selectedRun: ref,
+                    experimentId: expectedSlot.experimentId,
+                    slot,
+                    members,
+                });
+                slots.push(materialized.slot);
+                if (materialized.attempt !== undefined) {
+                    attemptsBySlot.set(slotKey(materialized.slot.runId, materialized.slot.slotId), materialized.attempt);
+                }
+            }
+        }
+        const canonicalRuns = Object.freeze([...runs].sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.runId, right.runId)));
+        const canonicalSlots = Object.freeze([...slots].sort(compareSlots));
+        const snapshot = makeSnapshot({ selection, runs: canonicalRuns, slots: canonicalSlots });
+        return Object.freeze({
+            snapshot,
+            attemptsBySlot,
+            slotIdentitiesBySlot,
+        });
+    });
+}
+/** Synchronous, monotonic narrowing over an already-frozen snapshot. */
+function narrowSampleSnapshot(snapshot, selector) {
+    const runIds = normalizedSelectorIds(selector.runIds);
+    const slotIds = normalizedSelectorIds(selector.slotIds);
+    if (runIds === undefined && slotIds === undefined) {
+        return requestError("narrowSample needs at least one runIds or slotIds selector");
     }
-    const selection = decodeSelectionSummary(valueAt(input, "selection"), ["selection"]);
+    const slots = snapshot.slots.map((slot) => {
+        if (slot.state === "excluded")
+            return slot;
+        const runMatches = runIds === undefined || runIds.has(slot.runId);
+        const slotMatches = slotIds === undefined || slotIds.has(slot.slotId);
+        if (runMatches && slotMatches)
+            return slot;
+        return Object.freeze({
+            runId: slot.runId,
+            slotId: slot.slotId,
+            experimentId: slot.experimentId,
+            evalId: slot.evalId,
+            attemptOrdinal: slot.attemptOrdinal,
+            executionIdentityDigest: slot.executionIdentityDigest,
+            state: "excluded",
+            base: slot,
+        });
+    });
+    return makeSnapshot({
+        selection: snapshot.selection,
+        runs: snapshot.runs,
+        slots: Object.freeze(slots),
+    });
+}
+/**
+ * `project-current` identity narrowing. Empty matching ids exclude every
+ * active Slot; unmatched members become `excluded` with `identity-mismatch`.
+ */
+function narrowSampleSnapshotByCurrentIdentity(snapshot, matchingOccurrences) {
+    const keep = new Set(matchingOccurrences.map((occurrence) => slotKey(occurrence.runId, occurrence.slotId)));
+    const slots = snapshot.slots.map((slot) => {
+        if (slot.state === "excluded")
+            return slot;
+        if (keep.has(slotKey(slot.runId, slot.slotId)))
+            return slot;
+        return Object.freeze({
+            runId: slot.runId,
+            slotId: slot.slotId,
+            experimentId: slot.experimentId,
+            evalId: slot.evalId,
+            attemptOrdinal: slot.attemptOrdinal,
+            executionIdentityDigest: slot.executionIdentityDigest,
+            state: "excluded",
+            base: slot,
+            reason: "identity-mismatch",
+        });
+    });
+    return makeSnapshot({
+        selection: snapshot.selection,
+        runs: snapshot.runs,
+        slots: Object.freeze(slots),
+    });
+}
+/** The only portable Sample encoding; it has no selected Record references. */
+function encodeSampleSnapshot(snapshot) {
+    return snapshotJson(decodeSampleSnapshot(snapshot));
+}
+/** Exact decode, canonical ordering, coverage validation, and deep freeze. */
+function decodeSampleSnapshot(value) {
+    const decoded = decodeSampleSnapshotEither(value);
+    if (effect_1.Either.isLeft(decoded))
+        throw codecException(decoded.left);
+    return decoded.right;
+}
+/** @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 encodedRuns = valueAt(input, "runs");
-    if (!Array.isArray(encodedRuns))
-        return effect_1.Either.left(codecError(["runs"], "must be an array"));
-    if (encodedRuns.length > MAX_SELECTED_RUNS) {
-        return effect_1.Either.left(codecError(["runs"], "exceeds the selected-runs limit"));
+    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);
+    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)) {
+        return effect_1.Either.left(codecError(["identity"], "does not match the canonical frozen selection"));
     }
-    const runs = [];
-    for (let index = 0; index < encodedRuns.length; index += 1) {
-        const decodedRun = decodeAnalysisRun(encodedRuns[index], ["runs", String(index)]);
-        if (effect_1.Either.isLeft(decodedRun))
-            return effect_1.Either.left(decodedRun.left);
-        runs.push(decodedRun.right);
+    if (!sameCoverage(valueAt(value, "coverage"), snapshot.coverage)) {
+        return effect_1.Either.left(codecError(["coverage"], "does not satisfy the canonical coverage equations"));
     }
-    const encodedSlots = valueAt(input, "slots");
-    if (!Array.isArray(encodedSlots))
-        return effect_1.Either.left(codecError(["slots"], "must be an array"));
-    if (encodedSlots.length > MAX_SLOTS) {
-        return effect_1.Either.left(codecError(["slots"], "exceeds the slots limit"));
-    }
-    const slots = [];
-    for (let index = 0; index < encodedSlots.length; index += 1) {
-        const decodedSlot = decodeAnalysisSlot(encodedSlots[index], ["slots", String(index)]);
-        if (effect_1.Either.isLeft(decodedSlot))
-            return effect_1.Either.left(decodedSlot.left);
-        slots.push(decodedSlot.right);
+    return effect_1.Either.right(snapshot);
+}
+function expectedSlotsByRun(selection) {
+    const result = new Map();
+    for (const entry of selection.expectedSlots) {
+        const slots = result.get(entry.run);
+        if (slots === undefined)
+            result.set(entry.run, [entry]);
+        else
+            result.set(entry.run, [...slots, entry]);
     }
-    const denominator = valueAt(input, "denominator");
-    if (!isNonNegativeInteger(denominator)) {
-        return effect_1.Either.left(codecError(["denominator"], "must be a non-negative safe integer"));
+    for (const [ref, slots] of result) {
+        result.set(ref, Object.freeze([...slots].sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.slot.slotId, right.slot.slotId))));
     }
-    const sample = makeAnalysisSample(selection.right, runs, slots);
-    if (sample.denominator !== denominator) {
-        return effect_1.Either.left(codecError(["denominator"], "must equal the number of non-excluded slots"));
+    return result;
+}
+function runFactsByRun(selection) {
+    return new Map(selection.runFacts.map((facts) => [facts.run, facts]));
+}
+function expectedSlotsForRun(ref, facts, fromSelection) {
+    if (fromSelection !== undefined)
+        return fromSelection;
+    return Object.freeze(facts.expectedSlots.map((slot) => Object.freeze({
+        run: ref,
+        experimentId: facts.experimentId,
+        slot,
+    })));
+}
+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,
+        })),
+    ]);
+    if (request.policy === "explicit-runs") {
+        return Object.freeze({
+            policy: "explicit-runs",
+            runIds: uniqueSorted(request.runIds),
+            selectedRunIds,
+            problems,
+        });
     }
-    const integrity = validateSampleIntegrity(sample);
-    if (integrity !== undefined)
-        return effect_1.Either.left(integrity);
-    return effect_1.Either.right(sample);
-}
-/** Encoding shares the exact decoder so callers cannot emit a non-canonical sample. */
-function encodeAnalysisSample(sample) {
-    return decodeAnalysisSample(sample);
-}
-/** Selects a portable denominator from exactly the supplied frozen Record view. */
-function selectAnalysisSample(reader, request) {
-    return effect_1.Effect.suspend(() => {
-        const normalized = normalizeSelectionRequest(request);
-        return effect_1.Either.isLeft(normalized)
-            ? effect_1.Effect.fail(normalized.left)
-            : selectNormalizedAnalysisSample(reader, normalized.right);
+    const requestedExperimentIds = request.experimentIds === undefined
+        ? uniqueSorted(request.currentSlots.map((slot) => slot.experimentId))
+        : uniqueSorted(request.experimentIds);
+    return Object.freeze({
+        policy: "project-current",
+        experimentIds: requestedExperimentIds.length === 0 ? "all" : requestedExperimentIds,
+        selectedRunIds,
+        problems,
     });
 }
-/** Narrow entry point for the explicit completed-Run policy. */
-function selectExplicitRuns(reader, input) {
-    return effect_1.Effect.suspend(() => {
-        const runIds = normalizeExplicitRunIds(input);
-        return effect_1.Either.isLeft(runIds)
-            ? effect_1.Effect.fail(runIds.left)
-            : selectNormalizedAnalysisSample(reader, Object.freeze({ policy: "explicit-runs", runIds: runIds.right }));
-    });
+function normalizedSelectionProblems(values) {
+    const byKey = new Map();
+    for (const problem of values) {
+        byKey.set(`${problem.code}\u0000${problem.runId}`, Object.freeze({ ...problem }));
+    }
+    return Object.freeze([...byKey.entries()]
+        .sort(([left], [right]) => (0, identifiers_ts_2.compareCanonicalIdentity)(left, right))
+        .map(([, problem]) => problem));
 }
-/** Narrow entry point for results whose durable identities match the project target. */
-function selectProjectCurrent(reader, input) {
-    return effect_1.Effect.suspend(() => {
-        const normalized = normalizeProjectCurrentInput(input);
-        return effect_1.Either.isLeft(normalized)
-            ? effect_1.Effect.fail(normalized.left)
-            : selectNormalizedAnalysisSample(reader, Object.freeze({
-                policy: "project-current",
-                target: normalized.right.target,
-            }));
+function closeRun(run, expectedSlots) {
+    return Object.freeze({
+        runId: run.document.runId,
+        experimentId: run.document.experimentId,
+        context: closeRunContext(run.document.context),
+        startedAt: run.document.startedAt,
+        completedAt: run.document.completedAt,
+        expectedSlots: Object.freeze(expectedSlots.map((slot) => slot.slotId)),
     });
 }
-/** Pure, monotonic narrowing. It neither needs nor restores Record I/O. */
-function narrowAnalysisSample(sample, selector) {
-    const canonical = encodeAnalysisSample(sample);
-    if (effect_1.Either.isLeft(canonical)) {
-        return effect_1.Either.left(selectionInvalid("sample", canonical.left.reason));
-    }
-    const normalized = normalizeSelector(selector);
-    if (effect_1.Either.isLeft(normalized))
-        return effect_1.Either.left(normalized.left);
-    const slots = [];
-    for (const slot of canonical.right.slots) {
-        if (slot.state === "excluded") {
-            slots.push(copyAnalysisSlot(slot));
-            continue;
-        }
-        const base = copyBaseSlot(slot);
-        if (matchesSelector(base, normalized.right)) {
-            slots.push(base);
-        }
-        else {
-            slots.push(excludedSlot(base));
-        }
-    }
-    return effect_1.Either.right(makeAnalysisSample(canonical.right.selection, canonical.right.runs, slots));
+function closeRunFacts(facts) {
+    return Object.freeze({
+        runId: facts.run.runId,
+        experimentId: facts.experimentId,
+        context: null,
+        startedAt: facts.startedAt,
+        completedAt: facts.completedAt,
+        expectedSlots: Object.freeze(facts.expectedSlots.map((slot) => slot.slotId)),
+    });
 }
 /**
- * Live narrowing validates the authentic handle and its reader first. The new
- * handle remains bound to exactly the same frozen Record view.
+ * Context is Core, but Sample owns an independent value-only closure rather
+ * than retaining a reference to a Record read result. Canonical key ordering
+ * keeps the Snapshot identity stable before it reaches JSON encoding.
  */
-function narrowAnalysisSampleHandle(handle, selector) {
-    return effect_1.Effect.suspend(() => {
-        const binding = handleBindings.get(handle);
-        if (binding === undefined
-            || handle.sample !== binding.sample
-            || (0, internal_ts_1.resolveFrozenRecordReaderPort)(binding.reader) !== binding.port) {
-            return effect_1.Effect.fail(recordHandleInvalid());
-        }
-        return effect_1.Effect.gen(function* () {
-            yield* binding.port.assertOpen(binding.reader);
-            const narrowed = narrowAnalysisSample(binding.sample, selector);
-            if (effect_1.Either.isLeft(narrowed))
-                return yield* effect_1.Effect.fail(narrowed.left);
-            return makeHandle(binding.reader, binding.port, narrowed.right);
-        });
+function closeRunContext(context) {
+    return Object.freeze({
+        execution: closeAnalysisRunExecution(context.execution),
+        labels: closeStringRecord(context.labels),
     });
 }
 /**
- * @internal Projection consumes the exact frozen reader capability bound when
- * selection minted this handle. This is intentionally not a public Sample
- * export: a pure AnalysisSample can never recover Record I/O.
+ * Internal closure shared by selected-Run snapshot construction and the
+ * origin-Attempt projection. It copies only durable JSON facts; neither path,
+ * reader, nor mutable Record object escapes into Sample.
  */
-function resolveAnalysisSampleHandle(handle) {
-    return effect_1.Effect.suspend(() => {
-        const binding = handleBindings.get(handle);
-        if (binding === undefined
-            || handle.sample !== binding.sample
-            || (0, internal_ts_1.resolveFrozenRecordReaderPort)(binding.reader) !== binding.port) {
-            return effect_1.Effect.fail(recordHandleInvalid());
-        }
-        return effect_1.Effect.map(binding.port.assertOpen(binding.reader), () => Object.freeze({ reader: binding.reader, sample: binding.sample }));
+function closeAnalysisRunExecution(execution) {
+    return Object.freeze({
+        agentId: execution.agentId,
+        model: execution.model,
+        reasoningEffort: execution.reasoningEffort,
+        flags: closeJsonObject(execution.flags),
     });
 }
-function selectNormalizedAnalysisSample(reader, selection) {
-    return effect_1.Effect.suspend(() => {
-        const port = (0, internal_ts_1.resolveFrozenRecordReaderPort)(reader);
-        if (port === undefined)
-            return effect_1.Effect.fail(recordHandleInvalid());
-        return effect_1.Effect.gen(function* () {
-            yield* port.assertOpen(reader);
-            if (selection.policy === "explicit-runs") {
-                const runs = yield* selectExplicitRunsFromPort(reader, port, selection.runIds);
-                const summary = Object.freeze({
-                    policy: "explicit-runs",
-                    runIds: selection.runIds,
-                });
-                const sample = yield* materializeAnalysisSample(reader, port, summary, runs);
-                return makeHandle(reader, port, sample);
-            }
-            const sample = yield* selectProjectCurrentFromPort(reader, port, selection);
-            const summary = Object.freeze({
-                policy: "project-current",
-                experimentIds: selection.target.experiments.map((experiment) => experiment.id),
-                selectedRunIds: Object.freeze(sample.runs.map((run) => run.runId)),
-            });
-            return makeHandle(reader, port, makeAnalysisSample(summary, sample.runs, sample.slots));
+function closeStringRecord(value) {
+    const result = Object.create(null);
+    for (const key of Object.keys(value).sort(identifiers_ts_2.compareCanonicalIdentity)) {
+        Object.defineProperty(result, key, {
+            value: value[key],
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    return Object.freeze(result);
+}
+function closeJsonObject(value) {
+    const result = Object.create(null);
+    for (const key of Object.keys(value).sort(identifiers_ts_2.compareCanonicalIdentity)) {
+        Object.defineProperty(result, key, {
+            value: closeJsonValue(value[key]),
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    return Object.freeze(result);
+}
+function closeJsonValue(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value))
+        return Object.freeze(value.map(closeJsonValue));
+    if (isRunContextJsonObject(value))
+        return closeJsonObject(value);
+    throw new TypeError("RunContext JSON value must be an object after scalar and array cases");
+}
+function isRunContextJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function membersBySlot(run) {
+    const result = new Map();
+    for (const member of run.members) {
+        if (result.has(member.document.slotId))
+            result.set(member.document.slotId, "duplicate");
+        else
+            result.set(member.document.slotId, member);
+    }
+    return result;
+}
+function materializeSlot(input) {
+    const member = input.members.get(input.slot.slotId);
+    if (member === undefined) {
+        return Object.freeze({
+            slot: Object.freeze({
+                runId: input.selectedRun.runId,
+                slotId: input.slot.slotId,
+                experimentId: input.experimentId,
+                evalId: input.slot.evalId,
+                attemptOrdinal: input.slot.attemptOrdinal,
+                executionIdentityDigest: input.slot.executionIdentityDigest,
+                state: "not-recorded",
+                action: null,
+                attempt: null,
+            }),
+        });
+    }
+    if (member === "duplicate" || member.document.slotId !== input.slot.slotId) {
+        return Object.freeze({
+            slot: coreInvalidSlot(input.selectedRun.runId, input.experimentId, input.slot, null, "the Run has an invalid Member mapping"),
+        });
+    }
+    if (member.document.attempt === null) {
+        return Object.freeze({
+            slot: Object.freeze({
+                runId: input.selectedRun.runId,
+                slotId: input.slot.slotId,
+                experimentId: input.experimentId,
+                evalId: input.slot.evalId,
+                attemptOrdinal: input.slot.attemptOrdinal,
+                executionIdentityDigest: input.slot.executionIdentityDigest,
+                state: "not-recorded",
+                action: member.document.action,
+                attempt: null,
+            }),
+        });
+    }
+    if (member.attempt === null ||
+        member.document.attempt.originRunId !== member.attempt.originRunId ||
+        member.document.attempt.attemptId !== member.attempt.attemptId) {
+        return Object.freeze({
+            slot: coreInvalidSlot(input.selectedRun.runId, input.experimentId, input.slot, member.document.action, "the selected Member did not receive the exact Attempt capability"),
         });
+    }
+    const slot = Object.freeze({
+        runId: input.selectedRun.runId,
+        slotId: input.slot.slotId,
+        experimentId: input.experimentId,
+        evalId: input.slot.evalId,
+        attemptOrdinal: input.slot.attemptOrdinal,
+        executionIdentityDigest: input.slot.executionIdentityDigest,
+        state: "included",
+        action: member.document.action,
+        relation: member.attempt.originRunId === input.selectedRun.runId ? "origin" : "reference",
+        attempt: Object.freeze({
+            kind: "attempt",
+            locator: (0, attempt_locator_ts_1.encodeAttemptLocator)(member.attempt.attemptId),
+            originRunId: member.attempt.originRunId,
+        }),
     });
+    return Object.freeze({ slot, attempt: member.attempt });
 }
-function selectExplicitRunsFromPort(reader, port, runIds) {
-    return effect_1.Effect.gen(function* () {
-        const runs = [];
-        for (const runId of runIds) {
-            const read = yield* port.run(reader, runId);
-            if (read.state === "missing") {
-                return yield* effect_1.Effect.fail(runNotFound(runId));
-            }
-            if (read.state === "core-invalid") {
-                return yield* effect_1.Effect.fail(runInvalid(runId, read.issues));
-            }
-            runs.push(read.value);
-        }
-        return Object.freeze(runs);
+function coreInvalidSlot(runId, experimentId, slot, action, message) {
+    return Object.freeze({
+        runId,
+        slotId: slot.slotId,
+        experimentId,
+        evalId: slot.evalId,
+        attemptOrdinal: slot.attemptOrdinal,
+        executionIdentityDigest: slot.executionIdentityDigest,
+        state: "core-invalid",
+        action,
+        attempt: null,
+        issues: Object.freeze([analysisIssue("input-invalid", message)]),
     });
 }
-function selectProjectCurrentFromPort(reader, port, selection) {
-    const targets = new Map(selection.target.experiments.map((experiment) => [
-        experiment.id,
-        Object.freeze({
-            attempts: experiment.attempts,
-            evals: new Map(experiment.evals.map((evaluation) => [evaluation.id, evaluation])),
-        }),
-    ]));
-    return effect_1.Stream.runFoldEffect(port.candidates(reader), { byRun: new Map(), slotCount: 0 }, (matches, candidate) => collectProjectCurrentCandidate(reader, port, targets, matches, candidate)).pipe(effect_1.Effect.flatMap((matches) => materializeProjectCurrentMatches(matches)));
+function makeSnapshot(input) {
+    const runs = Object.freeze([...input.runs].sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.runId, right.runId)));
+    const slots = Object.freeze([...input.slots].sort(compareSlots));
+    const canonicalSelection = selectionForSlots(input.selection, slots);
+    const coverage = coverageFor(slots);
+    return Object.freeze({
+        version: 1,
+        identity: sampleIdentity(canonicalSelection, runs, slots),
+        selection: canonicalSelection,
+        runs,
+        slots,
+        coverage,
+    });
 }
-function collectProjectCurrentCandidate(reader, port, targets, matches, candidate) {
-    return effect_1.Effect.gen(function* () {
-        // Project-current is a conservative filter. A candidate whose Core or
-        // identity facts cannot be proved contributes nothing, but does not hide
-        // a different Run whose durable identities do match.
-        if (candidate.state !== "available")
-            return matches;
-        const attachment = yield* port.readRunAttachment(reader, candidate.value, experiment_id_ts_1.evaluationsAttachmentFamily);
-        if (attachment.state !== "available")
-            return matches;
-        const experimentId = attachment.value.payload.experimentId;
-        const target = targets.get(experimentId);
-        if (target === undefined)
-            return matches;
-        const expectedSlots = new Set(candidate.value.expectedSlots);
-        if (expectedSlots.size !== candidate.value.expectedSlots.length)
-            return matches;
-        const matchedSlots = [];
-        for (const evaluation of attachment.value.payload.evaluations) {
-            const evalTarget = target.evals.get(evaluation.evalId);
-            if (evalTarget === undefined
-                || evalTarget.evaluationKind !== evaluation.evaluationKind)
-                continue;
-            for (const slot of evaluation.slots) {
-                if (slot.attempt >= target.attempts
-                    || !expectedSlots.has(slot.slotId))
-                    continue;
-                const member = yield* port.member(reader, candidate.value, slot.slotId);
-                if (member.state !== "available"
-                    || member.value.slotId !== slot.slotId)
-                    continue;
-                const attempt = yield* port.attempt(reader, member.value.attempt);
-                if (attempt.state !== "available"
-                    || attempt.value.originRunId !== member.value.attempt.originRunId
-                    || attempt.value.attemptId !== member.value.attempt.attemptId)
-                    continue;
-                const eligibility = yield* port.readAttemptAttachment(reader, attempt.value, eligibility_ts_1.eligibilityAttachmentFamilyV1);
-                if (eligibility.state !== "available")
-                    continue;
-                const facts = eligibility.value.payload;
-                if (facts.inputIdentity.domain !== CURRENT_INPUT_IDENTITY_DOMAIN
-                    || facts.inputIdentity.value !== evalTarget.fingerprint
-                    || facts.configIdentity.domain !== CURRENT_CONFIG_IDENTITY_DOMAIN
-                    || facts.configIdentity.value !== evalTarget.resultConfigHash)
-                    continue;
-                matchedSlots.push(Object.freeze({
-                    run: candidate.value,
-                    slotId: slot.slotId,
-                    attempt: copyAttemptRef(member.value.attempt),
-                    relation: attempt.value.originRunId === candidate.value.runId
-                        ? "origin"
-                        : "reference",
-                }));
-            }
-        }
-        if (matchedSlots.length === 0)
-            return matches;
-        const previous = matches.byRun.get(candidate.value.runId);
-        if (previous === undefined && matches.byRun.size >= MAX_SELECTED_RUNS) {
-            return yield* effect_1.Effect.fail(selectionLimit("selected-runs", matches.byRun.size + 1));
-        }
-        const nextSlotCount = matches.slotCount
-            - (previous?.slots.length ?? 0)
-            + matchedSlots.length;
-        if (nextSlotCount > MAX_SLOTS) {
-            return yield* effect_1.Effect.fail(selectionLimit("slots", nextSlotCount));
-        }
-        matches.byRun.set(candidate.value.runId, {
-            run: candidate.value,
-            slots: matchedSlots,
+/** Every derived Sample retains its source policy and refreshes its active result. */
+function selectionForSlots(selection, slots) {
+    const selectedRunIds = uniqueSorted(slots.flatMap((slot) => slot.state === "excluded" ? [] : [slot.runId]));
+    const problems = normalizedSelectionProblems(selection.problems);
+    if (selection.policy === "explicit-runs") {
+        return Object.freeze({
+            policy: "explicit-runs",
+            runIds: uniqueSorted(selection.runIds),
+            selectedRunIds,
+            problems,
         });
-        matches.slotCount = nextSlotCount;
-        return matches;
+    }
+    return Object.freeze({
+        policy: "project-current",
+        experimentIds: selection.experimentIds === "all"
+            ? "all"
+            : uniqueSorted(selection.experimentIds),
+        selectedRunIds,
+        problems,
     });
 }
-function materializeProjectCurrentMatches(matches) {
-    const runs = [];
-    const slots = [];
-    for (const [runId, bucket] of [...matches.byRun].sort(([left], [right]) => (0, identifiers_ts_2.compareCanonicalIdentity)(left, right))) {
-        const runSlots = [...bucket.slots].sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.slotId, right.slotId));
-        runs.push(Object.freeze({
-            runId,
-            startedAt: bucket.run.startedAt,
-            completedAt: bucket.run.completedAt,
-            expectedSlots: Object.freeze(runSlots.map((entry) => entry.slotId)),
-        }));
-        for (const entry of runSlots) {
-            slots.push(Object.freeze({
-                runId,
-                slotId: entry.slotId,
-                state: "included",
-                relation: entry.relation,
-                attempt: entry.attempt,
-            }));
+function coverageFor(slots) {
+    let selected = 0;
+    let included = 0;
+    let notRecorded = 0;
+    let coreInvalid = 0;
+    let excluded = 0;
+    for (const slot of slots) {
+        if (slot.state === "excluded") {
+            excluded += 1;
+            continue;
         }
+        selected += 1;
+        if (slot.state === "included")
+            included += 1;
+        else if (slot.state === "not-recorded")
+            notRecorded += 1;
+        else
+            coreInvalid += 1;
     }
-    return effect_1.Effect.succeed(Object.freeze({
-        runs: Object.freeze(runs),
-        slots: Object.freeze(slots),
-    }));
+    return Object.freeze({
+        frameTotal: slots.length,
+        selected,
+        included,
+        notRecorded,
+        coreInvalid,
+        excluded,
+    });
 }
-function materializeAnalysisSample(reader, port, selection, selectedRuns) {
-    return effect_1.Effect.gen(function* () {
-        const runs = [...selectedRuns].sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.runId, right.runId));
-        if (runs.length > MAX_SELECTED_RUNS) {
-            return yield* effect_1.Effect.fail(selectionLimit("selected-runs", runs.length));
-        }
-        const analysisRuns = [];
-        const slots = [];
-        let slotCount = 0;
-        for (const run of runs) {
-            const expectedSlots = sortedUnique(run.expectedSlots);
-            if (expectedSlots.length !== run.expectedSlots.length) {
-                return yield* effect_1.Effect.fail(runInvalid(run.runId, singleRecordIssue("record-expected-slot-duplicate", ["runs", run.runId])));
-            }
-            if (slotCount > MAX_SLOTS - expectedSlots.length) {
-                return yield* effect_1.Effect.fail(selectionLimit("slots", slotCount + expectedSlots.length));
-            }
-            slotCount += expectedSlots.length;
-            analysisRuns.push(Object.freeze({
-                runId: run.runId,
-                startedAt: run.startedAt,
-                completedAt: run.completedAt,
-                expectedSlots: Object.freeze(expectedSlots),
-            }));
-            for (const slotId of expectedSlots) {
-                slots.push(yield* materializeAnalysisSlot(reader, port, run, slotId));
-            }
-        }
-        return makeAnalysisSample(selection, analysisRuns, slots);
+function sampleIdentity(selection, runs, slots) {
+    return Object.freeze({
+        kind: "analysis-sample",
+        id: canonicalIdentity({ selection, runs, slots }),
     });
 }
-function materializeAnalysisSlot(reader, port, run, slotId) {
-    return effect_1.Effect.gen(function* () {
-        const member = yield* port.member(reader, run, slotId);
-        if (member.state === "missing") {
-            return Object.freeze({ runId: run.runId, slotId, state: "not-recorded" });
-        }
-        if (member.state === "core-invalid") {
-            return coreInvalidSlot(run.runId, slotId, member.issues);
-        }
-        if (member.value.slotId !== slotId) {
-            return coreInvalidSlot(run.runId, slotId, singleRecordIssue("record-member-slot-unexpected", ["members", slotId]));
-        }
-        const attempt = yield* port.attempt(reader, member.value.attempt);
-        if (attempt.state === "missing") {
-            return coreInvalidSlot(run.runId, slotId, singleRecordIssue("record-attempt-reference-missing", ["members", slotId, "attempt"]));
-        }
-        if (attempt.state === "core-invalid") {
-            return coreInvalidSlot(run.runId, slotId, attempt.issues);
-        }
-        if (attempt.value.originRunId !== member.value.attempt.originRunId
-            || attempt.value.attemptId !== member.value.attempt.attemptId) {
-            return coreInvalidSlot(run.runId, slotId, singleRecordIssue("record-attempt-owner-invalid", ["members", slotId, "attempt"]));
-        }
-        return Object.freeze({
+function compareSlots(left, right) {
+    const run = (0, identifiers_ts_2.compareCanonicalIdentity)(left.runId, right.runId);
+    return run === 0 ? (0, identifiers_ts_2.compareCanonicalIdentity)(left.slotId, right.slotId) : run;
+}
+function slotKey(runId, slotId) {
+    return `${runId}\u0000${slotId}`;
+}
+function normalizedSelectorIds(values) {
+    if (values === undefined)
+        return undefined;
+    return new Set(values);
+}
+function requestError(reason) {
+    return Object.freeze({ code: "analysis-request-invalid", reason });
+}
+function analysisIssue(code, message) {
+    return Object.freeze({ code, message, refs: Object.freeze([]) });
+}
+function snapshotJson(snapshot) {
+    return Object.freeze({
+        version: snapshot.version,
+        identity: Object.freeze({ kind: snapshot.identity.kind, id: snapshot.identity.id }),
+        selection: selectionJson(snapshot.selection),
+        runs: Object.freeze(snapshot.runs.map((run) => Object.freeze({
             runId: run.runId,
-            slotId,
-            state: "included",
-            relation: attempt.value.originRunId === run.runId ? "origin" : "reference",
-            attempt: copyAttemptRef(member.value.attempt),
-        });
+            experimentId: run.experimentId,
+            context: run.context === null ? null : Object.freeze({
+                execution: Object.freeze({
+                    agentId: run.context.execution.agentId,
+                    model: run.context.execution.model,
+                    reasoningEffort: run.context.execution.reasoningEffort,
+                    flags: closeJsonObject(run.context.execution.flags),
+                }),
+                labels: closeStringRecord(run.context.labels),
+            }),
+            startedAt: run.startedAt,
+            completedAt: run.completedAt,
+            expectedSlots: Object.freeze([...run.expectedSlots]),
+        }))),
+        slots: Object.freeze(snapshot.slots.map(slotJson)),
+        coverage: Object.freeze({ ...snapshot.coverage }),
     });
 }
-function normalizeSelectionRequest(input) {
-    if (!isExactObject(input, ["policy", "input"]) || !hasOwnProperty(input, "policy") || !hasOwnProperty(input, "input")) {
-        return effect_1.Either.left(selectionInvalid("request", "must contain exactly policy and input"));
-    }
-    const policy = valueAt(input, "policy");
-    if (policy === "explicit-runs") {
-        const runIds = normalizeExplicitRunIds(valueAt(input, "input"));
-        return effect_1.Either.isLeft(runIds)
-            ? effect_1.Either.left(runIds.left)
-            : effect_1.Either.right(Object.freeze({ policy, runIds: runIds.right }));
-    }
-    if (policy === "project-current") {
-        const normalized = normalizeProjectCurrentInput(valueAt(input, "input"));
-        return effect_1.Either.isLeft(normalized)
-            ? effect_1.Either.left(normalized.left)
-            : effect_1.Either.right(Object.freeze({
-                policy,
-                target: normalized.right.target,
-            }));
+function selectionJson(selection) {
+    const problems = Object.freeze(selection.problems.map((problem) => Object.freeze({ ...problem })));
+    if (selection.policy === "explicit-runs") {
+        return Object.freeze({
+            policy: selection.policy,
+            runIds: Object.freeze([...selection.runIds]),
+            selectedRunIds: Object.freeze([...selection.selectedRunIds]),
+            problems,
+        });
     }
-    return effect_1.Either.left(selectionInvalid("request.policy", "must be explicit-runs or project-current"));
+    return Object.freeze({
+        policy: selection.policy,
+        experimentIds: selection.experimentIds === "all"
+            ? "all"
+            : Object.freeze([...selection.experimentIds]),
+        selectedRunIds: Object.freeze([...selection.selectedRunIds]),
+        problems,
+    });
 }
-function normalizeExplicitRunIds(input) {
-    if (!isExactObject(input, ["runIds"]) || !hasOwnProperty(input, "runIds")) {
-        return effect_1.Either.left(selectionInvalid("input", "must contain exactly runIds"));
-    }
-    const encodedRunIds = valueAt(input, "runIds");
-    if (!Array.isArray(encodedRunIds) || encodedRunIds.length === 0) {
-        return effect_1.Either.left(selectionInvalid("input.runIds", "must be a non-empty array"));
-    }
-    const runIds = [];
-    for (let index = 0; index < encodedRunIds.length; index += 1) {
-        const runId = decodeRunId(encodedRunIds[index], ["input", "runIds", String(index)]);
-        if (effect_1.Either.isLeft(runId)) {
-            return effect_1.Either.left(selectionInvalid(`input.runIds.${index}`, runId.left.reason));
-        }
-        runIds.push(runId.right);
-    }
-    const normalized = sortedUnique(runIds);
-    return normalized.length > MAX_SELECTED_RUNS
-        ? effect_1.Either.left(selectionLimit("selected-runs", normalized.length))
-        : effect_1.Either.right(Object.freeze(normalized));
-}
-function normalizeProjectCurrentInput(input) {
-    if (!isExactObject(input, ["target"]) || !hasOwnProperty(input, "target")) {
-        return effect_1.Either.left(selectionInvalid("input", "must contain exactly target"));
-    }
-    const rawTarget = valueAt(input, "target");
-    if (typeof rawTarget !== "object" || rawTarget === null) {
-        return effect_1.Either.left(selectionInvalid("input.target", "must be a project target object"));
+function slotJson(slot) {
+    if (slot.state === "excluded") {
+        return Object.freeze({
+            runId: slot.runId,
+            slotId: slot.slotId,
+            experimentId: slot.experimentId,
+            evalId: slot.evalId,
+            attemptOrdinal: slot.attemptOrdinal,
+            executionIdentityDigest: slot.executionIdentityDigest,
+            state: slot.state,
+            base: slotJson(slot.base),
+            ...(slot.reason === undefined ? {} : { reason: slot.reason }),
+        });
     }
-    const encodedExperiments = Reflect.get(rawTarget, "experiments");
-    if (!Array.isArray(encodedExperiments) || encodedExperiments.length === 0) {
-        return effect_1.Either.left(selectionInvalid("input.target.experiments", "must be a non-empty array"));
+    if (slot.state === "included") {
+        return Object.freeze({
+            runId: slot.runId,
+            slotId: slot.slotId,
+            experimentId: slot.experimentId,
+            evalId: slot.evalId,
+            attemptOrdinal: slot.attemptOrdinal,
+            executionIdentityDigest: slot.executionIdentityDigest,
+            state: slot.state,
+            action: slot.action,
+            relation: slot.relation,
+            attempt: Object.freeze({ ...slot.attempt }),
+        });
     }
-    const experiments = [];
-    const seenExperiments = new Set();
-    for (let experimentIndex = 0; experimentIndex < encodedExperiments.length; experimentIndex += 1) {
-        const rawExperiment = encodedExperiments[experimentIndex];
-        if (typeof rawExperiment !== "object" || rawExperiment === null) {
-            return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}`, "must be an object"));
-        }
-        const id = Reflect.get(rawExperiment, "id");
-        const attempts = Reflect.get(rawExperiment, "attempts");
-        const rawEvals = Reflect.get(rawExperiment, "evals");
-        const decodedId = decodeExperimentId(id, ["input", "target", "experiments", String(experimentIndex), "id"]);
-        if (effect_1.Either.isLeft(decodedId)) {
-            return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.id`, decodedId.left.reason));
-        }
-        if (seenExperiments.has(decodedId.right)) {
-            return effect_1.Either.left(selectionInvalid("input.target.experiments", "must contain unique ExperimentIds"));
-        }
-        if (!Number.isSafeInteger(attempts) || attempts < 1) {
-            return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.attempts`, "must be a positive integer"));
-        }
-        if (!Array.isArray(rawEvals) || rawEvals.length === 0) {
-            return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.evals`, "must be a non-empty array"));
-        }
-        const evals = [];
-        const seenEvals = new Set();
-        for (let evalIndex = 0; evalIndex < rawEvals.length; evalIndex += 1) {
-            const rawEval = rawEvals[evalIndex];
-            if (typeof rawEval !== "object" || rawEval === null) {
-                return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.evals.${evalIndex}`, "must be an object"));
-            }
-            const evalId = Reflect.get(rawEval, "id");
-            const resultConfigHash = Reflect.get(rawEval, "resultConfigHash");
-            const fingerprint = Reflect.get(rawEval, "fingerprint");
-            const evaluationKind = Reflect.get(rawEval, "evaluationKind");
-            if (typeof evalId !== "string" || evalId.length === 0 || evalId.includes("\u0000") || seenEvals.has(evalId)) {
-                return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.evals.${evalIndex}.id`, "must be a unique non-empty EvalId"));
-            }
-            if (typeof resultConfigHash !== "string" || resultConfigHash.length === 0) {
-                return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.evals.${evalIndex}.resultConfigHash`, "must be non-empty"));
-            }
-            if (typeof fingerprint !== "string" || fingerprint.length === 0) {
-                return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.evals.${evalIndex}.fingerprint`, "must be non-empty"));
-            }
-            if (evaluationKind !== "pass" && evaluationKind !== "score") {
-                return effect_1.Either.left(selectionInvalid(`input.target.experiments.${experimentIndex}.evals.${evalIndex}.evaluationKind`, "must be pass or score"));
-            }
-            seenEvals.add(evalId);
-            evals.push(Object.freeze({ id: evalId, resultConfigHash, fingerprint, evaluationKind }));
-        }
-        seenExperiments.add(decodedId.right);
-        experiments.push(Object.freeze({
-            id: decodedId.right,
-            attempts: attempts,
-            evals: Object.freeze(evals.sort((left, right) => left.id.localeCompare(right.id))),
-        }));
+    if (slot.state === "not-recorded") {
+        return Object.freeze({
+            runId: slot.runId,
+            slotId: slot.slotId,
+            experimentId: slot.experimentId,
+            evalId: slot.evalId,
+            attemptOrdinal: slot.attemptOrdinal,
+            executionIdentityDigest: slot.executionIdentityDigest,
+            state: slot.state,
+            action: slot.action,
+            attempt: null,
+        });
     }
-    const target = Object.freeze({
-        experiments: Object.freeze(experiments.sort((left, right) => left.id.localeCompare(right.id))),
-    });
-    return effect_1.Either.right(Object.freeze({ target }));
-}
-function runNotFound(runId) {
-    return Object.freeze({ code: "sample-run-not-found", runId });
-}
-function runInvalid(runId, issues) {
-    return Object.freeze({ code: "sample-run-invalid", runId, issues: copyIssues(issues) });
-}
-function selectionLimit(limit, observedAtLeast) {
-    const maximum = limit === "selected-runs" ? MAX_SELECTED_RUNS : MAX_SLOTS;
     return Object.freeze({
-        code: "sample-limit-exceeded",
-        limit,
-        maximum,
-        observedAtLeast,
+        runId: slot.runId,
+        slotId: slot.slotId,
+        experimentId: slot.experimentId,
+        evalId: slot.evalId,
+        attemptOrdinal: slot.attemptOrdinal,
+        executionIdentityDigest: slot.executionIdentityDigest,
+        state: slot.state,
+        action: slot.action,
+        attempt: null,
+        issues: Object.freeze(slot.issues.map(issueJson)),
     });
 }
-function coreInvalidSlot(runId, slotId, issues) {
+function issueJson(issue) {
     return Object.freeze({
-        runId,
-        slotId,
-        state: "core-invalid",
-        issues: copyIssues(issues),
+        code: issue.code,
+        message: issue.message,
+        refs: Object.freeze(issue.refs.map((ref) => Object.freeze({
+            identity: Object.freeze({ kind: ref.identity.kind, locator: ref.identity.locator }),
+        }))),
     });
 }
-function singleRecordIssue(code, path) {
-    return Object.freeze([(0, record_errors_ts_1.recordIssue)(code, path)]);
-}
-function decodeSelectionSummary(input, path) {
-    if (!isExactObject(input, ["policy", "runIds", "experimentIds", "selectedRunIds"])) {
-        return effect_1.Either.left(codecError(path, "contains unsupported fields"));
-    }
-    const policy = valueAt(input, "policy");
+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(input, ["policy", "runIds"])) {
-            return effect_1.Either.left(codecError(path, "explicit selection must contain exactly policy and runIds"));
+        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 = decodeIdentityArray(valueAt(input, "runIds"), [...path, "runIds"], true, decodeRunId);
+        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);
-        const selection = {
+        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: runIds.right,
-        };
-        return effect_1.Either.right(Object.freeze(selection));
+            runIds: uniqueSorted(runIds.right),
+            selectedRunIds: uniqueSorted(selectedRunIds.right),
+            problems: normalizedSelectionProblems(problems.right),
+        }));
     }
     if (policy === "project-current") {
-        if (!isExactObject(input, ["policy", "experimentIds", "selectedRunIds"])) {
-            return effect_1.Either.left(codecError(path, "project-current selection must contain policy, experimentIds, and selectedRunIds"));
+        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 encodedExperimentIds = valueAt(input, "experimentIds");
+        const experimentIdsValue = valueAt(value, "experimentIds");
         let experimentIds;
-        if (encodedExperimentIds === "all") {
+        if (experimentIdsValue === "all") {
             experimentIds = "all";
         }
         else {
-            const decodedExperimentIds = decodeIdentityArray(encodedExperimentIds, [...path, "experimentIds"], true, decodeExperimentId);
-            if (effect_1.Either.isLeft(decodedExperimentIds)) {
+            const decodedExperimentIds = decodeArray(experimentIdsValue, [...path, "experimentIds"], decodeExperimentId);
+            if (effect_1.Either.isLeft(decodedExperimentIds))
                 return effect_1.Either.left(decodedExperimentIds.left);
-            }
-            experimentIds = decodedExperimentIds.right;
+            experimentIds = uniqueSorted(decodedExperimentIds.right);
         }
-        const selectedRunIds = decodeIdentityArray(valueAt(input, "selectedRunIds"), [...path, "selectedRunIds"], false, decodeRunId);
+        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);
-        const selection = {
+        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: selectedRunIds.right,
-        };
-        return effect_1.Either.right(Object.freeze(selection));
+            selectedRunIds: uniqueSorted(selectedRunIds.right),
+            problems: normalizedSelectionProblems(problems.right),
+        }));
     }
     return effect_1.Either.left(codecError([...path, "policy"], "must be explicit-runs or project-current"));
 }
-function decodeAnalysisRun(input, path) {
-    if (!isExactObject(input, ["runId", "startedAt", "completedAt", "expectedSlots"])) {
-        return effect_1.Either.left(codecError(path, "must contain exactly runId, startedAt, completedAt, and expectedSlots"));
+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(input, "runId"), [...path, "runId"]);
+    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);
-    const startedAt = decodeUtcMillis(valueAt(input, "startedAt"), [...path, "startedAt"]);
+    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);
-    const completedAt = decodeUtcMillis(valueAt(input, "completedAt"), [...path, "completedAt"]);
-    if (effect_1.Either.isLeft(completedAt) || completedAt.right < startedAt.right) {
-        return effect_1.Either.left(codecError([...path, "completedAt"], "must be a UTC millisecond no earlier than startedAt"));
-    }
-    const expectedSlots = decodeIdentityArray(valueAt(input, "expectedSlots"), [...path, "expectedSlots"], false, decodeSlotId);
-    if (effect_1.Either.isLeft(expectedSlots))
-        return effect_1.Either.left(expectedSlots.left);
-    const run = {
+    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: expectedSlots.right,
-    };
-    return effect_1.Either.right(Object.freeze(run));
+        expectedSlots: Object.freeze(uniqueSorted(slots.right)),
+    }));
 }
-function decodeAnalysisSlot(input, path) {
-    if (!isExactObject(input, ["runId", "slotId", "state", "relation", "attempt", "issues", "base"])) {
-        return effect_1.Either.left(codecError(path, "contains unsupported fields"));
+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");
+        }
     }
-    const state = valueAt(input, "state");
+    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") {
-        if (!isExactObject(input, ["runId", "slotId", "state", "base"])) {
-            return effect_1.Either.left(codecError(path, "excluded slot must contain runId, slotId, state, and base"));
+        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(input, "runId"), [...path, "runId"]);
+        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);
-        const slotId = decodeSlotId(valueAt(input, "slotId"), [...path, "slotId"]);
         if (effect_1.Either.isLeft(slotId))
             return effect_1.Either.left(slotId.left);
-        const base = decodeBaseSlot(valueAt(input, "base"), [...path, "base"]);
+        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.runId !== runId.right || base.right.slotId !== slotId.right) {
-            return effect_1.Either.left(codecError([...path, "base"], "must keep the same runId and slotId"));
+        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"));
         }
-        const slot = {
+        return effect_1.Either.right(Object.freeze({
             runId: runId.right,
             slotId: slotId.right,
-            state: "excluded",
+            experimentId: experimentId.right,
+            evalId: evalId.right,
+            attemptOrdinal: attemptOrdinal.right,
+            executionIdentityDigest: executionIdentityDigest.right,
+            state,
             base: base.right,
-        };
-        return effect_1.Either.right(Object.freeze(slot));
-    }
-    return decodeBaseSlot(input, path);
-}
-function decodeBaseSlot(input, path) {
-    if (!isExactObject(input, ["runId", "slotId", "state", "relation", "attempt", "issues"])) {
-        return effect_1.Either.left(codecError(path, "contains unsupported fields"));
+            ...(hasReason ? { reason: "identity-mismatch" } : {}),
+        }));
     }
-    const state = valueAt(input, "state");
+    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(input, ["runId", "slotId", "state", "relation", "attempt"])) {
-            return effect_1.Either.left(codecError(path, "included slot must contain runId, slotId, state, relation, and attempt"));
+        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 runId = decodeRunId(valueAt(input, "runId"), [...path, "runId"]);
-        if (effect_1.Either.isLeft(runId))
-            return effect_1.Either.left(runId.left);
-        const slotId = decodeSlotId(valueAt(input, "slotId"), [...path, "slotId"]);
-        if (effect_1.Either.isLeft(slotId))
-            return effect_1.Either.left(slotId.left);
-        const relation = valueAt(input, "relation");
-        if (relation !== "origin" && relation !== "reference") {
-            return effect_1.Either.left(codecError([...path, "relation"], "must be origin or reference"));
+        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"));
         }
-        const attempt = decodeAttemptRef(valueAt(input, "attempt"), [...path, "attempt"]);
         if (effect_1.Either.isLeft(attempt))
             return effect_1.Either.left(attempt.left);
-        const slot = {
+        return effect_1.Either.right(Object.freeze({
             runId: runId.right,
             slotId: slotId.right,
-            state: "included",
+            experimentId: experimentId.right,
+            evalId: evalId.right,
+            attemptOrdinal: attemptOrdinal.right,
+            executionIdentityDigest: executionIdentityDigest.right,
+            state,
+            action,
             relation,
             attempt: attempt.right,
-        };
-        return effect_1.Either.right(Object.freeze(slot));
+        }));
     }
     if (state === "not-recorded") {
-        if (!isExactObject(input, ["runId", "slotId", "state"])) {
-            return effect_1.Either.left(codecError(path, "not-recorded slot must contain runId, slotId, and state"));
+        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 runId = decodeRunId(valueAt(input, "runId"), [...path, "runId"]);
-        if (effect_1.Either.isLeft(runId))
-            return effect_1.Either.left(runId.left);
-        const slotId = decodeSlotId(valueAt(input, "slotId"), [...path, "slotId"]);
-        if (effect_1.Either.isLeft(slotId))
-            return effect_1.Either.left(slotId.left);
-        const slot = {
+        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,
-            state: "not-recorded",
-        };
-        return effect_1.Either.right(Object.freeze(slot));
+            experimentId: experimentId.right,
+            evalId: evalId.right,
+            attemptOrdinal: attemptOrdinal.right,
+            executionIdentityDigest: executionIdentityDigest.right,
+            state,
+            action,
+            attempt: null,
+        }));
     }
     if (state === "core-invalid") {
-        if (!isExactObject(input, ["runId", "slotId", "state", "issues"])) {
-            return effect_1.Either.left(codecError(path, "core-invalid slot must contain runId, slotId, state, and issues"));
+        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 runId = decodeRunId(valueAt(input, "runId"), [...path, "runId"]);
-        if (effect_1.Either.isLeft(runId))
-            return effect_1.Either.left(runId.left);
-        const slotId = decodeSlotId(valueAt(input, "slotId"), [...path, "slotId"]);
-        if (effect_1.Either.isLeft(slotId))
-            return effect_1.Either.left(slotId.left);
-        const issues = decodeIssues(valueAt(input, "issues"), [...path, "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);
-        const slot = {
+        return effect_1.Either.right(Object.freeze({
             runId: runId.right,
             slotId: slotId.right,
-            state: "core-invalid",
+            experimentId: experimentId.right,
+            evalId: evalId.right,
+            attemptOrdinal: attemptOrdinal.right,
+            executionIdentityDigest: executionIdentityDigest.right,
+            state,
+            action,
+            attempt: null,
             issues: issues.right,
-        };
-        return effect_1.Either.right(Object.freeze(slot));
+        }));
     }
-    return effect_1.Either.left(codecError([...path, "state"], "must be included, not-recorded, or core-invalid"));
+    return effect_1.Either.left(codecError([...path, "state"], "must be included, not-recorded, core-invalid, or excluded"));
 }
-function decodeAttemptRef(input, path) {
-    if (!isExactObject(input, ["originRunId", "attemptId"])) {
-        return effect_1.Either.left(codecError(path, "must contain exactly originRunId and attemptId"));
+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 originRunId = decodeRunId(valueAt(input, "originRunId"), [...path, "originRunId"]);
-    if (effect_1.Either.isLeft(originRunId))
-        return effect_1.Either.left(originRunId.left);
-    const attemptId = decodeAttemptId(valueAt(input, "attemptId"), [...path, "attemptId"]);
-    if (effect_1.Either.isLeft(attemptId))
-        return effect_1.Either.left(attemptId.left);
-    const ref = {
-        originRunId: originRunId.right,
-        attemptId: attemptId.right,
-    };
-    return effect_1.Either.right(Object.freeze(ref));
-}
-function decodeIssues(input, path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(record_errors_ts_1.NonEmptyRecordIssuesSchema, core_ts_1.RecordExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "must be a non-empty Record issue array"))
-        : effect_1.Either.right(copyIssues(decoded.right));
+    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 decodeIdentityArray(input, path, requireNonEmpty, decodeIdentity) {
-    if (!Array.isArray(input))
+function decodeIssues(value, path) {
+    if (!Array.isArray(value))
         return effect_1.Either.left(codecError(path, "must be an array"));
-    if (requireNonEmpty && input.length === 0)
-        return effect_1.Either.left(codecError(path, "must not be empty"));
-    const values = [];
-    let previous;
-    for (let index = 0; index < input.length; index += 1) {
-        const identity = decodeIdentity(input[index], [...path, String(index)]);
-        if (effect_1.Either.isLeft(identity))
-            return effect_1.Either.left(identity.left);
-        if (previous !== undefined && (0, identifiers_ts_2.compareCanonicalIdentity)(previous, identity.right) >= 0) {
-            return effect_1.Either.left(codecError(path, "must be strictly sorted and unique"));
+    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 }) }));
         }
-        previous = identity.right;
-        values.push(identity.right);
+        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(input, path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.RunIdSchema, core_ts_1.RecordExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "must be a portable RunId"))
-        : effect_1.Either.right(decoded.right);
+function decodeRunId(value, path) {
+    return decodeBrand(identifiers_ts_1.RunIdSchema, value, path, "a RunId");
 }
-function decodeSlotId(input, path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.SlotIdSchema, core_ts_1.RecordExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "must be a portable SlotId"))
-        : effect_1.Either.right(decoded.right);
+function decodeSlotId(value, path) {
+    return decodeBrand(identifiers_ts_1.SlotIdSchema, value, path, "a SlotId");
 }
-function decodeAttemptId(input, path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.AttemptIdSchema, core_ts_1.RecordExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "must be a portable AttemptId"))
-        : effect_1.Either.right(decoded.right);
+function decodeEvalId(value, path) {
+    return decodeBrand(identifiers_ts_1.EvalIdSchema, value, path, "an EvalId");
 }
-function decodeUtcMillis(input, path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.UtcMillisSchema, core_ts_1.RecordExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "must be a UTC millisecond"))
-        : effect_1.Either.right(decoded.right);
+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 decodeExperimentId(input, path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(experiment_id_ts_1.ExperimentIdSchema)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left(codecError(path, "must be an Experiment identity"))
-        : effect_1.Either.right(decoded.right);
-}
-function validateSampleIntegrity(sample) {
-    const expectedSlotsByRun = new Map();
-    let previousRunId;
-    let expectedSlotCount = 0;
-    for (const run of sample.runs) {
-        if (previousRunId !== undefined && (0, identifiers_ts_2.compareCanonicalIdentity)(previousRunId, run.runId) >= 0) {
-            return codecError(["runs"], "must be strictly sorted and unique by runId");
-        }
-        previousRunId = run.runId;
-        const slots = new Set();
-        for (const slotId of run.expectedSlots)
-            slots.add(slotId);
-        expectedSlotsByRun.set(run.runId, slots);
-        if (expectedSlotCount > MAX_SLOTS - run.expectedSlots.length) {
-            return codecError(["runs"], "expected slot count exceeds the slots limit");
-        }
-        expectedSlotCount += run.expectedSlots.length;
-    }
-    if (sample.slots.length !== expectedSlotCount) {
-        return codecError(["slots"], "must contain one entry for every expected slot");
-    }
-    const seenSlotsByRun = new Map();
-    let previousSlot;
-    let denominator = 0;
-    for (const slot of sample.slots) {
-        if (previousSlot !== undefined &&
-            compareSlotIdentity(previousSlot, slot) >= 0) {
-            return codecError(["slots"], "must be strictly sorted and unique by runId and slotId");
-        }
-        previousSlot = slot;
-        const expectedSlots = expectedSlotsByRun.get(slot.runId);
-        if (expectedSlots === undefined || !expectedSlots.has(slot.slotId)) {
-            return codecError(["slots"], "must reference an expected slot of a selected run");
-        }
-        let seenSlots = seenSlotsByRun.get(slot.runId);
-        if (seenSlots === undefined) {
-            seenSlots = new Set();
-            seenSlotsByRun.set(slot.runId, seenSlots);
-        }
-        seenSlots.add(slot.slotId);
-        if (slot.state !== "excluded")
-            denominator += 1;
-    }
-    if (denominator !== sample.denominator) {
-        return codecError(["denominator"], "must equal the number of non-excluded slots");
-    }
-    const runIds = sample.runs.map((run) => run.runId);
-    if (sample.selection.policy === "explicit-runs") {
-        if (!sameIdentitySequence(sample.selection.runIds, runIds)) {
-            return codecError(["selection", "runIds"], "must equal selected runs in canonical order");
-        }
-    }
-    else if (!sameIdentitySequence(sample.selection.selectedRunIds, runIds)) {
-        return codecError(["selection", "selectedRunIds"], "must equal selected runs in canonical order");
-    }
-    return undefined;
+function decodeExecutionIdentityDigest(value, path) {
+    return decodeBrand(identifiers_ts_1.ExecutionIdentityDigestSchema, value, path, "an execution identity digest");
 }
-function normalizeSelector(selector) {
-    if (!isExactObject(selector, ["runIds", "slotIds"])) {
-        return effect_1.Either.left(selectionInvalid("selector", "may contain only runIds and slotIds"));
-    }
-    if (hasOwnProperty(selector, "runIds") && selector.runIds === undefined) {
-        return effect_1.Either.left(selectionInvalid("selector.runIds", "must be omitted or an array"));
-    }
-    if (hasOwnProperty(selector, "slotIds") && selector.slotIds === undefined) {
-        return effect_1.Either.left(selectionInvalid("selector.slotIds", "must be omitted or an array"));
-    }
-    if (selector.runIds !== undefined && !Array.isArray(selector.runIds)) {
-        return effect_1.Either.left(selectionInvalid("selector.runIds", "must be an array"));
-    }
-    if (selector.slotIds !== undefined && !Array.isArray(selector.slotIds)) {
-        return effect_1.Either.left(selectionInvalid("selector.slotIds", "must be an array"));
-    }
-    let runIds;
-    if (selector.runIds !== undefined) {
-        const decodedRunIds = selectorIdentitySet(selector.runIds, "selector.runIds");
-        if (effect_1.Either.isLeft(decodedRunIds))
-            return effect_1.Either.left(decodedRunIds.left);
-        runIds = decodedRunIds.right;
-    }
-    let slotIds;
-    if (selector.slotIds !== undefined) {
-        const decodedSlotIds = selectorIdentitySet(selector.slotIds, "selector.slotIds");
-        if (effect_1.Either.isLeft(decodedSlotIds))
-            return effect_1.Either.left(decodedSlotIds.left);
-        slotIds = decodedSlotIds.right;
-    }
-    const normalized = {
-        runIds,
-        slotIds,
-    };
-    return effect_1.Either.right(Object.freeze(normalized));
-}
-function selectorIdentitySet(values, field) {
-    const selected = new Set();
+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) {
-        if (!(0, identifiers_ts_2.isPortableSegment)(value)) {
-            return effect_1.Either.left(selectionInvalid(field, "must contain portable Record identities"));
-        }
-        selected.add(value);
-    }
-    return effect_1.Either.right(selected);
-}
-function makeHandle(reader, port, sample) {
-    const handle = {
-        sample,
-        [analysisSampleHandleTypeId](boundSample) {
-            return boundSample;
-        },
-    };
-    const frozenHandle = Object.freeze(handle);
-    const binding = {
-        reader,
-        port,
-        sample,
-    };
-    handleBindings.set(frozenHandle, Object.freeze(binding));
-    return frozenHandle;
-}
-function makeAnalysisSample(selection, runs, slots) {
-    const copiedRuns = Object.freeze(runs.map(copyAnalysisRun));
-    const copiedSlots = Object.freeze(slots.map(copyAnalysisSlot));
-    let denominator = 0;
-    for (const slot of copiedSlots) {
-        if (slot.state !== "excluded")
-            denominator += 1;
-    }
-    const sample = {
-        selection: copySelectionSummary(selection),
-        runs: copiedRuns,
-        slots: copiedSlots,
-        denominator,
-    };
-    return Object.freeze(sample);
-}
-function copySelectionSummary(selection) {
-    if (selection.policy === "explicit-runs") {
-        const summary = {
-            policy: "explicit-runs",
-            runIds: Object.freeze(sortedUnique(selection.runIds)),
-        };
-        return Object.freeze(summary);
+        const identity = key(value);
+        if (byKey.has(identity))
+            throw new Error("SampleSnapshot contains duplicate identities");
+        byKey.set(identity, value);
     }
-    const experimentIds = selection.experimentIds === "all"
-        ? "all"
-        : Object.freeze(sortedUnique(selection.experimentIds));
-    const summary = {
-        policy: "project-current",
-        experimentIds,
-        selectedRunIds: Object.freeze(sortedUnique(selection.selectedRunIds)),
-    };
-    return Object.freeze(summary);
-}
-function copyAnalysisRun(run) {
-    const copy = {
-        runId: run.runId,
-        startedAt: run.startedAt,
-        completedAt: run.completedAt,
-        expectedSlots: Object.freeze(sortedUnique(run.expectedSlots)),
-    };
-    return Object.freeze(copy);
-}
-function copyAnalysisSlot(slot) {
-    if (slot.state === "excluded") {
-        const copy = {
-            runId: slot.runId,
-            slotId: slot.slotId,
-            state: "excluded",
-            base: copyBaseSlot(slot.base),
-        };
-        return Object.freeze(copy);
-    }
-    return copyBaseSlot(slot);
+    return Object.freeze([...byKey.entries()]
+        .sort(([left], [right]) => (0, identifiers_ts_2.compareCanonicalIdentity)(left, right))
+        .map(([, value]) => value));
 }
-function copyBaseSlot(slot) {
-    if (slot.state === "included") {
-        const copy = {
-            runId: slot.runId,
-            slotId: slot.slotId,
-            state: "included",
-            relation: slot.relation,
-            attempt: copyAttemptRef(slot.attempt),
-        };
-        return Object.freeze(copy);
-    }
-    if (slot.state === "not-recorded") {
-        const copy = {
-            runId: slot.runId,
-            slotId: slot.slotId,
-            state: "not-recorded",
-        };
-        return Object.freeze(copy);
-    }
-    const copy = {
-        runId: slot.runId,
-        slotId: slot.slotId,
-        state: "core-invalid",
-        issues: copyIssues(slot.issues),
-    };
-    return Object.freeze(copy);
-}
-function copyAttemptRef(ref) {
-    const copy = {
-        originRunId: ref.originRunId,
-        attemptId: ref.attemptId,
-    };
-    return Object.freeze(copy);
-}
-function copyIssues(issues) {
-    const [first, ...rest] = issues;
-    const copied = [copyIssue(first), ...rest.map(copyIssue)];
-    return Object.freeze(copied);
-}
-function copyIssue(issue) {
-    const copy = {
-        code: issue.code,
-        path: Object.freeze([...issue.path]),
-    };
-    return Object.freeze(copy);
-}
-function matchesSelector(slot, selector) {
-    const runMatches = selector.runIds === undefined || selector.runIds.has(slot.runId);
-    const slotMatches = selector.slotIds === undefined || selector.slotIds.has(slot.slotId);
-    return runMatches && slotMatches;
-}
-function excludedSlot(base) {
-    const excluded = {
-        runId: base.runId,
-        slotId: base.slotId,
-        state: "excluded",
-        base: copyBaseSlot(base),
-    };
-    return Object.freeze(excluded);
-}
-function compareSlotIdentity(left, right) {
-    const runComparison = (0, identifiers_ts_2.compareCanonicalIdentity)(left.runId, right.runId);
-    return runComparison === 0
-        ? (0, identifiers_ts_2.compareCanonicalIdentity)(left.slotId, right.slotId)
-        : runComparison;
-}
-function sameIdentitySequence(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function sortedUnique(values) {
-    const valuesByIdentity = new Set(values);
-    const sorted = [...valuesByIdentity];
-    sorted.sort(identifiers_ts_2.compareCanonicalIdentity);
-    return sorted;
-}
-function isNonNegativeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function isExactObject(value, allowed) {
+function sameIdentity(value, expected) {
+    return isExactObject(value, ["kind", "id"])
+        && valueAt(value, "kind") === expected.kind
+        && valueAt(value, "id") === expected.id;
+}
+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;
+}
+function codecException(error) {
+    const exception = new Error(error.reason);
+    Object.assign(exception, error);
+    return exception;
+}
+function codecError(path, reason) {
+    return Object.freeze({ code: "sample-snapshot-invalid", path: Object.freeze([...path]), reason });
+}
+/** Complete normalized selection data is collision-safe identity material. */
+function canonicalIdentity(value) {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        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);
-    if (prototype !== Object.prototype && prototype !== null)
+    return prototype === Object.prototype || prototype === null;
+}
+function isExactObject(value, keys) {
+    if (!isPlainObject(value))
         return false;
-    for (const key of Reflect.ownKeys(value)) {
-        if (typeof key !== "string" || !allowed.includes(key))
-            return false;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (descriptor === undefined || !("value" in descriptor))
-            return false;
-    }
-    return true;
+    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);
 }
-function hasOwnProperty(value, property) {
-    return Object.prototype.hasOwnProperty.call(value, property);
-}
-function selectionInvalid(field, reason) {
-    const error = {
-        code: "sample-selection-invalid",
-        field,
-        reason,
-    };
-    return Object.freeze(error);
-}
-function codecError(path, reason) {
-    const error = {
-        code: "analysis-sample-invalid",
-        path: Object.freeze([...path]),
-        reason,
-    };
-    return Object.freeze(error);
-}
-function recordHandleInvalid() {
-    return new errors_ts_1.RecordHandleInvalid({ code: "record-handle-invalid" });
-}
 //# sourceMappingURL=analysis.cjs.map