@yielded/agent-storage-memory 0.1.0-beta.167 → 0.1.0-beta.169

package/dist/MemorySubscriptionStore.mjs

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { compareScheduleNames } from "@yielded/agent/schedule-transition";
 import { Clock, Effect, Layer, Ref, Result, Schema } from "effect";
-import { Digest } from "@yielded/agent/records";
 import { AcceptedEvent, DeliveryChange, SourcePartition, SubscriptionChange, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionRetentionPolicy, SubscriptionScanCursors, SubscriptionStore, subscriptionDeliveryKeyString, subscriptionKeyString } from "@yielded/agent/subscription";
+import { Digest } from "@yielded/agent/records";
 import { applySubscriptionChange, applySubscriptionDeliveryChange, sameAcceptedEventIdentity, subscriptionCanSelect, subscriptionDeliveryCanSelect, validateEventRetention } from "@yielded/agent/subscription-transition";
 //#region src/MemorySubscriptionStore.ts
 var MemorySubscriptionStore_exports = /* @__PURE__ */ __exportAll({ memorySubscriptionStoreLayer: () => memorySubscriptionStoreLayer });
@@ -76,7 +76,7 @@ const recoveryCountsAfter = (current, next, keys) => {
 	}
 	return counts;
 };
-const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (ownedPartition) {
+const makeMemorySubscriptionStore = Effect.fnUntraced(function* (ownedPartition) {
 	const partition = yield* validate(SourcePartition, ownedPartition, "partition");
 	const state = yield* Ref.make({
 		sequence: 0,
@@ -107,7 +107,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 	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 register = Effect.fnUntraced(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");
@@ -160,12 +160,12 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* failpoint.hit("subscription:register:after");
 		return result;
 	});
-	const get = Effect.fn("MemorySubscriptionStore.get")(function* (input) {
+	const get = Effect.fnUntraced(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) {
+	const list = Effect.fnUntraced(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 = [];
@@ -178,7 +178,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		records.sort((a, b) => a.ordinal - b.ordinal);
 		return records.slice(0, limit);
 	});
-	const change = Effect.fn("MemorySubscriptionStore.change")(function* (input, expectedRevision, inputChange) {
+	const change = Effect.fnUntraced(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");
@@ -224,7 +224,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* failpoint.hit("subscription:change:after");
 		return updated;
 	});
-	const cancel = Effect.fn("MemorySubscriptionStore.cancel")(function* (input, expectedRevision) {
+	const cancel = Effect.fnUntraced(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) => {
@@ -269,7 +269,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* failpoint.hit("subscription:cancel:after");
 		return result;
 	});
-	const accept = Effect.fn("MemorySubscriptionStore.accept")(function* (input, inputLimits) {
+	const accept = Effect.fnUntraced(function* (input, inputLimits) {
 		const event = yield* validate(AcceptedEvent, input, "accept-event");
 		const currentTimeMillis = yield* Clock.currentTimeMillis;
 		const limits = yield* validate(SubscriptionLimits, inputLimits, "accept-limits");
@@ -316,17 +316,17 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* failpoint.hit("subscription:accept:after");
 		return result;
 	});
-	const event = Effect.fn("MemorySubscriptionStore.event")(function* (eventId) {
+	const event = Effect.fnUntraced(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 pendingEvents = Effect.fnUntraced(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 candidates = Effect.fnUntraced(function* (input, limit) {
 		const accepted = yield* validate(AcceptedEvent, input, "candidates-event");
 		yield* requirePartition(accepted, "candidates-partition");
 		const stored = yield* event(accepted.eventId);
@@ -344,7 +344,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		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 select = Effect.fnUntraced(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");
@@ -457,7 +457,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:select:after");
 	});
-	const catchUp = Effect.fn("MemorySubscriptionStore.catchUp")(function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
+	const catchUp = Effect.fnUntraced(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");
@@ -531,7 +531,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:catch-up:after");
 	});
-	const deferEvent = Effect.fn("MemorySubscriptionStore.deferEvent")(function* (eventId, nextAttemptAtMillis, code) {
+	const deferEvent = Effect.fnUntraced(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) => {
@@ -563,19 +563,19 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:defer-event:after");
 	});
-	const delivery = Effect.fn("MemorySubscriptionStore.delivery")(function* (input) {
+	const delivery = Effect.fnUntraced(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 pendingDeliveries = Effect.fnUntraced(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 listDeliveries = Effect.fnUntraced(function* (input, after, limit) {
 		const key = yield* requireKey(input, "list-deliveries-key");
 		const items = [];
 		for (const text of (yield* Ref.get(state)).deliveries.values()) {
@@ -586,7 +586,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		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 changeDelivery = Effect.fnUntraced(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");
@@ -633,7 +633,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:after`);
 		return result;
 	});
-	const recovering = Effect.fn("MemorySubscriptionStore.recovering")(function* (nowMillis, after, limit) {
+	const recovering = Effect.fnUntraced(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,
@@ -642,7 +642,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		records.sort((a, b) => a.ordinal - b.ordinal);
 		return records.slice(0, limit);
 	});
-	const deferRecovery = Effect.fn("MemorySubscriptionStore.deferRecovery")(function* (input, expectedRevision, recovery) {
+	const deferRecovery = Effect.fnUntraced(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) => {
@@ -678,7 +678,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		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 advanceScanCursors = Effect.fnUntraced(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) => ({
@@ -699,8 +699,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		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) {
+	});
+	const compact = Effect.fnUntraced(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({