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

package/dist/index.mjs

@@ -1,2258 +1,6 @@
-import { AttemptId, MemoryIndexCandidate, MemoryIndexError, MemoryIndexQuery, MemoryIndexReplacement, MemoryIndexSearch, MemoryIndexSource, MemoryKey, ReceiptId, SemanticMemoryChunk, SemanticMemoryIndex, SemanticMemoryProfile, SubmissionId, ThreadId } from "@effect-agent/core";
-import { AbortCommand, AbortIntent, AcceptedEvent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DeliveryChange, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, PersistedJson, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SourcePartition, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionScanCursors, SubscriptionStore, SuspendRequest, SuspensionSnapshot, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, applySubscriptionDeliveryChange, compareScheduleKeys, compareScheduleNames, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleKeyOf, scheduleKeyString, scheduleOwnerKey, scheduleUsesCapacity, settlementFailureFromRecord, subscriptionCanSelect, subscriptionDeliveryCanSelect, subscriptionDeliveryKeyString, subscriptionKeyString } from "@effect-agent/thread";
-import { Clock, Crypto, DateTime, Duration, Effect, Encoding, Layer, Option, PubSub, Ref, Result, Schema, Stream } from "effect";
-//#region src/memory-ledger.ts
-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$2 = 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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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$2(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
-//#region src/memory-schedule-store.ts
-const storageError = (operation, reason) => ScheduleStorageError.make({
-	operation,
-	reason
-});
-const encodeRecord = (operation, record) => Effect.try({
-	try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(record),
-	catch: () => storageError(operation, "corrupt")
-});
-const decodeRecord = (operation, encoded) => Effect.try({
-	try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(encoded),
-	catch: () => storageError(operation, "corrupt")
-});
-const decodeInput = (operation, schema, value) => Effect.try({
-	try: () => Schema.decodeUnknownSync(schema)(value),
-	catch: () => storageError(operation, "corrupt")
-});
-const sameOwner = (record, owner) => scheduleOwnerKey(record.owner) === scheduleOwnerKey(owner);
-const makeScheduleStore = Effect.gen(function* () {
-	const state = yield* Ref.make({ records: /* @__PURE__ */ new Map() });
-	const failpoint = yield* ScheduleFailpoint;
-	const insert = Effect.fn("MemoryScheduleStore.insert")((record, ownerLimit) => Effect.gen(function* () {
-		const encoded = yield* encodeRecord("insert", record);
-		yield* failpoint.hit("schedule:insert:before");
-		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const key = scheduleKeyString(record);
-			const existingText = current.records.get(key);
-			if (existingText !== void 0) {
-				const decoded = Result.try({
-					try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(existingText),
-					catch: () => storageError("insert", "corrupt")
-				});
-				if (Result.isFailure(decoded)) return [Result.fail(decoded.failure), current];
-				if (decoded.success.creationFingerprint === record.creationFingerprint) return [Result.succeed(decoded.success), current];
-				return [Result.fail(ScheduleConflict.make({
-					reason: "creation",
-					key: scheduleKeyOf(record)
-				})), current];
-			}
-			let ownerCount = 0;
-			for (const text of current.records.values()) {
-				const decoded = Result.try({
-					try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
-					catch: () => storageError("insert", "corrupt")
-				});
-				if (Result.isFailure(decoded)) return [Result.fail(decoded.failure), current];
-				if (sameOwner(decoded.success, record.owner) && scheduleUsesCapacity(decoded.success)) ownerCount += 1;
-			}
-			if (ownerCount >= ownerLimit) return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
-			const records = new Map(current.records);
-			records.set(key, encoded);
-			const next = { records };
-			return [Result.succeed(record), next];
-		}));
-		const inserted = yield* Effect.fromResult(decision);
-		yield* failpoint.hit("schedule:insert:after");
-		return yield* decodeRecord("insert", yield* encodeRecord("insert", inserted));
-	}));
-	const get = Effect.fn("MemoryScheduleStore.get")(function* (key) {
-		const decodedKey = yield* decodeInput("get", ScheduleKey, key);
-		const text = (yield* Ref.get(state)).records.get(scheduleKeyString(decodedKey));
-		return text === void 0 ? null : yield* decodeRecord("get", text);
-	});
-	const list = Effect.fn("MemoryScheduleStore.list")(function* (request) {
-		const decodedRequest = yield* decodeInput("list", SchedulePageRequest, request);
-		const records = [];
-		for (const text of (yield* Ref.get(state)).records.values()) {
-			const record = yield* decodeRecord("list", text);
-			if (sameOwner(record, decodedRequest.owner) && (decodedRequest.after === void 0 || compareScheduleNames(record.scheduleId, decodedRequest.after) > 0)) records.push(record);
-		}
-		records.sort((left, right) => compareScheduleNames(left.scheduleId, right.scheduleId));
-		const hasNext = records.length > decodedRequest.limit;
-		const items = records.slice(0, decodedRequest.limit);
-		return {
-			items,
-			next: hasNext ? items.at(-1)?.scheduleId ?? null : null
-		};
-	});
-	const change = Effect.fn("MemoryScheduleStore.change")((key, command, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) => Effect.gen(function* () {
-		const decodedKey = yield* decodeInput("change", ScheduleKey, key);
-		const decodedCommand = yield* decodeInput("change", ScheduleChange, command);
-		yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:before`);
-		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const storageKey = scheduleKeyString(decodedKey);
-			const text = current.records.get(storageKey);
-			if (text === void 0) return [Result.fail(ScheduleNotFound.make({ key: decodedKey })), current];
-			const decoded = Result.try({
-				try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),
-				catch: () => storageError("change", "corrupt")
-			});
-			if (Result.isFailure(decoded)) return [Result.fail(decoded.failure), current];
-			const applied = applyScheduleChange(decoded.success, decodedCommand);
-			if (Result.isFailure(applied)) return [Result.fail(applied.failure), current];
-			if (applied.success === decoded.success) return [Result.succeed(decoded.success), current];
-			if (!scheduleUsesCapacity(decoded.success) && scheduleUsesCapacity(applied.success)) {
-				let count = 0;
-				for (const text of current.records.values()) {
-					const candidate = Schema.decodeUnknownResult(Schema.fromJsonString(ScheduleRecord))(text);
-					if (Result.isFailure(candidate)) return [Result.fail(storageError("change", "corrupt")), current];
-					if (sameOwner(candidate.success, decodedKey.owner) && scheduleUsesCapacity(candidate.success)) count += 1;
-				}
-				if (count >= ownerLimit) return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];
-			}
-			const encoded = Result.try({
-				try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(applied.success),
-				catch: () => storageError("change", "corrupt")
-			});
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const records = new Map(current.records);
-			records.set(storageKey, encoded.success);
-			const next = { records };
-			return [Result.succeed(applied.success), next];
-		}));
-		const changed = yield* Effect.fromResult(decision);
-		yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:after`);
-		return yield* decodeRecord("change", yield* encodeRecord("change", changed));
-	}));
-	const due = Effect.fn("MemoryScheduleStore.due")(function* (nowMillis, limit, owner, after) {
-		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput("due", ScheduleOwner, owner);
-		const cursor = after === void 0 ? void 0 : yield* decodeInput("due", ScheduleDueCursor, after);
-		const records = [];
-		for (const text of (yield* Ref.get(state)).records.values()) {
-			const record = yield* decodeRecord("due", text);
-			const deadline = scheduleDeadline(record);
-			if (deadline !== null && deadline <= nowMillis && (decodedOwner === void 0 || sameOwner(record, decodedOwner)) && (cursor === void 0 || deadline > cursor.deadlineAtMillis || deadline === cursor.deadlineAtMillis && compareScheduleKeys(record, cursor) > 0)) records.push({
-				...scheduleKeyOf(record),
-				deadlineAtMillis: deadline
-			});
-		}
-		records.sort((left, right) => {
-			const byDeadline = left.deadlineAtMillis - right.deadlineAtMillis;
-			return byDeadline !== 0 ? byDeadline : compareScheduleKeys(left, right);
-		});
-		return records.slice(0, limit);
-	});
-	const nextDeadline = Effect.fn("MemoryScheduleStore.nextDeadline")(function* (owner) {
-		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
-		let earliest = null;
-		for (const text of (yield* Ref.get(state)).records.values()) {
-			const record = yield* decodeRecord("nextDeadline", text);
-			if (decodedOwner !== void 0 && !sameOwner(record, decodedOwner)) continue;
-			const deadline = scheduleDeadline(record);
-			if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;
-		}
-		return earliest;
-	});
-	return ScheduleStore.of({
-		insert,
-		get,
-		list,
-		change,
-		due,
-		nextDeadline
-	});
-});
-const memoryScheduleStoreLayer = () => Layer.effect(ScheduleStore, makeScheduleStore);
-const MemoryScheduleStoreLive = memoryScheduleStoreLayer();
-//#endregion
-//#region src/memory-subscription-store.ts
-const error$1 = (reason, code) => SubscriptionError.make({
-	reason,
-	code
-});
-const samePartition = (left, right) => left.tenantId === right.tenantId && left.address === right.address;
-const sameSource$1 = (left, right) => left.name === right.name && left.version === right.version;
-const encode = (schema, value, code) => Result.try({
-	try: () => Schema.encodeSync(Schema.fromJsonString(schema))(value),
-	catch: () => error$1("corrupt", code)
-});
-const decode = (schema, value, code) => Result.try({
-	try: () => Schema.decodeSync(Schema.fromJsonString(schema))(value),
-	catch: () => error$1("corrupt", code)
-});
-const decodeEffect = (schema, value, code) => Effect.fromResult(decode(schema, value, code));
-const validate$1 = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error$1("validation", code)));
-const jsonBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
-const sameDeliveryIdentity = (left, right) => subscriptionDeliveryKeyString(left.key) === subscriptionDeliveryKeyString(right.key) && left.deliveryId === right.deliveryId && left.source.name === right.source.name && left.source.version === right.source.version && left.threadId === right.threadId && left.admissionKey === right.admissionKey && left.subscriptionFingerprint === right.subscriptionFingerprint && left.eventDigest === right.eventDigest;
-const candidateIndexKey = (record) => JSON.stringify([
-	record.configuration.source.name,
-	record.configuration.source.version,
-	record.configuration.matchingKey
-]);
-const eventCandidateIndexKey = (event) => JSON.stringify([
-	event.source.name,
-	event.source.version,
-	event.matchingKey
-]);
-const sameEventIdentity = (left, right) => samePartition(left.partition, right.partition) && left.eventId === right.eventId && sameSource$1(left.source, right.source) && left.matchingKey === right.matchingKey && left.payloadDigest === right.payloadDigest;
-const deliveryBelongsTo = (delivery, record, event) => subscriptionKeyString(delivery.key.subscription) === subscriptionKeyString(record.key) && delivery.key.eventId === event.eventId && sameSource$1(delivery.source, event.source);
-const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (ownedPartition) {
-	const partition = yield* validate$1(SourcePartition, ownedPartition, "partition");
-	const state = yield* Ref.make({
-		sequence: 0,
-		registrations: /* @__PURE__ */ new Map(),
-		events: /* @__PURE__ */ new Map(),
-		deliveries: /* @__PURE__ */ new Map(),
-		registrationIndex: /* @__PURE__ */ new Map(),
-		candidateIndex: /* @__PURE__ */ new Map(),
-		ownerRegistrationCounts: /* @__PURE__ */ new Map(),
-		eventIndex: /* @__PURE__ */ new Map(),
-		deliveryIndex: /* @__PURE__ */ new Map(),
-		ownerDeliveryCounts: /* @__PURE__ */ new Map(),
-		scanCursors: {
-			events: "",
-			deliveries: "",
-			recovery: 0
-		}
-	});
-	const failpoint = yield* SubscriptionFailpoint;
-	const requirePartition = (value, code) => samePartition(value.partition, partition) ? Effect.succeed(value) : Effect.fail(error$1("validation", code));
-	const requireKey = (key, code) => validate$1(SubscriptionKey, key, code).pipe(Effect.flatMap((decoded) => requirePartition(decoded, code)));
-	const register = Effect.fn("MemorySubscriptionStore.register")(function* (input, inputLimits) {
-		const record = yield* validate$1(SubscriptionRecord, input, "register-record");
-		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "register-limits");
-		yield* requirePartition(record.key, "register-partition");
-		yield* failpoint.hit("subscription:register:before");
-		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const key = subscriptionKeyString(record.key);
-			const existingText = current.registrations.get(key);
-			if (existingText !== void 0) {
-				const existing = decode(SubscriptionRecord, existingText, "register-existing");
-				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-				return existing.success.creationFingerprint === record.creationFingerprint ? [Result.succeed(existing.success), current] : [Result.fail(error$1("conflict", "registration-identity")), current];
-			}
-			if (jsonBytes(record.configuration.context) > limits.maxContextBytes) return [Result.fail(error$1("capacity", "context-bytes")), current];
-			if (jsonBytes(record.configuration.parameters) > limits.maxPayloadBytes) return [Result.fail(error$1("capacity", "parameters-bytes")), current];
-			if (record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return [Result.fail(error$1("capacity", "lifetime")), current];
-			if (current.registrations.size >= limits.maxRegistrations) return [Result.fail(error$1("capacity", "registrations")), current];
-			const ownerCount = current.ownerRegistrationCounts.get(record.key.ownerId) ?? 0;
-			if (ownerCount >= limits.maxRegistrationsPerOwner) return [Result.fail(error$1("capacity", "owner-registrations")), current];
-			const assigned = {
-				...record,
-				ordinal: current.sequence + 1
-			};
-			const encoded = encode(SubscriptionRecord, assigned, "register-encode");
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const registrations = new Map(current.registrations);
-			registrations.set(key, encoded.success);
-			const registrationIndex = new Map(current.registrationIndex);
-			registrationIndex.set(key, {
-				key: assigned.key,
-				ordinal: assigned.ordinal,
-				state: assigned.state,
-				recoveryAt: assigned.recovery?.nextAttemptAtMillis ?? null
-			});
-			const candidateIndex = new Map(current.candidateIndex);
-			const candidateKey = candidateIndexKey(assigned);
-			candidateIndex.set(candidateKey, [...candidateIndex.get(candidateKey) ?? [], key]);
-			const ownerRegistrationCounts = new Map(current.ownerRegistrationCounts);
-			ownerRegistrationCounts.set(assigned.key.ownerId, ownerCount + 1);
-			return [Result.succeed(assigned), {
-				...current,
-				sequence: assigned.ordinal,
-				registrations,
-				registrationIndex,
-				candidateIndex,
-				ownerRegistrationCounts
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:register:after");
-		return result;
-	});
-	const get = Effect.fn("MemorySubscriptionStore.get")(function* (input) {
-		const key = yield* requireKey(input, "get-key");
-		const text = (yield* Ref.get(state)).registrations.get(subscriptionKeyString(key));
-		return text === void 0 ? null : yield* decodeEffect(SubscriptionRecord, text, "get-record");
-	});
-	const list = Effect.fn("MemorySubscriptionStore.list")(function* (ownerId, after, limit) {
-		if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit <= 0) return yield* error$1("validation", "list-page");
-		const current = yield* Ref.get(state);
-		const records = [];
-		for (const [storageKey, indexed] of current.registrationIndex) {
-			if (indexed.key.ownerId !== ownerId || indexed.ordinal <= after) continue;
-			const text = current.registrations.get(storageKey);
-			if (text === void 0) return yield* error$1("corrupt", "list-index");
-			records.push(yield* decodeEffect(SubscriptionRecord, text, "list-record"));
-		}
-		records.sort((a, b) => a.ordinal - b.ordinal);
-		return records.slice(0, limit);
-	});
-	const cancel = Effect.fn("MemorySubscriptionStore.cancel")(function* (input) {
-		const key = yield* requireKey(input, "cancel-key");
-		yield* failpoint.hit("subscription:cancel:before");
-		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const storageKey = subscriptionKeyString(key);
-			const text = current.registrations.get(storageKey);
-			if (text === void 0) return [Result.fail(error$1("not-found", "subscription")), current];
-			const decoded = decode(SubscriptionRecord, text, "cancel-record");
-			if (Result.isFailure(decoded)) return [decoded, current];
-			if (decoded.success.state === "cancelled") return [Result.succeed(decoded.success), current];
-			const cancelled = {
-				...decoded.success,
-				state: "cancelled",
-				recovery: null
-			};
-			const encoded = encode(SubscriptionRecord, cancelled, "cancel-encode");
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const registrations = new Map(current.registrations);
-			registrations.set(storageKey, encoded.success);
-			const registrationIndex = new Map(current.registrationIndex);
-			const indexed = registrationIndex.get(storageKey);
-			if (indexed === void 0) return [Result.fail(error$1("corrupt", "cancel-index")), current];
-			registrationIndex.set(storageKey, {
-				...indexed,
-				state: "cancelled",
-				recoveryAt: null
-			});
-			return [Result.succeed(cancelled), {
-				...current,
-				registrations,
-				registrationIndex
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:cancel:after");
-		return result;
-	});
-	const accept = Effect.fn("MemorySubscriptionStore.accept")(function* (input, inputLimits) {
-		const event = yield* validate$1(AcceptedEvent, input, "accept-event");
-		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "accept-limits");
-		yield* requirePartition(event, "accept-partition");
-		yield* failpoint.hit("subscription:accept:before");
-		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const existingText = current.events.get(event.eventId);
-			if (existingText !== void 0) {
-				const existing = decode(AcceptedEvent, existingText, "accept-existing");
-				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-				return sameEventIdentity(existing.success, event) ? [Result.succeed(existing.success), current] : [Result.fail(error$1("conflict", "event-identity")), current];
-			}
-			if (jsonBytes(event.payload) > limits.maxPayloadBytes) return [Result.fail(error$1("capacity", "payload-bytes")), current];
-			if (current.events.size >= limits.maxEvents) return [Result.fail(error$1("capacity", "events")), current];
-			const accepted = {
-				...event,
-				cutoff: current.sequence + 1,
-				cursor: 0,
-				routingComplete: false,
-				routingFailure: null
-			};
-			const encoded = encode(AcceptedEvent, accepted, "accept-encode");
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const events = new Map(current.events);
-			events.set(accepted.eventId, encoded.success);
-			const eventIndex = new Map(current.eventIndex);
-			eventIndex.set(accepted.eventId, {
-				routingComplete: false,
-				nextAttemptAtMillis: accepted.nextAttemptAtMillis
-			});
-			return [Result.succeed(accepted), {
-				...current,
-				sequence: accepted.cutoff,
-				events,
-				eventIndex
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:accept:after");
-		return result;
-	});
-	const event = Effect.fn("MemorySubscriptionStore.event")(function* (eventId) {
-		const text = (yield* Ref.get(state)).events.get(eventId);
-		return text === void 0 ? null : yield* decodeEffect(AcceptedEvent, text, "event-record");
-	});
-	const pendingEvents = Effect.fn("MemorySubscriptionStore.pendingEvents")(function* (nowMillis, after, limit) {
-		const events = [];
-		for (const [eventId, indexed] of (yield* Ref.get(state)).eventIndex) if (!indexed.routingComplete && indexed.nextAttemptAtMillis <= nowMillis && compareScheduleNames(eventId, after) > 0) events.push(eventId);
-		events.sort(compareScheduleNames);
-		return events.slice(0, limit);
-	});
-	const candidates = Effect.fn("MemorySubscriptionStore.candidates")(function* (input, limit) {
-		const accepted = yield* validate$1(AcceptedEvent, input, "candidates-event");
-		yield* requirePartition(accepted, "candidates-partition");
-		const stored = yield* event(accepted.eventId);
-		if (stored === null || !sameEventIdentity(stored, accepted)) return yield* error$1(stored === null ? "not-found" : "conflict", "event");
-		const current = yield* Ref.get(state);
-		const records = [];
-		for (const storageKey of current.candidateIndex.get(eventCandidateIndexKey(stored)) ?? []) {
-			const indexed = current.registrationIndex.get(storageKey);
-			if (indexed === void 0) return yield* error$1("corrupt", "candidate-index");
-			if (indexed.ordinal <= stored.cursor || indexed.ordinal > stored.cutoff) continue;
-			const text = current.registrations.get(storageKey);
-			if (text === void 0) return yield* error$1("corrupt", "candidate-record");
-			records.push(yield* decodeEffect(SubscriptionRecord, text, "candidate-record"));
-		}
-		records.sort((a, b) => a.ordinal - b.ordinal);
-		return records.slice(0, limit);
-	});
-	const select = Effect.fn("MemorySubscriptionStore.select")(function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
-		const suppliedEvent = yield* validate$1(AcceptedEvent, inputEvent, "select-event");
-		const deliveries = yield* validate$1(Schema.Array(SubscriptionDelivery), inputDeliveries, "select-deliveries");
-		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "select-limits");
-		yield* requirePartition(suppliedEvent, "select-partition");
-		yield* failpoint.hit("subscription:select:before");
-		const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
-		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const eventText = current.events.get(suppliedEvent.eventId);
-			if (eventText === void 0) return [Result.fail(error$1("not-found", "event")), current];
-			const decodedEvent = decode(AcceptedEvent, eventText, "select-event-record");
-			if (Result.isFailure(decodedEvent)) return [Result.fail(decodedEvent.failure), current];
-			const accepted = decodedEvent.success;
-			if (!sameEventIdentity(accepted, suppliedEvent) || suppliedEvent.cursor !== accepted.cursor) return [Result.fail(error$1("conflict", "event-cursor")), current];
-			if (accepted.routingComplete) return [complete && cursor === accepted.cursor ? Result.void : Result.fail(error$1("conflict", "routing-complete")), current];
-			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return [Result.fail(error$1("validation", "cursor")), current];
-			const additions = [];
-			const updates = [];
-			const additionIndex = [];
-			const registrationUpdates = [];
-			const owners = new Map(current.ownerDeliveryCounts);
-			for (const delivery of deliveries) {
-				const recordText = current.registrations.get(subscriptionKeyString(delivery.key.subscription));
-				if (recordText === void 0) return [Result.fail(error$1("not-found", "subscription")), current];
-				const record = decode(SubscriptionRecord, recordText, "select-registration");
-				if (Result.isFailure(record)) return [Result.fail(record.failure), current];
-				if (!deliveryBelongsTo(delivery, record.success, accepted) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted) || record.success.ordinal <= accepted.cursor || record.success.ordinal > cursor) return [Result.fail(error$1("conflict", "selection")), current];
-				if (!subscriptionCanSelect(record.success, accepted, effectiveNowMillis, false)) continue;
-				const deliveryKey = subscriptionDeliveryKeyString(delivery.key);
-				const existingText = current.deliveries.get(deliveryKey);
-				if (existingText !== void 0) {
-					const existing = decode(SubscriptionDelivery, existingText, "select-existing");
-					if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-					if (!sameDeliveryIdentity(existing.success, delivery)) return [Result.fail(error$1("conflict", "delivery-identity")), current];
-					continue;
-				}
-				const encodedDelivery = encode(SubscriptionDelivery, delivery, "select-delivery-encode");
-				if (Result.isFailure(encodedDelivery)) return [Result.fail(encodedDelivery.failure), current];
-				additions.push([deliveryKey, encodedDelivery.success]);
-				additionIndex.push([
-					deliveryKey,
-					{
-						key: delivery.key,
-						state: delivery.state,
-						nextAttemptAtMillis: delivery.retry.nextAttemptAtMillis
-					},
-					record.success.key.ownerId
-				]);
-				const ownerId = record.success.key.ownerId;
-				owners.set(ownerId, (owners.get(ownerId) ?? 0) + 1);
-				if ((owners.get(ownerId) ?? 0) > limits.maxDeliveriesPerOwner) return [Result.fail(error$1("capacity", "owner-deliveries")), current];
-				if (record.success.configuration.mode === "once") {
-					const consumed = {
-						...record.success,
-						state: "consumed",
-						recovery: null
-					};
-					const encodedRecord = encode(SubscriptionRecord, consumed, "select-registration-encode");
-					if (Result.isFailure(encodedRecord)) return [Result.fail(encodedRecord.failure), current];
-					const consumedKey = subscriptionKeyString(consumed.key);
-					updates.push([consumedKey, encodedRecord.success]);
-					const indexed = current.registrationIndex.get(consumedKey);
-					if (indexed === void 0) return [Result.fail(error$1("corrupt", "selection-index")), current];
-					registrationUpdates.push([consumedKey, {
-						...indexed,
-						state: "consumed",
-						recoveryAt: null
-					}]);
-				}
-			}
-			if (current.deliveries.size + additions.length > limits.maxDeliveries) return [Result.fail(error$1("capacity", "deliveries")), current];
-			const registrations = new Map(current.registrations);
-			for (const [key, value] of updates) registrations.set(key, value);
-			const nextDeliveries = new Map(current.deliveries);
-			for (const [key, value] of additions) nextDeliveries.set(key, value);
-			const deliveryIndex = new Map(current.deliveryIndex);
-			for (const [key, value] of additionIndex) deliveryIndex.set(key, value);
-			const registrationIndex = new Map(current.registrationIndex);
-			for (const [key, value] of registrationUpdates) registrationIndex.set(key, value);
-			const nextEvent = {
-				...accepted,
-				cursor,
-				routingComplete: complete,
-				routingFailure: null
-			};
-			const encodedEvent = encode(AcceptedEvent, nextEvent, "select-event-encode");
-			if (Result.isFailure(encodedEvent)) return [Result.fail(encodedEvent.failure), current];
-			const events = new Map(current.events);
-			events.set(nextEvent.eventId, encodedEvent.success);
-			const eventIndex = new Map(current.eventIndex);
-			eventIndex.set(nextEvent.eventId, {
-				routingComplete: nextEvent.routingComplete,
-				nextAttemptAtMillis: nextEvent.nextAttemptAtMillis
-			});
-			return [Result.void, {
-				...current,
-				registrations,
-				registrationIndex,
-				events,
-				eventIndex,
-				deliveries: nextDeliveries,
-				deliveryIndex,
-				ownerDeliveryCounts: owners
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:select:after");
-	});
-	const catchUp = Effect.fn("MemorySubscriptionStore.catchUp")(function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
-		const suppliedEvent = yield* validate$1(AcceptedEvent, inputEvent, "catch-up-event");
-		const delivery = yield* validate$1(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
-		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "catch-up-limits");
-		yield* requirePartition(suppliedEvent, "catch-up-partition");
-		yield* failpoint.hit("subscription:catch-up:before");
-		const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
-		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const eventText = current.events.get(suppliedEvent.eventId);
-			const recordText = current.registrations.get(subscriptionKeyString(delivery.key.subscription));
-			if (eventText === void 0 || recordText === void 0) return [Result.fail(error$1("not-found", eventText === void 0 ? "event" : "subscription")), current];
-			const accepted = decode(AcceptedEvent, eventText, "catch-up-event-record");
-			if (Result.isFailure(accepted)) return [Result.fail(accepted.failure), current];
-			const record = decode(SubscriptionRecord, recordText, "catch-up-registration");
-			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
-			if (!sameEventIdentity(accepted.success, suppliedEvent) || !deliveryBelongsTo(delivery, record.success, accepted.success) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted.success) || record.success.configuration.mode !== "once") return [Result.fail(error$1("conflict", "catch-up-identity")), current];
-			const key = subscriptionDeliveryKeyString(delivery.key);
-			const existingText = current.deliveries.get(key);
-			if (existingText !== void 0) {
-				const existing = decode(SubscriptionDelivery, existingText, "catch-up-existing");
-				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-				return sameDeliveryIdentity(existing.success, delivery) ? [Result.void, current] : [Result.fail(error$1("conflict", "delivery-identity")), current];
-			}
-			if (!subscriptionCanSelect(record.success, accepted.success, effectiveNowMillis, true)) return [Result.fail(error$1("conflict", "catch-up-eligibility")), current];
-			if (current.deliveries.size >= limits.maxDeliveries) return [Result.fail(error$1("capacity", "deliveries")), current];
-			const ownerCount = current.ownerDeliveryCounts.get(record.success.key.ownerId) ?? 0;
-			if (ownerCount >= limits.maxDeliveriesPerOwner) return [Result.fail(error$1("capacity", "owner-deliveries")), current];
-			const encodedDelivery = encode(SubscriptionDelivery, delivery, "catch-up-delivery-encode");
-			if (Result.isFailure(encodedDelivery)) return [Result.fail(encodedDelivery.failure), current];
-			const consumed = {
-				...record.success,
-				state: "consumed",
-				recovery: null
-			};
-			const encodedRecord = encode(SubscriptionRecord, consumed, "catch-up-registration-encode");
-			if (Result.isFailure(encodedRecord)) return [Result.fail(encodedRecord.failure), current];
-			const deliveries = new Map(current.deliveries);
-			deliveries.set(key, encodedDelivery.success);
-			const registrations = new Map(current.registrations);
-			const consumedKey = subscriptionKeyString(consumed.key);
-			registrations.set(consumedKey, encodedRecord.success);
-			const registrationIndex = new Map(current.registrationIndex);
-			const indexed = registrationIndex.get(consumedKey);
-			if (indexed === void 0) return [Result.fail(error$1("corrupt", "catch-up-index")), current];
-			registrationIndex.set(consumedKey, {
-				...indexed,
-				state: "consumed",
-				recoveryAt: null
-			});
-			const deliveryIndex = new Map(current.deliveryIndex);
-			deliveryIndex.set(key, {
-				key: delivery.key,
-				state: delivery.state,
-				nextAttemptAtMillis: delivery.retry.nextAttemptAtMillis
-			});
-			const ownerDeliveryCounts = new Map(current.ownerDeliveryCounts);
-			ownerDeliveryCounts.set(consumed.key.ownerId, ownerCount + 1);
-			return [Result.void, {
-				...current,
-				deliveries,
-				deliveryIndex,
-				ownerDeliveryCounts,
-				registrations,
-				registrationIndex
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:catch-up:after");
-	});
-	const deferEvent = Effect.fn("MemorySubscriptionStore.deferEvent")(function* (eventId, nextAttemptAtMillis, code) {
-		const routingFailure = code === void 0 ? "routing-failed" : yield* validate$1(SubscriptionName, code, "routing-failure");
-		yield* failpoint.hit("subscription:defer-event:before");
-		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const text = current.events.get(eventId);
-			if (text === void 0) return [Result.fail(error$1("not-found", "event")), current];
-			const accepted = decode(AcceptedEvent, text, "defer-event-record");
-			if (Result.isFailure(accepted)) return [Result.fail(accepted.failure), current];
-			const updated = {
-				...accepted.success,
-				nextAttemptAtMillis,
-				routingFailure
-			};
-			const encoded = encode(AcceptedEvent, updated, "defer-event-encode");
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const events = new Map(current.events);
-			events.set(eventId, encoded.success);
-			const eventIndex = new Map(current.eventIndex);
-			const indexed = eventIndex.get(eventId);
-			if (indexed === void 0) return [Result.fail(error$1("corrupt", "defer-event-index")), current];
-			eventIndex.set(eventId, {
-				...indexed,
-				nextAttemptAtMillis
-			});
-			return [Result.void, {
-				...current,
-				events,
-				eventIndex
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:defer-event:after");
-	});
-	const delivery = Effect.fn("MemorySubscriptionStore.delivery")(function* (input) {
-		const key = yield* validate$1(SubscriptionDeliveryKey, input, "delivery-key");
-		yield* requirePartition(key.subscription, "delivery-partition");
-		const text = (yield* Ref.get(state)).deliveries.get(subscriptionDeliveryKeyString(key));
-		return text === void 0 ? null : yield* decodeEffect(SubscriptionDelivery, text, "delivery-record");
-	});
-	const pendingDeliveries = Effect.fn("MemorySubscriptionStore.pendingDeliveries")(function* (nowMillis, after, limit) {
-		const items = [];
-		for (const [storageKey, item] of (yield* Ref.get(state)).deliveryIndex) if (item.state !== "delivered" && item.state !== "refused" && item.nextAttemptAtMillis <= nowMillis && compareScheduleNames(storageKey, after) > 0) items.push(item.key);
-		items.sort((a, b) => compareScheduleNames(subscriptionDeliveryKeyString(a), subscriptionDeliveryKeyString(b)));
-		return items.slice(0, limit);
-	});
-	const listDeliveries = Effect.fn("MemorySubscriptionStore.listDeliveries")(function* (input, after, limit) {
-		const key = yield* requireKey(input, "list-deliveries-key");
-		const items = [];
-		for (const text of (yield* Ref.get(state)).deliveries.values()) {
-			const item = yield* decodeEffect(SubscriptionDelivery, text, "list-delivery");
-			const itemKey = subscriptionDeliveryKeyString(item.key);
-			if (subscriptionKeyString(item.key.subscription) === subscriptionKeyString(key) && compareScheduleNames(itemKey, after) > 0) items.push(item);
-		}
-		items.sort((a, b) => compareScheduleNames(subscriptionDeliveryKeyString(a.key), subscriptionDeliveryKeyString(b.key)));
-		return items.slice(0, limit);
-	});
-	const changeDelivery = Effect.fn("MemorySubscriptionStore.changeDelivery")(function* (inputKey, inputDeliveryId, inputChange) {
-		const key = yield* validate$1(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
-		const deliveryId = yield* validate$1(Digest, inputDeliveryId, "change-delivery-id");
-		const change = yield* validate$1(DeliveryChange, inputChange, "change-delivery-change");
-		yield* requirePartition(key.subscription, "change-delivery-partition");
-		yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:before`);
-		const effectiveChange = change._tag === "Prepare" ? {
-			...change,
-			nowMillis: Math.max(change.nowMillis, yield* Clock.currentTimeMillis)
-		} : change;
-		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const storageKey = subscriptionDeliveryKeyString(key);
-			const text = current.deliveries.get(storageKey);
-			if (text === void 0) return [Result.fail(error$1("not-found", "delivery")), current];
-			const decoded = decode(SubscriptionDelivery, text, "change-delivery-record");
-			if (Result.isFailure(decoded)) return [decoded, current];
-			const registrationText = current.registrations.get(subscriptionKeyString(key.subscription));
-			if (registrationText === void 0) return [Result.fail(error$1("corrupt", "delivery-registration")), current];
-			const registration = decode(SubscriptionRecord, registrationText, "delivery-registration");
-			if (Result.isFailure(registration)) return [Result.fail(registration.failure), current];
-			const transition = applySubscriptionDeliveryChange(decoded.success, registration.success, deliveryId, effectiveChange);
-			if (Result.isFailure(transition)) return [Result.fail(transition.failure), current];
-			if (transition.success === decoded.success) return [Result.succeed(decoded.success), current];
-			const updated = transition.success;
-			const encoded = encode(SubscriptionDelivery, updated, "change-delivery-encode");
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const deliveries = new Map(current.deliveries);
-			deliveries.set(storageKey, encoded.success);
-			const deliveryIndex = new Map(current.deliveryIndex);
-			const indexed = deliveryIndex.get(storageKey);
-			if (indexed === void 0) return [Result.fail(error$1("corrupt", "delivery-index")), current];
-			deliveryIndex.set(storageKey, {
-				...indexed,
-				state: updated.state,
-				nextAttemptAtMillis: updated.retry.nextAttemptAtMillis
-			});
-			return [Result.succeed(updated), {
-				...current,
-				deliveries,
-				deliveryIndex
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:after`);
-		return result;
-	});
-	const recovering = Effect.fn("MemorySubscriptionStore.recovering")(function* (nowMillis, after, limit) {
-		const records = [];
-		for (const item of (yield* Ref.get(state)).registrationIndex.values()) if (item.ordinal > after && item.state === "active" && item.recoveryAt !== null && item.recoveryAt <= nowMillis) records.push({
-			key: item.key,
-			ordinal: item.ordinal
-		});
-		records.sort((a, b) => a.ordinal - b.ordinal);
-		return records.slice(0, limit);
-	});
-	const deferRecovery = Effect.fn("MemorySubscriptionStore.deferRecovery")(function* (input, recovery) {
-		const key = yield* requireKey(input, "defer-recovery-key");
-		yield* failpoint.hit("subscription:defer-recovery:before");
-		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const storageKey = subscriptionKeyString(key);
-			const text = current.registrations.get(storageKey);
-			if (text === void 0) return [Result.fail(error$1("not-found", "subscription")), current];
-			const record = decode(SubscriptionRecord, text, "defer-recovery-record");
-			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
-			const updated = {
-				...record.success,
-				recovery: record.success.state === "active" ? recovery : null
-			};
-			const encoded = encode(SubscriptionRecord, updated, "defer-recovery-encode");
-			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
-			const registrations = new Map(current.registrations);
-			registrations.set(storageKey, encoded.success);
-			const registrationIndex = new Map(current.registrationIndex);
-			const indexed = registrationIndex.get(storageKey);
-			if (indexed === void 0) return [Result.fail(error$1("corrupt", "recovery-index")), current];
-			registrationIndex.set(storageKey, {
-				...indexed,
-				recoveryAt: updated.recovery?.nextAttemptAtMillis ?? null
-			});
-			return [Result.void, {
-				...current,
-				registrations,
-				registrationIndex
-			}];
-		})).pipe(Effect.flatMap(Effect.fromResult));
-		yield* failpoint.hit("subscription:defer-recovery:after");
-	});
-	const readScanCursors = Ref.get(state).pipe(Effect.map((current) => current.scanCursors));
-	const advanceScanCursors = Effect.fn("MemorySubscriptionStore.advanceScanCursors")(function* (input) {
-		const cursors = yield* validate$1(SubscriptionScanCursors, input, "scan-cursors");
-		yield* failpoint.hit("subscription:advance-scan-cursors:before");
-		yield* Effect.uninterruptible(Ref.update(state, (current) => ({
-			...current,
-			scanCursors: cursors
-		})));
-		yield* failpoint.hit("subscription:advance-scan-cursors:after");
-	});
-	const nextDeadline = Effect.gen(function* () {
-		let deadline = null;
-		const current = yield* Ref.get(state);
-		if (current.scanCursors.events !== "" || current.scanCursors.deliveries !== "" || current.scanCursors.recovery !== 0) return 0;
-		const consider = (value) => {
-			if (deadline === null || value < deadline) deadline = value;
-		};
-		for (const accepted of current.eventIndex.values()) if (!accepted.routingComplete) consider(accepted.nextAttemptAtMillis);
-		for (const item of current.deliveryIndex.values()) if (item.state !== "delivered" && item.state !== "refused") consider(item.nextAttemptAtMillis);
-		for (const record of current.registrationIndex.values()) if (record.state === "active" && record.recoveryAt !== null) consider(record.recoveryAt);
-		return deadline;
-	}).pipe(Effect.withSpan("MemorySubscriptionStore.nextDeadline"));
-	return SubscriptionStore.of({
-		partition,
-		register,
-		get,
-		list,
-		cancel,
-		accept,
-		event,
-		pendingEvents,
-		candidates,
-		select,
-		catchUp,
-		deferEvent,
-		delivery,
-		pendingDeliveries,
-		listDeliveries,
-		changeDelivery,
-		recovering,
-		deferRecovery,
-		readScanCursors,
-		advanceScanCursors,
-		nextDeadline
-	});
-});
-const memorySubscriptionStoreLayer = (partition) => Layer.effect(SubscriptionStore, makeMemorySubscriptionStore(partition));
-//#endregion
-//#region src/memory-storage.ts
-const MAX_THREADS = 256;
-const MAX_RECORDS_PER_THREAD = 65536;
-const MAX_CHECKPOINTS_PER_THREAD = 1024;
-const storeError = (operation, message, cause) => cause === void 0 ? ThreadStoreError.make({
-	operation,
-	message
-}) : ThreadStoreError.make({
-	operation,
-	message,
-	cause
-});
-const validate = Effect.fn("MemoryThreadStore.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => storeError(operation, `Invalid ${operation} request`, error))));
-const decodeCanonicalSequence = Schema.decodeSync(CanonicalSequence);
-const ZERO_CANONICAL_SEQUENCE = decodeCanonicalSequence(0);
-const offsetSequence = Effect.fn("MemoryThreadStore.offsetSequence")((threadId, offset) => {
-	if (offset === void 0) return Effect.succeed(ZERO_CANONICAL_SEQUENCE);
-	const prefix = `memory:v1:${Encoding.encodeBase64(threadId)}:`;
-	const encodedSequence = offset.startsWith(prefix) ? offset.slice(prefix.length) : "";
-	if (!/^\d+$/.test(encodedSequence)) return Effect.fail(storeError("observe", "Malformed observation offset"));
-	const sequence = Number(encodedSequence);
-	return Number.isSafeInteger(sequence) ? Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.mapError(() => storeError("observe", "Malformed observation offset"))) : Effect.fail(storeError("observe", "Malformed observation offset"));
-});
-const observationOffset = (threadId, sequence) => Schema.decodeSync(ObservationOffset)(`memory:v1:${Encoding.encodeBase64(threadId)}:${sequence}`);
-const findThread = Effect.fn("MemoryThreadStore.findThread")((state, threadId) => {
-	const thread = state.threads.get(threadId);
-	return thread === void 0 ? Effect.fail(ThreadNotMaterialized.make({ threadId })) : Effect.succeed(thread);
-});
-const CheckpointVersionEnvelope = Schema.Struct({ checkpoint: Schema.Struct({
-	threadId: ThreadId,
-	schemaVersion: Schema.Natural
-}) });
-const validateCheckpointVersion = Effect.fn("MemoryThreadStore.validateCheckpointVersion")(function* (value) {
-	const envelope = yield* Schema.decodeUnknownEffect(CheckpointVersionEnvelope)(value).pipe(Effect.mapError(() => storeError("saveCheckpoint", "Invalid saveCheckpoint request")));
-	if (envelope.checkpoint.schemaVersion !== 1) return yield* CheckpointRejected.make({
-		threadId: envelope.checkpoint.threadId,
-		reason: "unsupported-version"
-	});
-});
-const makeThreadStore = Effect.gen(function* () {
-	const crypto = yield* Crypto.Crypto;
-	const state = yield* Ref.make({ threads: /* @__PURE__ */ new Map() });
-	const updates = yield* PubSub.sliding(1);
-	yield* Effect.addFinalizer(() => PubSub.shutdown(updates));
-	const materialize = Effect.fn("MemoryThreadStore.materialize")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ThreadMaterialization, "materialize", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const existing = current.threads.get(request.threadId);
-			if (existing !== void 0) {
-				if (request.producerEpoch < existing.producerEpoch) return [{
-					_tag: "failure",
-					error: FenceRejected.make({
-						threadId: request.threadId,
-						actualEpoch: existing.producerEpoch,
-						attemptedEpoch: request.producerEpoch
-					})
-				}, current];
-				if (request.producerEpoch === existing.producerEpoch) return [{ _tag: "success" }, current];
-				const threads = new Map(current.threads);
-				threads.set(request.threadId, {
-					...existing,
-					producerEpoch: request.producerEpoch
-				});
-				return [{ _tag: "success" }, { threads }];
-			}
-			if (current.threads.size >= MAX_THREADS) return [{
-				_tag: "failure",
-				error: storeError("materialize", `In-memory thread limit ${MAX_THREADS} exceeded`)
-			}, current];
-			const threads = new Map(current.threads);
-			threads.set(request.threadId, {
-				producerEpoch: request.producerEpoch,
-				tailSequence: ZERO_CANONICAL_SEQUENCE,
-				tailDigest: EMPTY_TAIL_DIGEST,
-				records: [],
-				recordIds: /* @__PURE__ */ new Set(),
-				batches: /* @__PURE__ */ new Map(),
-				tailDigests: /* @__PURE__ */ new Map([[ZERO_CANONICAL_SEQUENCE, EMPTY_TAIL_DIGEST]]),
-				checkpoints: /* @__PURE__ */ new Map()
-			});
-			return [{ _tag: "success" }, { threads }];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const append = Effect.fn("MemoryThreadStore.append")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(FencedAppendRequest, "append", unvalidated);
-		const digest = yield* digestCanonicalBatch(request.expectedTailDigest, request.batch).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((error) => storeError("append", error.message, error)));
-		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const thread = current.threads.get(request.threadId);
-			if (thread === void 0) return [{
-				_tag: "failure",
-				error: ThreadNotMaterialized.make({ threadId: request.threadId })
-			}, current];
-			if (request.producerEpoch !== thread.producerEpoch) return [{
-				_tag: "failure",
-				error: FenceRejected.make({
-					threadId: request.threadId,
-					actualEpoch: thread.producerEpoch,
-					attemptedEpoch: request.producerEpoch
-				})
-			}, current];
-			const previous = thread.batches.get(request.batch.batchId);
-			if (previous !== void 0) {
-				if (previous.digest !== digest) return [{
-					_tag: "failure",
-					error: AppendConflict.make({
-						threadId: request.threadId,
-						batchId: request.batch.batchId,
-						reason: "batch-digest"
-					})
-				}, current];
-				return [{
-					_tag: "success",
-					result: AppendResult.make({
-						firstSequence: previous.result.firstSequence,
-						lastSequence: previous.result.lastSequence,
-						tailDigest: previous.result.tailDigest,
-						replayed: true
-					}),
-					records: []
-				}, current];
-			}
-			if (request.expectedTailSequence !== thread.tailSequence || request.expectedTailDigest !== thread.tailDigest) return [{
-				_tag: "failure",
-				error: AppendConflict.make({
-					threadId: request.threadId,
-					batchId: request.batch.batchId,
-					reason: "tail",
-					actualTailSequence: thread.tailSequence,
-					actualTailDigest: thread.tailDigest
-				})
-			}, current];
-			if (thread.records.length + request.batch.records.length > MAX_RECORDS_PER_THREAD) return [{
-				_tag: "failure",
-				error: storeError("append", `In-memory record limit ${MAX_RECORDS_PER_THREAD} exceeded`)
-			}, current];
-			const batchRecordIds = /* @__PURE__ */ new Set();
-			for (const record of request.batch.records) {
-				if (thread.recordIds.has(record.recordId) || batchRecordIds.has(record.recordId)) return [{
-					_tag: "failure",
-					error: AppendConflict.make({
-						threadId: request.threadId,
-						batchId: request.batch.batchId,
-						reason: "record-identity"
-					})
-				}, current];
-				batchRecordIds.add(record.recordId);
-			}
-			const records = request.batch.records.map((record, index) => {
-				const sequence = decodeCanonicalSequence(thread.tailSequence + index + 1);
-				return CanonicalRecordEnvelope.make({
-					threadId: request.threadId,
-					batchId: request.batch.batchId,
-					sequence,
-					offset: observationOffset(request.threadId, sequence),
-					record
-				});
-			});
-			const lastSequence = decodeCanonicalSequence(thread.tailSequence + records.length);
-			const result = AppendResult.make({
-				firstSequence: decodeCanonicalSequence(thread.tailSequence + 1),
-				lastSequence,
-				tailDigest: digest,
-				replayed: false
-			});
-			const batches = new Map(thread.batches);
-			batches.set(request.batch.batchId, {
-				digest,
-				result
-			});
-			const recordIds = new Set(thread.recordIds);
-			for (const recordId of batchRecordIds) recordIds.add(recordId);
-			const tailDigests = new Map(thread.tailDigests);
-			tailDigests.set(lastSequence, digest);
-			const threads = new Map(current.threads);
-			threads.set(request.threadId, {
-				...thread,
-				tailSequence: lastSequence,
-				tailDigest: digest,
-				records: [...thread.records, ...records],
-				recordIds,
-				batches,
-				tailDigests
-			});
-			return [{
-				_tag: "success",
-				result,
-				records
-			}, { threads }];
-		}).pipe(Effect.tap((decision) => decision._tag === "success" && decision.records.length > 0 ? PubSub.publish(updates, void 0) : Effect.void)));
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.result;
-	}));
-	const readSnapshot = Effect.fn("MemoryThreadStore.readSnapshot")((threadId, afterSequence, limit) => Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, threadId)), Effect.map((thread) => thread.records.filter((record) => record.sequence > (afterSequence ?? ZERO_CANONICAL_SEQUENCE)).slice(0, limit))));
-	const read = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ThreadRead, "read", unvalidated);
-		const records = yield* readSnapshot(request.threadId, request.afterSequence, request.limit);
-		return Stream.fromIterable(records);
-	}));
-	const observe = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ThreadObservation, "observe", unvalidated);
-		const afterSequence = yield* offsetSequence(request.threadId, request.afterOffset);
-		return Stream.unwrap(Effect.gen(function* () {
-			const subscription = yield* PubSub.subscribe(updates);
-			const initial = yield* readSnapshot(request.threadId, afterSequence, MAX_RECORDS_PER_THREAD);
-			const highWater = initial.length === 0 ? afterSequence : initial.at(-1)?.sequence ?? afterSequence;
-			const live = Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(Stream.mapAccumEffect(() => highWater, (lastSequence) => readSnapshot(request.threadId, lastSequence, MAX_RECORDS_PER_THREAD).pipe(Effect.map((records) => [records.at(-1)?.sequence ?? lastSequence, records]))));
-			return Stream.fromIterable(initial).pipe(Stream.concat(live));
-		}));
-	}));
-	const exportThread = Effect.fn("MemoryThreadStore.export")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ThreadExportRequest, "export", unvalidated);
-		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
-		return ThreadExport.make({
-			format: "effect-agent/thread@1",
-			threadId: request.threadId,
-			tailSequence: thread.tailSequence,
-			tailDigest: thread.tailDigest,
-			records: thread.records
-		});
-	}));
-	const inspectTail = Effect.fn("MemoryThreadStore.inspectTail")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ThreadTailRequest, "inspectTail", unvalidated);
-		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
-		return ThreadTail.make({
-			threadId: request.threadId,
-			tailSequence: thread.tailSequence,
-			tailDigest: thread.tailDigest,
-			producerEpoch: thread.producerEpoch
-		});
-	}));
-	const saveCheckpoint = Effect.fn("MemoryThreadStore.saveCheckpoint")((unvalidated) => Effect.gen(function* () {
-		yield* validateCheckpointVersion(unvalidated);
-		const request = yield* validate(SaveCheckpointRequest, "saveCheckpoint", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const checkpoint = request.checkpoint;
-			const thread = current.threads.get(checkpoint.threadId);
-			if (thread === void 0) return [{
-				_tag: "failure",
-				error: ThreadNotMaterialized.make({ threadId: checkpoint.threadId })
-			}, current];
-			if (checkpoint.throughSequence > thread.tailSequence) return [{
-				_tag: "failure",
-				error: CheckpointRejected.make({
-					threadId: checkpoint.threadId,
-					reason: "ahead-of-tail"
-				})
-			}, current];
-			if (thread.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return [{
-				_tag: "failure",
-				error: CheckpointRejected.make({
-					threadId: checkpoint.threadId,
-					reason: "digest-mismatch"
-				})
-			}, current];
-			if (!thread.checkpoints.has(checkpoint.throughSequence) && thread.checkpoints.size >= MAX_CHECKPOINTS_PER_THREAD) return [{
-				_tag: "failure",
-				error: storeError("saveCheckpoint", `In-memory checkpoint limit ${MAX_CHECKPOINTS_PER_THREAD} exceeded`)
-			}, current];
-			const checkpoints = new Map(thread.checkpoints);
-			checkpoints.set(checkpoint.throughSequence, checkpoint);
-			const threads = new Map(current.threads);
-			threads.set(checkpoint.threadId, {
-				...thread,
-				checkpoints
-			});
-			return [{ _tag: "success" }, { threads }];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const loadCheckpoint = Effect.fn("MemoryThreadStore.loadCheckpoint")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(LoadCheckpointRequest, "loadCheckpoint", unvalidated);
-		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
-		const maximum = request.atOrBeforeSequence ?? thread.tailSequence;
-		let selected;
-		for (const [sequence, checkpoint] of thread.checkpoints) if (sequence <= maximum && (selected === void 0 || sequence > selected.throughSequence)) selected = checkpoint;
-		if (selected !== void 0 && thread.tailDigests.get(selected.throughSequence) !== selected.tailDigest) return yield* CheckpointRejected.make({
-			threadId: request.threadId,
-			reason: "digest-mismatch"
-		});
-		return Option.fromNullishOr(selected);
-	}));
-	return ThreadStore.of({
-		materialize,
-		append,
-		read,
-		observe,
-		export: exportThread,
-		inspectTail,
-		checkpoints: {
-			save: saveCheckpoint,
-			load: loadCheckpoint
-		}
-	});
-});
-const MemoryThreadStoreLive = Layer.effect(ThreadStore, makeThreadStore);
-/**
-* In-memory canonical Thread persistence. Durable accepted work is served by the separate
-* SubmissionLedger port; this Layer deliberately provides only the ThreadStore.
-*/
-const MemoryStorageLive = MemoryThreadStoreLive;
-//#endregion
-//#region src/semantic-memory-index.ts
-const PositiveCapacity = Schema.Int.check(Schema.isBetween({
-	minimum: 1,
-	maximum: 65536
-}));
-const MaxStoredVectorComponents = 16777216;
-/**
-* Hard per-Layer bounds for disposable semantic index state. maxChunks times profile dimensions
-* must not exceed 16,777,216 vector components. maxSourceBytes bounds the aggregate UTF-8 JSON
-* of retained source identities and defaults to 16 MiB; it is not a general heap limit.
-*/
-var InMemorySemanticIndexCapacity = class extends Schema.Class("@effect-agent/storage-memory/InMemorySemanticIndexCapacity")({
-	maxSources: PositiveCapacity,
-	maxChunks: PositiveCapacity,
-	maxSourceBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 67108864
-	})))
-}) {};
-const sameProfile = Schema.toEquivalence(SemanticMemoryProfile);
-const sameSource = Schema.toEquivalence(MemoryIndexSource.Wire);
-const error = (operation, reason) => MemoryIndexError.make({
-	operation,
-	reason
-});
-const keyString = (key) => JSON.stringify([key.namespace.address, key.id]);
-const sourceIdentityBytes = (source) => Encoding.encodeHex(JSON.stringify(source)).length / 2;
-const decodeBoundary = Effect.fn("InMemorySemanticIndex.decodeBoundary")(function* (schema, value, operation) {
-	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.flatMap((decoded) => Schema.encodeEffect(schema)(decoded).pipe(Effect.as(decoded))), Effect.mapError(() => error(operation, "invalid-input")));
-});
-const freezeSource = (source) => Object.freeze(MemoryIndexSource.make({
-	key: Object.freeze(MemoryKey.make({
-		...source.key,
-		namespace: Object.freeze({ address: source.key.namespace.address })
-	})),
-	source: Object.freeze({ ...source.source }),
-	sourceGeneration: source.sourceGeneration
-}));
-const freezeChunk = (chunk) => Object.freeze(SemanticMemoryChunk.make({
-	...chunk,
-	vector: Object.freeze([...chunk.vector])
-}));
-const sourceIsFenced = (source, existing) => source.sourceGeneration < existing.source.sourceGeneration || source.sourceGeneration === existing.source.sourceGeneration && !sameSource(source, existing.source);
-const squaredNorm = (vector) => {
-	let sum = 0;
-	for (const value of vector) {
-		sum += value * value;
-		if (!Number.isFinite(sum)) return null;
-	}
-	return sum > 0 ? sum : null;
-};
-const validVector = (vector, profile) => vector.length === profile.dimensions && squaredNorm(vector) !== null;
-const validateChunks = Effect.fn("InMemorySemanticIndex.validateChunks")(function* (chunks, profile, operation) {
-	let nextByte = 0;
-	const passageIds = /* @__PURE__ */ new Set();
-	for (let index = 0; index < chunks.length; index++) {
-		const chunk = chunks[index];
-		const byteLength = Encoding.encodeHex(chunk.text).length / 2;
-		if (chunk.ordinal !== index || chunk.startByte !== nextByte || chunk.endByte <= chunk.startByte || chunk.endByte - chunk.startByte !== byteLength || byteLength > profile.maxChunkBytes || passageIds.has(chunk.passageId) || !validVector(chunk.vector, profile)) return yield* error(operation, "invalid-input");
-		passageIds.add(chunk.passageId);
-		nextByte = chunk.endByte;
-	}
-});
-const cosine = (left, right) => {
-	const leftNorm = Math.sqrt(squaredNorm(left) ?? 1);
-	const rightNorm = Math.sqrt(squaredNorm(right) ?? 1);
-	let score = 0;
-	for (let index = 0; index < left.length; index++) score += left[index] / leftNorm * (right[index] / rightNorm);
-	const bounded = Math.max(-1, Math.min(1, score));
-	return bounded === 0 ? 0 : bounded;
-};
-const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (rawProfile, rawCapacity) {
-	const profile = Object.freeze(SemanticMemoryProfile.make({ ...yield* decodeBoundary(SemanticMemoryProfile, rawProfile, "configure semantic memory index") }));
-	const capacity = yield* decodeBoundary(InMemorySemanticIndexCapacity, rawCapacity, "configure semantic memory index");
-	if (capacity.maxChunks * profile.dimensions > MaxStoredVectorComponents) return yield* error("configure semantic memory index", "invalid-input");
-	const maxSourceBytes = capacity.maxSourceBytes ?? 16777216;
-	const data = yield* Ref.make({
-		closed: false,
-		entries: /* @__PURE__ */ new Map(),
-		sourceBytes: 0
-	});
-	yield* Effect.addFinalizer(() => Ref.set(data, {
-		closed: true,
-		entries: /* @__PURE__ */ new Map(),
-		sourceBytes: 0
-	}));
-	const ensureOpen = Effect.fn("InMemorySemanticIndex.ensureOpen")(function* (operation) {
-		if ((yield* Ref.get(data)).closed) return yield* error(operation, "unavailable");
-	});
-	const replace = Effect.fn("InMemorySemanticIndex.replace")(function* (rawRequest) {
-		const operation = "replace semantic memory source";
-		yield* ensureOpen(operation);
-		const request = yield* decodeBoundary(MemoryIndexReplacement.Wire, rawRequest, operation);
-		const source = freezeSource(request.source);
-		const sourceBytes = sourceIdentityBytes(source);
-		const chunks = Object.freeze(request.chunks.map(freezeChunk));
-		if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
-		if (!sameProfile(request.profile, profile)) return yield* error(operation, "incompatible");
-		yield* validateChunks(chunks, profile, operation);
-		const indexedAt = yield* Clock.currentTimeMillis;
-		const failure = yield* Ref.modify(data, (current) => {
-			if (current.closed) return [error(operation, "unavailable"), current];
-			const id = keyString(source.key);
-			const existing = current.entries.get(id);
-			if (existing !== void 0 && (existing._tag === "Withdrawn" || sourceIsFenced(source, existing))) return [error(operation, "fenced"), current];
-			if (existing === void 0 && current.entries.size >= capacity.maxSources) return [error(operation, "budget"), current];
-			const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
-			if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
-			let count = chunks.length;
-			for (const [entryId, entry] of current.entries) if (entryId !== id && entry._tag === "Indexed") count += entry.chunks.length;
-			if (count > capacity.maxChunks) return [error(operation, "budget"), current];
-			const entries = new Map(current.entries);
-			entries.set(id, {
-				_tag: "Indexed",
-				source,
-				sourceBytes,
-				chunks,
-				indexedAt
-			});
-			return [void 0, {
-				...current,
-				entries,
-				sourceBytes: nextSourceBytes
-			}];
-		});
-		if (failure !== void 0) return yield* failure;
-	});
-	const withdraw = Effect.fn("InMemorySemanticIndex.withdraw")(function* (rawSource) {
-		const operation = "withdraw semantic memory source";
-		yield* ensureOpen(operation);
-		const source = freezeSource(yield* decodeBoundary(MemoryIndexSource.Wire, rawSource, operation));
-		const sourceBytes = sourceIdentityBytes(source);
-		if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
-		const failure = yield* Ref.modify(data, (current) => {
-			if (current.closed) return [error(operation, "unavailable"), current];
-			const id = keyString(source.key);
-			const existing = current.entries.get(id);
-			if (existing !== void 0) {
-				if (existing._tag === "Withdrawn") return [sameSource(source, existing.source) ? void 0 : error(operation, "fenced"), current];
-				if (sourceIsFenced(source, existing)) return [error(operation, "fenced"), current];
-			} else if (current.entries.size >= capacity.maxSources) return [error(operation, "budget"), current];
-			const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
-			if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
-			const entries = new Map(current.entries);
-			entries.set(id, {
-				_tag: "Withdrawn",
-				source,
-				sourceBytes
-			});
-			return [void 0, {
-				...current,
-				entries,
-				sourceBytes: nextSourceBytes
-			}];
-		});
-		if (failure !== void 0) return yield* failure;
-	});
-	const search = Effect.fn("InMemorySemanticIndex.search")(function* (rawQuery) {
-		const operation = "search semantic memory index";
-		yield* ensureOpen(operation);
-		const query = yield* decodeBoundary(MemoryIndexQuery.Wire, rawQuery, operation);
-		const vector = Object.freeze([...query.vector]);
-		if (!validVector(vector, profile)) return yield* error(operation, "invalid-input");
-		const current = yield* Ref.get(data);
-		if (current.closed) return yield* error(operation, "unavailable");
-		let scannedChunks = 0;
-		let inspectedSources = 0;
-		const candidates = [];
-		for (const entry of current.entries.values()) {
-			inspectedSources += 1;
-			if (inspectedSources % 128 === 0) yield* Effect.yieldNow;
-			if (entry.source.key.namespace.address !== query.namespace.address || entry._tag !== "Indexed") continue;
-			scannedChunks += entry.chunks.length;
-			if (scannedChunks > query.maxScannedChunks) return yield* error(operation, "budget");
-		}
-		for (const entry of current.entries.values()) {
-			if (entry.source.key.namespace.address !== query.namespace.address || entry._tag !== "Indexed") continue;
-			yield* Effect.yieldNow;
-			for (const chunk of entry.chunks) {
-				const score = cosine(vector, chunk.vector);
-				if (score < query.minScore) continue;
-				candidates.push(MemoryIndexCandidate.make({
-					...entry.source,
-					passageId: chunk.passageId,
-					ordinal: chunk.ordinal,
-					startByte: chunk.startByte,
-					endByte: chunk.endByte,
-					text: chunk.text,
-					score,
-					indexedAt: entry.indexedAt
-				}));
-			}
-		}
-		candidates.sort((left, right) => right.score - left.score || compareText(left.key.id, right.key.id) || compareText(left.source.revision, right.source.revision) || left.ordinal - right.ordinal);
-		yield* ensureOpen(operation);
-		return MemoryIndexSearch.make({
-			candidates: candidates.slice(0, query.limit),
-			scannedChunks
-		});
-	});
-	return SemanticMemoryIndex.fromAdapter({
-		profile,
-		replace,
-		withdraw,
-		search
-	});
-});
-/** Scoped disposable semantic index. No persistent build or recovery state is retained. */
-const inMemorySemanticIndexLayer = (profile, capacity) => Layer.effect(SemanticMemoryIndex, makeIndex(profile, capacity));
-//#endregion
-export { InMemorySemanticIndexCapacity, MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemoryThreadStoreLive, inMemorySemanticIndexLayer, memoryScheduleStoreLayer, memorySubmissionLedgerLayer, memorySubscriptionStoreLayer };
-
-//# sourceMappingURL=index.mjs.map
+import { t as MemoryScheduleStore_exports } from "./MemoryScheduleStore.mjs";
+import { t as MemorySemanticIndex_exports } from "./MemorySemanticIndex.mjs";
+import { t as MemorySubmissionLedger_exports } from "./MemorySubmissionLedger.mjs";
+import { t as MemorySubscriptionStore_exports } from "./MemorySubscriptionStore.mjs";
+import { t as MemoryThreadStore_exports } from "./MemoryThreadStore.mjs";
+export { MemoryScheduleStore_exports as MemoryScheduleStore, MemorySemanticIndex_exports as MemorySemanticIndex, MemorySubmissionLedger_exports as MemorySubmissionLedger, MemorySubscriptionStore_exports as MemorySubscriptionStore, MemoryThreadStore_exports as MemoryThreadStore };