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

package/dist/MemoryMessageDeliveryStore.d.mts

@@ -0,0 +1,15 @@
+import { Layer } from "effect";
+import { MessageDeliveryError, MessageDeliveryStore, MessageDeliveryStoreLimits } from "effect-agent/message-delivery";
+declare namespace MemoryMessageDeliveryStore_d_exports {
+  export { MemoryMessageDeliveryStoreLive, MemoryMessageDeliveryStoreOptions, memoryMessageDeliveryStoreLayer };
+}
+interface MemoryMessageDeliveryStoreOptions {
+  /** UTF-8 bound on the complete stored record, including a processed Settlement. */
+  readonly maxStoredValueBytes?: number;
+}
+/** Reference adapter. All retained rows are bounded; completed deduplication evidence is never evicted. */
+declare const memoryMessageDeliveryStoreLayer: (limits?: MessageDeliveryStoreLimits, options?: MemoryMessageDeliveryStoreOptions) => Layer.Layer<MessageDeliveryStore, MessageDeliveryError>;
+declare const MemoryMessageDeliveryStoreLive: Layer.Layer<MessageDeliveryStore, MessageDeliveryError, never>;
+//#endregion
+export { MemoryMessageDeliveryStoreLive, MemoryMessageDeliveryStoreOptions, memoryMessageDeliveryStoreLayer, MemoryMessageDeliveryStore_d_exports as t };
+//# sourceMappingURL=MemoryMessageDeliveryStore.d.mts.map

package/dist/MemoryMessageDeliveryStore.mjs

@@ -0,0 +1,147 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { ScheduleInstant } from "effect-agent/schedule";
+import { ThreadId } from "effect-agent/identifiers";
+import { MessageDeliveryChange, MessageDeliveryError, MessageDeliveryFailpoint, MessageDeliveryKey, MessageDeliveryPageRequest, MessageDeliveryRecord, MessageDeliveryStore, MessageDeliveryStoreLimits, applyMessageDeliveryChange, defaultMessageDeliveryStoreLimits, isWorkerUpdateDelivery, messageDeliveryCapacity, messageDeliveryDeadline, messageDeliveryKeyString, messageDeliveryUsesCapacity, sameMessageDeliveryIdentity, validateMessageDelivery } from "effect-agent/message-delivery";
+//#region src/MemoryMessageDeliveryStore.ts
+var MemoryMessageDeliveryStore_exports = /* @__PURE__ */ __exportAll({
+	MemoryMessageDeliveryStoreLive: () => MemoryMessageDeliveryStoreLive,
+	memoryMessageDeliveryStoreLayer: () => memoryMessageDeliveryStoreLayer
+});
+const codec = Schema.fromJsonString(MessageDeliveryRecord);
+const decode = (text) => Schema.decodeEffect(codec)(text).pipe(Effect.mapError(() => MessageDeliveryError.make({
+	reason: "corrupt",
+	operation: "decode"
+})));
+const Scan = Schema.Struct({
+	nowMillis: ScheduleInstant,
+	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)),
+	ownerThreadId: Schema.optionalKey(ThreadId)
+});
+/** Reference adapter. All retained rows are bounded; completed deduplication evidence is never evicted. */
+const memoryMessageDeliveryStoreLayer = (limits = defaultMessageDeliveryStoreLimits, options = {}) => Layer.effect(MessageDeliveryStore, Effect.gen(function* () {
+	const config = yield* validateMessageDelivery(MessageDeliveryStoreLimits, limits, "limits");
+	const maxStoredValueBytes = yield* validateMessageDelivery(Schema.Int.check(Schema.isGreaterThan(0)), options.maxStoredValueBytes ?? 16777216, "stored-value-limit");
+	const state = yield* Ref.make(/* @__PURE__ */ new Map());
+	const lock = yield* Semaphore.make(1);
+	const failpoint = yield* MessageDeliveryFailpoint;
+	const encode = Effect.fn("MemoryMessageDeliveryStore.encode")(function* (record) {
+		const text = yield* Schema.encodeEffect(codec)(record).pipe(Effect.mapError(() => MessageDeliveryError.make({
+			reason: "corrupt",
+			operation: "encode"
+		})));
+		if (new TextEncoder().encode(text).byteLength > maxStoredValueBytes) return yield* MessageDeliveryError.make({
+			reason: "capacity",
+			operation: "stored-value-bytes"
+		});
+		return text;
+	});
+	const all = Effect.fn("MemoryMessageDeliveryStore.all")(function* () {
+		return yield* Effect.forEach((yield* Ref.get(state)).values(), decode);
+	});
+	const insert = Effect.fn("MemoryMessageDeliveryStore.insert")(function* (record) {
+		const encoded = yield* encode(record);
+		const input = yield* decode(encoded);
+		if (input.version !== 1 || input.status !== "pending" || input.leaseUntilMillis !== null || input.retry.attempts !== 0 || input.retry.generation !== 0 || input.retry.automaticAttempts !== 0 || input.retry.nextAttemptAtMillis !== input.createdAtMillis || input.retry.lastAttemptAtMillis !== null || input.retry.lastFailure !== null || input.deadlineAtMillis !== input.initialDeadlineAtMillis) return yield* MessageDeliveryError.make({
+			reason: "validation",
+			operation: "insert-state"
+		});
+		if (new TextEncoder().encode(JSON.stringify(input.envelope)).byteLength > config.maxEnvelopeBytes) return yield* MessageDeliveryError.make({
+			reason: "capacity",
+			operation: "envelope-bytes"
+		});
+		yield* failpoint.hit("message-delivery:insert:before");
+		const inserted = yield* lock.withPermit(Effect.uninterruptible(Effect.gen(function* () {
+			const records = yield* Ref.get(state);
+			const key = messageDeliveryKeyString(input.key);
+			const existingText = records.get(key);
+			if (existingText !== void 0) {
+				const existing = yield* decode(existingText);
+				if (!sameMessageDeliveryIdentity(existing, input)) return yield* MessageDeliveryError.make({
+					reason: "conflict",
+					operation: "insert"
+				});
+				return existing;
+			}
+			const owned = (yield* all()).filter((record) => record.key.ownerThreadId === input.key.ownerThreadId && isWorkerUpdateDelivery(record) === isWorkerUpdateDelivery(input));
+			const capacity = messageDeliveryCapacity(config, isWorkerUpdateDelivery(input));
+			if (owned.length >= capacity.retained || owned.filter(messageDeliveryUsesCapacity).length >= capacity.pending) return yield* MessageDeliveryError.make({
+				reason: "capacity",
+				operation: "insert"
+			});
+			yield* Ref.set(state, new Map(records).set(key, encoded));
+			return input;
+		})));
+		yield* failpoint.hit("message-delivery:insert:after");
+		return yield* decode(yield* encode(inserted));
+	});
+	const get = Effect.fn("MemoryMessageDeliveryStore.get")(function* (key) {
+		const input = yield* validateMessageDelivery(MessageDeliveryKey, key, "get");
+		const text = (yield* Ref.get(state)).get(messageDeliveryKeyString(input));
+		return text === void 0 ? null : yield* decode(text);
+	});
+	const change = Effect.fn("MemoryMessageDeliveryStore.change")(function* (key, change) {
+		const input = yield* validateMessageDelivery(MessageDeliveryChange, change, "change");
+		const decodedKey = yield* validateMessageDelivery(MessageDeliveryKey, key, "change");
+		const point = `message-delivery:${input._tag.toLowerCase()}`;
+		yield* failpoint.hit(`${point}:before`);
+		const changed = yield* lock.withPermit(Effect.uninterruptible(Effect.gen(function* () {
+			const existing = yield* get(decodedKey);
+			if (existing === null) return yield* MessageDeliveryError.make({
+				reason: "not-found",
+				operation: "change"
+			});
+			const next = yield* Effect.fromResult(applyMessageDeliveryChange(existing, input));
+			const encoded = yield* encode(next);
+			yield* Ref.update(state, (records) => new Map(records).set(messageDeliveryKeyString(decodedKey), encoded));
+			return next;
+		})));
+		yield* failpoint.hit(`${point}:after`);
+		return yield* decode(yield* encode(changed));
+	});
+	return MessageDeliveryStore.of({
+		limits: config,
+		maxStoredValueBytes,
+		insert,
+		get,
+		change,
+		list: Effect.fn("MemoryMessageDeliveryStore.list")(function* (request) {
+			const input = yield* validateMessageDelivery(MessageDeliveryPageRequest, request, "list");
+			const records = (yield* all()).filter((record) => record.key.ownerThreadId === input.ownerThreadId && (input.after === void 0 || record.key.messageId > input.after)).sort((left, right) => left.key.messageId < right.key.messageId ? -1 : left.key.messageId > right.key.messageId ? 1 : 0);
+			const items = records.slice(0, input.limit);
+			return {
+				items,
+				next: records.length > input.limit ? items.at(-1)?.key.messageId ?? null : null
+			};
+		}),
+		due: Effect.fn("MemoryMessageDeliveryStore.due")(function* (nowMillis, limit, ownerThreadId) {
+			const input = yield* validateMessageDelivery(Scan, {
+				nowMillis,
+				limit,
+				...ownerThreadId === void 0 ? {} : { ownerThreadId }
+			}, "due");
+			return (yield* all()).flatMap((record) => {
+				const deadline = messageDeliveryDeadline(record);
+				return deadline !== null && deadline <= input.nowMillis && (input.ownerThreadId === void 0 || input.ownerThreadId === record.key.ownerThreadId) ? [{
+					key: record.key,
+					deadline
+				}] : [];
+			}).sort((left, right) => left.deadline - right.deadline || (messageDeliveryKeyString(left.key) < messageDeliveryKeyString(right.key) ? -1 : 1)).slice(0, input.limit).map((record) => record.key);
+		}),
+		nextDeadline: Effect.fn("MemoryMessageDeliveryStore.nextDeadline")(function* (ownerThreadId) {
+			if (ownerThreadId !== void 0) yield* validateMessageDelivery(ThreadId, ownerThreadId, "nextDeadline");
+			let next = null;
+			for (const record of yield* all()) {
+				if (ownerThreadId !== void 0 && ownerThreadId !== record.key.ownerThreadId) continue;
+				const deadline = messageDeliveryDeadline(record);
+				if (deadline !== null && (next === null || deadline < next)) next = deadline;
+			}
+			return next;
+		})
+	});
+}));
+const MemoryMessageDeliveryStoreLive = memoryMessageDeliveryStoreLayer();
+//#endregion
+export { MemoryMessageDeliveryStoreLive, memoryMessageDeliveryStoreLayer, MemoryMessageDeliveryStore_exports as t };
+
+//# sourceMappingURL=MemoryMessageDeliveryStore.mjs.map

package/dist/MemoryMessageDeliveryStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryMessageDeliveryStore.mjs","names":[],"sources":["../src/MemoryMessageDeliveryStore.ts"],"sourcesContent":["import { Effect, Layer, Ref, Schema, Semaphore } from \"effect\";\nimport { ThreadId } from \"effect-agent/identifiers\";\nimport {\n  applyMessageDeliveryChange,\n  defaultMessageDeliveryStoreLimits,\n  MessageDeliveryChange,\n  MessageDeliveryError,\n  MessageDeliveryFailpoint,\n  MessageDeliveryKey,\n  MessageDeliveryPageRequest,\n  MessageDeliveryRecord,\n  MessageDeliveryStore,\n  MessageDeliveryStoreLimits,\n  messageDeliveryDeadline,\n  messageDeliveryKeyString,\n  messageDeliveryUsesCapacity,\n  isWorkerUpdateDelivery,\n  messageDeliveryCapacity,\n  sameMessageDeliveryIdentity,\n  validateMessageDelivery,\n} from \"effect-agent/message-delivery\";\nimport { ScheduleInstant } from \"effect-agent/schedule\";\n\nconst codec = Schema.fromJsonString(MessageDeliveryRecord);\n\nconst decode = (text: string) =>\n  Schema.decodeEffect(codec)(text).pipe(\n    Effect.mapError(() => MessageDeliveryError.make({ reason: \"corrupt\", operation: \"decode\" })),\n  );\n\nconst Scan = Schema.Struct({\n  nowMillis: ScheduleInstant,\n  limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)),\n  ownerThreadId: Schema.optionalKey(ThreadId),\n});\n\nexport interface MemoryMessageDeliveryStoreOptions {\n  /** UTF-8 bound on the complete stored record, including a processed Settlement. */\n  readonly maxStoredValueBytes?: number;\n}\n\n/** Reference adapter. All retained rows are bounded; completed deduplication evidence is never evicted. */\nexport const memoryMessageDeliveryStoreLayer = (\n  limits: MessageDeliveryStoreLimits = defaultMessageDeliveryStoreLimits,\n  options: MemoryMessageDeliveryStoreOptions = {},\n): Layer.Layer<MessageDeliveryStore, MessageDeliveryError> =>\n  Layer.effect(\n    MessageDeliveryStore,\n    Effect.gen(function* () {\n      const config = yield* validateMessageDelivery(MessageDeliveryStoreLimits, limits, \"limits\");\n\n      const maxStoredValueBytes = yield* validateMessageDelivery(\n        Schema.Int.check(Schema.isGreaterThan(0)),\n        options.maxStoredValueBytes ?? 16 * 1_024 * 1_024,\n        \"stored-value-limit\",\n      );\n\n      const state = yield* Ref.make<ReadonlyMap<string, string>>(new Map());\n      const lock = yield* Semaphore.make(1);\n      const failpoint = yield* MessageDeliveryFailpoint;\n\n      const encode = Effect.fn(\"MemoryMessageDeliveryStore.encode\")(function* (\n        record: MessageDeliveryRecord,\n      ) {\n        const text = yield* Schema.encodeEffect(codec)(record).pipe(\n          Effect.mapError(() =>\n            MessageDeliveryError.make({ reason: \"corrupt\", operation: \"encode\" }),\n          ),\n        );\n\n        if (new TextEncoder().encode(text).byteLength > maxStoredValueBytes) {\n          return yield* MessageDeliveryError.make({\n            reason: \"capacity\",\n            operation: \"stored-value-bytes\",\n          });\n        }\n\n        return text;\n      });\n\n      const all = Effect.fn(\"MemoryMessageDeliveryStore.all\")(function* () {\n        return yield* Effect.forEach((yield* Ref.get(state)).values(), decode);\n      });\n\n      const insert: MessageDeliveryStore[\"Service\"][\"insert\"] = Effect.fn(\n        \"MemoryMessageDeliveryStore.insert\",\n      )(function* (record) {\n        const encoded = yield* encode(record);\n        const input = yield* decode(encoded);\n\n        if (\n          input.version !== 1 ||\n          input.status !== \"pending\" ||\n          input.leaseUntilMillis !== null ||\n          input.retry.attempts !== 0 ||\n          input.retry.generation !== 0 ||\n          input.retry.automaticAttempts !== 0 ||\n          input.retry.nextAttemptAtMillis !== input.createdAtMillis ||\n          input.retry.lastAttemptAtMillis !== null ||\n          input.retry.lastFailure !== null ||\n          input.deadlineAtMillis !== input.initialDeadlineAtMillis\n        ) {\n          return yield* MessageDeliveryError.make({\n            reason: \"validation\",\n            operation: \"insert-state\",\n          });\n        }\n        if (\n          new TextEncoder().encode(JSON.stringify(input.envelope)).byteLength >\n          config.maxEnvelopeBytes\n        ) {\n          return yield* MessageDeliveryError.make({\n            reason: \"capacity\",\n            operation: \"envelope-bytes\",\n          });\n        }\n        yield* failpoint.hit(\"message-delivery:insert:before\");\n\n        const inserted = yield* lock.withPermit(\n          Effect.uninterruptible(\n            Effect.gen(function* () {\n              const records = yield* Ref.get(state);\n              const key = messageDeliveryKeyString(input.key);\n              const existingText = records.get(key);\n\n              if (existingText !== undefined) {\n                const existing = yield* decode(existingText);\n\n                if (!sameMessageDeliveryIdentity(existing, input))\n                  return yield* MessageDeliveryError.make({\n                    reason: \"conflict\",\n                    operation: \"insert\",\n                  });\n\n                return existing;\n              }\n\n              const owned = (yield* all()).filter(\n                (record) =>\n                  record.key.ownerThreadId === input.key.ownerThreadId &&\n                  isWorkerUpdateDelivery(record) === isWorkerUpdateDelivery(input),\n              );\n\n              const capacity = messageDeliveryCapacity(config, isWorkerUpdateDelivery(input));\n\n              if (\n                owned.length >= capacity.retained ||\n                owned.filter(messageDeliveryUsesCapacity).length >= capacity.pending\n              ) {\n                return yield* MessageDeliveryError.make({\n                  reason: \"capacity\",\n                  operation: \"insert\",\n                });\n              }\n              yield* Ref.set(state, new Map(records).set(key, encoded));\n\n              return input;\n            }),\n          ),\n        );\n\n        yield* failpoint.hit(\"message-delivery:insert:after\");\n\n        return yield* decode(yield* encode(inserted));\n      });\n\n      const get: MessageDeliveryStore[\"Service\"][\"get\"] = Effect.fn(\n        \"MemoryMessageDeliveryStore.get\",\n      )(function* (key) {\n        const input = yield* validateMessageDelivery(MessageDeliveryKey, key, \"get\");\n        const text = (yield* Ref.get(state)).get(messageDeliveryKeyString(input));\n\n        return text === undefined ? null : yield* decode(text);\n      });\n\n      const change: MessageDeliveryStore[\"Service\"][\"change\"] = Effect.fn(\n        \"MemoryMessageDeliveryStore.change\",\n      )(function* (key, change) {\n        const input = yield* validateMessageDelivery(MessageDeliveryChange, change, \"change\");\n        const decodedKey = yield* validateMessageDelivery(MessageDeliveryKey, key, \"change\");\n        const point = `message-delivery:${input._tag.toLowerCase()}`;\n\n        yield* failpoint.hit(`${point}:before`);\n\n        const changed = yield* lock.withPermit(\n          Effect.uninterruptible(\n            Effect.gen(function* () {\n              const existing = yield* get(decodedKey);\n\n              if (existing === null)\n                return yield* MessageDeliveryError.make({\n                  reason: \"not-found\",\n                  operation: \"change\",\n                });\n              const next = yield* Effect.fromResult(applyMessageDeliveryChange(existing, input));\n              const encoded = yield* encode(next);\n\n              yield* Ref.update(state, (records) =>\n                new Map(records).set(messageDeliveryKeyString(decodedKey), encoded),\n              );\n\n              return next;\n            }),\n          ),\n        );\n\n        yield* failpoint.hit(`${point}:after`);\n\n        return yield* decode(yield* encode(changed));\n      });\n\n      return MessageDeliveryStore.of({\n        limits: config,\n        maxStoredValueBytes,\n        insert,\n        get,\n        change,\n        list: Effect.fn(\"MemoryMessageDeliveryStore.list\")(function* (request) {\n          const input = yield* validateMessageDelivery(MessageDeliveryPageRequest, request, \"list\");\n\n          const records = (yield* all())\n            .filter(\n              (record) =>\n                record.key.ownerThreadId === input.ownerThreadId &&\n                (input.after === undefined || record.key.messageId > input.after),\n            )\n            .sort((left, right) =>\n              left.key.messageId < right.key.messageId\n                ? -1\n                : left.key.messageId > right.key.messageId\n                  ? 1\n                  : 0,\n            );\n\n          const items = records.slice(0, input.limit);\n\n          return {\n            items,\n            next: records.length > input.limit ? (items.at(-1)?.key.messageId ?? null) : null,\n          };\n        }),\n        due: Effect.fn(\"MemoryMessageDeliveryStore.due\")(\n          function* (nowMillis, limit, ownerThreadId) {\n            const input = yield* validateMessageDelivery(\n              Scan,\n              { nowMillis, limit, ...(ownerThreadId === undefined ? {} : { ownerThreadId }) },\n              \"due\",\n            );\n\n            return (yield* all())\n              .flatMap((record) => {\n                const deadline = messageDeliveryDeadline(record);\n\n                return deadline !== null &&\n                  deadline <= input.nowMillis &&\n                  (input.ownerThreadId === undefined ||\n                    input.ownerThreadId === record.key.ownerThreadId)\n                  ? [{ key: record.key, deadline }]\n                  : [];\n              })\n              .sort(\n                (left, right) =>\n                  left.deadline - right.deadline ||\n                  (messageDeliveryKeyString(left.key) < messageDeliveryKeyString(right.key)\n                    ? -1\n                    : 1),\n              )\n              .slice(0, input.limit)\n              .map((record) => record.key);\n          },\n        ),\n        nextDeadline: Effect.fn(\"MemoryMessageDeliveryStore.nextDeadline\")(\n          function* (ownerThreadId) {\n            if (ownerThreadId !== undefined)\n              yield* validateMessageDelivery(ThreadId, ownerThreadId, \"nextDeadline\");\n            let next: number | null = null;\n\n            for (const record of yield* all()) {\n              if (ownerThreadId !== undefined && ownerThreadId !== record.key.ownerThreadId)\n                continue;\n              const deadline = messageDeliveryDeadline(record);\n\n              if (deadline !== null && (next === null || deadline < next)) next = deadline;\n            }\n\n            return next;\n          },\n        ),\n      });\n    }),\n  );\n\nexport const MemoryMessageDeliveryStoreLive = memoryMessageDeliveryStoreLayer();\n"],"mappings":"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"}

package/dist/MemoryScheduleStore.d.mts

@@ -0,0 +1,10 @@
+import { Layer } from "effect";
+import { ScheduleStore } from "effect-agent/schedule";
+declare namespace MemoryScheduleStore_d_exports {
+  export { MemoryScheduleStoreLive, memoryScheduleStoreLayer };
+}
+declare const memoryScheduleStoreLayer: () => Layer.Layer<ScheduleStore>;
+declare const MemoryScheduleStoreLive: Layer.Layer<ScheduleStore>;
+//#endregion
+export { MemoryScheduleStoreLive, memoryScheduleStoreLayer, MemoryScheduleStore_d_exports as t };
+//# sourceMappingURL=MemoryScheduleStore.d.mts.map

package/dist/MemoryScheduleStore.mjs

@@ -0,0 +1,169 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Effect, Layer, Ref, Result, Schema } from "effect";
+import { ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, defaultSchedulingLimits } from "effect-agent/schedule";
+import { applyScheduleChange, compareScheduleKeys, compareScheduleNames, scheduleDeadline, scheduleKeyOf, scheduleKeyString, scheduleOwnerKey, scheduleUsesCapacity } from "effect-agent/schedule-transition";
+//#region src/MemoryScheduleStore.ts
+var MemoryScheduleStore_exports = /* @__PURE__ */ __exportAll({
+	MemoryScheduleStoreLive: () => MemoryScheduleStoreLive,
+	memoryScheduleStoreLayer: () => memoryScheduleStoreLayer
+});
+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.decodeResult(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
+export { MemoryScheduleStoreLive, memoryScheduleStoreLayer, MemoryScheduleStore_exports as t };
+
+//# sourceMappingURL=MemoryScheduleStore.mjs.map

package/dist/MemoryScheduleStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryScheduleStore.mjs","names":[],"sources":["../src/MemoryScheduleStore.ts"],"sourcesContent":["import { Effect, Layer, Ref, Result, Schema } from \"effect\";\nimport {\n  ScheduleCapacityError,\n  ScheduleDueCursor,\n  defaultSchedulingLimits,\n  ScheduleChange,\n  ScheduleConflict,\n  ScheduleFailpoint,\n  ScheduleKey,\n  ScheduleNotFound,\n  ScheduleOwner,\n  SchedulePageRequest,\n  ScheduleRecord,\n  ScheduleStorageError,\n  ScheduleStore,\n} from \"effect-agent/schedule\";\nimport {\n  scheduleUsesCapacity,\n  applyScheduleChange,\n  compareScheduleKeys,\n  compareScheduleNames,\n  scheduleDeadline,\n  scheduleKeyString,\n  scheduleKeyOf,\n  scheduleOwnerKey,\n} from \"effect-agent/schedule-transition\";\n\ninterface MemoryScheduleState {\n  readonly records: ReadonlyMap<string, string>;\n}\n\nconst storageError = (operation: string, reason: \"unavailable\" | \"corrupt\") =>\n  ScheduleStorageError.make({ operation, reason });\n\nconst encodeRecord = (operation: string, record: ScheduleRecord) =>\n  Effect.try({\n    try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(record),\n    catch: () => storageError(operation, \"corrupt\"),\n  });\n\nconst decodeRecord = (operation: string, encoded: string) =>\n  Effect.try({\n    try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(encoded),\n    catch: () => storageError(operation, \"corrupt\"),\n  });\n\nconst decodeInput = <A, I>(operation: string, schema: Schema.Codec<A, I>, value: unknown) =>\n  Effect.try({\n    try: () => Schema.decodeUnknownSync(schema)(value),\n    catch: () => storageError(operation, \"corrupt\"),\n  });\n\nconst sameOwner = (record: ScheduleRecord, owner: ScheduleOwner): boolean =>\n  scheduleOwnerKey(record.owner) === scheduleOwnerKey(owner);\n\nconst makeScheduleStore = Effect.gen(function* () {\n  const state = yield* Ref.make<MemoryScheduleState>({ records: new Map() });\n  const failpoint = yield* ScheduleFailpoint;\n\n  const insert: ScheduleStore[\"Service\"][\"insert\"] = Effect.fn(\"MemoryScheduleStore.insert\")(\n    (record, ownerLimit) =>\n      Effect.gen(function* () {\n        const encoded = yield* encodeRecord(\"insert\", record);\n\n        yield* failpoint.hit(\"schedule:insert:before\");\n\n        const decision = yield* Effect.uninterruptible(\n          Ref.modify(\n            state,\n            (\n              current,\n            ): readonly [\n              Result.Result<\n                ScheduleRecord,\n                ScheduleConflict | ScheduleCapacityError | ScheduleStorageError\n              >,\n              MemoryScheduleState,\n            ] => {\n              const key = scheduleKeyString(record);\n              const existingText = current.records.get(key);\n\n              if (existingText !== undefined) {\n                const decoded = Result.try({\n                  try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(existingText),\n                  catch: () => storageError(\"insert\", \"corrupt\"),\n                });\n\n                if (Result.isFailure(decoded)) {\n                  return [Result.fail(decoded.failure), current];\n                }\n                if (decoded.success.creationFingerprint === record.creationFingerprint) {\n                  return [Result.succeed(decoded.success), current];\n                }\n\n                return [\n                  Result.fail(\n                    ScheduleConflict.make({ reason: \"creation\", key: scheduleKeyOf(record) }),\n                  ),\n                  current,\n                ];\n              }\n\n              let ownerCount = 0;\n\n              for (const text of current.records.values()) {\n                const decoded = Result.try({\n                  try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),\n                  catch: () => storageError(\"insert\", \"corrupt\"),\n                });\n\n                if (Result.isFailure(decoded)) {\n                  return [Result.fail(decoded.failure), current];\n                }\n                if (\n                  sameOwner(decoded.success, record.owner) &&\n                  scheduleUsesCapacity(decoded.success)\n                )\n                  ownerCount += 1;\n              }\n              if (ownerCount >= ownerLimit) {\n                return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];\n              }\n              const records = new Map(current.records);\n\n              records.set(key, encoded);\n              const next = { records };\n\n              return [Result.succeed(record), next];\n            },\n          ),\n        );\n\n        const inserted = yield* Effect.fromResult(decision);\n\n        yield* failpoint.hit(\"schedule:insert:after\");\n\n        return yield* decodeRecord(\"insert\", yield* encodeRecord(\"insert\", inserted));\n      }),\n  );\n\n  const get: ScheduleStore[\"Service\"][\"get\"] = Effect.fn(\"MemoryScheduleStore.get\")(\n    function* (key) {\n      const decodedKey = yield* decodeInput(\"get\", ScheduleKey, key);\n      const text = (yield* Ref.get(state)).records.get(scheduleKeyString(decodedKey));\n\n      return text === undefined ? null : yield* decodeRecord(\"get\", text);\n    },\n  );\n\n  const list: ScheduleStore[\"Service\"][\"list\"] = Effect.fn(\"MemoryScheduleStore.list\")(\n    function* (request) {\n      const decodedRequest = yield* decodeInput(\"list\", SchedulePageRequest, request);\n      const records: Array<ScheduleRecord> = [];\n\n      for (const text of (yield* Ref.get(state)).records.values()) {\n        const record = yield* decodeRecord(\"list\", text);\n\n        if (\n          sameOwner(record, decodedRequest.owner) &&\n          (decodedRequest.after === undefined ||\n            compareScheduleNames(record.scheduleId, decodedRequest.after) > 0)\n        ) {\n          records.push(record);\n        }\n      }\n      records.sort((left, right) => compareScheduleNames(left.scheduleId, right.scheduleId));\n      const hasNext = records.length > decodedRequest.limit;\n      const items = records.slice(0, decodedRequest.limit);\n\n      return {\n        items,\n        next: hasNext ? (items.at(-1)?.scheduleId ?? null) : null,\n      };\n    },\n  );\n\n  const change: ScheduleStore[\"Service\"][\"change\"] = Effect.fn(\"MemoryScheduleStore.change\")(\n    (key, command, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) =>\n      Effect.gen(function* () {\n        const decodedKey = yield* decodeInput(\"change\", ScheduleKey, key);\n        const decodedCommand = yield* decodeInput(\"change\", ScheduleChange, command);\n\n        yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:before`);\n\n        const decision = yield* Effect.uninterruptible(\n          Ref.modify(\n            state,\n            (\n              current,\n            ): readonly [\n              Result.Result<\n                ScheduleRecord,\n                ScheduleConflict | ScheduleStorageError | ScheduleNotFound | ScheduleCapacityError\n              >,\n              MemoryScheduleState,\n            ] => {\n              const storageKey = scheduleKeyString(decodedKey);\n              const text = current.records.get(storageKey);\n\n              if (text === undefined) {\n                return [Result.fail(ScheduleNotFound.make({ key: decodedKey })), current];\n              }\n\n              const decoded = Result.try({\n                try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(text),\n                catch: () => storageError(\"change\", \"corrupt\"),\n              });\n\n              if (Result.isFailure(decoded)) {\n                return [Result.fail(decoded.failure), current];\n              }\n              const applied = applyScheduleChange(decoded.success, decodedCommand);\n\n              if (Result.isFailure(applied)) {\n                return [Result.fail(applied.failure), current];\n              }\n              if (applied.success === decoded.success) {\n                return [Result.succeed(decoded.success), current];\n              }\n              if (!scheduleUsesCapacity(decoded.success) && scheduleUsesCapacity(applied.success)) {\n                let count = 0;\n\n                for (const text of current.records.values()) {\n                  const candidate = Schema.decodeResult(Schema.fromJsonString(ScheduleRecord))(\n                    text,\n                  );\n\n                  if (Result.isFailure(candidate))\n                    return [Result.fail(storageError(\"change\", \"corrupt\")), current];\n                  if (\n                    sameOwner(candidate.success, decodedKey.owner) &&\n                    scheduleUsesCapacity(candidate.success)\n                  )\n                    count += 1;\n                }\n                if (count >= ownerLimit)\n                  return [Result.fail(ScheduleCapacityError.make({ limit: ownerLimit })), current];\n              }\n\n              const encoded = Result.try({\n                try: () =>\n                  Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(applied.success),\n                catch: () => storageError(\"change\", \"corrupt\"),\n              });\n\n              if (Result.isFailure(encoded)) {\n                return [Result.fail(encoded.failure), current];\n              }\n              const records = new Map(current.records);\n\n              records.set(storageKey, encoded.success);\n              const next = { records };\n\n              return [Result.succeed(applied.success), next];\n            },\n          ),\n        );\n\n        const changed = yield* Effect.fromResult(decision);\n\n        yield* failpoint.hit(`schedule:${decodedCommand._tag.toLowerCase()}:after`);\n\n        return yield* decodeRecord(\"change\", yield* encodeRecord(\"change\", changed));\n      }),\n  );\n\n  const due: ScheduleStore[\"Service\"][\"due\"] = Effect.fn(\"MemoryScheduleStore.due\")(\n    function* (nowMillis, limit, owner, after) {\n      const decodedOwner =\n        owner === undefined ? undefined : yield* decodeInput(\"due\", ScheduleOwner, owner);\n\n      const cursor =\n        after === undefined ? undefined : yield* decodeInput(\"due\", ScheduleDueCursor, after);\n\n      const records: Array<ScheduleDueCursor> = [];\n\n      for (const text of (yield* Ref.get(state)).records.values()) {\n        const record = yield* decodeRecord(\"due\", text);\n        const deadline = scheduleDeadline(record);\n\n        if (\n          deadline !== null &&\n          deadline <= nowMillis &&\n          (decodedOwner === undefined || sameOwner(record, decodedOwner)) &&\n          (cursor === undefined ||\n            deadline > cursor.deadlineAtMillis ||\n            (deadline === cursor.deadlineAtMillis && compareScheduleKeys(record, cursor) > 0))\n        ) {\n          records.push({ ...scheduleKeyOf(record), deadlineAtMillis: deadline });\n        }\n      }\n      records.sort((left, right) => {\n        const byDeadline = left.deadlineAtMillis - right.deadlineAtMillis;\n\n        return byDeadline !== 0 ? byDeadline : compareScheduleKeys(left, right);\n      });\n\n      return records.slice(0, limit);\n    },\n  );\n\n  const nextDeadline: ScheduleStore[\"Service\"][\"nextDeadline\"] = Effect.fn(\n    \"MemoryScheduleStore.nextDeadline\",\n  )(function* (owner) {\n    const decodedOwner =\n      owner === undefined ? undefined : yield* decodeInput(\"nextDeadline\", ScheduleOwner, owner);\n\n    let earliest: number | null = null;\n\n    for (const text of (yield* Ref.get(state)).records.values()) {\n      const record = yield* decodeRecord(\"nextDeadline\", text);\n\n      if (decodedOwner !== undefined && !sameOwner(record, decodedOwner)) continue;\n      const deadline = scheduleDeadline(record);\n\n      if (deadline !== null && (earliest === null || deadline < earliest)) earliest = deadline;\n    }\n\n    return earliest;\n  });\n\n  return ScheduleStore.of({ insert, get, list, change, due, nextDeadline });\n});\n\nexport const memoryScheduleStoreLayer = (): Layer.Layer<ScheduleStore> =>\n  Layer.effect(ScheduleStore, makeScheduleStore);\n\nexport const MemoryScheduleStoreLive: Layer.Layer<ScheduleStore> = memoryScheduleStoreLayer();\n"],"mappings":";;;;;;;;;AA+BA,MAAM,gBAAgB,WAAmB,WACvC,qBAAqB,KAAK;CAAE;CAAW;AAAO,CAAC;AAEjD,MAAM,gBAAgB,WAAmB,WACvC,OAAO,IAAI;CACT,WAAW,OAAO,WAAW,OAAO,eAAe,cAAc,CAAC,CAAC,CAAC,MAAM;CAC1E,aAAa,aAAa,WAAW,SAAS;AAChD,CAAC;AAEH,MAAM,gBAAgB,WAAmB,YACvC,OAAO,IAAI;CACT,WAAW,OAAO,WAAW,OAAO,eAAe,cAAc,CAAC,CAAC,CAAC,OAAO;CAC3E,aAAa,aAAa,WAAW,SAAS;AAChD,CAAC;AAEH,MAAM,eAAqB,WAAmB,QAA4B,UACxE,OAAO,IAAI;CACT,WAAW,OAAO,kBAAkB,MAAM,CAAC,CAAC,KAAK;CACjD,aAAa,aAAa,WAAW,SAAS;AAChD,CAAC;AAEH,MAAM,aAAa,QAAwB,UACzC,iBAAiB,OAAO,KAAK,MAAM,iBAAiB,KAAK;AAE3D,MAAM,oBAAoB,OAAO,IAAI,aAAa;CAChD,MAAM,QAAQ,OAAO,IAAI,KAA0B,EAAE,yBAAS,IAAI,IAAI,EAAE,CAAC;CACzE,MAAM,YAAY,OAAO;CAEzB,MAAM,SAA6C,OAAO,GAAG,4BAA4B,CAAC,EACvF,QAAQ,eACP,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,aAAa,UAAU,MAAM;EAEpD,OAAO,UAAU,IAAI,wBAAwB;EAE7C,MAAM,WAAW,OAAO,OAAO,gBAC7B,IAAI,OACF,QAEE,YAOG;GACH,MAAM,MAAM,kBAAkB,MAAM;GACpC,MAAM,eAAe,QAAQ,QAAQ,IAAI,GAAG;GAE5C,IAAI,iBAAiB,KAAA,GAAW;IAC9B,MAAM,UAAU,OAAO,IAAI;KACzB,WAAW,OAAO,WAAW,OAAO,eAAe,cAAc,CAAC,CAAC,CAAC,YAAY;KAChF,aAAa,aAAa,UAAU,SAAS;IAC/C,CAAC;IAED,IAAI,OAAO,UAAU,OAAO,GAC1B,OAAO,CAAC,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO;IAE/C,IAAI,QAAQ,QAAQ,wBAAwB,OAAO,qBACjD,OAAO,CAAC,OAAO,QAAQ,QAAQ,OAAO,GAAG,OAAO;IAGlD,OAAO,CACL,OAAO,KACL,iBAAiB,KAAK;KAAE,QAAQ;KAAY,KAAK,cAAc,MAAM;IAAE,CAAC,CAC1E,GACA,OACF;GACF;GAEA,IAAI,aAAa;GAEjB,KAAK,MAAM,QAAQ,QAAQ,QAAQ,OAAO,GAAG;IAC3C,MAAM,UAAU,OAAO,IAAI;KACzB,WAAW,OAAO,WAAW,OAAO,eAAe,cAAc,CAAC,CAAC,CAAC,IAAI;KACxE,aAAa,aAAa,UAAU,SAAS;IAC/C,CAAC;IAED,IAAI,OAAO,UAAU,OAAO,GAC1B,OAAO,CAAC,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO;IAE/C,IACE,UAAU,QAAQ,SAAS,OAAO,KAAK,KACvC,qBAAqB,QAAQ,OAAO,GAEpC,cAAc;GAClB;GACA,IAAI,cAAc,YAChB,OAAO,CAAC,OAAO,KAAK,sBAAsB,KAAK,EAAE,OAAO,WAAW,CAAC,CAAC,GAAG,OAAO;GAEjF,MAAM,UAAU,IAAI,IAAI,QAAQ,OAAO;GAEvC,QAAQ,IAAI,KAAK,OAAO;GACxB,MAAM,OAAO,EAAE,QAAQ;GAEvB,OAAO,CAAC,OAAO,QAAQ,MAAM,GAAG,IAAI;EACtC,CACF,CACF;EAEA,MAAM,WAAW,OAAO,OAAO,WAAW,QAAQ;EAElD,OAAO,UAAU,IAAI,uBAAuB;EAE5C,OAAO,OAAO,aAAa,UAAU,OAAO,aAAa,UAAU,QAAQ,CAAC;CAC9E,CAAC,CACL;CAEA,MAAM,MAAuC,OAAO,GAAG,yBAAyB,CAAC,CAC/E,WAAW,KAAK;EACd,MAAM,aAAa,OAAO,YAAY,OAAO,aAAa,GAAG;EAC7D,MAAM,QAAQ,OAAO,IAAI,IAAI,KAAK,EAAA,CAAG,QAAQ,IAAI,kBAAkB,UAAU,CAAC;EAE9E,OAAO,SAAS,KAAA,IAAY,OAAO,OAAO,aAAa,OAAO,IAAI;CACpE,CACF;CAEA,MAAM,OAAyC,OAAO,GAAG,0BAA0B,CAAC,CAClF,WAAW,SAAS;EAClB,MAAM,iBAAiB,OAAO,YAAY,QAAQ,qBAAqB,OAAO;EAC9E,MAAM,UAAiC,CAAC;EAExC,KAAK,MAAM,SAAS,OAAO,IAAI,IAAI,KAAK,EAAA,CAAG,QAAQ,OAAO,GAAG;GAC3D,MAAM,SAAS,OAAO,aAAa,QAAQ,IAAI;GAE/C,IACE,UAAU,QAAQ,eAAe,KAAK,MACrC,eAAe,UAAU,KAAA,KACxB,qBAAqB,OAAO,YAAY,eAAe,KAAK,IAAI,IAElE,QAAQ,KAAK,MAAM;EAEvB;EACA,QAAQ,MAAM,MAAM,UAAU,qBAAqB,KAAK,YAAY,MAAM,UAAU,CAAC;EACrF,MAAM,UAAU,QAAQ,SAAS,eAAe;EAChD,MAAM,QAAQ,QAAQ,MAAM,GAAG,eAAe,KAAK;EAEnD,OAAO;GACL;GACA,MAAM,UAAW,MAAM,GAAG,EAAE,CAAC,EAAE,cAAc,OAAQ;EACvD;CACF,CACF;CAEA,MAAM,SAA6C,OAAO,GAAG,4BAA4B,CAAC,EACvF,KAAK,SAAS,aAAa,wBAAwB,yBAClD,OAAO,IAAI,aAAa;EACtB,MAAM,aAAa,OAAO,YAAY,UAAU,aAAa,GAAG;EAChE,MAAM,iBAAiB,OAAO,YAAY,UAAU,gBAAgB,OAAO;EAE3E,OAAO,UAAU,IAAI,YAAY,eAAe,KAAK,YAAY,EAAE,QAAQ;EAE3E,MAAM,WAAW,OAAO,OAAO,gBAC7B,IAAI,OACF,QAEE,YAOG;GACH,MAAM,aAAa,kBAAkB,UAAU;GAC/C,MAAM,OAAO,QAAQ,QAAQ,IAAI,UAAU;GAE3C,IAAI,SAAS,KAAA,GACX,OAAO,CAAC,OAAO,KAAK,iBAAiB,KAAK,EAAE,KAAK,WAAW,CAAC,CAAC,GAAG,OAAO;GAG1E,MAAM,UAAU,OAAO,IAAI;IACzB,WAAW,OAAO,WAAW,OAAO,eAAe,cAAc,CAAC,CAAC,CAAC,IAAI;IACxE,aAAa,aAAa,UAAU,SAAS;GAC/C,CAAC;GAED,IAAI,OAAO,UAAU,OAAO,GAC1B,OAAO,CAAC,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO;GAE/C,MAAM,UAAU,oBAAoB,QAAQ,SAAS,cAAc;GAEnE,IAAI,OAAO,UAAU,OAAO,GAC1B,OAAO,CAAC,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO;GAE/C,IAAI,QAAQ,YAAY,QAAQ,SAC9B,OAAO,CAAC,OAAO,QAAQ,QAAQ,OAAO,GAAG,OAAO;GAElD,IAAI,CAAC,qBAAqB,QAAQ,OAAO,KAAK,qBAAqB,QAAQ,OAAO,GAAG;IACnF,IAAI,QAAQ;IAEZ,KAAK,MAAM,QAAQ,QAAQ,QAAQ,OAAO,GAAG;KAC3C,MAAM,YAAY,OAAO,aAAa,OAAO,eAAe,cAAc,CAAC,CAAC,CAC1E,IACF;KAEA,IAAI,OAAO,UAAU,SAAS,GAC5B,OAAO,CAAC,OAAO,KAAK,aAAa,UAAU,SAAS,CAAC,GAAG,OAAO;KACjE,IACE,UAAU,UAAU,SAAS,WAAW,KAAK,KAC7C,qBAAqB,UAAU,OAAO,GAEtC,SAAS;IACb;IACA,IAAI,SAAS,YACX,OAAO,CAAC,OAAO,KAAK,sBAAsB,KAAK,EAAE,OAAO,WAAW,CAAC,CAAC,GAAG,OAAO;GACnF;GAEA,MAAM,UAAU,OAAO,IAAI;IACzB,WACE,OAAO,WAAW,OAAO,eAAe,cAAc,CAAC,CAAC,CAAC,QAAQ,OAAO;IAC1E,aAAa,aAAa,UAAU,SAAS;GAC/C,CAAC;GAED,IAAI,OAAO,UAAU,OAAO,GAC1B,OAAO,CAAC,OAAO,KAAK,QAAQ,OAAO,GAAG,OAAO;GAE/C,MAAM,UAAU,IAAI,IAAI,QAAQ,OAAO;GAEvC,QAAQ,IAAI,YAAY,QAAQ,OAAO;GACvC,MAAM,OAAO,EAAE,QAAQ;GAEvB,OAAO,CAAC,OAAO,QAAQ,QAAQ,OAAO,GAAG,IAAI;EAC/C,CACF,CACF;EAEA,MAAM,UAAU,OAAO,OAAO,WAAW,QAAQ;EAEjD,OAAO,UAAU,IAAI,YAAY,eAAe,KAAK,YAAY,EAAE,OAAO;EAE1E,OAAO,OAAO,aAAa,UAAU,OAAO,aAAa,UAAU,OAAO,CAAC;CAC7E,CAAC,CACL;CAEA,MAAM,MAAuC,OAAO,GAAG,yBAAyB,CAAC,CAC/E,WAAW,WAAW,OAAO,OAAO,OAAO;EACzC,MAAM,eACJ,UAAU,KAAA,IAAY,KAAA,IAAY,OAAO,YAAY,OAAO,eAAe,KAAK;EAElF,MAAM,SACJ,UAAU,KAAA,IAAY,KAAA,IAAY,OAAO,YAAY,OAAO,mBAAmB,KAAK;EAEtF,MAAM,UAAoC,CAAC;EAE3C,KAAK,MAAM,SAAS,OAAO,IAAI,IAAI,KAAK,EAAA,CAAG,QAAQ,OAAO,GAAG;GAC3D,MAAM,SAAS,OAAO,aAAa,OAAO,IAAI;GAC9C,MAAM,WAAW,iBAAiB,MAAM;GAExC,IACE,aAAa,QACb,YAAY,cACX,iBAAiB,KAAA,KAAa,UAAU,QAAQ,YAAY,OAC5D,WAAW,KAAA,KACV,WAAW,OAAO,oBACjB,aAAa,OAAO,oBAAoB,oBAAoB,QAAQ,MAAM,IAAI,IAEjF,QAAQ,KAAK;IAAE,GAAG,cAAc,MAAM;IAAG,kBAAkB;GAAS,CAAC;EAEzE;EACA,QAAQ,MAAM,MAAM,UAAU;GAC5B,MAAM,aAAa,KAAK,mBAAmB,MAAM;GAEjD,OAAO,eAAe,IAAI,aAAa,oBAAoB,MAAM,KAAK;EACxE,CAAC;EAED,OAAO,QAAQ,MAAM,GAAG,KAAK;CAC/B,CACF;CAEA,MAAM,eAAyD,OAAO,GACpE,kCACF,CAAC,CAAC,WAAW,OAAO;EAClB,MAAM,eACJ,UAAU,KAAA,IAAY,KAAA,IAAY,OAAO,YAAY,gBAAgB,eAAe,KAAK;EAE3F,IAAI,WAA0B;EAE9B,KAAK,MAAM,SAAS,OAAO,IAAI,IAAI,KAAK,EAAA,CAAG,QAAQ,OAAO,GAAG;GAC3D,MAAM,SAAS,OAAO,aAAa,gBAAgB,IAAI;GAEvD,IAAI,iBAAiB,KAAA,KAAa,CAAC,UAAU,QAAQ,YAAY,GAAG;GACpE,MAAM,WAAW,iBAAiB,MAAM;GAExC,IAAI,aAAa,SAAS,aAAa,QAAQ,WAAW,WAAW,WAAW;EAClF;EAEA,OAAO;CACT,CAAC;CAED,OAAO,cAAc,GAAG;EAAE;EAAQ;EAAK;EAAM;EAAQ;EAAK;CAAa,CAAC;AAC1E,CAAC;AAED,MAAa,iCACX,MAAM,OAAO,eAAe,iBAAiB;AAE/C,MAAa,0BAAsD,yBAAyB"}

package/dist/MemorySemanticIndex.d.mts

@@ -0,0 +1,21 @@
+import { Layer, Schema } from "effect";
+import { MemoryIndexError, SemanticMemoryIndex, SemanticMemoryProfile } from "effect-agent/semantic-memory-index";
+declare namespace MemorySemanticIndex_d_exports {
+  export { InMemorySemanticIndexCapacity, inMemorySemanticIndexLayer };
+}
+declare const InMemorySemanticIndexCapacity_base: Schema.Class<InMemorySemanticIndexCapacity, Schema.Struct<{
+  readonly maxSources: Schema.Int;
+  readonly maxChunks: Schema.Int;
+  readonly maxSourceBytes: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/**
+ * 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.
+ */
+declare class InMemorySemanticIndexCapacity extends InMemorySemanticIndexCapacity_base {}
+/** Scoped disposable semantic index. No persistent build or recovery state is retained. */
+declare const inMemorySemanticIndexLayer: (profile: SemanticMemoryProfile, capacity: InMemorySemanticIndexCapacity) => Layer.Layer<SemanticMemoryIndex, MemoryIndexError>;
+//#endregion
+export { InMemorySemanticIndexCapacity, inMemorySemanticIndexLayer, MemorySemanticIndex_d_exports as t };
+//# sourceMappingURL=MemorySemanticIndex.d.mts.map