@effect-agent/storage-memory 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/MemorySubscriptionStore.mjs

@@ -0,0 +1,849 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Clock, Effect, Layer, Ref, Result, Schema } from "effect";
+import { compareScheduleNames } from "effect-agent/schedule-transition";
+import { Digest } from "effect-agent/records";
+import { AcceptedEvent, DeliveryChange, SourcePartition, SubscriptionChange, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionRetentionPolicy, SubscriptionScanCursors, SubscriptionStore, subscriptionDeliveryKeyString, subscriptionKeyString } from "effect-agent/subscription";
+import { applySubscriptionChange, applySubscriptionDeliveryChange, sameAcceptedEventIdentity, subscriptionCanSelect, subscriptionDeliveryCanSelect, validateEventRetention } from "effect-agent/subscription-transition";
+//#region src/MemorySubscriptionStore.ts
+var MemorySubscriptionStore_exports = /* @__PURE__ */ __exportAll({ memorySubscriptionStoreLayer: () => memorySubscriptionStoreLayer });
+const error = (reason, code) => SubscriptionError.make({
+	reason,
+	code
+});
+const samePartition = (left, right) => left.tenantId === right.tenantId && left.address === right.address;
+const sameSource = (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("corrupt", code)
+});
+const decode = (schema, value, code) => Result.try({
+	try: () => Schema.decodeSync(Schema.fromJsonString(schema))(value),
+	catch: () => error("corrupt", code)
+});
+const decodeEffect = (schema, value, code) => Effect.fromResult(decode(schema, value, code));
+const validate = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error("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 = sameAcceptedEventIdentity;
+const deliveryBelongsTo = (delivery, record, event) => subscriptionKeyString(delivery.key.subscription) === subscriptionKeyString(record.key) && delivery.key.eventId === event.eventId && sameSource(delivery.source, event.source);
+const removeKeys = (keys, removed) => {
+	if (removed.size === 0) return keys;
+	const result = [...keys];
+	for (const key of removed) {
+		const index = upperBound(result, key) - 1;
+		if (result[index] === key) result.splice(index, 1);
+	}
+	return result;
+};
+const upperBound = (keys, after) => {
+	let low = 0;
+	let high = keys.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		const key = keys[middle];
+		if (key !== void 0 && compareScheduleNames(key, after) <= 0) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+};
+const insertKey = (keys, key) => {
+	const at = upperBound(keys, key);
+	if (at > 0 && keys[at - 1] === key) return keys;
+	return [
+		...keys.slice(0, at),
+		key,
+		...keys.slice(at)
+	];
+};
+const recoveryCountsAfter = (current, next, keys) => {
+	const counts = new Map(current.recoveryCounts);
+	for (const key of keys) {
+		const before = current.registrationIndex.get(key)?.recoveryKey;
+		const after = next.get(key)?.recoveryKey;
+		if (before === after) continue;
+		if (before !== null && before !== void 0) counts.set(before, (counts.get(before) ?? 0) - 1);
+		if (after !== null && after !== void 0) counts.set(after, (counts.get(after) ?? 0) + 1);
+	}
+	return counts;
+};
+const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (ownedPartition) {
+	const partition = yield* validate(SourcePartition, ownedPartition, "partition");
+	const state = yield* Ref.make({
+		sequence: 0,
+		retentionDeadline: null,
+		tombstoneCount: 0,
+		eventKeys: [],
+		deliveryKeys: [],
+		maintenanceEvents: "",
+		maintenanceDeliveries: "",
+		recoveryCounts: /* @__PURE__ */ new Map(),
+		eventDeliveryCounts: /* @__PURE__ */ new Map(),
+		retentionHorizon: null,
+		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("validation", code));
+	const requireKey = (key, code) => validate(SubscriptionKey, key, code).pipe(Effect.flatMap((decoded) => requirePartition(decoded, code)));
+	const register = Effect.fn("MemorySubscriptionStore.register")(function* (input, inputLimits) {
+		const record = yield* validate(SubscriptionRecord, input, "register-record");
+		const limits = yield* validate(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("conflict", "registration-identity")), current];
+			}
+			if (jsonBytes(record.configuration.context) > limits.maxContextBytes) return [Result.fail(error("capacity", "context-bytes")), current];
+			if (jsonBytes(record.configuration.parameters) > limits.maxPayloadBytes) return [Result.fail(error("capacity", "parameters-bytes")), current];
+			if (record.configuration.expiresAtMillis !== null && record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return [Result.fail(error("capacity", "lifetime")), current];
+			if (current.registrations.size >= limits.maxRegistrations) return [Result.fail(error("capacity", "registrations")), current];
+			const ownerCount = current.ownerRegistrationCounts.get(record.key.ownerId) ?? 0;
+			if (ownerCount >= limits.maxRegistrationsPerOwner) return [Result.fail(error("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,
+				recoveryKey: assigned.recovery === null ? null : candidateIndexKey(assigned),
+				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,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [key]),
+				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("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("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 change = Effect.fn("MemorySubscriptionStore.change")(function* (input, expectedRevision, inputChange) {
+		const key = yield* requireKey(input, "change-key");
+		const change = yield* validate(SubscriptionChange, inputChange, "change");
+		yield* validate(Schema.Int.check(Schema.isGreaterThan(0)), expectedRevision, "revision");
+		yield* failpoint.hit("subscription:change:before");
+		const updated = 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("not-found", "subscription")), current];
+			const existing = decode(SubscriptionRecord, text, "change-record");
+			if (Result.isFailure(existing)) return [existing, current];
+			const updated = applySubscriptionChange(existing.success, expectedRevision, change);
+			if (Result.isFailure(updated)) return [updated, current];
+			const revised = {
+				...updated.success,
+				ordinal: current.sequence + 1
+			};
+			const encoded = encode(SubscriptionRecord, revised, "change-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);
+			registrationIndex.set(storageKey, {
+				key,
+				ordinal: revised.ordinal,
+				state: revised.state,
+				recoveryKey: revised.recovery === null ? null : candidateIndexKey(revised),
+				recoveryAt: revised.recovery?.nextAttemptAtMillis ?? null
+			});
+			const candidateIndex = new Map(current.candidateIndex);
+			const oldKey = candidateIndexKey(existing.success);
+			const nextKey = candidateIndexKey(revised);
+			candidateIndex.set(oldKey, (candidateIndex.get(oldKey) ?? []).filter((key) => key !== storageKey));
+			candidateIndex.set(nextKey, [...candidateIndex.get(nextKey) ?? [], storageKey].sort((a, b) => (registrationIndex.get(a)?.ordinal ?? 0) - (registrationIndex.get(b)?.ordinal ?? 0)));
+			return [Result.succeed(revised), {
+				...current,
+				sequence: revised.ordinal,
+				registrations,
+				registrationIndex,
+				candidateIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey])
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:change:after");
+		return updated;
+	});
+	const cancel = Effect.fn("MemorySubscriptionStore.cancel")(function* (input, expectedRevision) {
+		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("not-found", "subscription")), current];
+			const decoded = decode(SubscriptionRecord, text, "cancel-record");
+			if (Result.isFailure(decoded)) return [decoded, current];
+			if (expectedRevision !== void 0 && expectedRevision !== decoded.success.configurationRevision && !(decoded.success.state === "cancelled" && expectedRevision + 1 === decoded.success.configurationRevision)) return [Result.fail(SubscriptionError.make({
+				reason: "conflict",
+				code: "configuration-revision",
+				currentRevision: decoded.success.configurationRevision,
+				currentState: decoded.success.state
+			})), current];
+			if (decoded.success.state === "cancelled") return [Result.succeed(decoded.success), current];
+			const cancelled = {
+				...decoded.success,
+				configurationRevision: decoded.success.configurationRevision + 1,
+				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("corrupt", "cancel-index")), current];
+			registrationIndex.set(storageKey, {
+				...indexed,
+				state: "cancelled",
+				recoveryAt: null,
+				recoveryKey: null
+			});
+			return [Result.succeed(cancelled), {
+				...current,
+				registrations,
+				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey])
+			}];
+		})).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(AcceptedEvent, input, "accept-event");
+		const currentTimeMillis = yield* Clock.currentTimeMillis;
+		const limits = yield* validate(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("conflict", "event-identity")), current];
+			}
+			if (current.retentionHorizon !== null && current.retentionHorizon !== limits.retention?.replayHorizonMillis) return [Result.fail(error("conflict", "retention-horizon")), current];
+			const horizon = validateEventRetention(event, limits, currentTimeMillis);
+			if (Result.isFailure(horizon)) return [Result.fail(horizon.failure), current];
+			if (jsonBytes(event.payload) > limits.maxPayloadBytes) return [Result.fail(error("capacity", "payload-bytes")), current];
+			if (current.events.size - current.tombstoneCount >= limits.maxEvents) return [Result.fail(error("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,
+				eventKeys: insertKey(current.eventKeys, accepted.eventId),
+				retentionHorizon: limits.retention?.replayHorizonMillis ?? current.retentionHorizon,
+				retentionDeadline: limits.retention === void 0 ? current.retentionDeadline : accepted.acceptedAtMillis
+			}];
+		})).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(AcceptedEvent, input, "candidates-event");
+		yield* requirePartition(accepted, "candidates-partition");
+		const stored = yield* event(accepted.eventId);
+		if (stored === null || !sameEventIdentity(stored, accepted)) return yield* error(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("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("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(AcceptedEvent, inputEvent, "select-event");
+		const deliveries = yield* validate(Schema.Array(SubscriptionDelivery), inputDeliveries, "select-deliveries");
+		const limits = yield* validate(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("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("conflict", "event-cursor")), current];
+			if (accepted.routingComplete) return [complete && cursor === accepted.cursor ? Result.void : Result.fail(error("conflict", "routing-complete")), current];
+			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return [Result.fail(error("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("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("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("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("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("corrupt", "selection-index")), current];
+					registrationUpdates.push([consumedKey, {
+						...indexed,
+						state: "consumed",
+						recoveryAt: null,
+						recoveryKey: null
+					}]);
+				}
+			}
+			if (current.deliveries.size + additions.length > limits.maxDeliveries) return [Result.fail(error("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 eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+			eventDeliveryCounts.set(accepted.eventId, (eventDeliveryCounts.get(accepted.eventId) ?? 0) + additions.length);
+			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,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, registrationUpdates.map(([key]) => key)),
+				eventDeliveryCounts,
+				events,
+				eventIndex,
+				deliveries: nextDeliveries,
+				deliveryKeys: additions.reduce((keys, [key]) => insertKey(keys, key), current.deliveryKeys),
+				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(AcceptedEvent, inputEvent, "catch-up-event");
+		const delivery = yield* validate(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
+		const limits = yield* validate(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("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("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("conflict", "delivery-identity")), current];
+			}
+			if (!subscriptionCanSelect(record.success, accepted.success, effectiveNowMillis, true)) return [Result.fail(error("conflict", "catch-up-eligibility")), current];
+			if (current.deliveries.size >= limits.maxDeliveries) return [Result.fail(error("capacity", "deliveries")), current];
+			const ownerCount = current.ownerDeliveryCounts.get(record.success.key.ownerId) ?? 0;
+			if (ownerCount >= limits.maxDeliveriesPerOwner) return [Result.fail(error("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("corrupt", "catch-up-index")), current];
+			registrationIndex.set(consumedKey, {
+				...indexed,
+				state: "consumed",
+				recoveryAt: null,
+				recoveryKey: 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);
+			const eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+			eventDeliveryCounts.set(accepted.success.eventId, (eventDeliveryCounts.get(accepted.success.eventId) ?? 0) + 1);
+			ownerDeliveryCounts.set(consumed.key.ownerId, ownerCount + 1);
+			return [Result.void, {
+				...current,
+				deliveries,
+				deliveryIndex,
+				deliveryKeys: insertKey(current.deliveryKeys, key),
+				ownerDeliveryCounts,
+				registrations,
+				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [consumedKey]),
+				eventDeliveryCounts
+			}];
+		})).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(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("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("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(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.parked !== true || item.state === "delivered" && item.observeSettlement === true) && 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(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
+		const deliveryId = yield* validate(Digest, inputDeliveryId, "change-delivery-id");
+		const change = yield* validate(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("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("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("corrupt", "delivery-index")), current];
+			deliveryIndex.set(storageKey, {
+				...indexed,
+				state: updated.state,
+				parked: updated.retry.parked ?? false,
+				observeSettlement: updated.observeSettlement ?? false,
+				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, expectedRevision, 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("not-found", "subscription")), current];
+			const record = decode(SubscriptionRecord, text, "defer-recovery-record");
+			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
+			if (record.success.configurationRevision !== expectedRevision) return [Result.void, current];
+			const updated = {
+				...record.success,
+				recovery: record.success.state === "active" || record.success.state === "paused" ? 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("corrupt", "recovery-index")), current];
+			registrationIndex.set(storageKey, {
+				...indexed,
+				recoveryKey: updated.recovery === null ? null : candidateIndexKey(updated),
+				recoveryAt: updated.recovery?.nextAttemptAtMillis ?? null
+			});
+			return [Result.void, {
+				...current,
+				registrations,
+				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey])
+			}];
+		})).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(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;
+		};
+		if (current.retentionDeadline !== null) consider(current.retentionDeadline);
+		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" && item.parked !== true || item.state === "delivered" && item.observeSettlement === true) 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"));
+	const compact = Effect.fn("MemorySubscriptionStore.compact")(function* (nowMillis, inputPolicy, requestedLimit) {
+		nowMillis = Math.min(nowMillis, yield* Clock.currentTimeMillis);
+		const policy = yield* validate(SubscriptionRetentionPolicy, inputPolicy, "retention-policy");
+		const limit = yield* validate(Schema.Int.check(Schema.isBetween({
+			minimum: 1,
+			maximum: 100
+		})), requestedLimit, "maintenance-limit");
+		yield* failpoint.hit("subscription:compact:before");
+		let corruptCandidates = 0;
+		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			if (current.retentionHorizon !== null && current.retentionHorizon !== policy.replayHorizonMillis) return [Result.fail(error("conflict", "retention-horizon")), current];
+			const events = new Map(current.events);
+			const eventIndex = new Map(current.eventIndex);
+			const deliveries = new Map(current.deliveries);
+			const deliveryIndex = new Map(current.deliveryIndex);
+			const eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+			const ownerDeliveryCounts = new Map(current.ownerDeliveryCounts);
+			const deliveryPage = current.deliveryKeys.slice(upperBound(current.deliveryKeys, current.maintenanceDeliveries), upperBound(current.deliveryKeys, current.maintenanceDeliveries) + limit);
+			const eventPage = current.eventKeys.slice(upperBound(current.eventKeys, current.maintenanceEvents), upperBound(current.eventKeys, current.maintenanceEvents) + limit);
+			const cutoff = nowMillis - policy.completedRetentionMillis;
+			let removed = 0;
+			const removedEvents = /* @__PURE__ */ new Set();
+			const removedDeliveries = /* @__PURE__ */ new Set();
+			for (const key of deliveryPage) {
+				const text = deliveries.get(key);
+				if (text === void 0) continue;
+				const decoded = decode(SubscriptionDelivery, text, "compact-delivery");
+				if (Result.isFailure(decoded)) {
+					corruptCandidates++;
+					continue;
+				}
+				const delivery = decoded.success;
+				if (subscriptionDeliveryKeyString(delivery.key) !== key || !samePartition(delivery.key.subscription.partition, partition)) {
+					corruptCandidates++;
+					continue;
+				}
+				if (delivery.state !== "refused" && (delivery.state !== "delivered" || delivery.settledAtMillis === void 0)) continue;
+				if ((delivery.settledAtMillis ?? delivery.completedAtMillis ?? delivery.selectedAtMillis) > cutoff) continue;
+				const eventText = events.get(delivery.key.eventId);
+				if (eventText === void 0) continue;
+				const accepted = decode(AcceptedEvent, eventText, "compact-delivery-event");
+				if (Result.isFailure(accepted)) {
+					corruptCandidates++;
+					continue;
+				}
+				const event = accepted.success;
+				if (event.eventId !== delivery.key.eventId || !samePartition(event.partition, partition)) {
+					corruptCandidates++;
+					continue;
+				}
+				if (!event.routingComplete || event.occurredAtMillis === void 0 || event.acceptedAtMillis > cutoff || (current.recoveryCounts.get(eventCandidateIndexKey(event)) ?? 0) > 0) continue;
+				deliveries.delete(key);
+				removedDeliveries.add(key);
+				deliveryIndex.delete(key);
+				eventDeliveryCounts.set(event.eventId, (eventDeliveryCounts.get(event.eventId) ?? 1) - 1);
+				const owner = delivery.key.subscription.ownerId;
+				ownerDeliveryCounts.set(owner, (ownerDeliveryCounts.get(owner) ?? 1) - 1);
+			}
+			let tombstones = current.tombstoneCount;
+			for (const key of eventPage) {
+				const text = events.get(key);
+				if (text === void 0) continue;
+				const decoded = decode(AcceptedEvent, text, "compact-event");
+				if (Result.isFailure(decoded)) {
+					corruptCandidates++;
+					continue;
+				}
+				const event = decoded.success;
+				if (event.eventId !== key || !samePartition(event.partition, partition)) {
+					corruptCandidates++;
+					continue;
+				}
+				if (!event.routingComplete || event.occurredAtMillis === void 0) continue;
+				const expired = event.occurredAtMillis <= nowMillis - policy.replayHorizonMillis;
+				if (event.tombstone === true && !expired) continue;
+				if (event.acceptedAtMillis > cutoff || (eventDeliveryCounts.get(key) ?? 0) > 0 || (current.recoveryCounts.get(eventCandidateIndexKey(event)) ?? 0) > 0) continue;
+				if (expired) {
+					events.delete(key);
+					removedEvents.add(key);
+					eventIndex.delete(key);
+					eventDeliveryCounts.delete(key);
+					if (event.tombstone === true) tombstones--;
+				} else {
+					if (tombstones >= policy.maxTombstones) continue;
+					const encoded = encode(AcceptedEvent, {
+						...event,
+						payload: null,
+						tombstone: true
+					}, "compact-tombstone");
+					if (Result.isFailure(encoded)) continue;
+					events.set(key, encoded.success);
+					tombstones++;
+				}
+				removed++;
+			}
+			return [Result.succeed(removed), {
+				...current,
+				events,
+				eventIndex,
+				deliveries,
+				deliveryIndex,
+				eventDeliveryCounts,
+				ownerDeliveryCounts,
+				eventKeys: removeKeys(current.eventKeys, removedEvents),
+				deliveryKeys: removeKeys(current.deliveryKeys, removedDeliveries),
+				tombstoneCount: tombstones,
+				maintenanceEvents: eventPage.length < limit ? "" : eventPage.at(-1) ?? "",
+				maintenanceDeliveries: deliveryPage.length < limit ? "" : deliveryPage.at(-1) ?? "",
+				retentionHorizon: policy.replayHorizonMillis,
+				retentionDeadline: events.size === 0 ? null : nowMillis + 6e4
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		if (corruptCandidates > 0) yield* Effect.logWarning("Subscription retention preserved corrupt candidates", { count: corruptCandidates });
+		yield* failpoint.hit("subscription:compact:after");
+		return result;
+	});
+	return SubscriptionStore.of({
+		partition,
+		compact,
+		register,
+		get,
+		list,
+		cancel,
+		change,
+		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
+export { memorySubscriptionStoreLayer, MemorySubscriptionStore_exports as t };
+
+//# sourceMappingURL=MemorySubscriptionStore.mjs.map