@skein-js/storage-memory 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,46 @@
+# @skein-js/storage-memory
+
+> In-memory SkeinStore + queue driver for development and tests.
+
+Part of **[skein-js](https://github.com/mainawycliffe/skein)** — a TypeScript [Agent Protocol](https://github.com/langchain-ai/agent-protocol) server for [LangGraph.js](https://github.com/langchain-ai/langgraphjs), and a drop-in replacement for the LangGraph CLI.
+
+**Status:** 🚧 Pre-alpha — implemented and passing the shared conformance suite.
+
+## What it does
+
+Zero-dependency, in-process drivers that power `skein dev`:
+
+- **`MemorySkeinStore`** — `SkeinStore` over plain `Map`s (assistants / threads / runs / store items), with the run-concurrency guard, thread→runs cascade delete, and naive prefix/substring store search. Every read and write deep-clones at the boundary — like a real serializing driver — so callers can't mutate stored rows or corrupt the store through a retained input.
+- **`MemoryRunQueue`** — a single-process FIFO of background runs.
+- **`MemoryRunEventBus`** — buffered run-frame pub/sub with replay (`afterSeq`) and live-tail, so a client can join a run's stream late or reconnect.
+
+Validated against the shared `SkeinStore` conformance suite, so it behaves identically to the Postgres driver.
+
+## Usage
+
+```ts
+import { MemorySkeinStore, MemoryRunQueue, MemoryRunEventBus } from "@skein-js/storage-memory";
+
+const store = new MemorySkeinStore();
+const thread = await store.threads.create({ metadata: { user: "a" } });
+```
+
+## Reuse
+
+Pairs with `MemorySaver` from `@langchain/langgraph-checkpoint` for graph checkpoints — it stores only Agent Protocol _resources_, never graph state.
+
+## Install
+
+```bash
+pnpm add @skein-js/storage-memory
+```
+
+## Learn more
+
+- [skein-js overview](../../docs/index.md)
+- [Reuse-first architecture](../../docs/reuse.md)
+- [Roadmap](../../docs/roadmap.md)
+
+## License
+
+[Apache-2.0](../../LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { SkeinStore, AssistantRepo, ThreadRepo, RunRepo, StoreRepo, Assistant, Thread, Run, RunKwargs, Item, RunEventBus, RunFrame, RunQueue, QueuedRun, RunProcessor, RunConsumerOptions, RunConsumer } from '@skein-js/core';
+
+/** In-process SkeinStore for development and tests. */
+declare class MemorySkeinStore implements SkeinStore {
+    #private;
+    readonly assistants: AssistantRepo;
+    readonly threads: ThreadRepo;
+    readonly runs: RunRepo;
+    readonly store: StoreRepo;
+    /**
+     * A JSON-serializable copy of every row, so `skein dev` can persist dev state to disk and
+     * restore it on the next boot. Rows are deep-cloned at the boundary, exactly like the repo reads.
+     */
+    snapshot(): MemoryStoreSnapshot;
+    /** Replace all rows with a {@link snapshot}. Used by `skein dev` to restore persisted dev state. */
+    hydrate(snapshot: MemoryStoreSnapshot): void;
+}
+/** A JSON-serializable copy of a {@link MemorySkeinStore}'s rows. */
+interface MemoryStoreSnapshot {
+    assistants: [string, Assistant][];
+    threads: [string, Thread][];
+    runs: [string, Run][];
+    runKwargs: [string, RunKwargs][];
+    items: [string, Item][];
+}
+
+/**
+ * In-memory FIFO of background runs, drained by a single-process consumer — all `skein dev` needs.
+ * `@skein-js/redis` (BullMQ) provides the durable, cross-instance version; the run worker talks
+ * only to the `RunQueue` interface, so it is unaware which one it has.
+ */
+declare class MemoryRunQueue implements RunQueue {
+    #private;
+    enqueue(run: QueuedRun): Promise<void>;
+    consume(process: RunProcessor, options?: RunConsumerOptions): RunConsumer;
+}
+/**
+ * In-memory fan-out of run frames. Each frame is buffered, so a subscriber that joins late (or
+ * reconnects with an `afterSeq`) replays what it missed and then live-tails until the run
+ * closes. Buffering also means publish never blocks on a slow consumer.
+ *
+ * A closed run's frame buffer is retained for late-join replay, but only for the most recent
+ * `maxRetainedRuns` closed runs (LRU). Beyond that the buffer is dropped and the channel is kept as
+ * a lightweight *closed tombstone* — so a long-lived process can't grow its frame memory without
+ * bound, yet a late join to an evicted run still completes at once (empty) instead of hanging.
+ * Active (unclosed) runs and runs with live subscribers keep their frames. `@skein-js/redis` bounds
+ * this with a real TTL in production.
+ */
+declare class MemoryRunEventBus implements RunEventBus {
+    #private;
+    constructor(options?: {
+        maxRetainedRuns?: number;
+    });
+    publish(runId: string, frame: RunFrame): Promise<void>;
+    close(runId: string): Promise<void>;
+    subscribe(runId: string, afterSeq?: number): AsyncIterable<RunFrame>;
+}
+
+export { MemoryRunEventBus, MemoryRunQueue, MemorySkeinStore, type MemoryStoreSnapshot };

package/dist/index.js

@@ -0,0 +1,340 @@
+// src/memory-skein-store.ts
+import { randomUUID } from "crypto";
+import {
+  isTerminalRunStatus,
+  SkeinHttpError
+} from "@skein-js/core";
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var clone = (value) => structuredClone(value);
+function readOne(map, id) {
+  const found = map.get(id);
+  return found ? clone(found) : null;
+}
+function readAll(map) {
+  return [...map.values()].map((row) => clone(row));
+}
+function write(map, id, row) {
+  const stored = clone(row);
+  map.set(id, stored);
+  return clone(stored);
+}
+function hasPrefix(namespace, prefix) {
+  if (!prefix || prefix.length === 0) return true;
+  if (prefix.length > namespace.length) return false;
+  return prefix.every((segment, i) => namespace[i] === segment);
+}
+function itemKey(namespace, key) {
+  return JSON.stringify([namespace, key]);
+}
+var MemorySkeinStore = class {
+  #assistants = /* @__PURE__ */ new Map();
+  #threads = /* @__PURE__ */ new Map();
+  #runs = /* @__PURE__ */ new Map();
+  // The opaque execution payload lives beside the run row (it is not part of the wire `Run`).
+  #runKwargs = /* @__PURE__ */ new Map();
+  #items = /* @__PURE__ */ new Map();
+  assistants = {
+    list: async () => readAll(this.#assistants),
+    get: async (assistantId) => readOne(this.#assistants, assistantId),
+    create: async (input) => {
+      const at = nowIso();
+      const assistant = {
+        assistant_id: input.assistant_id ?? randomUUID(),
+        graph_id: input.graph_id,
+        config: input.config ?? {},
+        context: input.context ?? {},
+        created_at: at,
+        updated_at: at,
+        metadata: input.metadata ?? {},
+        version: 1,
+        name: input.name ?? input.graph_id,
+        description: input.description
+      };
+      return write(this.#assistants, assistant.assistant_id, assistant);
+    },
+    delete: async (assistantId) => {
+      this.#assistants.delete(assistantId);
+    }
+  };
+  threads = {
+    list: async () => readAll(this.#threads),
+    get: async (threadId) => readOne(this.#threads, threadId),
+    create: async (input) => {
+      const at = nowIso();
+      const thread = {
+        thread_id: input?.thread_id ?? randomUUID(),
+        created_at: at,
+        updated_at: at,
+        state_updated_at: at,
+        metadata: input?.metadata ?? {},
+        status: input?.status ?? "idle",
+        values: {},
+        interrupts: {}
+      };
+      return write(this.#threads, thread.thread_id, thread);
+    },
+    update: async (threadId, patch) => {
+      const existing = this.#threads.get(threadId);
+      if (!existing) throw SkeinHttpError.notFound(`Thread "${threadId}" not found.`);
+      const at = nowIso();
+      const updated = {
+        ...existing,
+        metadata: patch.metadata ?? existing.metadata,
+        status: patch.status ?? existing.status,
+        values: patch.values ?? existing.values,
+        interrupts: patch.interrupts ?? existing.interrupts,
+        updated_at: at,
+        state_updated_at: patch.values !== void 0 ? at : existing.state_updated_at
+      };
+      return write(this.#threads, threadId, updated);
+    },
+    delete: async (threadId) => {
+      this.#threads.delete(threadId);
+      for (const [runId, run] of this.#runs) {
+        if (run.thread_id === threadId) {
+          this.#runs.delete(runId);
+          this.#runKwargs.delete(runId);
+        }
+      }
+    }
+  };
+  runs = {
+    get: async (runId) => readOne(this.#runs, runId),
+    listByThread: async (threadId) => readAll(this.#runs).filter((run) => run.thread_id === threadId),
+    create: async (input) => {
+      const at = nowIso();
+      const run = {
+        run_id: input.run_id ?? randomUUID(),
+        thread_id: input.thread_id,
+        assistant_id: input.assistant_id,
+        created_at: at,
+        updated_at: at,
+        status: input.status ?? "pending",
+        metadata: input.metadata ?? {},
+        multitask_strategy: input.multitask_strategy ?? null
+      };
+      const stored = write(this.#runs, run.run_id, run);
+      if (input.kwargs) this.#runKwargs.set(run.run_id, clone(input.kwargs));
+      return stored;
+    },
+    setStatus: async (runId, status) => {
+      const existing = this.#runs.get(runId);
+      if (!existing) throw SkeinHttpError.notFound(`Run "${runId}" not found.`);
+      return write(this.#runs, runId, { ...existing, status, updated_at: nowIso() });
+    },
+    delete: async (runId) => {
+      this.#runs.delete(runId);
+      this.#runKwargs.delete(runId);
+    },
+    getKwargs: async (runId) => {
+      const found = this.#runKwargs.get(runId);
+      return found ? clone(found) : null;
+    },
+    hasActiveRun: async (threadId) => {
+      for (const run of this.#runs.values()) {
+        if (run.thread_id === threadId && !isTerminalRunStatus(run.status)) return true;
+      }
+      return false;
+    }
+  };
+  store = {
+    get: async (namespace, key) => {
+      const found = this.#items.get(itemKey(namespace, key));
+      return found ? clone(found) : null;
+    },
+    put: async (namespace, key, value) => {
+      const id = itemKey(namespace, key);
+      const at = nowIso();
+      const existing = this.#items.get(id);
+      const item = {
+        namespace: [...namespace],
+        key,
+        value,
+        createdAt: existing?.createdAt ?? at,
+        updatedAt: at
+      };
+      const stored = clone(item);
+      this.#items.set(id, stored);
+      return clone(stored);
+    },
+    delete: async (namespace, key) => {
+      this.#items.delete(itemKey(namespace, key));
+    },
+    search: async (query) => {
+      const needle = query.query?.toLowerCase();
+      const matches = [...this.#items.values()].filter((item) => hasPrefix(item.namespace, query.prefix)).filter(
+        (item) => needle ? JSON.stringify(item.value).toLowerCase().includes(needle) : true
+      ).map((item) => {
+        const result = clone(item);
+        if (needle) result.score = 1;
+        return result;
+      });
+      const offset = query.offset ?? 0;
+      return matches.slice(offset, query.limit === void 0 ? void 0 : offset + query.limit);
+    },
+    listNamespaces: async (prefix) => {
+      const seen = /* @__PURE__ */ new Map();
+      for (const item of this.#items.values()) {
+        if (hasPrefix(item.namespace, prefix)) {
+          seen.set(JSON.stringify(item.namespace), item.namespace);
+        }
+      }
+      return [...seen.values()].map((namespace) => [...namespace]);
+    }
+  };
+  /**
+   * A JSON-serializable copy of every row, so `skein dev` can persist dev state to disk and
+   * restore it on the next boot. Rows are deep-cloned at the boundary, exactly like the repo reads.
+   */
+  snapshot() {
+    const entries = (map) => [...map.entries()].map(([id, row]) => [id, clone(row)]);
+    return {
+      assistants: entries(this.#assistants),
+      threads: entries(this.#threads),
+      runs: entries(this.#runs),
+      runKwargs: entries(this.#runKwargs),
+      items: entries(this.#items)
+    };
+  }
+  /** Replace all rows with a {@link snapshot}. Used by `skein dev` to restore persisted dev state. */
+  hydrate(snapshot) {
+    const fill = (map, rows) => {
+      map.clear();
+      for (const [id, row] of rows) map.set(id, clone(row));
+    };
+    fill(this.#assistants, snapshot.assistants);
+    fill(this.#threads, snapshot.threads);
+    fill(this.#runs, snapshot.runs);
+    fill(this.#runKwargs, snapshot.runKwargs);
+    fill(this.#items, snapshot.items);
+  }
+};
+
+// src/memory-queue.ts
+var MemoryRunQueue = class {
+  #items = [];
+  /** Resolvers of consumers parked waiting for the next run. */
+  #waiters = [];
+  async enqueue(run) {
+    this.#items.push({ ...run });
+    this.#waiters.shift()?.();
+  }
+  consume(process, options = {}) {
+    return new MemoryRunConsumer(this.#items, this.#waiters, process, options.concurrency ?? 1);
+  }
+};
+var MemoryRunConsumer = class {
+  constructor(items, waiters, process, concurrency) {
+    this.items = items;
+    this.waiters = waiters;
+    this.process = process;
+    this.concurrency = concurrency;
+    this.#loop = this.#run();
+  }
+  items;
+  waiters;
+  process;
+  concurrency;
+  #running = true;
+  #inFlight = /* @__PURE__ */ new Set();
+  #loop;
+  async #run() {
+    while (this.#running) {
+      if (this.#inFlight.size >= this.concurrency) {
+        await Promise.race(this.#inFlight);
+        continue;
+      }
+      const next = this.items.shift();
+      if (!next) {
+        if (!this.#running) break;
+        await new Promise((resolve) => this.waiters.push(resolve));
+        continue;
+      }
+      const task = this.process(next).catch(() => void 0).finally(() => this.#inFlight.delete(task));
+      this.#inFlight.add(task);
+    }
+  }
+  async close(force = false) {
+    this.#running = false;
+    for (const wake of this.waiters.splice(0)) wake();
+    if (force) return;
+    await this.#loop;
+    await Promise.all(this.#inFlight);
+  }
+};
+var DEFAULT_MAX_RETAINED_RUNS = 1e3;
+var MemoryRunEventBus = class {
+  #channels = /* @__PURE__ */ new Map();
+  /** Closed runs in close order (oldest first), for LRU eviction of retained buffers. */
+  #closedOrder = [];
+  #maxRetainedRuns;
+  constructor(options = {}) {
+    this.#maxRetainedRuns = options.maxRetainedRuns ?? DEFAULT_MAX_RETAINED_RUNS;
+  }
+  #channel(runId) {
+    let channel = this.#channels.get(runId);
+    if (!channel) {
+      channel = { frames: [], closed: false, waiters: [], subscribers: 0 };
+      this.#channels.set(runId, channel);
+    }
+    return channel;
+  }
+  #wake(channel) {
+    const waiters = channel.waiters.splice(0);
+    for (const resolve of waiters) resolve();
+  }
+  // Free the frame buffers of the oldest retained closed runs beyond the cap, leaving a closed
+  // tombstone so a late join replays nothing and completes at once (rather than hanging on a
+  // recreated open channel). A channel with live subscribers is mid-replay: keep its frames and
+  // re-queue it so it's reconsidered after the reader detaches.
+  #evictClosedBeyondCap() {
+    let scanned = 0;
+    while (this.#closedOrder.length > this.#maxRetainedRuns && scanned < this.#closedOrder.length) {
+      scanned += 1;
+      const runId = this.#closedOrder.shift();
+      if (runId === void 0) break;
+      const channel = this.#channels.get(runId);
+      if (!channel) continue;
+      if (channel.subscribers > 0) {
+        this.#closedOrder.push(runId);
+        continue;
+      }
+      channel.frames = [];
+    }
+  }
+  async publish(runId, frame) {
+    const channel = this.#channel(runId);
+    channel.frames.push(frame);
+    this.#wake(channel);
+  }
+  async close(runId) {
+    const channel = this.#channel(runId);
+    channel.closed = true;
+    this.#wake(channel);
+    this.#closedOrder.push(runId);
+    this.#evictClosedBeyondCap();
+  }
+  async *subscribe(runId, afterSeq = 0) {
+    const channel = this.#channel(runId);
+    channel.subscribers += 1;
+    try {
+      let index = 0;
+      for (; ; ) {
+        while (index < channel.frames.length) {
+          const frame = channel.frames[index];
+          index += 1;
+          if (frame && frame.seq > afterSeq) yield frame;
+        }
+        if (channel.closed) return;
+        await new Promise((resolve) => channel.waiters.push(resolve));
+      }
+    } finally {
+      channel.subscribers -= 1;
+    }
+  }
+};
+export {
+  MemoryRunEventBus,
+  MemoryRunQueue,
+  MemorySkeinStore
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@skein-js/storage-memory",
+  "version": "0.1.0",
+  "description": "In-memory SkeinStore + queue driver for development and tests.",
+  "license": "Apache-2.0",
+  "author": "Maina Wycliffe <wmmaina7@gmail.com>",
+  "homepage": "https://github.com/mainawycliffe/skein/tree/main/packages/storage-memory#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mainawycliffe/skein.git",
+    "directory": "packages/storage-memory"
+  },
+  "bugs": {
+    "url": "https://github.com/mainawycliffe/skein/issues"
+  },
+  "keywords": [
+    "langgraph",
+    "agent-protocol",
+    "storage",
+    "in-memory"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@skein-js/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@skein-js/test-support": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}