@yielded/agent-storage-memory 0.1.0-beta.166

package/src/MemoryMessageDeliveryStore.ts

@@ -0,0 +1,373 @@
+import { ThreadId } from "@yielded/agent/identifiers";
+import {
+  applyMessageDeliveryChange,
+  defaultMessageDeliveryStoreLimits,
+  MessageDeliveryChange,
+  MessageDeliveryError,
+  MessageDeliveryFailpoint,
+  MessageDeliveryKey,
+  MessageDeliveryPageRequest,
+  MessageDeliveryRecord,
+  MessageDeliveryStore,
+  MessageDeliveryStoreLimits,
+  messageDeliveryDeadline,
+  messageDeliveryKeyString,
+  messageDeliveryUsesCapacity,
+  isWorkerUpdateDelivery,
+  messageDeliveryCapacity,
+  sameMessageDeliveryIdentity,
+  validateMessageDelivery,
+} from "@yielded/agent/message-delivery";
+import { ScheduleInstant } from "@yielded/agent/schedule";
+import { Effect, Layer, Ref, Schema, Semaphore } from "effect";
+
+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({
+        records: new Map<string, string>(),
+        pending: new Map<ThreadId, ReadonlySet<MessageDeliveryKey["messageId"]>>(),
+        workers: new Map<string, ReadonlySet<MessageDeliveryKey["messageId"]>>(),
+      });
+
+      const commit = (record: MessageDeliveryRecord, encoded: string) =>
+        Ref.update(state, (current) => {
+          const key = messageDeliveryKeyString(record.key);
+          const keys = new Set(current.pending.get(record.key.ownerThreadId));
+
+          if (messageDeliveryUsesCapacity(record)) keys.add(record.key.messageId);
+          else keys.delete(record.key.messageId);
+          const pending = new Map(current.pending);
+
+          if (keys.size === 0) pending.delete(record.key.ownerThreadId);
+          else pending.set(record.key.ownerThreadId, keys);
+
+          const workers = new Map(current.workers);
+          const admission = record.envelope.workerAdmission;
+
+          if (admission !== undefined) {
+            const worker = admission.origin.worker;
+
+            const startKey = JSON.stringify([
+              record.key.ownerThreadId,
+              worker.delegationId,
+              worker.targetAgentId,
+            ]);
+
+            if (record.key.messageId === admission.origin.firstMessageId)
+              workers.set(
+                startKey,
+                new Set([...(workers.get(startKey) ?? []), record.key.messageId]),
+              );
+            const pendingKey = JSON.stringify([record.key.ownerThreadId, worker.threadId]);
+            const inputs = new Set(workers.get(pendingKey));
+
+            if (
+              (record.status === "pending" || record.status === "parked") &&
+              record.receipt === null
+            )
+              inputs.add(record.key.messageId);
+            else inputs.delete(record.key.messageId);
+            workers.set(pendingKey, inputs);
+          }
+
+          return { records: new Map(current.records).set(key, encoded), pending, workers };
+        });
+
+      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)).records.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* commit(input, 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)).records.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* commit(next, 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 current = yield* Ref.get(state);
+
+          const workerKey =
+            input.workerStarts !== undefined
+              ? JSON.stringify([
+                  input.ownerThreadId,
+                  input.workerStarts.delegationId,
+                  input.workerStarts.targetAgentId,
+                ])
+              : input.pendingWorker !== undefined
+                ? JSON.stringify([input.ownerThreadId, input.pendingWorker])
+                : undefined;
+
+          const retained =
+            workerKey !== undefined || input.pendingOnly
+              ? yield* Effect.forEach(
+                  [
+                    ...((workerKey === undefined
+                      ? current.pending.get(input.ownerThreadId)
+                      : current.workers.get(workerKey)) ?? []),
+                  ]
+                    .filter((messageId) => input.after === undefined || messageId > input.after)
+                    .sort()
+                    .slice(0, input.limit + 1),
+                  (messageId) =>
+                    decode(
+                      current.records.get(
+                        messageDeliveryKeyString({ ownerThreadId: input.ownerThreadId, messageId }),
+                      ) ?? "",
+                    ),
+                )
+              : yield* all();
+
+          const records = retained
+            .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 {
+  ScheduleCapacityError,
+  ScheduleDueCursor,
+  defaultSchedulingLimits,
+  ScheduleChange,
+  ScheduleConflict,
+  ScheduleFailpoint,
+  ScheduleKey,
+  ScheduleNotFound,
+  ScheduleOwner,
+  SchedulePageRequest,
+  ScheduleRecord,
+  ScheduleStorageError,
+  ScheduleStore,
+} from "@yielded/agent/schedule";
+import {
+  scheduleUsesCapacity,
+  applyScheduleChange,
+  compareScheduleKeys,
+  compareScheduleNames,
+  scheduleDeadline,
+  scheduleKeyString,
+  scheduleKeyOf,
+  scheduleOwnerKey,
+} from "@yielded/agent/schedule-transition";
+import { Effect, Layer, Ref, Result, Schema } from "effect";
+
+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();