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

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -1,45 +1 @@
-{
-  "name": "@effect-agent/storage-memory",
-  "version": "0.1.0-beta.9",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
-    },
-    "./testing": {
-      "types": "./dist/testing.d.mts",
-      "default": "./dist/testing.mjs"
-    }
-  },
-  "dependencies": {
-    "@effect-agent/core": "0.1.0-beta.9",
-    "@effect-agent/session": "0.1.0-beta.9",
-    "effect": "4.0.0-beta.107"
-  },
-  "description": "In-memory Conversation store and submission ledger reference adapters for Effect Agent tests and conformance suites.",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/danieljvdm/effect-agent.git",
-    "directory": "packages/storage-memory"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "vp pack",
-    "check": "tsc --noEmit -p tsconfig.json",
-    "test": "vp test --passWithNoTests"
-  },
-  "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.107",
-    "@effect/vitest": "4.0.0-beta.107",
-    "typescript": "7.0.2",
-    "vite-plus": "0.2.6"
-  }
-}
+{"name":"@effect-agent/storage-memory","version":"0.1.0-beta.91","dependencies":{"effect-agent":"0.1.0-beta.91"},"devDependencies":{"@effect/platform-node":"4.0.0-rc.112","@effect/vitest":"4.0.0-rc.112","effect":"4.0.0-rc.112","typescript":"7.0.2","vite-plus":"0.3.0"},"peerDependencies":{"effect":"^4.0.0-rc.112"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./memory-message-delivery-store":{"types":"./dist/MemoryMessageDeliveryStore.d.mts","default":"./dist/MemoryMessageDeliveryStore.mjs"},"./memory-schedule-store":{"types":"./dist/MemoryScheduleStore.d.mts","default":"./dist/MemoryScheduleStore.mjs"},"./memory-semantic-index":{"types":"./dist/MemorySemanticIndex.d.mts","default":"./dist/MemorySemanticIndex.mjs"},"./memory-submission-ledger":{"types":"./dist/MemorySubmissionLedger.d.mts","default":"./dist/MemorySubmissionLedger.mjs"},"./memory-subscription-store":{"types":"./dist/MemorySubscriptionStore.d.mts","default":"./dist/MemorySubscriptionStore.mjs"},"./memory-thread-store":{"types":"./dist/MemoryThreadStore.d.mts","default":"./dist/MemoryThreadStore.mjs"}},"description":"In-memory Thread store and submission ledger reference adapters for Effect Agent tests and conformance suites.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/storage-memory"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test --passWithNoTests"}}

package/src/MemoryMessageDeliveryStore.ts

@@ -0,0 +1,293 @@
+import { Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { ThreadId } from "effect-agent/identifiers";
+import {
+  applyMessageDeliveryChange,
+  defaultMessageDeliveryStoreLimits,
+  MessageDeliveryChange,
+  MessageDeliveryError,
+  MessageDeliveryFailpoint,
+  MessageDeliveryKey,
+  MessageDeliveryPageRequest,
+  MessageDeliveryRecord,
+  MessageDeliveryStore,
+  MessageDeliveryStoreLimits,
+  messageDeliveryDeadline,
+  messageDeliveryKeyString,
+  messageDeliveryUsesCapacity,
+  isWorkerUpdateDelivery,
+  messageDeliveryCapacity,
+  sameMessageDeliveryIdentity,
+  validateMessageDelivery,
+} from "effect-agent/message-delivery";
+import { ScheduleInstant } from "effect-agent/schedule";
+
+const codec = Schema.fromJsonString(MessageDeliveryRecord);
+
+const decode = (text: string) =>
+  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),
+});
+
+export 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. */
+export const memoryMessageDeliveryStoreLayer = (
+  limits: MessageDeliveryStoreLimits = defaultMessageDeliveryStoreLimits,
+  options: MemoryMessageDeliveryStoreOptions = {},
+): Layer.Layer<MessageDeliveryStore, MessageDeliveryError> =>
+  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 ?? 16 * 1_024 * 1_024,
+        "stored-value-limit",
+      );
+
+      const state = yield* Ref.make<ReadonlyMap<string, string>>(new Map());
+      const lock = yield* Semaphore.make(1);
+      const failpoint = yield* MessageDeliveryFailpoint;
+
+      const encode = Effect.fn("MemoryMessageDeliveryStore.encode")(function* (
+        record: MessageDeliveryRecord,
+      ) {
+        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: MessageDeliveryStore["Service"]["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 !== undefined) {
+                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: MessageDeliveryStore["Service"]["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 === undefined ? null : yield* decode(text);
+      });
+
+      const change: MessageDeliveryStore["Service"]["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 === undefined || 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 === undefined ? {} : { ownerThreadId }) },
+              "due",
+            );
+
+            return (yield* all())
+              .flatMap((record) => {
+                const deadline = messageDeliveryDeadline(record);
+
+                return deadline !== null &&
+                  deadline <= input.nowMillis &&
+                  (input.ownerThreadId === undefined ||
+                    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 !== undefined)
+              yield* validateMessageDelivery(ThreadId, ownerThreadId, "nextDeadline");
+            let next: number | null = null;
+
+            for (const record of yield* all()) {
+              if (ownerThreadId !== undefined && ownerThreadId !== record.key.ownerThreadId)
+                continue;
+              const deadline = messageDeliveryDeadline(record);
+
+              if (deadline !== null && (next === null || deadline < next)) next = deadline;
+            }
+
+            return next;
+          },
+        ),
+      });
+    }),
+  );
+
+export const MemoryMessageDeliveryStoreLive = memoryMessageDeliveryStoreLayer();

package/src/MemoryScheduleStore.ts

@@ -0,0 +1,328 @@
+import { Effect, Layer, Ref, Result, Schema } from "effect";
+import {
+  ScheduleCapacityError,
+  ScheduleDueCursor,
+  defaultSchedulingLimits,
+  ScheduleChange,
+  ScheduleConflict,
+  ScheduleFailpoint,
+  ScheduleKey,
+  ScheduleNotFound,
+  ScheduleOwner,
+  SchedulePageRequest,
+  ScheduleRecord,
+  ScheduleStorageError,
+  ScheduleStore,
+} from "effect-agent/schedule";
+import {
+  scheduleUsesCapacity,
+  applyScheduleChange,
+  compareScheduleKeys,
+  compareScheduleNames,
+  scheduleDeadline,
+  scheduleKeyString,
+  scheduleKeyOf,
+  scheduleOwnerKey,
+} from "effect-agent/schedule-transition";
+
+interface MemoryScheduleState {
+  readonly records: ReadonlyMap<string, string>;
+}
+
+const storageError = (operation: string, reason: "unavailable" | "corrupt") =>
+  ScheduleStorageError.make({ operation, reason });
+
+const encodeRecord = (operation: string, record: ScheduleRecord) =>
+  Effect.try({
+    try: () => Schema.encodeSync(Schema.fromJsonString(ScheduleRecord))(record),
+    catch: () => storageError(operation, "corrupt"),
+  });
+
+const decodeRecord = (operation: string, encoded: string) =>
+  Effect.try({
+    try: () => Schema.decodeSync(Schema.fromJsonString(ScheduleRecord))(encoded),
+    catch: () => storageError(operation, "corrupt"),
+  });
+
+const decodeInput = <A, I>(operation: string, schema: Schema.Codec<A, I>, value: unknown) =>
+  Effect.try({
+    try: () => Schema.decodeUnknownSync(schema)(value),
+    catch: () => storageError(operation, "corrupt"),
+  });
+
+const sameOwner = (record: ScheduleRecord, owner: ScheduleOwner): boolean =>
+  scheduleOwnerKey(record.owner) === scheduleOwnerKey(owner);
+
+const makeScheduleStore = Effect.gen(function* () {
+  const state = yield* Ref.make<MemoryScheduleState>({ records: new Map() });
+  const failpoint = yield* ScheduleFailpoint;
+
+  const insert: ScheduleStore["Service"]["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,
+            ): readonly [
+              Result.Result<
+                ScheduleRecord,
+                ScheduleConflict | ScheduleCapacityError | ScheduleStorageError
+              >,
+              MemoryScheduleState,
+            ] => {
+              const key = scheduleKeyString(record);
+              const existingText = current.records.get(key);
+
+              if (existingText !== undefined) {
+                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: ScheduleStore["Service"]["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 === undefined ? null : yield* decodeRecord("get", text);
+    },
+  );
+
+  const list: ScheduleStore["Service"]["list"] = Effect.fn("MemoryScheduleStore.list")(
+    function* (request) {
+      const decodedRequest = yield* decodeInput("list", SchedulePageRequest, request);
+      const records: Array<ScheduleRecord> = [];
+
+      for (const text of (yield* Ref.get(state)).records.values()) {
+        const record = yield* decodeRecord("list", text);
+
+        if (
+          sameOwner(record, decodedRequest.owner) &&
+          (decodedRequest.after === undefined ||
+            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: ScheduleStore["Service"]["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,
+            ): readonly [
+              Result.Result<
+                ScheduleRecord,
+                ScheduleConflict | ScheduleStorageError | ScheduleNotFound | ScheduleCapacityError
+              >,
+              MemoryScheduleState,
+            ] => {
+              const storageKey = scheduleKeyString(decodedKey);
+              const text = current.records.get(storageKey);
+
+              if (text === undefined) {
+                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: ScheduleStore["Service"]["due"] = Effect.fn("MemoryScheduleStore.due")(
+    function* (nowMillis, limit, owner, after) {
+      const decodedOwner =
+        owner === undefined ? undefined : yield* decodeInput("due", ScheduleOwner, owner);
+
+      const cursor =
+        after === undefined ? undefined : yield* decodeInput("due", ScheduleDueCursor, after);
+
+      const records: Array<ScheduleDueCursor> = [];
+
+      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 === undefined || sameOwner(record, decodedOwner)) &&
+          (cursor === undefined ||
+            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: ScheduleStore["Service"]["nextDeadline"] = Effect.fn(
+    "MemoryScheduleStore.nextDeadline",
+  )(function* (owner) {
+    const decodedOwner =
+      owner === undefined ? undefined : yield* decodeInput("nextDeadline", ScheduleOwner, owner);
+
+    let earliest: number | null = null;
+
+    for (const text of (yield* Ref.get(state)).records.values()) {
+      const record = yield* decodeRecord("nextDeadline", text);
+
+      if (decodedOwner !== undefined && !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 });
+});
+
+export const memoryScheduleStoreLayer = (): Layer.Layer<ScheduleStore> =>
+  Layer.effect(ScheduleStore, makeScheduleStore);
+
+export const MemoryScheduleStoreLive: Layer.Layer<ScheduleStore> = memoryScheduleStoreLayer();