niceeval 0.12.2-canary.31 → 0.13.0

package/dist/record/host/runtime.cjs

@@ -0,0 +1,1696 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordHost = void 0;
+const effect_1 = require("effect");
+const record_leases_ts_1 = require("../../coordination/record-leases.cjs");
+const internal_ts_1 = require("../attachment/internal.cjs");
+const errors_ts_1 = require("../attachment/errors.cjs");
+const index_ts_1 = require("../codec/index.cjs");
+const record_errors_ts_1 = require("../errors/record-errors.cjs");
+const catalog_ts_1 = require("../family/catalog.cjs");
+const observability_ts_1 = require("../family/observability.cjs");
+const assertions_ts_1 = require("../family/assertions.cjs");
+const source_navigation_ts_1 = require("../family/source-navigation.cjs");
+const run_context_ts_1 = require("../model/run-context.cjs");
+const definition_ts_1 = require("../model/definition.cjs");
+const validation_ts_1 = require("../model/validation.cjs");
+const identifiers_ts_1 = require("../model/identifiers.cjs");
+const errors_ts_2 = require("../platform/errors.cjs");
+const root_ts_1 = require("../platform/root.cjs");
+const services_ts_1 = require("../platform/services.cjs");
+const errors_ts_3 = require("../reader/errors.cjs");
+const format_ts_1 = require("../reader/format.cjs");
+const runtime_ts_1 = require("../reader/runtime.cjs");
+const errors_ts_4 = require("../writer/errors.cjs");
+const attachment_payload_ts_1 = require("../writer/attachment-payload.cjs");
+const limits_ts_1 = require("../writer/limits.cjs");
+const types_ts_1 = require("./types.cjs");
+const MAXIMUM_RUN_ENTRIES = 100000;
+const MAXIMUM_ATTEMPT_ENTRIES = 100000;
+const MAXIMUM_CORE_BYTES = 1024 * 1024;
+const ENTROPY_RETRY_LIMIT = 16;
+const MAXIMUM_ATTACHMENT_BLOB_BYTES = 64 * 1024 * 1024;
+function sameFixedAttachmentWrite(actual, expected) {
+    return actual === expected.write;
+}
+const selectedAttemptCapabilities = new WeakMap();
+const runSessions = new WeakMap();
+const attemptSessions = new WeakMap();
+const consumedFixedFamilyWrites = new WeakMap();
+function recordPath(root, ...segments) {
+    return (0, services_ts_1.recordPortablePath)(root, ...segments);
+}
+function runPath(root, runId, ...segments) {
+    return recordPath(root, "runs", runId, ...segments);
+}
+function readerClosed() {
+    return new errors_ts_3.RecordReaderClosed({ code: "record-reader-closed" });
+}
+function handleInvalid() {
+    return new errors_ts_3.RecordHandleInvalid({ code: "record-handle-invalid" });
+}
+function migrationInterrupted() {
+    return new errors_ts_3.RecordMigrationInterruptedState({
+        code: "record-migration-interrupted",
+    });
+}
+function bootstrapInvalid() {
+    return new errors_ts_3.RecordBootstrapInvalid({
+        code: "record-bootstrap-invalid",
+        reason: "record-document-invalid",
+    });
+}
+function coreInvalid() {
+    const issues = (0, record_errors_ts_1.nonEmptyRecordIssues)([(0, record_errors_ts_1.recordIssue)("record-schema-invalid")]);
+    if (issues === undefined) {
+        throw new Error("Record Core invalid state must contain one issue");
+    }
+    return new record_errors_ts_1.RecordCoreInvalid({ code: "record-core-invalid", issues });
+}
+function coreInvalidFromCodec(error) {
+    return new record_errors_ts_1.RecordCoreInvalid({
+        code: "record-core-invalid",
+        issues: error.issues,
+    });
+}
+function referenceInvalid() {
+    return new record_errors_ts_1.RecordReferenceInvalid({ code: "record-reference-invalid" });
+}
+function stateError(operation, state) {
+    return (0, errors_ts_4.recordDraftStateError)({
+        code: state === "failed" ? "record-draft-write-failed" : "record-draft-state-invalid",
+        operation,
+        state,
+    });
+}
+function jsonBytes(value) {
+    return (0, limits_ts_1.encodeRecordJsonUtf8)(value);
+}
+function parseJson(bytes) {
+    try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        return undefined;
+    }
+}
+function readJson(fileSystem, path) {
+    return fileSystem.readFile({ file: path, maximumBytes: MAXIMUM_CORE_BYTES }).pipe(effect_1.Effect.map((bytes) => bytes === undefined ? undefined : parseJson(bytes)), effect_1.Effect.catchTag("RecordResourceLimitExceeded", () => effect_1.Effect.succeed(undefined)), effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(undefined)));
+}
+function decodeRunId(value) {
+    const decoded = effect_1.Schema.decodeUnknownEither(index_ts_1.RunIdSchema)(value);
+    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
+}
+function decodeAttemptId(value) {
+    const decoded = effect_1.Schema.decodeUnknownEither(index_ts_1.AttemptIdSchema)(value);
+    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
+}
+function orderedEntries(entries) {
+    return Object.freeze([...entries].sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.name, right.name)));
+}
+function sameRoot(left, right) {
+    const leftPaths = (0, root_ts_1.recordRootPaths)(left);
+    const rightPaths = (0, root_ts_1.recordRootPaths)(right);
+    return leftPaths !== undefined && rightPaths !== undefined &&
+        leftPaths.portableRoot === rightPaths.portableRoot;
+}
+function currentFormatInspection(fileSystem, root) {
+    return (0, format_ts_1.readCurrentRecordFormat)(fileSystem, root).pipe(effect_1.Effect.map(() => ({
+        state: "already-current",
+        format: identifiers_ts_1.RECORD_FORMAT,
+    })), effect_1.Effect.catchAll((error) => error instanceof errors_ts_3.RecordFormatUnsupported
+        ? effect_1.Effect.succeed({
+            state: "unsupported-format",
+            format: error.format,
+        })
+        : effect_1.Effect.fail(error)));
+}
+function isSealedRun(fileSystem, root, runId) {
+    return effect_1.Effect.map(fileSystem.pathKind(runPath(root, runId, "complete")), (kind) => kind === "file");
+}
+function readRunDocument(fileSystem, root, runId) {
+    return effect_1.Effect.map(readJson(fileSystem, runPath(root, runId, "run.json")), (json) => {
+        if (json === undefined)
+            return undefined;
+        const decoded = (0, index_ts_1.decodeRunDocument)(json);
+        return effect_1.Either.isRight(decoded) && decoded.right.runId === runId
+            ? decoded.right
+            : undefined;
+    });
+}
+function readAttemptDocument(fileSystem, root, ref) {
+    return effect_1.Effect.map(readJson(fileSystem, runPath(root, ref.originRunId, "attempts", ref.attemptId, "attempt.json")), (json) => {
+        if (json === undefined)
+            return undefined;
+        const decoded = (0, index_ts_1.decodeAttemptDocument)(json);
+        return effect_1.Either.isRight(decoded) &&
+            decoded.right.attemptId === ref.attemptId &&
+            decoded.right.originRunId === ref.originRunId
+            ? decoded.right
+            : undefined;
+    });
+}
+function readMemberDocument(fileSystem, root, runId, slotId) {
+    return effect_1.Effect.map(readJson(fileSystem, runPath(root, runId, "members", `${slotId}.json`)), (json) => {
+        if (json === undefined)
+            return undefined;
+        const decoded = (0, index_ts_1.decodeMemberDocument)(json);
+        return effect_1.Either.isRight(decoded) && decoded.right.slotId === slotId
+            ? decoded.right
+            : undefined;
+    });
+}
+function decodeSlotId(value) {
+    const decoded = effect_1.Schema.decodeUnknownEither(index_ts_1.SlotIdSchema)(value);
+    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
+}
+function readRunMembers(fileSystem, root, runId) {
+    return effect_1.Effect.gen(function* () {
+        const directory = runPath(root, runId, "members");
+        if ((yield* fileSystem.pathKind(directory)) !== "directory")
+            return undefined;
+        const entries = orderedEntries(yield* fileSystem.listDirectory({
+            directory,
+            maximumEntries: MAXIMUM_ATTEMPT_ENTRIES,
+        }));
+        const members = [];
+        for (const entry of entries) {
+            if (entry.kind !== "file" || !entry.name.endsWith(".json"))
+                return undefined;
+            const slotId = decodeSlotId(entry.name.slice(0, -".json".length));
+            if (slotId === undefined)
+                return undefined;
+            const member = yield* readMemberDocument(fileSystem, root, runId, slotId);
+            if (member === undefined || members.some((current) => current.slotId === member.slotId)) {
+                return undefined;
+            }
+            members.push(member);
+        }
+        return Object.freeze(members);
+    });
+}
+/**
+ * Reads every exact Attempt document owned by a sealed Run. An absent attempts
+ * directory is legitimate for an all-reference / terminal Run; every other
+ * non-directory shape is a Core failure.
+ */
+function readRunAttempts(fileSystem, root, runId) {
+    return effect_1.Effect.gen(function* () {
+        const directory = runPath(root, runId, "attempts");
+        const kind = yield* fileSystem.pathKind(directory);
+        if (kind === "missing")
+            return Object.freeze([]);
+        if (kind !== "directory")
+            return undefined;
+        const entries = orderedEntries(yield* fileSystem.listDirectory({
+            directory,
+            maximumEntries: MAXIMUM_ATTEMPT_ENTRIES,
+        }));
+        const attempts = [];
+        for (const entry of entries) {
+            if (entry.kind !== "directory")
+                return undefined;
+            const attemptId = decodeAttemptId(entry.name);
+            if (attemptId === undefined)
+                return undefined;
+            const document = yield* readAttemptDocument(fileSystem, root, {
+                originRunId: runId,
+                attemptId,
+            });
+            if (document === undefined)
+                return undefined;
+            attempts.push(document);
+        }
+        return Object.freeze(attempts);
+    });
+}
+/**
+ * The reader deliberately reconstructs the complete published aggregate only
+ * at the point where it is about to sign a Run/Attempt as available. This is
+ * the same `RecordCoreDefinition` refine used by the writer's seal boundary,
+ * so a marker cannot promote a partial Member denominator to availability.
+ */
+function loadSealedCoreSnapshot(runtime, fileSystem) {
+    return effect_1.Effect.gen(function* () {
+        const entries = orderedEntries(yield* fileSystem.listDirectory({
+            directory: recordPath(runtime.root, "runs"),
+            maximumEntries: MAXIMUM_RUN_ENTRIES,
+        }));
+        const cores = [];
+        for (const entry of entries) {
+            if (entry.kind !== "directory")
+                continue;
+            const runId = decodeRunId(entry.name);
+            if (runId === undefined || !(yield* isSealedRun(fileSystem, runtime.root, runId))) {
+                continue;
+            }
+            const run = yield* readRunDocument(fileSystem, runtime.root, runId);
+            const members = run === undefined
+                ? undefined
+                : yield* readRunMembers(fileSystem, runtime.root, runId);
+            const attempts = members === undefined
+                ? undefined
+                : yield* readRunAttempts(fileSystem, runtime.root, runId);
+            if (run === undefined || members === undefined || attempts === undefined) {
+                return Object.freeze({ state: "core-invalid", issues: coreInvalid().issues });
+            }
+            cores.push(Object.freeze({ run, members, attempts }));
+        }
+        const ordered = Object.freeze(cores.sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.run.runId, right.run.runId)));
+        const aggregate = Object.freeze({ record: runtime.record, runs: ordered });
+        const encoded = (0, index_ts_1.encodeRecordCore)(aggregate);
+        if (effect_1.Either.isLeft(encoded)) {
+            return Object.freeze({ state: "core-invalid", issues: encoded.left.issues });
+        }
+        return Object.freeze({
+            state: "available",
+            byRunId: new Map(ordered.map((core) => [core.run.runId, core])),
+        });
+    });
+}
+/**
+ * A read session holds the Record read lease, so its published Core cannot
+ * change underneath it. Share one exact snapshot across selection and all
+ * subsequent Run / Attempt reads instead of rebuilding the whole aggregate
+ * for every capability lookup.
+ */
+function readSealedCoreSnapshot(runtime, fileSystem) {
+    return effect_1.Effect.uninterruptibleMask((restore) => effect_1.Effect.gen(function* () {
+        const fresh = yield* effect_1.Deferred.make();
+        const flight = yield* effect_1.Effect.sync(() => {
+            if (runtime.sealedCoreSnapshot !== undefined) {
+                return { _tag: "Follower", deferred: runtime.sealedCoreSnapshot };
+            }
+            runtime.sealedCoreSnapshot = fresh;
+            return { _tag: "Leader", deferred: fresh };
+        });
+        if (flight._tag === "Follower")
+            return yield* restore(effect_1.Deferred.await(flight.deferred));
+        const completed = yield* effect_1.Effect.exit(restore(loadSealedCoreSnapshot(runtime, fileSystem)));
+        yield* effect_1.Deferred.done(flight.deferred, completed);
+        return yield* effect_1.Deferred.await(flight.deferred);
+    }));
+}
+function makeRunRef(runtime, document) {
+    const existing = runtime.runsById.get(document.runId);
+    if (existing !== undefined)
+        return existing;
+    const ref = Object.freeze({
+        runId: document.runId,
+        [types_ts_1.selectedRunRefBrand]: () => undefined,
+    });
+    runtime.runs.set(ref, Object.freeze({
+        document,
+        root: runtime.root,
+        lifecycle: runtime.lifecycle,
+    }));
+    runtime.runsById.set(document.runId, ref);
+    return ref;
+}
+function attemptKey(ref) {
+    return `${ref.originRunId}\u0000${ref.attemptId}`;
+}
+function makeAttemptRef(runtime, input) {
+    const key = attemptKey(input);
+    const existing = runtime.attemptsByKey.get(key);
+    if (existing !== undefined)
+        return existing;
+    const ref = Object.freeze({
+        originRunId: input.originRunId,
+        attemptId: input.attemptId,
+        [types_ts_1.selectedAttemptRefBrand]: () => undefined,
+    });
+    const contents = Object.freeze({ root: runtime.root, lifecycle: runtime.lifecycle });
+    runtime.attempts.set(ref, contents);
+    selectedAttemptCapabilities.set(ref, contents);
+    runtime.attemptsByKey.set(key, ref);
+    return ref;
+}
+function makeOwner(runtime, contents) {
+    const owner = Object.freeze({
+        [types_ts_1.selectedOwnerRefBrand]: () => undefined,
+    });
+    runtime.owners.set(owner, Object.freeze(contents));
+    return owner;
+}
+function assertReaderLive(runtime) {
+    return runtime.lifecycle.closed ? effect_1.Effect.fail(readerClosed()) : effect_1.Effect.void;
+}
+function scanSelection(runtime, fileSystem, request) {
+    return effect_1.Effect.gen(function* () {
+        yield* assertReaderLive(runtime);
+        const wanted = request?.runIds === undefined
+            ? undefined
+            : new Set(request.runIds);
+        const entries = orderedEntries(yield* fileSystem.listDirectory({
+            directory: recordPath(runtime.root, "runs"),
+            maximumEntries: MAXIMUM_RUN_ENTRIES,
+        }));
+        const snapshot = yield* readSealedCoreSnapshot(runtime, fileSystem);
+        const found = new Set();
+        const warnings = [];
+        const problems = [];
+        const documents = [];
+        for (const entry of entries) {
+            if (entry.kind !== "directory")
+                continue;
+            const runId = decodeRunId(entry.name);
+            if (runId === undefined)
+                continue;
+            found.add(runId);
+            const sealed = yield* isSealedRun(fileSystem, runtime.root, runId);
+            if (!sealed) {
+                warnings.push(Object.freeze({
+                    code: "incomplete-run",
+                    runId,
+                    cleanupCommand: "niceeval clean",
+                }));
+                if (wanted?.has(runId)) {
+                    problems.push(Object.freeze({ code: "incomplete-run", runId }));
+                }
+                continue;
+            }
+            if (wanted !== undefined && !wanted.has(runId))
+                continue;
+            const core = snapshot.state === "available" ? snapshot.byRunId.get(runId) : undefined;
+            if (core === undefined) {
+                problems.push(Object.freeze({ code: "record-core-invalid", runId }));
+            }
+            else {
+                documents.push(core.run);
+            }
+        }
+        if (wanted !== undefined) {
+            for (const runId of wanted) {
+                if (!found.has(runId)) {
+                    problems.push(Object.freeze({ code: "selection-run-missing", runId }));
+                }
+            }
+        }
+        const orderedDocuments = documents.sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.runId, right.runId));
+        const runFacts = orderedDocuments.map((document) => Object.freeze({
+            run: makeRunRef(runtime, document),
+            experimentId: document.experimentId,
+            startedAt: document.startedAt,
+            completedAt: document.completedAt,
+            expectedSlots: Object.freeze([...document.expectedSlots]),
+        }));
+        const refs = runFacts.map((facts) => facts.run);
+        const expectedSlots = runFacts.flatMap((facts) => {
+            return facts.expectedSlots.map((slot) => Object.freeze({
+                run: facts.run,
+                experimentId: facts.experimentId,
+                slot,
+            }));
+        });
+        return Object.freeze({
+            runRefs: Object.freeze(refs),
+            runFacts: Object.freeze(runFacts),
+            expectedSlots: Object.freeze(expectedSlots),
+            problems: Object.freeze(problems),
+            warnings: Object.freeze(warnings),
+        });
+    });
+}
+function readFixedFamily(input) {
+    return effect_1.Effect.suspend(() => {
+        if (input.runtime.lifecycle.closed)
+            return effect_1.Effect.fail(readerClosed());
+        const owner = input.runtime.owners.get(input.owner);
+        if (owner === undefined || owner.kind !== input.descriptor.owner) {
+            return effect_1.Effect.fail(handleInvalid());
+        }
+        if (owner.kind === "run") {
+            const descriptor = input.descriptor;
+            return (0, runtime_ts_1.readFixedRecordAttachment)({
+                fileSystem: input.fileSystem,
+                root: input.runtime.root,
+                location: Object.freeze({ owner: "run", runId: owner.runId }),
+                descriptor,
+            }).pipe(effect_1.Effect.flatMap((value) => {
+                if (value.state !== "available") {
+                    return effect_1.Effect.succeed(value.state === "unavailable"
+                        ? Object.freeze({ state: "not-recorded" })
+                        : value);
+                }
+                return validateFixedCrossFamilyJoin({
+                    fileSystem: input.fileSystem,
+                    root: input.runtime.root,
+                    runId: owner.runId,
+                    descriptor: descriptor,
+                    payload: value.value,
+                }).pipe(effect_1.Effect.map((joined) => joined
+                    ? value
+                    : Object.freeze({ state: "invalid", issues: coreInvalid().issues })));
+            }));
+        }
+        const descriptor = input.descriptor;
+        return (0, runtime_ts_1.readFixedRecordAttachment)({
+            fileSystem: input.fileSystem,
+            root: input.runtime.root,
+            location: Object.freeze({
+                owner: "attempt",
+                runId: owner.ref.originRunId,
+                attemptId: owner.ref.attemptId,
+            }),
+            descriptor,
+        }).pipe(effect_1.Effect.flatMap((value) => {
+            if (value.state !== "available") {
+                return effect_1.Effect.succeed(value.state === "unavailable"
+                    ? Object.freeze({ state: "not-recorded" })
+                    : value);
+            }
+            return validateFixedCrossFamilyJoin({
+                fileSystem: input.fileSystem,
+                root: input.runtime.root,
+                runId: owner.ref.originRunId,
+                attemptId: owner.ref.attemptId,
+                descriptor: descriptor,
+                payload: value.value,
+            }).pipe(effect_1.Effect.map((joined) => joined
+                ? value
+                : Object.freeze({ state: "invalid", issues: coreInvalid().issues })));
+        }));
+    });
+}
+function isObservabilityDescriptor(descriptor) {
+    return descriptor === catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt ||
+        descriptor === catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.run;
+}
+function isAssertionsDescriptor(descriptor) {
+    return descriptor === catalog_ts_1.NiceEvalRecordFamilyCatalog.assertions;
+}
+function isSourceNavigationDescriptor(descriptor) {
+    return descriptor === catalog_ts_1.NiceEvalRecordFamilyCatalog.sourceNavigation;
+}
+function hasSourceFrames(payload) {
+    return payload.diagnostics.diagnostics.some((diagnostic) => diagnostic.sourceFrame !== null);
+}
+/** Common cross-family closure boundary used by both reader and writer seal. */
+function validateObservabilitySourceFrameJoin(input) {
+    return effect_1.Effect.gen(function* () {
+        if (!hasSourceFrames(input.payload))
+            return true;
+        const sources = yield* (0, runtime_ts_1.readFixedRecordAttachment)({
+            fileSystem: input.fileSystem,
+            root: input.root,
+            location: Object.freeze({ owner: "run", runId: input.runId }),
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sources,
+        });
+        if (sources.state !== "available")
+            return false;
+        return (0, observability_ts_1.observabilitySourceFrameIntegrityIssues)(input.payload, sources.value).length === 0;
+    });
+}
+function hasMappedNavigationRows(payload) {
+    return payload.rows.some((row) => row.source.state === "mapped");
+}
+/**
+ * The fixed catalog's only cross-family boundary.  All joins use explicit
+ * durable IDs and digests; absent siblings fail closed instead of falling
+ * back to path lookup or array order.
+ */
+function validateFixedCrossFamilyJoin(input) {
+    if (isObservabilityDescriptor(input.descriptor)) {
+        return validateObservabilitySourceFrameJoin({
+            fileSystem: input.fileSystem,
+            root: input.root,
+            runId: input.runId,
+            payload: input.payload,
+        });
+    }
+    if (isAssertionsDescriptor(input.descriptor)) {
+        const payload = input.payload;
+        if (payload.sourceSites.length === 0)
+            return effect_1.Effect.succeed(true);
+        return effect_1.Effect.gen(function* () {
+            const sources = yield* (0, runtime_ts_1.readFixedRecordAttachment)({
+                fileSystem: input.fileSystem,
+                root: input.root,
+                location: Object.freeze({ owner: "run", runId: input.runId }),
+                descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sources,
+            });
+            return sources.state === "available" &&
+                (0, assertions_ts_1.assertionsSourceSiteIntegrityIssues)(payload, sources.value).length === 0;
+        });
+    }
+    if (isSourceNavigationDescriptor(input.descriptor)) {
+        const payload = input.payload;
+        if (input.attemptId === undefined)
+            return effect_1.Effect.succeed(false);
+        return effect_1.Effect.gen(function* () {
+            const observability = yield* (0, runtime_ts_1.readFixedRecordAttachment)({
+                fileSystem: input.fileSystem,
+                root: input.root,
+                location: Object.freeze({
+                    owner: "attempt",
+                    runId: input.runId,
+                    attemptId: input.attemptId,
+                }),
+                descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt,
+            });
+            if (observability.state !== "available")
+                return false;
+            const sources = hasMappedNavigationRows(payload)
+                ? yield* (0, runtime_ts_1.readFixedRecordAttachment)({
+                    fileSystem: input.fileSystem,
+                    root: input.root,
+                    location: Object.freeze({ owner: "run", runId: input.runId }),
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sources,
+                })
+                : undefined;
+            if (sources !== undefined && sources.state !== "available")
+                return false;
+            return (0, source_navigation_ts_1.sourceNavigationIntegrityIssues)({
+                payload,
+                observability: observability.value,
+                sources: sources?.state === "available" ? sources.value : undefined,
+            }).length === 0;
+        });
+    }
+    return effect_1.Effect.succeed(true);
+}
+function makeReadSession(runtime, fileSystem) {
+    const session = Object.freeze({
+        selectRuns: (request) => scanSelection(runtime, fileSystem, request),
+        readRun: (ref) => effect_1.Effect.suspend(() => {
+            const contents = runtime.runs.get(ref);
+            if (runtime.lifecycle.closed)
+                return effect_1.Effect.fail(readerClosed());
+            if (contents === undefined)
+                return effect_1.Effect.fail(handleInvalid());
+            return effect_1.Effect.map(readSealedCoreSnapshot(runtime, fileSystem), (snapshot) => {
+                const core = snapshot.state === "available" ? snapshot.byRunId.get(ref.runId) : undefined;
+                if (core === undefined) {
+                    return Object.freeze({
+                        state: "core-invalid",
+                        issues: snapshot.state === "core-invalid" ? snapshot.issues : coreInvalid().issues,
+                    });
+                }
+                return Object.freeze({
+                    state: "available",
+                    value: Object.freeze({
+                        ref,
+                        owner: makeOwner(runtime, Object.freeze({ kind: "run", runId: ref.runId })),
+                        document: core.run,
+                        members: Object.freeze(core.members.map((document) => Object.freeze({
+                            document,
+                            attempt: document.attempt === null ? null : makeAttemptRef(runtime, document.attempt),
+                        }))),
+                    }),
+                });
+            });
+        }),
+        readAttempt: (ref) => effect_1.Effect.suspend(() => {
+            const contents = runtime.attempts.get(ref);
+            if (runtime.lifecycle.closed)
+                return effect_1.Effect.fail(readerClosed());
+            if (contents === undefined)
+                return effect_1.Effect.fail(handleInvalid());
+            const exact = {
+                originRunId: ref.originRunId,
+                attemptId: ref.attemptId,
+            };
+            return effect_1.Effect.gen(function* () {
+                if (!(yield* isSealedRun(fileSystem, contents.root, exact.originRunId))) {
+                    return Object.freeze({ state: "missing" });
+                }
+                const snapshot = yield* readSealedCoreSnapshot(runtime, fileSystem);
+                const core = snapshot.state === "available"
+                    ? snapshot.byRunId.get(exact.originRunId)
+                    : undefined;
+                if (core === undefined) {
+                    return Object.freeze({
+                        state: "core-invalid",
+                        issues: snapshot.state === "core-invalid" ? snapshot.issues : coreInvalid().issues,
+                    });
+                }
+                const originRun = core.run;
+                const document = core.attempts.find((attempt) => attempt.attemptId === exact.attemptId);
+                if (document === undefined) {
+                    return Object.freeze({ state: "core-invalid", issues: coreInvalid().issues });
+                }
+                const expected = originRun.expectedSlots.find((slot) => slot.slotId === document.slotId);
+                if (expected === undefined
+                    || expected.evalId !== document.evalId
+                    || expected.executionIdentityDigest !== document.executionIdentityDigest) {
+                    return Object.freeze({ state: "core-invalid", issues: coreInvalid().issues });
+                }
+                return Object.freeze({
+                    state: "available",
+                    value: Object.freeze({
+                        ref,
+                        owner: makeOwner(runtime, Object.freeze({ kind: "attempt", ref: exact })),
+                        document,
+                        origin: Object.freeze({
+                            owner: makeOwner(runtime, Object.freeze({
+                                kind: "run",
+                                runId: originRun.runId,
+                            })),
+                            runId: originRun.runId,
+                            experimentId: originRun.experimentId,
+                            startedAt: originRun.startedAt,
+                            context: originRun.context,
+                        }),
+                    }),
+                });
+            });
+        }),
+        readAssertions: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.assertions,
+        }),
+        readAttemptObservability: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt,
+        }),
+        readFileChanges: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.fileChanges,
+        }),
+        readSourceNavigation: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sourceNavigation,
+        }),
+        readAttemptArtifacts: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.attempt,
+        }),
+        readSources: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sources,
+        }),
+        readRunObservability: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.run,
+        }),
+        readRunArtifacts: (owner) => readFixedFamily({
+            runtime,
+            fileSystem,
+            owner,
+            descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.run,
+        }),
+    });
+    return session;
+}
+function mintRecordDocument(entropy) {
+    const format = effect_1.Schema.decodeUnknownEither(index_ts_1.RecordFormatSchema, index_ts_1.RecordExactParseOptions)(identifiers_ts_1.RECORD_FORMAT);
+    if (effect_1.Either.isLeft(format))
+        return effect_1.Effect.fail(coreInvalid());
+    return effect_1.Effect.flatMap(entropy.uuid, (raw) => {
+        const id = effect_1.Schema.decodeUnknownEither(index_ts_1.RecordIdSchema, index_ts_1.RecordExactParseOptions)(raw);
+        return effect_1.Either.isLeft(id)
+            ? effect_1.Effect.fail(coreInvalid())
+            : effect_1.Effect.succeed(Object.freeze({
+                format: format.right,
+                schemaVersion: identifiers_ts_1.RECORD_SCHEMA_VERSION,
+                recordId: id.right,
+            }));
+    });
+}
+function createDirectoryIfMissing(fileSystem, path) {
+    return fileSystem.createDirectory(path).pipe(effect_1.Effect.catchAll((error) => error instanceof errors_ts_2.RecordPathAlreadyExists ? effect_1.Effect.void : effect_1.Effect.fail(error)));
+}
+function initializeRecord(input) {
+    return effect_1.Effect.gen(function* () {
+        const documentPath = recordPath(input.root, "record.json");
+        if ((yield* input.fileSystem.pathKind(documentPath)) !== "missing")
+            return;
+        yield* input.fileSystem.ensureDirectory(recordPath(input.root));
+        yield* createDirectoryIfMissing(input.fileSystem, recordPath(input.root, "runs"));
+        // If another append writer won the bootstrap race, do not inspect or alter
+        // its durable identity. Re-read the election file and let exact format
+        // validation decide the next step.
+        if ((yield* input.fileSystem.pathKind(documentPath)) !== "missing")
+            return;
+        const entries = yield* input.fileSystem.listDirectory({
+            directory: recordPath(input.root),
+            maximumEntries: 2,
+        });
+        if (entries.some((entry) => entry.name !== "runs" || entry.kind !== "directory")) {
+            if ((yield* input.fileSystem.pathKind(documentPath)) !== "missing")
+                return;
+            return yield* effect_1.Effect.fail(bootstrapInvalid());
+        }
+        const document = yield* mintRecordDocument(input.entropy);
+        const encoded = (0, index_ts_1.encodeRecordDocument)(document);
+        if (effect_1.Either.isLeft(encoded))
+            return yield* effect_1.Effect.fail(coreInvalidFromCodec(encoded.left));
+        yield* input.fileSystem.writeFile({
+            file: documentPath,
+            bytes: jsonBytes(encoded.right),
+            maximumBytes: format_ts_1.RECORD_FORMAT_DOCUMENT_MAXIMUM_BYTES,
+            mode: "exclusive",
+        }).pipe(effect_1.Effect.catchAll((error) => error instanceof errors_ts_2.RecordPathAlreadyExists ? effect_1.Effect.void : effect_1.Effect.fail(error)));
+        yield* input.fileSystem.syncDirectory(recordPath(input.root));
+    });
+}
+function openCurrentRead(input) {
+    return effect_1.Effect.gen(function* () {
+        const coordination = yield* record_leases_ts_1.RecordCoordination;
+        const fileSystem = yield* services_ts_1.RecordFileSystem;
+        yield* coordination.enterRecordRead(input.root);
+        if (yield* fileSystem.migrationSentinelPresent(input.root)) {
+            return yield* effect_1.Effect.fail(migrationInterrupted());
+        }
+        const current = yield* (0, format_ts_1.readCurrentRecordFormat)(fileSystem, input.root);
+        yield* coordination.verifyRecordIdentity({ root: input.root, recordId: current.document.recordId });
+        const lifecycle = { closed: false };
+        const runtime = {
+            root: input.root,
+            record: current.document,
+            lifecycle,
+            runs: new WeakMap(),
+            attempts: new WeakMap(),
+            owners: new WeakMap(),
+            runsById: new Map(),
+            attemptsByKey: new Map(),
+            sealedCoreSnapshot: undefined,
+        };
+        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => { lifecycle.closed = true; }));
+        return makeReadSession(runtime, fileSystem);
+    });
+}
+function mintRunId(entropy) {
+    return effect_1.Effect.flatMap(entropy.uuid, (raw) => {
+        const decoded = effect_1.Schema.decodeUnknownEither(index_ts_1.RunIdSchema, index_ts_1.RecordExactParseOptions)(raw);
+        return effect_1.Either.isLeft(decoded) ? effect_1.Effect.fail(coreInvalid()) : effect_1.Effect.succeed(decoded.right);
+    });
+}
+function mintAttemptId(entropy) {
+    return effect_1.Effect.flatMap(entropy.uuid, (raw) => {
+        const decoded = effect_1.Schema.decodeUnknownEither(index_ts_1.AttemptIdSchema, index_ts_1.RecordExactParseOptions)(raw);
+        return effect_1.Either.isLeft(decoded) ? effect_1.Effect.fail(coreInvalid()) : effect_1.Effect.succeed(decoded.right);
+    });
+}
+function createFreshRunDirectory(root, fileSystem, entropy, remaining = ENTROPY_RETRY_LIMIT) {
+    return effect_1.Effect.flatMap(mintRunId(entropy), (runId) => fileSystem.createRunDirectory({ root, runId }).pipe(effect_1.Effect.as(runId), effect_1.Effect.catchAll((error) => error instanceof errors_ts_2.RecordPathAlreadyExists && remaining > 0
+        ? createFreshRunDirectory(root, fileSystem, entropy, remaining - 1)
+        : effect_1.Effect.fail(error))));
+}
+function assertRunLive(run) {
+    return run.closed ? effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)()) : effect_1.Effect.void;
+}
+/**
+ * `CreateRunRequest` is public-facing TypeScript but may still receive forged
+ * JavaScript values. Normalize every Slot through the exact definition before
+ * allocating a Run directory so both normal and reference Runs freeze the
+ * same denominator facts.
+ */
+function canonicalizeExpectedSlots(input) {
+    const slots = [];
+    for (const [index, slot] of input.entries()) {
+        const encoded = definition_ts_1.RecordSlotIdentityDefinition.encode(slot);
+        if (effect_1.Either.isLeft(encoded)) {
+            const issues = (0, record_errors_ts_1.nonEmptyRecordIssues)([
+                (0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["expectedSlots", String(index)]),
+            ]);
+            if (issues === undefined)
+                throw new Error("Expected Slot codec failure must have an issue");
+            return effect_1.Either.left(issues);
+        }
+        const decoded = definition_ts_1.RecordSlotIdentityDefinition.decode(encoded.right);
+        if (effect_1.Either.isLeft(decoded)) {
+            const issues = (0, record_errors_ts_1.nonEmptyRecordIssues)([
+                (0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["expectedSlots", String(index)]),
+            ]);
+            if (issues === undefined)
+                throw new Error("Expected Slot codec failure must have an issue");
+            return effect_1.Either.left(issues);
+        }
+        slots.push(decoded.right);
+    }
+    const issues = (0, record_errors_ts_1.nonEmptyRecordIssues)((0, validation_ts_1.validateExpectedSlots)(slots));
+    return issues === undefined
+        ? effect_1.Either.right(Object.freeze(slots))
+        : effect_1.Either.left(issues);
+}
+function createFreshAttemptDirectory(run, remaining = ENTROPY_RETRY_LIMIT) {
+    return effect_1.Effect.flatMap(mintAttemptId(run.entropy), (attemptId) => run.fileSystem.ensureDirectory(runPath(run.root, run.runId, "attempts")).pipe(effect_1.Effect.zipRight(run.fileSystem.createDirectory(runPath(run.root, run.runId, "attempts", attemptId))), effect_1.Effect.as(attemptId), effect_1.Effect.catchAll((error) => error instanceof errors_ts_2.RecordPathAlreadyExists && remaining > 0
+        ? createFreshAttemptDirectory(run, remaining - 1)
+        : effect_1.Effect.fail(error))));
+}
+function beginRunMutation(run, input) {
+    return run.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
+        yield* assertRunLive(run);
+        if (run.state !== "open") {
+            return yield* effect_1.Effect.fail(stateError(input.operation, run.state));
+        }
+        if (input.slotId !== undefined) {
+            if (!run.expectedBySlot.has(input.slotId) || run.slotReservations.has(input.slotId)) {
+                return yield* effect_1.Effect.fail(coreInvalid());
+            }
+            run.slotReservations.set(input.slotId, input.reservation);
+        }
+        const mutation = yield* effect_1.Deferred.make();
+        run.inFlightMutations.add(mutation);
+        return mutation;
+    }));
+}
+function finishRunMutation(run, mutation, exit) {
+    return run.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+        run.inFlightMutations.delete(mutation);
+        if (!effect_1.Exit.isSuccess(exit) && !run.markerCreated) {
+            run.state = "failed";
+            consumeRunCapabilities(run);
+        }
+    })).pipe(effect_1.Effect.zipRight(effect_1.Deferred.succeed(mutation, undefined).pipe(effect_1.Effect.asVoid)));
+}
+/**
+ * Publication consumes every writer capability for the Run, including child
+ * Attempt capabilities. Durable visibility is still the complete marker; the
+ * in-memory handles must never remain usable after that point.
+ */
+function consumeRunCapabilities(run) {
+    run.closed = true;
+    if (run.handle !== undefined) {
+        runSessions.delete(run.handle);
+        run.handle = undefined;
+    }
+    for (const attempt of run.attempts.values()) {
+        consumeAttemptCapability(attempt);
+    }
+}
+/** Remove the exact-object authority before a completed/failed Attempt escapes. */
+function consumeAttemptCapability(attempt) {
+    if (attempt.handle !== undefined) {
+        attemptSessions.delete(attempt.handle);
+        attempt.handle = undefined;
+    }
+}
+function fixedFamilyWriteInvalid() {
+    return (0, errors_ts_1.recordAttachmentClosureInvalid)([
+        (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-id-mismatch", ["family"]),
+    ]);
+}
+function attachmentEncodeFailure(error) {
+    return (0, errors_ts_4.recordAttachmentEncodeError)(error);
+}
+function nextBlobKey(entropy, forbidden, remaining = ENTROPY_RETRY_LIMIT) {
+    return effect_1.Effect.flatMap(entropy.uuid, (candidate) => {
+        if ((0, identifiers_ts_1.isPortableSegment)(candidate) && !forbidden.has(candidate)) {
+            return effect_1.Effect.succeed(candidate);
+        }
+        return remaining > 0
+            ? nextBlobKey(entropy, forbidden, remaining - 1)
+            : effect_1.Effect.fail(coreInvalid());
+    });
+}
+function allocateBlobKeys(input) {
+    return effect_1.Effect.gen(function* () {
+        const forbidden = new Set((0, attachment_payload_ts_1.attachmentPayloadStrings)(input.payload));
+        const keys = new Map();
+        for (const blob of input.blobs) {
+            const key = yield* nextBlobKey(input.entropy, forbidden);
+            forbidden.add(key);
+            keys.set(blob.ref, key);
+        }
+        return keys;
+    });
+}
+function reserveFixedAttachment(input) {
+    return input.run.mutex.withPermits(1)(effect_1.Effect.suspend(() => {
+        if (input.run.state !== "open") {
+            return effect_1.Effect.fail(stateError("record", input.run.state));
+        }
+        if (input.target.attachments.has(input.attachment.name) ||
+            consumedFixedFamilyWrites.has(input.attachment.write)) {
+            return effect_1.Effect.fail(stateError("record", input.run.state));
+        }
+        input.target.attachments.set(input.attachment.name, input.attachment);
+        consumedFixedFamilyWrites.set(input.attachment.write, input.target);
+        return effect_1.Effect.void;
+    }));
+}
+function assertAttemptCollecting(attempt) {
+    return attempt.mutex.withPermits(1)(effect_1.Effect.suspend(() => attempt.state === "open"
+        ? effect_1.Effect.void
+        : effect_1.Effect.fail(stateError("record", attempt.draft.state))));
+}
+function writeFixedAttachment(input) {
+    return effect_1.Effect.flatMap(beginRunMutation(input.run, { operation: "record" }), (mutation) => effect_1.Effect.gen(function* () {
+        if (input.target !== input.run) {
+            yield* assertAttemptCollecting(input.target);
+        }
+        const captured = (0, internal_ts_1.recordAttachmentWriteContents)(input.write);
+        if (effect_1.Either.isLeft(captured))
+            return yield* effect_1.Effect.fail(captured.left);
+        if (!sameFixedAttachmentWrite(captured.right.fixed, input.descriptor)) {
+            return yield* effect_1.Effect.fail(fixedFamilyWriteInvalid());
+        }
+        const encodedPayload = input.descriptor.write.encodePayload(captured.right.payload);
+        if (effect_1.Either.isLeft(encodedPayload)) {
+            return yield* effect_1.Effect.fail(attachmentEncodeFailure(encodedPayload.left));
+        }
+        const attachment = Object.freeze({
+            owner: input.owner,
+            name: input.descriptor.family,
+            base: input.base,
+            descriptor: input.descriptor,
+            write: input.write,
+            blobCount: captured.right.blobs.length,
+            attemptId: input.target === input.run
+                ? undefined
+                : input.target.attemptId,
+        });
+        yield* reserveFixedAttachment({ run: input.run, target: input.target, attachment });
+        const blobKeys = yield* allocateBlobKeys({
+            entropy: input.run.entropy,
+            payload: encodedPayload.right,
+            blobs: captured.right.blobs,
+        });
+        const storedPayload = (0, attachment_payload_ts_1.encodeAttachmentPayloadForStorage)({
+            payload: encodedPayload.right,
+            blobKeys,
+        });
+        if (effect_1.Either.isLeft(storedPayload)) {
+            return yield* effect_1.Effect.fail(attachmentEncodeFailure(storedPayload.left));
+        }
+        const encodedEnvelope = (0, catalog_ts_1.encodeFixedRecordAttachmentEnvelope)({
+            family: input.descriptor.family,
+            schemaVersion: input.descriptor.schemaVersion,
+        });
+        if (effect_1.Either.isLeft(encodedEnvelope)) {
+            return yield* effect_1.Effect.fail(fixedFamilyWriteInvalid());
+        }
+        const attachmentRoot = (0, services_ts_1.recordPortablePath)(input.base.root, ...input.base.segments, input.descriptor.family);
+        yield* input.run.fileSystem.ensureDirectory(input.base);
+        yield* input.run.fileSystem.createDirectory(attachmentRoot);
+        yield* input.run.fileSystem.writeFile({
+            file: (0, services_ts_1.recordPortablePath)(input.base.root, ...attachmentRoot.segments, "attachment.json"),
+            bytes: jsonBytes(encodedEnvelope.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* input.run.fileSystem.writeFile({
+            file: (0, services_ts_1.recordPortablePath)(input.base.root, ...attachmentRoot.segments, "payload.json"),
+            bytes: (0, attachment_payload_ts_1.encodeRecordAttachmentJsonBytes)(storedPayload.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* effect_1.Effect.forEach(captured.right.blobs, (blob) => {
+            const key = blobKeys.get(blob.ref);
+            if (key === undefined) {
+                throw new Error("Record fixed Attachment lost its writer-assigned blob key");
+            }
+            return input.run.fileSystem.writeFileStream({
+                file: (0, services_ts_1.recordPortablePath)(input.base.root, ...attachmentRoot.segments, "blobs", key),
+                stream: blob.stream,
+                maximumBytes: Math.min(MAXIMUM_ATTACHMENT_BLOB_BYTES, input.descriptor.write.budget.maximumBlobBytes),
+                mode: "exclusive",
+            });
+        }, { discard: true });
+    }).pipe(effect_1.Effect.onExit((exit) => finishRunMutation(input.run, mutation, exit))));
+}
+function validateAndSyncFixedAttachment(run, attachment) {
+    return effect_1.Effect.gen(function* () {
+        const captured = (0, internal_ts_1.recordAttachmentWriteContents)(attachment.write);
+        if (effect_1.Either.isLeft(captured) ||
+            !sameFixedAttachmentWrite(captured.right.fixed, attachment.descriptor) ||
+            captured.right.blobs.length !== attachment.blobCount) {
+            return yield* effect_1.Effect.fail(effect_1.Either.isLeft(captured) ? captured.left : fixedFamilyWriteInvalid());
+        }
+        const encodedPayload = attachment.descriptor.write.encodePayload(captured.right.payload);
+        if (effect_1.Either.isLeft(encodedPayload)) {
+            return yield* effect_1.Effect.fail(attachmentEncodeFailure(encodedPayload.left));
+        }
+        const root = (0, services_ts_1.recordPortablePath)(attachment.base.root, ...attachment.base.segments, attachment.name);
+        const blobs = (0, services_ts_1.recordPortablePath)(attachment.base.root, ...root.segments, "blobs");
+        if ((yield* run.fileSystem.pathKind(blobs)) === "directory") {
+            yield* run.fileSystem.syncDirectory(blobs);
+        }
+        yield* run.fileSystem.syncDirectory(root);
+        yield* run.fileSystem.syncDirectory(attachment.base);
+        const materialized = yield* (0, runtime_ts_1.readFixedRecordAttachment)({
+            fileSystem: run.fileSystem,
+            root: run.root,
+            location: attachment.owner === "run"
+                ? Object.freeze({ owner: "run", runId: run.runId })
+                : Object.freeze({
+                    owner: "attempt",
+                    runId: run.runId,
+                    attemptId: attachment.attemptId,
+                }),
+            descriptor: attachment.descriptor,
+        });
+        if (materialized.state !== "available") {
+            return yield* effect_1.Effect.fail(fixedFamilyWriteInvalid());
+        }
+        if (!(yield* validateFixedCrossFamilyJoin({
+            fileSystem: run.fileSystem,
+            root: run.root,
+            runId: run.runId,
+            ...(attachment.owner === "attempt" ? { attemptId: attachment.attemptId } : {}),
+            descriptor: attachment.descriptor,
+            payload: materialized.value,
+        }))) {
+            return yield* effect_1.Effect.fail(fixedFamilyWriteInvalid());
+        }
+    });
+}
+function validateAndSyncFixedAttachments(run) {
+    return effect_1.Effect.gen(function* () {
+        yield* effect_1.Effect.forEach(run.attachments.values(), (attachment) => validateAndSyncFixedAttachment(run, attachment), { discard: true });
+        for (const attempt of run.attempts.values()) {
+            yield* effect_1.Effect.forEach(attempt.attachments.values(), (attachment) => validateAndSyncFixedAttachment(run, attachment), { discard: true });
+            const attemptDirectory = runPath(run.root, run.runId, "attempts", attempt.attemptId);
+            if ((yield* run.fileSystem.pathKind(attemptDirectory)) === "directory") {
+                yield* run.fileSystem.syncDirectory(attemptDirectory);
+            }
+        }
+        const members = runPath(run.root, run.runId, "members");
+        if ((yield* run.fileSystem.pathKind(members)) === "directory") {
+            yield* run.fileSystem.syncDirectory(members);
+        }
+        const attempts = runPath(run.root, run.runId, "attempts");
+        if ((yield* run.fileSystem.pathKind(attempts)) === "directory") {
+            yield* run.fileSystem.syncDirectory(attempts);
+        }
+    });
+}
+function writeRunFamily(input) {
+    return writeFixedAttachment({
+        run: input.run,
+        target: input.run,
+        owner: "run",
+        base: runPath(input.run.root, input.run.runId, "attachments"),
+        descriptor: input.descriptor,
+        write: input.value,
+    });
+}
+function writeAttemptFamily(input) {
+    return writeFixedAttachment({
+        run: input.attempt.draft,
+        target: input.attempt,
+        owner: "attempt",
+        base: runPath(input.attempt.draft.root, input.attempt.draft.runId, "attempts", input.attempt.attemptId, "attachments"),
+        descriptor: input.descriptor,
+        write: input.value,
+    });
+}
+function completeAttempt(attempt, outcome) {
+    return effect_1.Effect.flatMap(beginRunMutation(attempt.draft, { operation: "record" }), (mutation) => effect_1.Effect.gen(function* () {
+        yield* attempt.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
+            yield* assertRunLive(attempt.draft);
+            if (attempt.state !== "open") {
+                return yield* effect_1.Effect.fail(stateError("record", attempt.draft.state));
+            }
+            attempt.state = "completing";
+        }));
+        const slot = attempt.draft.expectedBySlot.get(attempt.slotId);
+        if (slot === undefined)
+            return yield* effect_1.Effect.fail(coreInvalid());
+        const document = {
+            attemptId: attempt.attemptId,
+            originRunId: attempt.draft.runId,
+            slotId: attempt.slotId,
+            evalId: slot.evalId,
+            executionIdentityDigest: slot.executionIdentityDigest,
+            outcome,
+        };
+        const member = {
+            slotId: attempt.slotId,
+            action: "executed",
+            attempt: { originRunId: attempt.draft.runId, attemptId: attempt.attemptId },
+        };
+        const encodedAttempt = (0, index_ts_1.encodeAttemptDocument)(document);
+        const encodedMember = (0, index_ts_1.encodeMemberDocument)(member);
+        if (effect_1.Either.isLeft(encodedAttempt) || effect_1.Either.isLeft(encodedMember)) {
+            return yield* effect_1.Effect.fail(coreInvalid());
+        }
+        yield* attempt.draft.fileSystem.writeFile({
+            file: runPath(attempt.draft.root, attempt.draft.runId, "attempts", attempt.attemptId, "attempt.json"),
+            bytes: jsonBytes(encodedAttempt.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* attempt.draft.fileSystem.writeFile({
+            file: runPath(attempt.draft.root, attempt.draft.runId, "members", `${attempt.slotId}.json`),
+            bytes: jsonBytes(encodedMember.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* attempt.mutex.withPermits(1)(attempt.draft.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+            attempt.state = "completed";
+            attempt.document = document;
+            attempt.draft.membership.set(attempt.slotId, { document: member });
+        })));
+        yield* effect_1.Deferred.succeed(attempt.settled, undefined).pipe(effect_1.Effect.asVoid);
+    }).pipe(effect_1.Effect.onExit((exit) => attempt.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+        if (!effect_1.Exit.isSuccess(exit) && attempt.state === "completing") {
+            attempt.state = "failed";
+        }
+    })).pipe(effect_1.Effect.zipRight(effect_1.Deferred.succeed(attempt.settled, undefined).pipe(effect_1.Effect.asVoid)), effect_1.Effect.zipRight(finishRunMutation(attempt.draft, mutation, exit)))))).pipe(
+    // Complete is terminal even when its durable write fails or is interrupted.
+    // A leaked session must then fail at the capability boundary, not re-enter
+    // the draft state machine.
+    effect_1.Effect.onExit(() => effect_1.Effect.sync(() => consumeAttemptCapability(attempt))));
+}
+function makeAttemptSession(attempt) {
+    const session = Object.freeze({
+        attemptId: attempt.attemptId,
+        slotId: attempt.slotId,
+        [types_ts_1.attemptWriteSessionBrand]: () => undefined,
+        complete(outcome) {
+            return attemptSessions.get(this) === attempt
+                ? completeAttempt(attempt, outcome)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeAssertions(value) {
+            return attemptSessions.get(this) === attempt
+                ? writeAttemptFamily({
+                    attempt,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.assertions,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeAttemptObservability(value) {
+            return attemptSessions.get(this) === attempt
+                ? writeAttemptFamily({
+                    attempt,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeFileChanges(value) {
+            return attemptSessions.get(this) === attempt
+                ? writeAttemptFamily({
+                    attempt,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.fileChanges,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeSourceNavigation(value) {
+            return attemptSessions.get(this) === attempt
+                ? writeAttemptFamily({
+                    attempt,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sourceNavigation,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeAttemptArtifacts(value) {
+            return attemptSessions.get(this) === attempt
+                ? writeAttemptFamily({
+                    attempt,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.attempt,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+    });
+    attempt.handle = session;
+    attemptSessions.set(session, attempt);
+    return session;
+}
+function createAttempt(run, input) {
+    return effect_1.Effect.flatMap(beginRunMutation(run, {
+        operation: "create-attempt",
+        slotId: input.slotId,
+        reservation: "attempt",
+    }), (mutation) => effect_1.Effect.gen(function* () {
+        const attemptId = yield* createFreshAttemptDirectory(run);
+        const mutex = yield* effect_1.Effect.makeSemaphore(1);
+        const settled = yield* effect_1.Deferred.make();
+        const attempt = {
+            draft: run,
+            attemptId,
+            slotId: input.slotId,
+            mutex,
+            settled,
+            state: "open",
+            document: undefined,
+            attachments: new Map(),
+            handle: undefined,
+        };
+        yield* run.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+            run.attempts.set(attemptId, attempt);
+        }));
+        return makeAttemptSession(attempt);
+    }).pipe(effect_1.Effect.onExit((exit) => finishRunMutation(run, mutation, exit))));
+}
+function assertSelectedReference(root, ref) {
+    const selected = selectedAttemptCapabilities.get(ref);
+    return selected === undefined || selected.lifecycle.closed || !sameRoot(selected.root, root)
+        ? effect_1.Effect.fail(referenceInvalid())
+        : effect_1.Effect.void;
+}
+function referenceAttempt(run, input) {
+    return effect_1.Effect.flatMap(assertSelectedReference(run.root, input.attempt), () => effect_1.Effect.flatMap(beginRunMutation(run, {
+        operation: "reference",
+        slotId: input.slotId,
+        reservation: "reference",
+    }), (mutation) => effect_1.Effect.gen(function* () {
+        const member = {
+            slotId: input.slotId,
+            action: input.action,
+            attempt: {
+                originRunId: input.attempt.originRunId,
+                attemptId: input.attempt.attemptId,
+            },
+        };
+        yield* validateReference(run, { document: member });
+        const encoded = (0, index_ts_1.encodeMemberDocument)(member);
+        if (effect_1.Either.isLeft(encoded))
+            return yield* effect_1.Effect.fail(coreInvalidFromCodec(encoded.left));
+        yield* run.fileSystem.ensureDirectory(runPath(run.root, run.runId, "members"));
+        yield* run.fileSystem.writeFile({
+            file: runPath(run.root, run.runId, "members", `${input.slotId}.json`),
+            bytes: jsonBytes(encoded.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* run.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+            run.membership.set(input.slotId, { document: member });
+        }));
+    }).pipe(effect_1.Effect.onExit((exit) => finishRunMutation(run, mutation, exit)))));
+}
+function recordTerminalMember(run, input) {
+    return effect_1.Effect.flatMap(beginRunMutation(run, {
+        operation: "record",
+        slotId: input.slotId,
+        reservation: "terminal",
+    }), (mutation) => effect_1.Effect.gen(function* () {
+        const member = {
+            slotId: input.slotId,
+            action: input.action,
+            attempt: null,
+        };
+        const encoded = (0, index_ts_1.encodeMemberDocument)(member);
+        if (effect_1.Either.isLeft(encoded))
+            return yield* effect_1.Effect.fail(coreInvalidFromCodec(encoded.left));
+        yield* run.fileSystem.ensureDirectory(runPath(run.root, run.runId, "members"));
+        yield* run.fileSystem.writeFile({
+            file: runPath(run.root, run.runId, "members", `${input.slotId}.json`),
+            bytes: jsonBytes(encoded.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* run.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+            run.membership.set(input.slotId, { document: member });
+        }));
+    }).pipe(effect_1.Effect.onExit((exit) => finishRunMutation(run, mutation, exit))));
+}
+function draftRunDocument(run, completion) {
+    return Object.freeze({
+        runId: run.runId,
+        experimentId: run.experimentId,
+        context: run.context,
+        startedAt: run.startedAt,
+        completedAt: completion.completedAt,
+        expectedSlots: Object.freeze([...run.expectedSlots]),
+    });
+}
+function readPublishedAttempts(fileSystem, root, runId) {
+    return effect_1.Effect.flatMap(readRunAttempts(fileSystem, root, runId), (attempts) => attempts === undefined ? effect_1.Effect.fail(coreInvalid()) : effect_1.Effect.succeed(attempts));
+}
+function readPublishedMembers(fileSystem, root, runId) {
+    return effect_1.Effect.flatMap(readRunMembers(fileSystem, root, runId), (members) => members === undefined ? effect_1.Effect.fail(coreInvalid()) : effect_1.Effect.succeed(members));
+}
+function scanPublishedCore(fileSystem, root, omitRunId) {
+    return effect_1.Effect.gen(function* () {
+        const entries = orderedEntries(yield* fileSystem.listDirectory({
+            directory: recordPath(root, "runs"),
+            maximumEntries: MAXIMUM_RUN_ENTRIES,
+        }));
+        const runs = [];
+        for (const entry of entries) {
+            if (entry.kind !== "directory")
+                continue;
+            const runId = decodeRunId(entry.name);
+            if (runId === undefined || runId === omitRunId)
+                continue;
+            if (!(yield* isSealedRun(fileSystem, root, runId)))
+                continue;
+            const run = yield* readRunDocument(fileSystem, root, runId);
+            if (run === undefined)
+                return yield* effect_1.Effect.fail(coreInvalid());
+            const members = yield* readPublishedMembers(fileSystem, root, runId);
+            const attempts = yield* readPublishedAttempts(fileSystem, root, runId);
+            runs.push(Object.freeze({ run, members, attempts }));
+        }
+        return Object.freeze(runs);
+    });
+}
+function validateReference(run, member) {
+    return effect_1.Effect.gen(function* () {
+        const reference = member.document.attempt;
+        if (reference === null)
+            return;
+        if (!(yield* isSealedRun(run.fileSystem, run.root, reference.originRunId))) {
+            return yield* effect_1.Effect.fail(referenceInvalid());
+        }
+        const source = yield* readAttemptDocument(run.fileSystem, run.root, reference);
+        const originRun = yield* readRunDocument(run.fileSystem, run.root, reference.originRunId);
+        const expected = run.expectedBySlot.get(member.document.slotId);
+        if (source === undefined || expected === undefined || originRun === undefined) {
+            return yield* effect_1.Effect.fail(referenceInvalid());
+        }
+        const originExpected = originRun.expectedSlots.find((slot) => slot.slotId === source.slotId);
+        if (originExpected === undefined)
+            return yield* effect_1.Effect.fail(referenceInvalid());
+        if (source.slotId !== originExpected.slotId
+            || source.evalId !== originExpected.evalId
+            || source.executionIdentityDigest !== originExpected.executionIdentityDigest) {
+            return yield* effect_1.Effect.fail(referenceInvalid());
+        }
+        if (member.document.action === "accepted") {
+            // Explicit adoption occupies a current target Slot. The origin Attempt
+            // keeps its own Slot identity; only the exact sealed reference is required.
+            return;
+        }
+        if (expected.slotId !== originExpected.slotId
+            || expected.evalId !== originExpected.evalId
+            || expected.attemptOrdinal !== originExpected.attemptOrdinal
+            || expected.executionIdentityDigest !== originExpected.executionIdentityDigest) {
+            return yield* effect_1.Effect.fail(referenceInvalid());
+        }
+    });
+}
+function startSeal(run) {
+    return run.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
+        yield* assertRunLive(run);
+        if (run.state !== "open")
+            return yield* effect_1.Effect.fail(stateError("publish", run.state));
+        run.state = "publishing";
+        return Object.freeze([...run.inFlightMutations]);
+    }));
+}
+function sealRun(run, completion) {
+    return effect_1.Effect.flatMap(startSeal(run), (inFlight) => effect_1.Effect.gen(function* () {
+        yield* effect_1.Effect.forEach(inFlight, (mutation) => effect_1.Deferred.await(mutation), {
+            discard: true,
+        });
+        const attempts = yield* run.mutex.withPermits(1)(effect_1.Effect.sync(() => Object.freeze([...run.attempts.values()])));
+        yield* effect_1.Effect.forEach(attempts, (attempt) => effect_1.Deferred.await(attempt.settled), {
+            discard: true,
+        });
+        yield* run.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
+            if (run.state !== "publishing")
+                return yield* effect_1.Effect.fail(stateError("publish", run.state));
+            if (run.inFlightMutations.size !== 0 || attempts.some((attempt) => attempt.state !== "completed")) {
+                return yield* effect_1.Effect.fail(stateError("publish", "failed"));
+            }
+        }));
+        yield* validateAndSyncFixedAttachments(run);
+        for (const slot of run.expectedSlots) {
+            if (!run.membership.has(slot.slotId)) {
+                return yield* effect_1.Effect.fail(coreInvalid());
+            }
+        }
+        const draft = draftRunDocument(run, completion);
+        for (const member of run.membership.values()) {
+            if (member.document.attempt !== null && member.document.attempt.originRunId !== run.runId) {
+                yield* validateReference(run, member);
+            }
+        }
+        const existing = yield* scanPublishedCore(run.fileSystem, run.root, run.runId);
+        const currentAttempts = attempts.map((attempt) => attempt.document);
+        if (currentAttempts.some((document) => document === undefined)) {
+            return yield* effect_1.Effect.fail(coreInvalid());
+        }
+        const currentMembers = [...run.membership.values()]
+            .map((member) => member.document)
+            .sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.slotId, right.slotId));
+        const aggregate = {
+            record: run.record,
+            runs: Object.freeze([...existing, Object.freeze({
+                    run: draft,
+                    members: Object.freeze(currentMembers),
+                    attempts: Object.freeze(currentAttempts
+                        .sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.attemptId, right.attemptId))),
+                })].sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.run.runId, right.run.runId))),
+        };
+        const aggregateEncoded = (0, index_ts_1.encodeRecordCore)(aggregate);
+        if (effect_1.Either.isLeft(aggregateEncoded))
+            return yield* effect_1.Effect.fail(coreInvalidFromCodec(aggregateEncoded.left));
+        const encoded = (0, index_ts_1.encodeRunDocument)(draft);
+        if (effect_1.Either.isLeft(encoded))
+            return yield* effect_1.Effect.fail(coreInvalidFromCodec(encoded.left));
+        yield* run.fileSystem.writeFile({
+            file: runPath(run.root, run.runId, "run.json"),
+            bytes: jsonBytes(encoded.right),
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+            mode: "exclusive",
+        });
+        yield* effect_1.Effect.uninterruptibleMask(() => effect_1.Effect.gen(function* () {
+            yield* run.fileSystem.syncDirectory(runPath(run.root, run.runId));
+            yield* run.fileSystem.createCompleteMarker({ root: run.root, runId: run.runId });
+            yield* effect_1.Effect.sync(() => {
+                run.markerCreated = true;
+                run.state = "published";
+                consumeRunCapabilities(run);
+            });
+            yield* run.fileSystem.syncDirectory(runPath(run.root, run.runId));
+            yield* run.fileSystem.syncDirectory(recordPath(run.root, "runs"));
+        }));
+        return Object.freeze({ runId: run.runId, state: "sealed" });
+    }).pipe(effect_1.Effect.onExit((exit) => effect_1.Exit.isSuccess(exit)
+        ? effect_1.Effect.void
+        :
+            run.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+                if (!run.markerCreated)
+                    run.state = "failed";
+            }))))).pipe(
+    // `startSeal` itself may fail, so this finalizer belongs outside the
+    // flatMap. Both a failed seal and a published Run consume every writer
+    // authority.
+    effect_1.Effect.onExit(() => effect_1.Effect.sync(() => consumeRunCapabilities(run))));
+}
+function makeRunSession(run) {
+    const session = Object.freeze({
+        runId: run.runId,
+        [types_ts_1.runWriteSessionBrand]: () => undefined,
+        createAttempt(input) {
+            return runSessions.get(this) === run
+                ? createAttempt(run, input)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        referenceAttempt(input) {
+            return runSessions.get(this) === run
+                ? referenceAttempt(run, input)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        recordAcceptedMembership(input) {
+            return runSessions.get(this) === run
+                ? referenceAttempt(run, { slotId: input.slotId, action: "accepted", attempt: input.attempt })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        recordTerminalMember(input) {
+            return runSessions.get(this) === run
+                ? recordTerminalMember(run, input)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeSources(value) {
+            return runSessions.get(this) === run
+                ? writeRunFamily({
+                    run,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.sources,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeRunObservability(value) {
+            return runSessions.get(this) === run
+                ? writeRunFamily({
+                    run,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.run,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeRunArtifacts(value) {
+            return runSessions.get(this) === run
+                ? writeRunFamily({
+                    run,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.run,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        seal(completion) {
+            return runSessions.get(this) === run
+                ? sealRun(run, completion)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+    });
+    run.handle = session;
+    runSessions.set(session, run);
+    return session;
+}
+function makeReferenceRunSession(run) {
+    const session = Object.freeze({
+        runId: run.runId,
+        [types_ts_1.runWriteSessionBrand]: () => undefined,
+        referenceAttempt(input) {
+            return runSessions.get(this) === run
+                ? referenceAttempt(run, input)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        recordAcceptedMembership(input) {
+            return runSessions.get(this) === run
+                ? referenceAttempt(run, { slotId: input.slotId, action: "accepted", attempt: input.attempt })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        recordTerminalMember(input) {
+            return runSessions.get(this) === run
+                ? recordTerminalMember(run, input)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeRunObservability(value) {
+            return runSessions.get(this) === run
+                ? writeRunFamily({
+                    run,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.run,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        writeRunArtifacts(value) {
+            return runSessions.get(this) === run
+                ? writeRunFamily({
+                    run,
+                    descriptor: catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.run,
+                    value,
+                })
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+        seal(completion) {
+            return runSessions.get(this) === run
+                ? sealRun(run, completion)
+                : effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
+        },
+    });
+    run.handle = session;
+    runSessions.set(session, run);
+    return session;
+}
+function openNewRuntime(request) {
+    return effect_1.Effect.gen(function* () {
+        // This must precede bootstrap as well as `createRunDirectory`: malformed
+        // public JS input must not leave even a newly initialized Record skeleton.
+        const expectedSlots = canonicalizeExpectedSlots(request.expectedSlots);
+        if (effect_1.Either.isLeft(expectedSlots)) {
+            return yield* effect_1.Effect.fail(new record_errors_ts_1.RecordCoreInvalid({
+                code: "record-core-invalid",
+                issues: expectedSlots.left,
+            }));
+        }
+        const context = (0, run_context_ts_1.canonicalizeRunContext)(request.context);
+        if (effect_1.Either.isLeft(context)) {
+            return yield* effect_1.Effect.fail(new record_errors_ts_1.RecordCoreInvalid({
+                code: "record-core-invalid",
+                issues: context.left,
+            }));
+        }
+        if (context.right.experimentId !== request.experimentId) {
+            const issues = (0, record_errors_ts_1.nonEmptyRecordIssues)([
+                (0, record_errors_ts_1.recordIssue)("record-run-context-experiment-mismatch", ["context", "experimentId"]),
+            ]);
+            if (issues === undefined)
+                return yield* effect_1.Effect.fail(coreInvalid());
+            return yield* effect_1.Effect.fail(new record_errors_ts_1.RecordCoreInvalid({
+                code: "record-core-invalid",
+                issues,
+            }));
+        }
+        const expectedBySlot = new Map(expectedSlots.right.map((slot) => [slot.slotId, slot]));
+        if (expectedBySlot.size !== expectedSlots.right.length)
+            return yield* effect_1.Effect.fail(coreInvalid());
+        const coordination = yield* record_leases_ts_1.RecordCoordination;
+        const fileSystem = yield* services_ts_1.RecordFileSystem;
+        const entropy = yield* services_ts_1.RecordEntropy;
+        yield* coordination.enterRecordAppend(request.root);
+        if (yield* fileSystem.migrationSentinelPresent(request.root)) {
+            return yield* effect_1.Effect.fail(migrationInterrupted());
+        }
+        yield* initializeRecord({ root: request.root, fileSystem, entropy });
+        const current = yield* (0, format_ts_1.readCurrentRecordFormat)(fileSystem, request.root);
+        yield* coordination.verifyRecordIdentity({ root: request.root, recordId: current.document.recordId });
+        const runId = yield* createFreshRunDirectory(request.root, fileSystem, entropy);
+        const mutex = yield* effect_1.Effect.makeSemaphore(1);
+        const runtime = {
+            root: request.root,
+            fileSystem,
+            entropy,
+            record: current.document,
+            runId,
+            experimentId: request.experimentId,
+            context: context.right,
+            startedAt: request.startedAt,
+            expectedSlots: expectedSlots.right,
+            expectedBySlot,
+            mutex,
+            attempts: new Map(),
+            slotReservations: new Map(),
+            membership: new Map(),
+            attachments: new Map(),
+            inFlightMutations: new Set(),
+            closed: false,
+            markerCreated: false,
+            state: "open",
+            handle: undefined,
+        };
+        yield* effect_1.Effect.addFinalizer(() => runtime.mutex.withPermits(1)(effect_1.Effect.sync(() => {
+            if (!runtime.markerCreated && runtime.state !== "published")
+                runtime.state = "failed";
+            consumeRunCapabilities(runtime);
+        })));
+        return runtime;
+    });
+}
+function openNewRun(request) {
+    return effect_1.Effect.map(openNewRuntime(request), makeRunSession);
+}
+function openNewReferenceRun(request) {
+    return effect_1.Effect.map(openNewRuntime(request), makeReferenceRunSession);
+}
+function openMaintenance(input) {
+    return effect_1.Effect.gen(function* () {
+        const coordination = yield* record_leases_ts_1.RecordCoordination;
+        const fileSystem = yield* services_ts_1.RecordFileSystem;
+        yield* coordination.enterRecordMaintenance(input.root);
+        if (yield* fileSystem.migrationSentinelPresent(input.root)) {
+            return yield* effect_1.Effect.fail(migrationInterrupted());
+        }
+        const inspect = () => currentFormatInspection(fileSystem, input.root);
+        return Object.freeze({
+            inspect,
+            planMigrate: () => effect_1.Effect.map(inspect(), (inspection) => inspection.state === "already-current"
+                ? Object.freeze({ state: "already-current", format: inspection.format })
+                : Object.freeze({ state: "unsupported-format", format: inspection.format })),
+            applyMigrate: (plan) => plan.state === "already-current" && plan.format === identifiers_ts_1.RECORD_FORMAT
+                ? effect_1.Effect.succeed(Object.freeze({ state: "already-current", format: identifiers_ts_1.RECORD_FORMAT }))
+                : effect_1.Effect.fail(new errors_ts_3.RecordFormatUnsupported({
+                    code: "record-format-unsupported",
+                    format: plan.format,
+                })),
+        });
+    });
+}
+exports.recordHost = Object.freeze({
+    current: Object.freeze({
+        openRead: openCurrentRead,
+        createRun: openNewRun,
+        createReferenceRun: openNewReferenceRun,
+    }),
+    maintenance: Object.freeze({ open: openMaintenance }),
+});
+//# sourceMappingURL=runtime.cjs.map