@effect-agent/storage-memory 0.1.0-beta.44 → 0.1.0-beta.46

package/dist/MemorySubmissionLedger.mjs

@@ -0,0 +1,1003 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Clock, DateTime, Duration, Effect, Layer, Option, Ref, Schema, Stream } from "effect";
+import { AttemptId, ReceiptId, SubmissionId } from "@effect-agent/core/Identifiers";
+import { PersistedJson, ProducerEpoch } from "@effect-agent/thread/Records";
+import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SuspendRequest, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, settlementFailureFromRecord } from "@effect-agent/thread/SubmissionLedger";
+//#region src/MemorySubmissionLedger.ts
+var MemorySubmissionLedger_exports = /* @__PURE__ */ __exportAll({
+	MemorySubmissionLedgerLive: () => MemorySubmissionLedgerLive,
+	memorySubmissionLedgerLayer: () => memorySubmissionLedgerLayer
+});
+const MAX_SUBMISSIONS = 65536;
+/**
+* Lifecycle ordering used to advance-but-never-regress the operational state marker: a reclaimed
+* Attempt must not erase progress markers (input-applied, terminalizing) that an earlier Attempt
+* already committed.
+*/
+const STATE_RANK = {
+	admitted: 0,
+	ready: 1,
+	joining: 2,
+	joined: 3,
+	running: 4,
+	"input-applied": 5,
+	suspended: 6,
+	unknown: 7,
+	terminalizing: 8,
+	settled: 9
+};
+/**
+* States in which `claim` never grants the head: the lane is host-owned (`joining`/`joined`)
+* or durably suspended rather than worker-claimable. Unknown heads are checked against abort
+* intent separately: abort authorizes cleanup and settlement, never ordinary Tool replay.
+*/
+const BLOCKED_HEAD_STATES = /* @__PURE__ */ new Set([
+	"joining",
+	"joined",
+	"suspended"
+]);
+const failure = (error) => ({
+	_tag: "failure",
+	error
+});
+const success = (value) => ({
+	_tag: "success",
+	value
+});
+const ledgerError = (operation, message, cause) => cause === void 0 ? LedgerError.make({
+	operation,
+	message
+}) : LedgerError.make({
+	operation,
+	message,
+	cause
+});
+const validate = Effect.fn("MemorySubmissionLedger.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => ledgerError(operation, `Invalid ${operation} request`, error))));
+const decodeSubmissionId = Schema.decodeSync(SubmissionId);
+const decodeReceiptId = Schema.decodeSync(ReceiptId);
+const decodeAttemptId = Schema.decodeSync(AttemptId);
+const decodeOwnershipToken = Schema.decodeSync(OwnershipToken);
+const decodeQueueSequence = Schema.decodeSync(QueueSequence);
+const decodeProducerEpoch = Schema.decodeSync(ProducerEpoch);
+const equivalentPersistedJson = Schema.toEquivalence(PersistedJson);
+const equivalentUnknownResolution = Schema.toEquivalence(UnknownResolution);
+const utc = (millis) => DateTime.toUtc(DateTime.makeUnsafe(millis));
+const admissionKey = (threadId, principal, idempotencyKey) => `${threadId}\u001f${principal}\u001f${idempotencyKey}`;
+const toSnapshot = (row) => SubmissionSnapshot.make({
+	submissionId: row.submissionId,
+	threadId: row.threadId,
+	queueSequence: row.queueSequence,
+	principal: row.principal,
+	idempotencyKey: row.idempotencyKey,
+	agentId: row.agentId,
+	agentDigests: row.agentDigests,
+	deploymentId: row.deploymentId,
+	inputPayload: row.inputPayload,
+	inputDigest: row.inputDigest,
+	receiptId: row.receiptId,
+	state: row.state,
+	createdAt: utc(row.createdAtMillis),
+	...row.settledOutcome === void 0 ? {} : { settledOutcome: row.settledOutcome },
+	...row.readyAtMillis === void 0 ? {} : { readyAt: utc(row.readyAtMillis) },
+	...row.parentLinkage === void 0 ? {} : { parentLinkage: row.parentLinkage }
+});
+const toReservationSnapshot = (row) => ChildBudgetReservationSnapshot.make({
+	reservationId: row.reservationId,
+	parentSubmissionId: row.parentSubmissionId,
+	parentToolCallId: row.parentToolCallId,
+	status: row.status,
+	allocation: row.allocation,
+	allocationDigest: row.allocationDigest,
+	reservedAt: utc(row.reservedAtMillis),
+	...row.childSubmissionId === void 0 ? {} : { childSubmissionId: row.childSubmissionId },
+	...row.accounting === void 0 ? {} : { accounting: row.accounting },
+	...row.releaseBeganAtMillis === void 0 ? {} : { releaseBeganAt: utc(row.releaseBeganAtMillis) },
+	...row.releasedAtMillis === void 0 ? {} : { releasedAt: utc(row.releasedAtMillis) }
+});
+/** Linkage equality: both absent, or both present naming the same parent Tool Call. */
+const sameParentLinkage = (left, right) => left === void 0 ? right === void 0 : right !== void 0 && left.parentSubmissionId === right.parentSubmissionId && left.parentToolCallId === right.parentToolCallId;
+const laneEpoch = (state, threadId) => state.lanes.get(threadId)?.producerEpoch ?? 0;
+const ownershipLost = (state, stored) => OwnershipLost.make({
+	submissionId: stored.row.submissionId,
+	actualEpoch: decodeProducerEpoch(laneEpoch(state, stored.row.threadId))
+});
+/** The presented token owns the lane only while it matches the live ownership record. */
+const ownsLane = (stored, ownershipToken) => stored.ownership !== void 0 && stored.ownership.ownershipToken === ownershipToken;
+const withSubmission = (state, stored) => ({
+	...state,
+	submissions: new Map(state.submissions).set(stored.row.submissionId, stored)
+});
+const withChildReservation = (state, reservation) => ({
+	...state,
+	childReservations: new Map(state.childReservations).set(reservation.reservationId, reservation)
+});
+const findHead = (state, threadId) => {
+	let head;
+	for (const stored of state.submissions.values()) {
+		if (stored.row.threadId !== threadId || stored.row.state === "settled") continue;
+		if (head === void 0 || stored.row.queueSequence < head.row.queueSequence) head = stored;
+	}
+	return head;
+};
+/**
+* Reference in-memory SubmissionLedger. It implements the full port contract — atomic idempotent
+* admission, FIFO-head claims, producer-epoch fencing, Clock-driven ownership leases, idempotent
+* settlement reservation/finalization, and durable abort intent — with every transition applied
+* as one atomic `Ref.modify`, but its state does not survive the process (`non-durable`).
+*
+* Adapter-specific semantics within the port's latitude:
+*
+* - Time comes exclusively from the Effect `Clock` service, so `TestClock` drives lease expiry
+*   deterministically; no wall clock is consulted.
+* - The ownership lease is pinned to `DEFAULT_OWNERSHIP_LEASE_DURATION` (D5); durable adapters
+*   own the configuration seam.
+* - A live lease blocks claims from other producers only: the same `producerId` may reclaim its
+*   own live lease (restart recovery), which supersedes and fences the prior Attempt's token.
+* - Claiming advances `ready` to `running` and otherwise preserves the recorded state, so
+*   progress markers from an earlier Attempt survive a reclaim.
+* - `renewOwnership` keeps the token stable (the port allows rotation); a replayed admission
+*   reports the Submission's current state alongside the original identities.
+* - `claimJoining` walks the strictly-later queue: rows already `joining`/`joined` to the
+*   SAME host extend the claimed prefix and are skipped, and an aborted-settled row is a
+*   closed obligation that is also skipped (P7 §7(c)); any other non-`ready` row (an
+*   `admitted` gap, a non-aborted settled row, foreign-host linkage) breaks the prefix
+*   conservatively.
+* - `markJoined` verifies the token against the HOST's live ownership (the lane is
+*   host-owned), so a later host Attempt can repair a lost marker from history (DUR-016). The
+*   join marker reuses the input-applied marker: the joined input IS `input:{sid}`.
+* - `suspend` and `markUnknown` refuse when an exact settlement is already reserved
+*   (`SettlementConflict` with the reserved outcome) — DUR-011's reservation wins.
+* - `resolveAdmission` derives its answer from the single strongly consistent store, so it
+*   never answers `Indeterminate` on its own; the test-only `resolveAdmissionFault` option
+*   injects the `Indeterminate` classification so SUB-031 callers can be conformance-tested.
+* - `recordChildSettled` and `suspend(WaitingForChild)` observe child settlement directly from
+*   the child rows (single-store latitude); no separate notification marker is stored.
+*/
+const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
+	const state = yield* Ref.make({
+		submissions: /* @__PURE__ */ new Map(),
+		admissionIndex: /* @__PURE__ */ new Map(),
+		lanes: /* @__PURE__ */ new Map(),
+		childReservations: /* @__PURE__ */ new Map(),
+		mintCounter: 0
+	});
+	const leaseMillis = Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION);
+	const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "non-durable" }));
+	const admit = Effect.fn("MemorySubmissionLedger.admit")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(AdmissionRequest, "admit", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const key = admissionKey(request.threadId, request.principal, request.idempotencyKey);
+			const existingId = current.admissionIndex.get(key);
+			if (existingId !== void 0) {
+				const existing = current.submissions.get(existingId);
+				if (existing === void 0) return [failure(ledgerError("admit", "Admission index references a missing Submission")), current];
+				if (existing.row.inputDigest !== request.inputDigest || !sameParentLinkage(existing.row.parentLinkage, request.parentLinkage)) return [failure(AdmissionConflict.make({
+					threadId: request.threadId,
+					principal: request.principal,
+					idempotencyKey: request.idempotencyKey,
+					existingInputDigest: existing.row.inputDigest,
+					attemptedInputDigest: request.inputDigest
+				})), current];
+				return [success(AdmissionResult.make({
+					submissionId: existing.row.submissionId,
+					receiptId: existing.row.receiptId,
+					queueSequence: existing.row.queueSequence,
+					state: existing.row.state,
+					replayed: true
+				})), current];
+			}
+			if (current.submissions.size >= MAX_SUBMISSIONS) return [failure(ledgerError("admit", `In-memory submission limit ${MAX_SUBMISSIONS} exceeded`)), current];
+			const lane = current.lanes.get(request.threadId) ?? {
+				nextQueueSequence: 1,
+				producerEpoch: 0
+			};
+			const mintCounter = current.mintCounter + 1;
+			const row = {
+				submissionId: decodeSubmissionId(`submission-memory-${mintCounter}`),
+				threadId: request.threadId,
+				queueSequence: decodeQueueSequence(lane.nextQueueSequence),
+				principal: request.principal,
+				idempotencyKey: request.idempotencyKey,
+				agentId: request.agentId,
+				agentDigests: request.agentDigests,
+				deploymentId: request.deploymentId,
+				inputPayload: request.inputPayload,
+				inputDigest: request.inputDigest,
+				receiptId: decodeReceiptId(`receipt-memory-${mintCounter}`),
+				state: "admitted",
+				settledOutcome: void 0,
+				createdAtMillis: nowMillis,
+				readyAtMillis: void 0,
+				parentLinkage: request.parentLinkage
+			};
+			const submissions = new Map(current.submissions).set(row.submissionId, {
+				row,
+				ownership: void 0,
+				inputApplied: void 0,
+				reservation: void 0,
+				abortIntent: void 0,
+				joinedHostSubmissionId: void 0,
+				suspension: void 0,
+				unknownMark: void 0,
+				approvalDecisions: /* @__PURE__ */ new Map(),
+				unknownResolutions: /* @__PURE__ */ new Map()
+			});
+			const admissionIndex = new Map(current.admissionIndex).set(key, row.submissionId);
+			const lanes = new Map(current.lanes).set(request.threadId, {
+				nextQueueSequence: lane.nextQueueSequence + 1,
+				producerEpoch: lane.producerEpoch
+			});
+			return [success(AdmissionResult.make({
+				submissionId: row.submissionId,
+				receiptId: row.receiptId,
+				queueSequence: row.queueSequence,
+				state: row.state,
+				replayed: false
+			})), {
+				...current,
+				submissions,
+				admissionIndex,
+				lanes,
+				mintCounter
+			}];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const markReady = Effect.fn("MemorySubmissionLedger.markReady")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(MarkReadyRequest, "markReady", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("markReady", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.row.state !== "admitted") return [success(void 0), current];
+			return [success(void 0), withSubmission(current, {
+				...stored,
+				row: {
+					...stored.row,
+					state: "ready",
+					readyAtMillis: nowMillis
+				}
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+	}));
+	const lookup = Effect.fn("MemorySubmissionLedger.lookup")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(SubmissionLookup, "lookup", unvalidated);
+		const current = yield* Ref.get(state);
+		const submissionId = request._tag === "SubmissionLookupById" ? request.submissionId : current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
+		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
+		return stored === void 0 ? Option.none() : Option.some(toSnapshot(stored.row));
+	}));
+	const resolveAdmission = Effect.fn("MemorySubmissionLedger.resolveAdmission")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(SubmissionLookupByKey, "resolveAdmission", unvalidated);
+		if (options.resolveAdmissionFault !== void 0) {
+			const fault = yield* options.resolveAdmissionFault;
+			if (Option.isSome(fault)) return AdmissionIndeterminate.make({ reason: fault.value });
+		}
+		const current = yield* Ref.get(state);
+		const submissionId = current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
+		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
+		return stored === void 0 ? AdmissionNotAdmitted.make() : AdmissionAdmitted.make({ submission: toSnapshot(stored.row) });
+	}));
+	const claim = Effect.fn("MemorySubmissionLedger.claim")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ClaimRequest, "claim", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const head = findHead(current, request.threadId);
+			if (head === void 0) return [success(Option.none()), current];
+			if (BLOCKED_HEAD_STATES.has(head.row.state) || head.row.state === "unknown" && head.abortIntent === void 0) return [success(Option.none()), current];
+			if (head.ownership !== void 0 && head.ownership.leaseExpiresAtMillis > nowMillis && head.ownership.ownerProducerId !== request.producerId) return [success(Option.none()), current];
+			const lane = current.lanes.get(request.threadId);
+			if (lane === void 0) return [failure(ledgerError("claim", "Claimable head without a Thread lane")), current];
+			const producerEpoch = decodeProducerEpoch(lane.producerEpoch + 1);
+			const mintCounter = current.mintCounter + 1;
+			const ownership = {
+				attemptId: decodeAttemptId(`attempt-memory-${mintCounter}`),
+				ownershipToken: decodeOwnershipToken(`ownership-memory-${mintCounter}`),
+				producerEpoch,
+				ownerProducerId: request.producerId,
+				leaseExpiresAtMillis: nowMillis + leaseMillis
+			};
+			const row = head.row.state === "ready" ? {
+				...head.row,
+				state: "running"
+			} : head.row;
+			const next = withSubmission(current, {
+				...head,
+				row,
+				ownership
+			});
+			const lanes = new Map(next.lanes).set(request.threadId, {
+				nextQueueSequence: lane.nextQueueSequence,
+				producerEpoch: lane.producerEpoch + 1
+			});
+			return [success(Option.some(Claim.make({
+				submissionId: row.submissionId,
+				attemptId: ownership.attemptId,
+				ownershipToken: ownership.ownershipToken,
+				producerEpoch,
+				leaseExpiresAt: utc(ownership.leaseExpiresAtMillis),
+				inputPayload: row.inputPayload
+			}))), {
+				...next,
+				lanes,
+				mintCounter
+			}];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const renewOwnership = Effect.fn("MemorySubmissionLedger.renewOwnership")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(RenewOwnershipRequest, "renewOwnership", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("renewOwnership", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.ownership === void 0 || !ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
+			const ownership = {
+				...stored.ownership,
+				leaseExpiresAtMillis: nowMillis + leaseMillis
+			};
+			return [success(OwnershipRenewal.make({
+				ownershipToken: ownership.ownershipToken,
+				leaseExpiresAt: utc(ownership.leaseExpiresAtMillis)
+			})), withSubmission(current, {
+				...stored,
+				ownership
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const releaseOwnership = Effect.fn("MemorySubmissionLedger.releaseOwnership")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ReleaseOwnershipRequest, "releaseOwnership", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("releaseOwnership", `Unknown Submission ${request.submissionId}`)), current];
+			if (!ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
+			return [success(void 0), withSubmission(current, {
+				...stored,
+				ownership: void 0
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+	}));
+	const markInputApplied = Effect.fn("MemorySubmissionLedger.markInputApplied")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(MarkInputAppliedRequest, "markInputApplied", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("markInputApplied", `Unknown Submission ${request.submissionId}`)), current];
+			if (!ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
+			const marker = InputAppliedMarker.make({
+				recordId: request.recordId,
+				sequence: request.sequence
+			});
+			const row = STATE_RANK[stored.row.state] < STATE_RANK["input-applied"] ? {
+				...stored.row,
+				state: "input-applied"
+			} : stored.row;
+			return [success(void 0), withSubmission(current, {
+				...stored,
+				row,
+				inputApplied: marker
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+	}));
+	const reserveSettlement = Effect.fn("MemorySubmissionLedger.reserveSettlement")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(SettlementReservation, "reserveSettlement", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("reserveSettlement", `Unknown Submission ${request.submissionId}`)), current];
+			const joinedSettlement = stored.row.state === "joined" && stored.joinedHostSubmissionId !== void 0;
+			const queuedAbortSettlement = request.outcome === "aborted" && stored.abortIntent !== void 0 && stored.ownership === void 0 && (stored.row.state === "ready" || stored.row.state === "terminalizing");
+			if (!joinedSettlement && !queuedAbortSettlement && !ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
+			const existing = stored.reservation;
+			if (existing !== void 0) {
+				if (existing.settlementId !== request.settlementId || existing.outcome !== request.outcome || existing.recordDigest !== request.recordDigest) return [failure(SettlementConflict.make({
+					submissionId: request.submissionId,
+					existingOutcome: existing.outcome
+				})), current];
+				return [success(ReservedSettlement.make({
+					submissionId: request.submissionId,
+					settlementId: existing.settlementId,
+					outcome: existing.outcome,
+					record: existing.record,
+					recordDigest: existing.recordDigest,
+					replayed: true
+				})), current];
+			}
+			const reservation = {
+				settlementId: request.settlementId,
+				outcome: request.outcome,
+				record: request.record,
+				recordDigest: request.recordDigest,
+				finalizedAtMillis: void 0
+			};
+			const row = STATE_RANK[stored.row.state] < STATE_RANK.terminalizing ? {
+				...stored.row,
+				state: "terminalizing"
+			} : stored.row;
+			return [success(ReservedSettlement.make({
+				submissionId: request.submissionId,
+				settlementId: reservation.settlementId,
+				outcome: reservation.outcome,
+				record: reservation.record,
+				recordDigest: reservation.recordDigest,
+				replayed: false
+			})), withSubmission(current, {
+				...stored,
+				row,
+				reservation
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const finalizeSettlement = Effect.fn("MemorySubmissionLedger.finalizeSettlement")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(SettlementFinalization, "finalizeSettlement", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("finalizeSettlement", `Unknown Submission ${request.submissionId}`)), current];
+			const reservation = stored.reservation;
+			if (reservation === void 0) return [failure(ledgerError("finalizeSettlement", `No settlement reservation for Submission ${request.submissionId}`)), current];
+			const settlementFailure = settlementFailureFromRecord(reservation.record);
+			if (reservation.outcome === "failed" !== (settlementFailure !== void 0)) return [failure(ledgerError("finalizeSettlement", `Settlement reservation for Submission ${request.submissionId} has contradictory failure evidence`)), current];
+			if (reservation.settlementId !== request.settlementId) return [failure(SettlementConflict.make({
+				submissionId: request.submissionId,
+				existingOutcome: reservation.outcome
+			})), current];
+			if (reservation.finalizedAtMillis !== void 0) return [success(Settlement.make({
+				submissionId: stored.row.submissionId,
+				settlementId: reservation.settlementId,
+				receiptId: stored.row.receiptId,
+				outcome: reservation.outcome,
+				...settlementFailure === void 0 ? {} : { failure: settlementFailure },
+				settledAt: utc(reservation.finalizedAtMillis)
+			})), current];
+			const next = withSubmission(current, {
+				...stored,
+				row: {
+					...stored.row,
+					state: "settled",
+					settledOutcome: reservation.outcome
+				},
+				ownership: void 0,
+				reservation: {
+					...reservation,
+					finalizedAtMillis: nowMillis
+				}
+			});
+			return [success(Settlement.make({
+				submissionId: stored.row.submissionId,
+				settlementId: reservation.settlementId,
+				receiptId: stored.row.receiptId,
+				outcome: reservation.outcome,
+				...settlementFailure === void 0 ? {} : { failure: settlementFailure },
+				settledAt: utc(nowMillis)
+			})), next];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const requestAbort = Effect.fn("MemorySubmissionLedger.requestAbort")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(AbortCommand, "requestAbort", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("requestAbort", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.row.state === "joined") {
+				if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("requestAbort", `Joined Submission ${request.submissionId} is missing its host linkage`)), current];
+				return [failure(JoinedToHost.make({
+					submissionId: request.submissionId,
+					hostSubmissionId: stored.joinedHostSubmissionId
+				})), current];
+			}
+			if (stored.row.state === "settled") {
+				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("requestAbort", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
+				return [failure(SettlementConflict.make({
+					submissionId: request.submissionId,
+					existingOutcome: stored.row.settledOutcome
+				})), current];
+			}
+			if (stored.abortIntent !== void 0) return [success(stored.abortIntent), current];
+			const intent = AbortIntent.make({
+				submissionId: request.submissionId,
+				author: request.author,
+				reason: request.reason,
+				requestedAt: utc(nowMillis)
+			});
+			return [success(intent), withSubmission(current, {
+				...stored,
+				abortIntent: intent
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const claimJoining = Effect.fn("MemorySubmissionLedger.claimJoining")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ClaimJoiningRequest, "claimJoining", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const host = current.submissions.get(request.hostSubmissionId);
+			if (host === void 0) return [failure(ledgerError("claimJoining", `Unknown Submission ${request.hostSubmissionId}`)), current];
+			if (host.row.threadId !== request.threadId) return [failure(ledgerError("claimJoining", `Host Submission ${request.hostSubmissionId} does not belong to Thread ${request.threadId}`)), current];
+			if (!ownsLane(host, request.ownershipToken)) return [failure(ownershipLost(current, host)), current];
+			const later = [...current.submissions.values()].filter((stored) => stored.row.threadId === request.threadId && stored.row.queueSequence > host.row.queueSequence).sort((left, right) => left.row.queueSequence - right.row.queueSequence);
+			const claims = [];
+			const submissions = new Map(current.submissions);
+			for (const stored of later) {
+				if (claims.length >= request.maxCount) break;
+				if ((stored.row.state === "joining" || stored.row.state === "joined") && stored.joinedHostSubmissionId === request.hostSubmissionId) continue;
+				if (stored.row.state === "settled" && stored.row.settledOutcome === "aborted") continue;
+				if (stored.row.state !== "ready") break;
+				submissions.set(stored.row.submissionId, {
+					...stored,
+					row: {
+						...stored.row,
+						state: "joining"
+					},
+					joinedHostSubmissionId: request.hostSubmissionId
+				});
+				claims.push(JoiningClaim.make({
+					submissionId: stored.row.submissionId,
+					queueSequence: stored.row.queueSequence,
+					inputPayload: stored.row.inputPayload
+				}));
+			}
+			return [success(claims), {
+				...current,
+				submissions
+			}];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const markJoined = Effect.fn("MemorySubmissionLedger.markJoined")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(MarkJoinedRequest, "markJoined", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("markJoined", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("markJoined", `Submission ${request.submissionId} was never claimed for joining`)), current];
+			const host = current.submissions.get(stored.joinedHostSubmissionId);
+			if (host === void 0) return [failure(ledgerError("markJoined", `Host Submission ${stored.joinedHostSubmissionId} is missing`)), current];
+			if (!ownsLane(host, request.ownershipToken)) return [failure(ownershipLost(current, host)), current];
+			if (stored.inputApplied !== void 0) {
+				if (stored.inputApplied.recordId === request.recordId && stored.inputApplied.sequence === request.sequence) return [success(void 0), current];
+				return [failure(ledgerError("markJoined", `A different join marker is already recorded for Submission ${request.submissionId}`)), current];
+			}
+			if (stored.row.state !== "joining" && stored.row.state !== "joined") return [failure(ledgerError("markJoined", `Cannot mark Submission ${request.submissionId} joined from state ${stored.row.state}`)), current];
+			const marker = InputAppliedMarker.make({
+				recordId: request.recordId,
+				sequence: request.sequence
+			});
+			return [success(void 0), withSubmission(current, {
+				...stored,
+				row: {
+					...stored.row,
+					state: "joined"
+				},
+				inputApplied: marker
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+	}));
+	const revertJoining = Effect.fn("MemorySubmissionLedger.revertJoining")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(RevertJoiningRequest, "revertJoining", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("revertJoining", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.row.state !== "joining") return [success(void 0), current];
+			return [success(void 0), withSubmission(current, {
+				...stored,
+				row: {
+					...stored.row,
+					state: "ready"
+				},
+				joinedHostSubmissionId: void 0
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+	}));
+	const suspend = Effect.fn("MemorySubmissionLedger.suspend")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(SuspendRequest, "suspend", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("suspend", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.row.state === "settled") {
+				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("suspend", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
+				return [failure(SettlementConflict.make({
+					submissionId: request.submissionId,
+					existingOutcome: stored.row.settledOutcome
+				})), current];
+			}
+			if (stored.reservation !== void 0) return [failure(SettlementConflict.make({
+				submissionId: request.submissionId,
+				existingOutcome: stored.reservation.outcome
+			})), current];
+			if (!ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
+			if (request.reason._tag === "ApprovalPending" ? request.reason.toolCallIds.every((toolCallId) => stored.approvalDecisions.has(toolCallId)) : request.reason.children.every((child) => current.submissions.get(child.childSubmissionId)?.row.state === "settled")) return [success("resume-immediately"), current];
+			return [success("suspended"), withSubmission(current, {
+				...stored,
+				row: {
+					...stored.row,
+					state: "suspended"
+				},
+				ownership: void 0,
+				suspension: {
+					reason: request.reason,
+					suspendedAtMillis: nowMillis
+				}
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const recordApprovalDecision = Effect.fn("MemorySubmissionLedger.recordApprovalDecision")((unvalidated) => Effect.gen(function* () {
+		const command = yield* validate(ApprovalDecisionCommand, "recordApprovalDecision", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(command.submissionId);
+			if (stored === void 0) return [failure(ledgerError("recordApprovalDecision", `Unknown Submission ${command.submissionId}`)), current];
+			if (stored.row.state === "settled") {
+				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordApprovalDecision", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
+				return [failure(SettlementConflict.make({
+					submissionId: command.submissionId,
+					existingOutcome: stored.row.settledOutcome
+				})), current];
+			}
+			const existing = stored.approvalDecisions.get(command.toolCallId);
+			if (existing !== void 0) {
+				if (existing.decision !== command.decision) return [failure(ApprovalConflict.make({
+					submissionId: command.submissionId,
+					toolCallId: command.toolCallId,
+					existingDecision: existing.decision
+				})), current];
+				return [success(existing), current];
+			}
+			const intent = ApprovalDecisionIntent.make({
+				submissionId: command.submissionId,
+				toolCallId: command.toolCallId,
+				decision: command.decision,
+				resolver: command.resolver,
+				reason: command.reason,
+				decidedAt: utc(nowMillis)
+			});
+			const approvalDecisions = new Map(stored.approvalDecisions).set(command.toolCallId, intent);
+			const wakes = stored.row.state === "suspended" && stored.suspension !== void 0 && stored.suspension.reason._tag === "ApprovalPending" && stored.suspension.reason.toolCallIds.every((toolCallId) => approvalDecisions.has(toolCallId));
+			return [success(intent), withSubmission(current, {
+				...stored,
+				row: wakes ? {
+					...stored.row,
+					state: "input-applied"
+				} : stored.row,
+				suspension: wakes ? void 0 : stored.suspension,
+				approvalDecisions
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const markUnknown = Effect.fn("MemorySubmissionLedger.markUnknown")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(MarkUnknownRequest, "markUnknown", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return [failure(ledgerError("markUnknown", `Unknown Submission ${request.submissionId}`)), current];
+			if (stored.row.state === "settled") {
+				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("markUnknown", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
+				return [failure(SettlementConflict.make({
+					submissionId: request.submissionId,
+					existingOutcome: stored.row.settledOutcome
+				})), current];
+			}
+			if (stored.reservation !== void 0) return [failure(SettlementConflict.make({
+				submissionId: request.submissionId,
+				existingOutcome: stored.reservation.outcome
+			})), current];
+			const existing = stored.unknownMark;
+			const known = new Set(existing?.toolCallIds ?? []);
+			const merged = [...existing?.toolCallIds ?? [], ...request.toolCallIds.filter((toolCallId) => !known.has(toolCallId))];
+			return [success(void 0), withSubmission(current, {
+				...stored,
+				row: stored.row.state === "unknown" ? stored.row : {
+					...stored.row,
+					state: "unknown"
+				},
+				unknownMark: {
+					reason: existing?.reason ?? request.reason,
+					toolCallIds: merged
+				}
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+	}));
+	const recordUnknownResolution = Effect.fn("MemorySubmissionLedger.recordUnknownResolution")((unvalidated) => Effect.gen(function* () {
+		const command = yield* validate(UnknownResolutionCommand, "recordUnknownResolution", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const stored = current.submissions.get(command.submissionId);
+			if (stored === void 0) return [failure(ledgerError("recordUnknownResolution", `Unknown Submission ${command.submissionId}`)), current];
+			if (stored.row.state === "settled") {
+				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordUnknownResolution", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
+				return [failure(SettlementConflict.make({
+					submissionId: command.submissionId,
+					existingOutcome: stored.row.settledOutcome
+				})), current];
+			}
+			const existing = stored.unknownResolutions.get(command.toolCallId);
+			if (existing !== void 0 && !equivalentUnknownResolution(existing.intent.resolution, command.resolution)) return [failure(UnknownResolutionConflict.make({
+				submissionId: command.submissionId,
+				toolCallId: command.toolCallId
+			})), current];
+			const intent = existing?.intent ?? UnknownResolutionIntent.make({
+				submissionId: command.submissionId,
+				toolCallId: command.toolCallId,
+				author: command.author,
+				reason: command.reason,
+				resolution: command.resolution,
+				resolvedAt: utc(nowMillis)
+			});
+			const unknownResolutions = existing !== void 0 ? stored.unknownResolutions : new Map(stored.unknownResolutions).set(command.toolCallId, { intent });
+			const wakes = stored.row.state === "unknown" && stored.unknownMark !== void 0 && stored.unknownMark.toolCallIds.every((toolCallId) => unknownResolutions.has(toolCallId));
+			return [success(intent), withSubmission(current, {
+				...stored,
+				row: wakes ? {
+					...stored.row,
+					state: "input-applied"
+				} : stored.row,
+				unknownMark: wakes ? void 0 : stored.unknownMark,
+				unknownResolutions
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const recordChildSettled = Effect.fn("MemorySubmissionLedger.recordChildSettled")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ChildSettledNotification, "recordChildSettled", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const parent = current.submissions.get(request.parentSubmissionId);
+			if (parent === void 0) return [failure(ledgerError("recordChildSettled", `Unknown Submission ${request.parentSubmissionId}`)), current];
+			const child = current.submissions.get(request.childSubmissionId);
+			if (!(child !== void 0 && (child.row.state === "settled" || child.row.state === "terminalizing" && child.reservation !== void 0))) return [failure(ledgerError("recordChildSettled", `Child Submission ${request.childSubmissionId} has no recorded settlement`)), current];
+			if (parent.row.state !== "suspended" || parent.suspension === void 0 || parent.suspension.reason._tag !== "WaitingForChild") return [success("not-waiting"), current];
+			const children = parent.suspension.reason.children;
+			if (!children.some((entry) => entry.childSubmissionId === request.childSubmissionId)) return [success("not-waiting"), current];
+			if (!children.every((entry) => {
+				const listed = current.submissions.get(entry.childSubmissionId);
+				return listed?.row.state === "settled" || listed?.row.state === "terminalizing" && listed.reservation !== void 0;
+			})) return [success("still-waiting"), current];
+			return [success("woken"), withSubmission(current, {
+				...parent,
+				row: {
+					...parent.row,
+					state: "input-applied"
+				},
+				suspension: void 0
+			})];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const reserveChildBudget = Effect.fn("MemorySubmissionLedger.reserveChildBudget")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ChildBudgetReservationRequest, "reserveChildBudget", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const existing = current.childReservations.get(request.reservationId);
+			if (existing !== void 0) {
+				if (!(existing.parentSubmissionId === request.parentSubmissionId && existing.parentToolCallId === request.parentToolCallId && existing.allocationDigest === request.allocationDigest && equivalentPersistedJson(existing.allocation, request.allocation))) return [failure(ChildReservationConflict.make({
+					reservationId: request.reservationId,
+					status: existing.status,
+					message: "A reservation with this identity exists with a different parent Tool Call or allocation."
+				})), current];
+				return [success(ReservedChildBudget.make({
+					reservation: toReservationSnapshot(existing),
+					replayed: true
+				})), current];
+			}
+			for (const reservation of current.childReservations.values()) if (reservation.parentSubmissionId === request.parentSubmissionId && reservation.parentToolCallId === request.parentToolCallId) return [failure(ChildReservationConflict.make({
+				reservationId: request.reservationId,
+				status: reservation.status,
+				message: `Parent Tool Call ${request.parentToolCallId} already owns reservation ${reservation.reservationId}.`
+			})), current];
+			const parent = current.submissions.get(request.parentSubmissionId);
+			if (parent === void 0) return [failure(ledgerError("reserveChildBudget", `Unknown Submission ${request.parentSubmissionId}`)), current];
+			if (!ownsLane(parent, request.ownershipToken)) return [failure(ownershipLost(current, parent)), current];
+			const reservation = {
+				reservationId: request.reservationId,
+				parentSubmissionId: request.parentSubmissionId,
+				parentToolCallId: request.parentToolCallId,
+				childSubmissionId: void 0,
+				status: "reserved",
+				allocation: request.allocation,
+				allocationDigest: request.allocationDigest,
+				accounting: void 0,
+				reservedAtMillis: nowMillis,
+				releaseBeganAtMillis: void 0,
+				releasedAtMillis: void 0
+			};
+			return [success(ReservedChildBudget.make({
+				reservation: toReservationSnapshot(reservation),
+				replayed: false
+			})), withChildReservation(current, reservation)];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const attachChildToReservation = Effect.fn("MemorySubmissionLedger.attachChildToReservation")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(AttachChildToReservationRequest, "attachChildToReservation", unvalidated);
+		const decision = yield* Ref.modify(state, (current) => {
+			const reservation = current.childReservations.get(request.reservationId);
+			if (reservation === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown child reservation ${request.reservationId}`)), current];
+			if (reservation.childSubmissionId !== void 0) {
+				if (reservation.childSubmissionId === request.childSubmissionId) return [success(toReservationSnapshot(reservation)), current];
+				return [failure(ChildReservationConflict.make({
+					reservationId: request.reservationId,
+					status: reservation.status,
+					message: `Reservation ${request.reservationId} already records child ${reservation.childSubmissionId}.`
+				})), current];
+			}
+			const parent = current.submissions.get(reservation.parentSubmissionId);
+			if (parent === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown Submission ${reservation.parentSubmissionId}`)), current];
+			if (!ownsLane(parent, request.ownershipToken)) return [failure(ownershipLost(current, parent)), current];
+			if (reservation.status !== "reserved") return [failure(ChildReservationConflict.make({
+				reservationId: request.reservationId,
+				status: reservation.status,
+				message: `Cannot attach a child to a ${reservation.status} reservation.`
+			})), current];
+			if (!current.submissions.has(request.childSubmissionId)) return [failure(ledgerError("attachChildToReservation", `Unknown child Submission ${request.childSubmissionId}`)), current];
+			const attached = {
+				...reservation,
+				childSubmissionId: request.childSubmissionId
+			};
+			return [success(toReservationSnapshot(attached)), withChildReservation(current, attached)];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const beginChildBudgetRelease = Effect.fn("MemorySubmissionLedger.beginChildBudgetRelease")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(BeginChildBudgetReleaseRequest, "beginChildBudgetRelease", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const reservation = current.childReservations.get(request.reservationId);
+			if (reservation === void 0) return [failure(ledgerError("beginChildBudgetRelease", `Unknown child reservation ${request.reservationId}`)), current];
+			if (reservation.status !== "reserved") {
+				if (reservation.accounting !== void 0 && equivalentPersistedJson(reservation.accounting, request.accounting)) return [success(toReservationSnapshot(reservation)), current];
+				return [failure(ChildReservationConflict.make({
+					reservationId: request.reservationId,
+					status: reservation.status,
+					message: "A different accounting decision is already frozen for this reservation."
+				})), current];
+			}
+			const frozen = {
+				...reservation,
+				status: "releasePending",
+				accounting: request.accounting,
+				releaseBeganAtMillis: nowMillis
+			};
+			return [success(toReservationSnapshot(frozen)), withChildReservation(current, frozen)];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const releaseChildBudget = Effect.fn("MemorySubmissionLedger.releaseChildBudget")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ReleaseChildBudgetRequest, "releaseChildBudget", unvalidated);
+		const nowMillis = yield* Clock.currentTimeMillis;
+		const decision = yield* Ref.modify(state, (current) => {
+			const reservation = current.childReservations.get(request.reservationId);
+			if (reservation === void 0) return [failure(ledgerError("releaseChildBudget", `Unknown child reservation ${request.reservationId}`)), current];
+			if (reservation.status === "released") return [success(toReservationSnapshot(reservation)), current];
+			if (reservation.status !== "releasePending") return [failure(ChildReservationConflict.make({
+				reservationId: request.reservationId,
+				status: reservation.status,
+				message: "Cannot release a reservation whose accounting decision is not frozen."
+			})), current];
+			const released = {
+				...reservation,
+				status: "released",
+				releasedAtMillis: nowMillis
+			};
+			return [success(toReservationSnapshot(released)), withChildReservation(current, released)];
+		});
+		if (decision._tag === "failure") return yield* decision.error;
+		return decision.value;
+	}));
+	const scanNonterminal = Stream.unwrap(Ref.get(state).pipe(Effect.map((current) => {
+		const snapshots = [...current.submissions.values()].filter((stored) => stored.row.state !== "settled").sort((left, right) => left.row.threadId < right.row.threadId ? -1 : left.row.threadId > right.row.threadId ? 1 : left.row.queueSequence - right.row.queueSequence).map((stored) => toSnapshot(stored.row));
+		return Stream.fromIterable(snapshots);
+	})));
+	const loadRecoverySnapshot = Effect.fn("MemorySubmissionLedger.loadRecoverySnapshot")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(RecoverySnapshotRequest, "loadRecoverySnapshot", unvalidated);
+		const current = yield* Ref.get(state);
+		const stored = current.submissions.get(request.submissionId);
+		if (stored === void 0) return yield* ledgerError("loadRecoverySnapshot", `Unknown Submission ${request.submissionId}`);
+		const joins = [...current.submissions.values()].filter((candidate) => candidate.joinedHostSubmissionId === request.submissionId).sort((left, right) => left.row.queueSequence - right.row.queueSequence).map((candidate) => JoinSnapshot.make({
+			submissionId: candidate.row.submissionId,
+			state: candidate.row.state,
+			hostSubmissionId: request.submissionId
+		}));
+		const byToolCallId = (left, right) => left.toolCallId < right.toolCallId ? -1 : left.toolCallId > right.toolCallId ? 1 : 0;
+		const childReservations = [...current.childReservations.values()].filter((reservation) => reservation.parentSubmissionId === request.submissionId).sort((left, right) => left.parentToolCallId < right.parentToolCallId ? -1 : left.parentToolCallId > right.parentToolCallId ? 1 : 0);
+		const childAttachments = [];
+		for (const reservation of childReservations) {
+			if (reservation.childSubmissionId === void 0) continue;
+			const child = current.submissions.get(reservation.childSubmissionId);
+			if (child === void 0) continue;
+			childAttachments.push(ChildAttachmentSnapshot.make({
+				toolCallId: reservation.parentToolCallId,
+				childSubmissionId: reservation.childSubmissionId,
+				childState: child.row.state,
+				...child.row.settledOutcome === void 0 ? {} : { childOutcome: child.row.settledOutcome }
+			}));
+		}
+		return RecoverySnapshot.make({
+			submission: toSnapshot(stored.row),
+			joins,
+			approvalDecisions: [...stored.approvalDecisions.values()].sort(byToolCallId),
+			unknownResolutions: [...stored.unknownResolutions.values()].map((resolution) => resolution.intent).sort(byToolCallId),
+			childReservations: childReservations.map(toReservationSnapshot),
+			childAttachments,
+			...stored.row.parentLinkage === void 0 ? {} : { parentLinkage: stored.row.parentLinkage },
+			...stored.joinedHostSubmissionId === void 0 ? {} : { hostSubmissionId: stored.joinedHostSubmissionId },
+			...stored.suspension === void 0 ? {} : { suspension: SuspensionSnapshot.make({
+				reason: stored.suspension.reason,
+				suspendedAt: utc(stored.suspension.suspendedAtMillis)
+			}) },
+			...stored.ownership === void 0 ? {} : { ownership: OwnershipSnapshot.make({
+				attemptId: stored.ownership.attemptId,
+				ownerProducerId: stored.ownership.ownerProducerId,
+				producerEpoch: stored.ownership.producerEpoch,
+				leaseExpiresAt: utc(stored.ownership.leaseExpiresAtMillis)
+			}) },
+			...stored.inputApplied === void 0 ? {} : { inputApplied: stored.inputApplied },
+			...stored.reservation === void 0 ? {} : { reservation: SettlementReservationSnapshot.make({
+				settlementId: stored.reservation.settlementId,
+				outcome: stored.reservation.outcome,
+				record: stored.reservation.record,
+				recordDigest: stored.reservation.recordDigest,
+				finalized: stored.reservation.finalizedAtMillis !== void 0
+			}) },
+			...stored.abortIntent === void 0 ? {} : { abortIntent: stored.abortIntent }
+		});
+	}));
+	return SubmissionLedger.of({
+		capabilities,
+		admit,
+		markReady,
+		lookup,
+		resolveAdmission,
+		claim,
+		renewOwnership,
+		releaseOwnership,
+		markInputApplied,
+		reserveSettlement,
+		finalizeSettlement,
+		requestAbort,
+		claimJoining,
+		markJoined,
+		revertJoining,
+		suspend,
+		recordApprovalDecision,
+		markUnknown,
+		recordUnknownResolution,
+		recordChildSettled,
+		reserveChildBudget,
+		attachChildToReservation,
+		beginChildBudgetRelease,
+		releaseChildBudget,
+		scanNonterminal,
+		loadRecoverySnapshot
+	});
+});
+/**
+* In-memory reference SubmissionLedger Layer (durability `non-durable`). All state lives in one
+* `Ref` owned by the Layer's Scope; no daemon fibers are spawned and no wall clock is consulted.
+*/
+const memorySubmissionLedgerLayer = (options = {}) => Layer.effect(SubmissionLedger, makeSubmissionLedger(options));
+const MemorySubmissionLedgerLive = memorySubmissionLedgerLayer();
+//#endregion
+export { MemorySubmissionLedgerLive, memorySubmissionLedgerLayer, MemorySubmissionLedger_exports as t };
+
+//# sourceMappingURL=MemorySubmissionLedger.mjs.map