niceeval 0.12.2-canary.31 → 0.13.0

package/dist/record/writer/runtime.cjs

@@ -1,656 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.openRecordWriteSession = void 0;
-const effect_1 = require("effect");
-const index_ts_1 = require("../attachment/index.cjs");
-const internal_ts_1 = require("../attachment/internal.cjs");
-const errors_ts_1 = require("../attachment/errors.cjs");
-const index_ts_2 = require("../codec/index.cjs");
-const record_errors_ts_1 = require("../errors/record-errors.cjs");
-const identifiers_ts_1 = require("../model/identifiers.cjs");
-const validation_ts_1 = require("../model/validation.cjs");
-const errors_ts_2 = require("../platform/errors.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 attachment_payload_ts_1 = require("./attachment-payload.cjs");
-const errors_ts_4 = require("./errors.cjs");
-const limits_ts_1 = require("./limits.cjs");
-const types_ts_1 = require("./types.cjs");
-const BLOB_MAXIMUM_BYTES = 64 * 1024 * 1024;
-const ENTROPY_RETRY_LIMIT = 16;
-const ROOT_EMPTY_CHECK_MAXIMUM_ENTRIES = 1;
-const ROOT_INITIALIZATION_CHECK_MAXIMUM_ENTRIES = 2;
-const sessionStates = new WeakMap();
-const draftStates = new WeakMap();
-const attemptStates = new WeakMap();
-const consumedWrites = new WeakMap();
-function coreInvalidFromIssues(issues) {
-    const nonEmpty = (0, record_errors_ts_1.nonEmptyRecordIssues)(issues);
-    if (nonEmpty === undefined) {
-        throw new Error("RecordCoreInvalid requires at least one issue");
-    }
-    return new record_errors_ts_1.RecordCoreInvalid({ code: "record-core-invalid", issues: nonEmpty });
-}
-function coreInvalidFromCodec(error) {
-    return new record_errors_ts_1.RecordCoreInvalid({
-        code: "record-core-invalid",
-        issues: error.issues,
-    });
-}
-function jsonBytes(value) {
-    return (0, limits_ts_1.encodeRecordJsonUtf8)(value);
-}
-function bytesFromCodec(encoded) {
-    return effect_1.Either.isLeft(encoded)
-        ? effect_1.Effect.fail(coreInvalidFromCodec(encoded.left))
-        : effect_1.Effect.succeed(jsonBytes(encoded.right));
-}
-function bootstrapInvalid() {
-    return new errors_ts_3.RecordBootstrapInvalid({
-        code: "record-bootstrap-invalid",
-        reason: "record-document-invalid",
-    });
-}
-function recordRootPath(root) {
-    return (0, services_ts_1.recordPortablePath)(root);
-}
-function recordDocumentPath(root) {
-    return (0, services_ts_1.recordPortablePath)(root, "record.json");
-}
-function recordRunsPath(root) {
-    return (0, services_ts_1.recordPortablePath)(root, "runs");
-}
-function recordRootIsEmpty(fileSystem, root) {
-    return effect_1.Effect.map(fileSystem.listDirectory({
-        directory: recordRootPath(root),
-        maximumEntries: ROOT_EMPTY_CHECK_MAXIMUM_ENTRIES,
-    }), (entries) => entries.length === 0);
-}
-function assertEmptyRecordRoot(fileSystem, root) {
-    return effect_1.Effect.flatMap(recordRootIsEmpty(fileSystem, root), (empty) => empty ? effect_1.Effect.void : effect_1.Effect.fail(bootstrapInvalid()));
-}
-function assertRecordRootContainsOnlyRuns(fileSystem, root) {
-    return effect_1.Effect.flatMap(fileSystem.listDirectory({
-        directory: recordRootPath(root),
-        maximumEntries: ROOT_INITIALIZATION_CHECK_MAXIMUM_ENTRIES,
-    }), (entries) => entries.length === 1 &&
-        entries[0]?.name === "runs" &&
-        entries[0].kind === "directory"
-        ? effect_1.Effect.void
-        : effect_1.Effect.fail(bootstrapInvalid()));
-}
-function mintRecordDocument(entropy) {
-    const format = effect_1.Schema.decodeUnknownEither(index_ts_2.RecordFormatV1Schema, index_ts_2.RecordExactParseOptions)(identifiers_ts_1.RECORD_FORMAT_V1);
-    if (effect_1.Either.isLeft(format)) {
-        return effect_1.Effect.fail(coreInvalidFromIssues([(0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["format"])]));
-    }
-    return effect_1.Effect.flatMap(entropy.uuid, (raw) => {
-        const recordId = effect_1.Schema.decodeUnknownEither(index_ts_2.RecordIdSchema, index_ts_2.RecordExactParseOptions)(raw);
-        return effect_1.Either.isLeft(recordId)
-            ? effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["recordId"]),
-            ]))
-            : effect_1.Effect.succeed({ format: format.right, recordId: recordId.right });
-    });
-}
-/**
- * Creates the current root identity only when no durable Record state exists.
- * An existing root is deliberately delegated unchanged to the reader, which
- * preserves format and migration diagnostics for partial or foreign state.
- */
-function initializeRecordIfNeeded(input) {
-    return effect_1.Effect.gen(function* () {
-        const rootKind = yield* input.fileSystem.pathKind(recordRootPath(input.root));
-        if (rootKind === "directory") {
-            const documentKind = yield* input.fileSystem.pathKind(recordDocumentPath(input.root));
-            if (documentKind !== "missing") {
-                return;
-            }
-            if ((yield* recordRootIsEmpty(input.fileSystem, input.root)) === false) {
-                return;
-            }
-        }
-        else if (rootKind !== "missing") {
-            return;
-        }
-        const document = yield* mintRecordDocument(input.entropy);
-        const bytes = yield* bytesFromCodec((0, index_ts_2.encodeRecordDocumentV1)(document));
-        yield* input.fileSystem.ensureDirectory(recordRootPath(input.root));
-        yield* assertEmptyRecordRoot(input.fileSystem, input.root);
-        yield* input.fileSystem.createDirectory(recordRunsPath(input.root));
-        yield* assertRecordRootContainsOnlyRuns(input.fileSystem, input.root);
-        yield* input.fileSystem.writeFile({
-            file: recordDocumentPath(input.root),
-            bytes,
-            maximumBytes: format_ts_1.RECORD_FORMAT_DOCUMENT_MAXIMUM_BYTES,
-            mode: "exclusive",
-        });
-        yield* input.fileSystem.syncDirectory(recordRootPath(input.root));
-    });
-}
-function assertSessionLive(session) {
-    return effect_1.Effect.suspend(() => session.closed ? effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)()) : effect_1.Effect.void);
-}
-function assertSessionIdentity(session, runtime) {
-    return effect_1.Effect.flatMap(assertSessionLive(runtime), () => typeof session !== "object" ||
-        session === null ||
-        sessionStates.get(session) !== runtime
-        ? effect_1.Effect.fail((0, errors_ts_4.recordWriteSessionInvalid)())
-        : effect_1.Effect.void);
-}
-function assertDraftIdentity(draft, handle) {
-    return effect_1.Effect.flatMap(assertSessionLive(draft.session), () => draft.handle === undefined ||
-        typeof handle !== "object" ||
-        handle === null ||
-        draftStates.get(handle) !== draft
-        ? effect_1.Effect.fail((0, errors_ts_4.recordDraftHandleInvalid)())
-        : effect_1.Effect.void);
-}
-function assertAttemptIdentity(attempt, handle) {
-    return effect_1.Effect.flatMap(assertSessionLive(attempt.draft.session), () => attempt.handle === undefined ||
-        typeof handle !== "object" ||
-        handle === null ||
-        attemptStates.get(handle) !== attempt
-        ? effect_1.Effect.fail((0, errors_ts_4.recordDraftHandleInvalid)())
-        : effect_1.Effect.void);
-}
-function stateErrorFor(operation, state) {
-    return (0, errors_ts_4.recordDraftStateError)({
-        code: state === "failed" ? "record-draft-write-failed" : "record-draft-state-invalid",
-        operation,
-        state,
-    });
-}
-function beginMutation(draft, operation) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
-        yield* assertSessionLive(draft.session);
-        yield* assertDraftIdentity(draft, draft.handle);
-        if (draft.state !== "open") {
-            return yield* effect_1.Effect.fail(stateErrorFor(operation, draft.state));
-        }
-        if (draft.inFlightMutations === 0) {
-            draft.drained = yield* effect_1.Deferred.make();
-        }
-        draft.inFlightMutations += 1;
-    }));
-}
-function finishMutation(draft, exit) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.sync(() => {
-        if (!effect_1.Exit.isSuccess(exit) && draft.state !== "published") {
-            draft.state = "failed";
-        }
-        if (draft.inFlightMutations <= 0) {
-            throw new Error("Record draft mutation accounting underflow");
-        }
-        draft.inFlightMutations -= 1;
-        if (draft.inFlightMutations !== 0) {
-            return undefined;
-        }
-        const drained = draft.drained;
-        draft.drained = undefined;
-        return drained;
-    })).pipe(effect_1.Effect.flatMap((drained) => drained === undefined
-        ? effect_1.Effect.void
-        : effect_1.Deferred.succeed(drained, undefined).pipe(effect_1.Effect.asVoid)));
-}
-function mutate(draft, operation, work) {
-    return effect_1.Effect.flatMap(beginMutation(draft, operation), () => work.pipe(effect_1.Effect.onExit((exit) => finishMutation(draft, exit))));
-}
-function mintRunId(session) {
-    return effect_1.Effect.flatMap(session.entropy.uuid, (raw) => {
-        const decoded = effect_1.Schema.decodeUnknownEither(index_ts_2.RunIdSchema, index_ts_2.RecordExactParseOptions)(raw);
-        return effect_1.Either.isLeft(decoded)
-            ? effect_1.Effect.fail(coreInvalidFromIssues([(0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["runId"])]))
-            : effect_1.Effect.succeed(decoded.right);
-    });
-}
-function mintAttemptId(draft) {
-    return effect_1.Effect.flatMap(draft.session.entropy.uuid, (raw) => {
-        const decoded = effect_1.Schema.decodeUnknownEither(index_ts_2.AttemptIdSchema, index_ts_2.RecordExactParseOptions)(raw);
-        return effect_1.Either.isLeft(decoded)
-            ? effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["attemptId"]),
-            ]))
-            : effect_1.Effect.succeed(decoded.right);
-    });
-}
-function createFreshRunDirectory(session, remaining = ENTROPY_RETRY_LIMIT) {
-    return effect_1.Effect.flatMap(mintRunId(session), (runId) => session.fileSystem.createRunDirectory({ root: session.root, runId }).pipe(effect_1.Effect.as(runId), effect_1.Effect.catchAll((error) => error instanceof errors_ts_2.RecordPathAlreadyExists && remaining > 0
-        ? createFreshRunDirectory(session, remaining - 1)
-        : effect_1.Effect.fail(error))));
-}
-function makeRunPath(draft, ...segments) {
-    return (0, services_ts_1.recordPortablePath)(draft.session.root, "runs", draft.runId, ...segments);
-}
-function makeAttemptPath(attempt, ...segments) {
-    return makeRunPath(attempt.draft, "attempts", attempt.attemptId, ...segments);
-}
-function reserveMember(draft, slotId, member, operation) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
-        yield* assertSessionLive(draft.session);
-        if (draft.state !== "open" && draft.state !== "publishing") {
-            return yield* effect_1.Effect.fail(stateErrorFor(operation, draft.state));
-        }
-        if (!draft.expectedSlotSet.has(slotId)) {
-            return yield* effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-member-slot-unexpected", ["members", slotId]),
-            ]));
-        }
-        if (draft.members.has(slotId)) {
-            return yield* effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-member-slot-duplicate", ["members", slotId]),
-            ]));
-        }
-        draft.members.set(slotId, member);
-    }));
-}
-function reserveAttempt(draft, attempt) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.suspend(() => {
-        if (draft.attemptsById.has(attempt.attemptId)) {
-            return effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-attempt-duplicate", ["attempts", attempt.attemptId]),
-            ]));
-        }
-        draft.attemptsById.set(attempt.attemptId, attempt);
-        return effect_1.Effect.void;
-    }));
-}
-function reserveAttachment(draft, names, name, write) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.suspend(() => {
-        if (draft.state !== "open" && draft.state !== "publishing") {
-            return effect_1.Effect.fail(stateErrorFor("record", draft.state));
-        }
-        if (consumedWrites.has(write) || names.has(name)) {
-            return effect_1.Effect.fail(stateErrorFor("record", draft.state));
-        }
-        consumedWrites.set(write, draft);
-        names.add(name);
-        return effect_1.Effect.void;
-    }));
-}
-function writeCoreFile(fileSystem, file, bytes) {
-    return fileSystem.writeFile({
-        file,
-        bytes,
-        maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
-        mode: "exclusive",
-    });
-}
-function nextBlobKey(session, forbidden, remaining = ENTROPY_RETRY_LIMIT) {
-    return effect_1.Effect.flatMap(session.entropy.uuid, (candidate) => {
-        if ((0, identifiers_ts_1.isPortableSegment)(candidate) && !forbidden.has(candidate)) {
-            return effect_1.Effect.succeed(candidate);
-        }
-        return remaining > 0
-            ? nextBlobKey(session, forbidden, remaining - 1)
-            : effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-schema-invalid", ["attachments", "blobs"]),
-            ]));
-    });
-}
-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.session, forbidden);
-            forbidden.add(key);
-            keys.set(blob.ref, key);
-        }
-        return keys;
-    });
-}
-function attachmentEncodeFailure(error) {
-    return (0, errors_ts_4.recordAttachmentEncodeError)(error);
-}
-function writeAttachment(input) {
-    return mutate(input.draft, "record", effect_1.Effect.gen(function* () {
-        const captured = (0, internal_ts_1.recordAttachmentWriteContents)(input.write);
-        if (effect_1.Either.isLeft(captured)) {
-            return yield* effect_1.Effect.fail(captured.left);
-        }
-        if (captured.right.definition.owner !== input.owner) {
-            return yield* effect_1.Effect.fail((0, errors_ts_1.recordAttachmentClosureInvalid)([
-                (0, errors_ts_1.recordAttachmentIssue)("record-attachment-owner-invalid", ["owner"]),
-            ]));
-        }
-        const encodedPayload = (0, index_ts_1.encodeJsonRecordAttachmentPayload)(captured.right.definition, captured.right.payload);
-        if (effect_1.Either.isLeft(encodedPayload)) {
-            return yield* effect_1.Effect.fail(attachmentEncodeFailure(encodedPayload.left));
-        }
-        yield* reserveAttachment(input.draft, input.names, captured.right.definition.name, input.write);
-        const blobKeys = yield* allocateBlobKeys({
-            session: input.draft.session,
-            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 payloadBytes = (0, attachment_payload_ts_1.encodeRecordAttachmentJsonBytes)(storedPayload.right);
-        const attachment = {
-            name: captured.right.definition.name,
-            schemaId: captured.right.definition.schemaId,
-        };
-        const attachmentBytes = yield* bytesFromCodec((0, index_ts_2.encodeRecordAttachmentEnvelopeV1)(attachment));
-        const attachmentRoot = (0, services_ts_1.recordPortablePath)(input.base.root, ...input.base.segments, attachment.name);
-        yield* input.draft.session.fileSystem.ensureDirectory(input.base);
-        yield* input.draft.session.fileSystem.createDirectory(attachmentRoot);
-        yield* writeCoreFile(input.draft.session.fileSystem, (0, services_ts_1.recordPortablePath)(input.base.root, ...attachmentRoot.segments, "attachment.json"), attachmentBytes);
-        yield* writeCoreFile(input.draft.session.fileSystem, (0, services_ts_1.recordPortablePath)(input.base.root, ...attachmentRoot.segments, "payload.json"), payloadBytes);
-        yield* effect_1.Effect.forEach(captured.right.blobs, (blob) => {
-            const key = blobKeys.get(blob.ref);
-            if (key === undefined) {
-                throw new Error("Record Attachment closure lost a writer-assigned blob key");
-            }
-            return input.draft.session.fileSystem.writeFileStream({
-                file: (0, services_ts_1.recordPortablePath)(input.base.root, ...attachmentRoot.segments, "blobs", key),
-                stream: blob.stream,
-                maximumBytes: BLOB_MAXIMUM_BYTES,
-                mode: "exclusive",
-            });
-        }, { discard: true });
-    }));
-}
-function verifyReference(session, attempt) {
-    const ref = {
-        originRunId: attempt.originRunId,
-        attemptId: attempt.attemptId,
-    };
-    return session.view.attempt(ref).pipe(effect_1.Effect.flatMap((result) => result.state === "available" && result.value === attempt
-        ? effect_1.Effect.void
-        : effect_1.Effect.fail(new record_errors_ts_1.RecordReferenceInvalid({ code: "record-reference-invalid" }))), effect_1.Effect.catchAll((error) => {
-        if (error instanceof errors_ts_3.RecordReaderClosed) {
-            return effect_1.Effect.fail((0, errors_ts_4.recordWriterClosed)());
-        }
-        if (error instanceof errors_ts_3.RecordHandleInvalid) {
-            return effect_1.Effect.fail(new record_errors_ts_1.RecordReferenceInvalid({ code: "record-reference-invalid" }));
-        }
-        return effect_1.Effect.fail(error);
-    }), effect_1.Effect.asVoid);
-}
-function makeAttemptHandle(attempt) {
-    const handle = {
-        attemptId: attempt.attemptId,
-        [types_ts_1.recordAttemptDraftBrand]: () => undefined,
-        record(write) {
-            return effect_1.Effect.flatMap(assertAttemptIdentity(attempt, this), () => writeAttachment({
-                draft: attempt.draft,
-                names: attempt.attachmentNames,
-                base: makeAttemptPath(attempt, "attachments"),
-                owner: "attempt",
-                write,
-            }));
-        },
-    };
-    const frozen = Object.freeze(handle);
-    attempt.handle = frozen;
-    attemptStates.set(frozen, attempt);
-    return frozen;
-}
-function createAttempt(draft, input) {
-    return mutate(draft, "create-attempt", effect_1.Effect.gen(function* () {
-        let attemptId = yield* mintAttemptId(draft);
-        for (let retries = ENTROPY_RETRY_LIMIT; draft.attemptsById.has(attemptId) && retries > 0; retries -= 1) {
-            attemptId = yield* mintAttemptId(draft);
-        }
-        if (draft.attemptsById.has(attemptId)) {
-            return yield* effect_1.Effect.fail(coreInvalidFromIssues([
-                (0, record_errors_ts_1.recordIssue)("record-attempt-duplicate", ["attempts", attemptId]),
-            ]));
-        }
-        const attempt = {
-            draft,
-            attemptId,
-            slotId: input.slotId,
-            attachmentNames: new Set(),
-            handle: undefined,
-        };
-        const document = {
-            attemptId,
-            originRunId: draft.runId,
-        };
-        const member = {
-            slotId: input.slotId,
-            attempt: { originRunId: draft.runId, attemptId },
-        };
-        yield* reserveMember(draft, input.slotId, {
-            document: member,
-            reference: undefined,
-        }, "create-attempt");
-        yield* reserveAttempt(draft, attempt);
-        const attemptBytes = yield* bytesFromCodec((0, index_ts_2.encodeAttemptDocumentV1)(document));
-        const memberBytes = yield* bytesFromCodec((0, index_ts_2.encodeMemberDocumentV1)(member));
-        yield* writeCoreFile(draft.session.fileSystem, makeAttemptPath(attempt, "attempt.json"), attemptBytes);
-        yield* writeCoreFile(draft.session.fileSystem, makeRunPath(draft, "members", `${input.slotId}.json`), memberBytes);
-        return makeAttemptHandle(attempt);
-    }));
-}
-function referenceAttempt(draft, input) {
-    return mutate(draft, "reference", effect_1.Effect.gen(function* () {
-        yield* verifyReference(draft.session, input.attempt);
-        const member = {
-            slotId: input.slotId,
-            attempt: {
-                originRunId: input.attempt.originRunId,
-                attemptId: input.attempt.attemptId,
-            },
-        };
-        yield* reserveMember(draft, input.slotId, {
-            document: member,
-            reference: input.attempt,
-        }, "reference");
-        const bytes = yield* bytesFromCodec((0, index_ts_2.encodeMemberDocumentV1)(member));
-        yield* writeCoreFile(draft.session.fileSystem, makeRunPath(draft, "members", `${input.slotId}.json`), bytes);
-    }));
-}
-function makeRunHandle(draft) {
-    const handle = {
-        runId: draft.runId,
-        [types_ts_1.recordRunDraftBrand]: () => undefined,
-        record(write) {
-            return effect_1.Effect.flatMap(assertDraftIdentity(draft, this), () => writeAttachment({
-                draft,
-                names: draft.runAttachmentNames,
-                base: makeRunPath(draft, "attachments"),
-                owner: "run",
-                write,
-            }));
-        },
-        createAttempt(input) {
-            return effect_1.Effect.flatMap(assertDraftIdentity(draft, this), () => createAttempt(draft, input));
-        },
-        reference(input) {
-            return effect_1.Effect.flatMap(assertDraftIdentity(draft, this), () => referenceAttempt(draft, input));
-        },
-        publish(input) {
-            return effect_1.Effect.flatMap(assertDraftIdentity(draft, this), () => publishDraft(draft, input));
-        },
-    };
-    const frozen = Object.freeze(handle);
-    draft.handle = frozen;
-    draftStates.set(frozen, draft);
-    return frozen;
-}
-function startPublish(draft) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
-        yield* assertSessionLive(draft.session);
-        if (draft.state !== "open") {
-            return yield* effect_1.Effect.fail(stateErrorFor("publish", draft.state));
-        }
-        draft.state = "publishing";
-        return draft.drained;
-    }));
-}
-function publishFailed(draft, exit) {
-    return effect_1.Exit.isSuccess(exit)
-        ? effect_1.Effect.void
-        : draft.mutex.withPermits(1)(effect_1.Effect.sync(() => {
-            if (draft.state === "publishing") {
-                draft.state = "failed";
-            }
-        }));
-}
-function ensureReadyToPublish(draft) {
-    return draft.mutex.withPermits(1)(effect_1.Effect.gen(function* () {
-        yield* assertSessionLive(draft.session);
-        if (draft.state !== "publishing") {
-            return yield* effect_1.Effect.fail(stateErrorFor("publish", draft.state));
-        }
-        if (draft.inFlightMutations !== 0) {
-            throw new Error("Record draft published before in-flight writes drained");
-        }
-    }));
-}
-function draftReceipt(draft) {
-    const attempts = [];
-    for (const slotId of draft.expectedSlots) {
-        const member = draft.members.get(slotId);
-        if (member === undefined) {
-            continue;
-        }
-        attempts.push(Object.freeze({
-            slotId,
-            ref: Object.freeze({ ...member.document.attempt }),
-        }));
-    }
-    return Object.freeze({
-        runId: draft.runId,
-        attempts: Object.freeze(attempts),
-    });
-}
-function validateReferencesAtPublish(draft) {
-    return effect_1.Effect.forEach([...draft.members.values()], (member) => member.reference === undefined
-        ? effect_1.Effect.void
-        : verifyReference(draft.session, member.reference), { discard: true });
-}
-function finishOrdinaryWrites(draft, completedAt) {
-    return effect_1.Effect.gen(function* () {
-        yield* validateReferencesAtPublish(draft);
-        const run = {
-            runId: draft.runId,
-            startedAt: draft.startedAt,
-            completedAt,
-            expectedSlots: draft.expectedSlots,
-        };
-        const runBytes = yield* bytesFromCodec((0, index_ts_2.encodeRunDocumentV1)(run));
-        yield* writeCoreFile(draft.session.fileSystem, makeRunPath(draft, "run.json"), runBytes);
-        return draftReceipt(draft);
-    });
-}
-function publishDraft(draft, input) {
-    return effect_1.Effect.flatMap(startPublish(draft), (drained) => effect_1.Effect.gen(function* () {
-        if (drained !== undefined) {
-            yield* effect_1.Deferred.await(drained);
-        }
-        yield* ensureReadyToPublish(draft);
-        const receipt = yield* finishOrdinaryWrites(draft, input.completedAt);
-        yield* effect_1.Effect.uninterruptibleMask(() => effect_1.Effect.gen(function* () {
-            yield* draft.session.fileSystem.syncDirectory(makeRunPath(draft));
-            yield* draft.session.fileSystem.createCompleteMarker({
-                root: draft.session.root,
-                runId: draft.runId,
-            });
-            yield* effect_1.Effect.sync(() => {
-                draft.state = "published";
-            });
-        }));
-        return receipt;
-    }).pipe(effect_1.Effect.onExit((exit) => publishFailed(draft, exit))));
-}
-function createRun(session, input) {
-    const issues = (0, validation_ts_1.validateExpectedSlots)(input.expectedSlots);
-    if (issues.length > 0) {
-        return effect_1.Effect.fail(coreInvalidFromIssues(issues));
-    }
-    return effect_1.Effect.gen(function* () {
-        yield* assertSessionLive(session);
-        const runId = yield* createFreshRunDirectory(session);
-        const mutex = yield* effect_1.Effect.makeSemaphore(1);
-        const draft = {
-            session,
-            runId,
-            startedAt: input.startedAt,
-            expectedSlots: Object.freeze([...input.expectedSlots]),
-            expectedSlotSet: new Set(input.expectedSlots),
-            mutex,
-            members: new Map(),
-            attemptsById: new Map(),
-            runAttachmentNames: new Set(),
-            state: "open",
-            inFlightMutations: 0,
-            drained: undefined,
-            handle: undefined,
-        };
-        session.drafts.add(draft);
-        return makeRunHandle(draft);
-    });
-}
-/**
- * @internal Shared by the public opener once reader construction has frozen a
- * view. The session is exact-identity branded and its Scope finalizer only
- * invalidates capabilities; it never deletes an incomplete Run directory.
- */
-function makeRecordWriteSession(input) {
-    return effect_1.Effect.gen(function* () {
-        const runtime = {
-            root: input.root,
-            view: input.view,
-            fileSystem: input.fileSystem,
-            entropy: input.entropy,
-            drafts: new Set(),
-            closed: false,
-        };
-        const session = {
-            [types_ts_1.recordWriteSessionBrand]: () => undefined,
-            view: input.view,
-            createRun(runInput) {
-                return effect_1.Effect.flatMap(assertSessionIdentity(this, runtime), () => createRun(runtime, runInput));
-            },
-        };
-        const frozen = Object.freeze(session);
-        sessionStates.set(frozen, runtime);
-        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => {
-            runtime.closed = true;
-            for (const draft of runtime.drafts) {
-                if (draft.state === "open" || draft.state === "publishing") {
-                    draft.state = "failed";
-                }
-            }
-        }));
-        return frozen;
-    });
-}
-/**
- * Open a scoped writer before any producer work. The outer shared lock fixes
- * maintenance-before-writer ordering; `openRecordReader` retains its own
- * scoped shared lock while constructing the authoritative frozen view.
- */
-const openRecordWriteSession = (input) => effect_1.Effect.gen(function* () {
-    const maintenance = yield* services_ts_1.RecordMaintenanceLock;
-    yield* maintenance.acquireShared(input.root);
-    const writerLock = yield* services_ts_1.RecordWriterLock;
-    yield* writerLock.acquire(input.root);
-    const fileSystem = yield* services_ts_1.RecordFileSystem;
-    const entropy = yield* services_ts_1.RecordEntropy;
-    yield* initializeRecordIfNeeded({
-        root: input.root,
-        fileSystem,
-        entropy,
-    });
-    const view = yield* (0, runtime_ts_1.openRecordReader)({ root: input.root });
-    return yield* makeRecordWriteSession({
-        root: input.root,
-        view,
-        fileSystem,
-        entropy,
-    });
-});
-exports.openRecordWriteSession = openRecordWriteSession;
-//# sourceMappingURL=runtime.cjs.map