@noy-db/to-memory 0.1.0-pre.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vLannaAi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @noy-db/to-memory
+
+> In-memory adapter for [noy-db](https://github.com/vLannaAi/noy-db) — ideal for testing and ephemeral workloads.
+
+[![npm](https://img.shields.io/npm/v/@noy-db/to-memory.svg)](https://www.npmjs.com/package/@noy-db/to-memory)
+
+## Install
+
+```bash
+pnpm add @noy-db/hub @noy-db/to-memory
+```
+
+## Usage
+
+```ts
+import { createNoydb } from '@noy-db/hub'
+import { memory } from '@noy-db/to-memory'
+
+const db = await createNoydb({
+  adapter: memory(),
+  userId: 'alice',
+  passphrase: 'correct horse battery staple',
+})
+```
+
+Data lives only in the current process — it's gone when the process exits. Perfect for:
+
+- Unit and integration tests
+- Short-lived scripts
+- Benchmarks
+- Prototyping before wiring up persistent storage
+
+## License
+
+MIT © vLannaAi — see the [noy-db repo](https://github.com/vLannaAi/noy-db) for full documentation.

package/dist/index.cjs

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  memory: () => memory
+});
+module.exports = __toCommonJS(index_exports);
+var import_hub = require("@noy-db/hub");
+function memory() {
+  const store = /* @__PURE__ */ new Map();
+  function getCollection(vault, collection) {
+    let comp = store.get(vault);
+    if (!comp) {
+      comp = /* @__PURE__ */ new Map();
+      store.set(vault, comp);
+    }
+    let coll = comp.get(collection);
+    if (!coll) {
+      coll = /* @__PURE__ */ new Map();
+      comp.set(collection, coll);
+    }
+    return coll;
+  }
+  return {
+    name: "memory",
+    async get(vault, collection, id) {
+      return store.get(vault)?.get(collection)?.get(id) ?? null;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const coll = getCollection(vault, collection);
+      const existing = coll.get(id);
+      if (expectedVersion !== void 0 && existing) {
+        if (existing._v !== expectedVersion) {
+          throw new import_hub.ConflictError(existing._v, `Version conflict: expected ${expectedVersion}, found ${existing._v}`);
+        }
+      }
+      coll.set(id, envelope);
+    },
+    async delete(vault, collection, id) {
+      store.get(vault)?.get(collection)?.delete(id);
+    },
+    async list(vault, collection) {
+      const coll = store.get(vault)?.get(collection);
+      return coll ? [...coll.keys()] : [];
+    },
+    async loadAll(vault) {
+      const comp = store.get(vault);
+      const snapshot = {};
+      if (comp) {
+        for (const [collName, coll] of comp) {
+          if (collName.startsWith("_")) continue;
+          const records = {};
+          for (const [id, envelope] of coll) {
+            records[id] = envelope;
+          }
+          snapshot[collName] = records;
+        }
+      }
+      return snapshot;
+    },
+    async saveAll(vault, data) {
+      const comp = store.get(vault);
+      if (comp) {
+        for (const key of [...comp.keys()]) {
+          if (!key.startsWith("_")) {
+            comp.delete(key);
+          }
+        }
+      }
+      for (const [collName, records] of Object.entries(data)) {
+        const coll = getCollection(vault, collName);
+        for (const [id, envelope] of Object.entries(records)) {
+          coll.set(id, envelope);
+        }
+      }
+    },
+    async ping() {
+      return true;
+    },
+    /**
+     * Enumerate every top-level vault held by this in-memory
+     * store. Used by `Noydb.listAccessibleVaults()`
+     * to get the universe of compartments before filtering down to
+     * the ones the calling principal can unwrap.
+     *
+     * Returns the outer Map's keys directly — O(compartments) and
+     * cheap. The result is intentionally unsorted; consumers that
+     * want a stable order should sort themselves.
+     */
+    async listVaults() {
+      return [...store.keys()];
+    },
+    /**
+     * Multi-record atomic transaction.
+     *
+     * Validates every op's `expectedVersion` against the current Map
+     * state, throws `ConflictError` on the first mismatch (nothing
+     * written), then applies every put/delete in one synchronous burst
+     * — the Map mutations are single-threaded in the JS event loop so
+     * no concurrent writer can interleave. Truly atomic.
+     */
+    async tx(ops) {
+      for (const op of ops) {
+        if (op.expectedVersion === void 0) continue;
+        const existing = store.get(op.vault)?.get(op.collection)?.get(op.id);
+        const actual = existing?._v ?? 0;
+        if (actual !== op.expectedVersion) {
+          throw new import_hub.ConflictError(
+            actual,
+            `tx: ${op.vault}/${op.collection}/${op.id} expected v${op.expectedVersion}, found v${actual}`
+          );
+        }
+      }
+      for (const op of ops) {
+        if (op.type === "put") {
+          if (!op.envelope) {
+            throw new Error(`tx: put op for ${op.id} is missing envelope`);
+          }
+          getCollection(op.vault, op.collection).set(op.id, op.envelope);
+        } else {
+          store.get(op.vault)?.get(op.collection)?.delete(op.id);
+        }
+      }
+    },
+    /**
+     * Paginate over a collection. Cursor is a numeric offset (as a string)
+     * into the sorted id list — same ordering on every call so pages are
+     * stable across runs.
+     *
+     * The default `limit` is 100. Final page returns `nextCursor: null`.
+     */
+    async listPage(vault, collection, cursor, limit = 100) {
+      const coll = store.get(vault)?.get(collection);
+      if (!coll) return { items: [], nextCursor: null };
+      const ids = [...coll.keys()].sort();
+      const start = cursor ? parseInt(cursor, 10) : 0;
+      const end = Math.min(start + limit, ids.length);
+      const items = [];
+      for (let i = start; i < end; i++) {
+        const id = ids[i];
+        const envelope = coll.get(id);
+        if (envelope) items.push({ id, envelope });
+      }
+      return {
+        items,
+        nextCursor: end < ids.length ? String(end) : null
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  memory
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * **@noy-db/to-memory** — in-memory store for NOYDB (testing and development).\n *\n * Backed by nested `Map` objects: `vault → collection → id → envelope`.\n * Data is lost when the process exits — this store is intentionally\n * non-persistent.\n *\n * ## When to use\n *\n * - **Unit tests** — fast, zero I/O, works in any environment.\n * - **In-memory caching layer** — pair with `routeStore` to keep a hot\n *   copy of frequently-read collections in memory while persisting to\n *   a durable backend.\n * - **REPL / prototyping** — explore the NOYDB API without setting up\n *   a backend.\n *\n * ## Capabilities\n *\n * | Capability | Value |\n * |---|---|\n * | `casAtomic` | `true` — Map operations are synchronous and inherently atomic |\n * | `txAtomic` | `true` — multi-record `tx()` applies every op in a single synchronous burst |\n * | `listVaults` | ✓ — iterates outer Map keys |\n * | `listPage` | ✓ — cursor-based pagination over sorted id list |\n * | `ping` | ✓ — always returns `true` |\n *\n * @packageDocumentation\n */\n\nimport type { NoydbStore, EncryptedEnvelope, VaultSnapshot, TxOp } from '@noy-db/hub'\nimport { ConflictError } from '@noy-db/hub'\n\n/**\n * Create an in-memory adapter backed by nested Maps.\n * No persistence — data is lost when the process exits.\n * Intended for testing and development.\n */\nexport function memory(): NoydbStore {\n  // vault -> collection -> id -> envelope\n  const store = new Map<string, Map<string, Map<string, EncryptedEnvelope>>>()\n\n  function getCollection(vault: string, collection: string): Map<string, EncryptedEnvelope> {\n    let comp = store.get(vault)\n    if (!comp) {\n      comp = new Map()\n      store.set(vault, comp)\n    }\n    let coll = comp.get(collection)\n    if (!coll) {\n      coll = new Map()\n      comp.set(collection, coll)\n    }\n    return coll\n  }\n\n  return {\n    name: 'memory',\n\n    async get(vault, collection, id) {\n      return store.get(vault)?.get(collection)?.get(id) ?? null\n    },\n\n    async put(vault, collection, id, envelope, expectedVersion) {\n      const coll = getCollection(vault, collection)\n      const existing = coll.get(id)\n\n      if (expectedVersion !== undefined && existing) {\n        if (existing._v !== expectedVersion) {\n          throw new ConflictError(existing._v, `Version conflict: expected ${expectedVersion}, found ${existing._v}`)\n        }\n      }\n\n      coll.set(id, envelope)\n    },\n\n    async delete(vault, collection, id) {\n      store.get(vault)?.get(collection)?.delete(id)\n    },\n\n    async list(vault, collection) {\n      const coll = store.get(vault)?.get(collection)\n      return coll ? [...coll.keys()] : []\n    },\n\n    async loadAll(vault) {\n      const comp = store.get(vault)\n      const snapshot: VaultSnapshot = {}\n      if (comp) {\n        for (const [collName, coll] of comp) {\n          if (collName.startsWith('_')) continue\n          const records: Record<string, EncryptedEnvelope> = {}\n          for (const [id, envelope] of coll) {\n            records[id] = envelope\n          }\n          snapshot[collName] = records\n        }\n      }\n      return snapshot\n    },\n\n    async saveAll(vault, data) {\n      const comp = store.get(vault)\n      if (comp) {\n        for (const key of [...comp.keys()]) {\n          if (!key.startsWith('_')) {\n            comp.delete(key)\n          }\n        }\n      }\n\n      for (const [collName, records] of Object.entries(data)) {\n        const coll = getCollection(vault, collName)\n        for (const [id, envelope] of Object.entries(records)) {\n          coll.set(id, envelope)\n        }\n      }\n    },\n\n    async ping() {\n      return true\n    },\n\n    /**\n     * Enumerate every top-level vault held by this in-memory\n     * store. Used by `Noydb.listAccessibleVaults()`\n     * to get the universe of compartments before filtering down to\n     * the ones the calling principal can unwrap.\n     *\n     * Returns the outer Map's keys directly — O(compartments) and\n     * cheap. The result is intentionally unsorted; consumers that\n     * want a stable order should sort themselves.\n     */\n    async listVaults() {\n      return [...store.keys()]\n    },\n\n    /**\n     * Multi-record atomic transaction.\n     *\n     * Validates every op's `expectedVersion` against the current Map\n     * state, throws `ConflictError` on the first mismatch (nothing\n     * written), then applies every put/delete in one synchronous burst\n     * — the Map mutations are single-threaded in the JS event loop so\n     * no concurrent writer can interleave. Truly atomic.\n     */\n    async tx(ops: readonly TxOp[]) {\n      // Phase 1 — validate every expectedVersion against current state.\n      // We read the state ONCE up front; subsequent ops that target the\n      // same (vault, coll, id) see the same snapshot, matching the\n      // atomicity guarantee callers expect from a storage-layer tx.\n      for (const op of ops) {\n        if (op.expectedVersion === undefined) continue\n        const existing = store.get(op.vault)?.get(op.collection)?.get(op.id)\n        const actual = existing?._v ?? 0\n        if (actual !== op.expectedVersion) {\n          throw new ConflictError(\n            actual,\n            `tx: ${op.vault}/${op.collection}/${op.id} expected v${op.expectedVersion}, found v${actual}`,\n          )\n        }\n      }\n      // Phase 2 — apply every op synchronously. No await between ops =\n      // no interleave window.\n      for (const op of ops) {\n        if (op.type === 'put') {\n          if (!op.envelope) {\n            throw new Error(`tx: put op for ${op.id} is missing envelope`)\n          }\n          getCollection(op.vault, op.collection).set(op.id, op.envelope)\n        } else {\n          store.get(op.vault)?.get(op.collection)?.delete(op.id)\n        }\n      }\n    },\n\n    /**\n     * Paginate over a collection. Cursor is a numeric offset (as a string)\n     * into the sorted id list — same ordering on every call so pages are\n     * stable across runs.\n     *\n     * The default `limit` is 100. Final page returns `nextCursor: null`.\n     */\n    async listPage(vault, collection, cursor, limit = 100) {\n      const coll = store.get(vault)?.get(collection)\n      if (!coll) return { items: [], nextCursor: null }\n\n      // Sorted ids for stable pagination — Map preserves insertion order\n      // but tests rely on lexicographic order across different inserts.\n      const ids = [...coll.keys()].sort()\n      const start = cursor ? parseInt(cursor, 10) : 0\n      const end = Math.min(start + limit, ids.length)\n\n      const items: Array<{ id: string; envelope: EncryptedEnvelope }> = []\n      for (let i = start; i < end; i++) {\n        const id = ids[i]!\n        const envelope = coll.get(id)\n        if (envelope) items.push({ id, envelope })\n      }\n\n      return {\n        items,\n        nextCursor: end < ids.length ? String(end) : null,\n      }\n    },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,39 @@
+import { NoydbStore } from '@noy-db/hub';
+
+/**
+ * **@noy-db/to-memory** — in-memory store for NOYDB (testing and development).
+ *
+ * Backed by nested `Map` objects: `vault → collection → id → envelope`.
+ * Data is lost when the process exits — this store is intentionally
+ * non-persistent.
+ *
+ * ## When to use
+ *
+ * - **Unit tests** — fast, zero I/O, works in any environment.
+ * - **In-memory caching layer** — pair with `routeStore` to keep a hot
+ *   copy of frequently-read collections in memory while persisting to
+ *   a durable backend.
+ * - **REPL / prototyping** — explore the NOYDB API without setting up
+ *   a backend.
+ *
+ * ## Capabilities
+ *
+ * | Capability | Value |
+ * |---|---|
+ * | `casAtomic` | `true` — Map operations are synchronous and inherently atomic |
+ * | `txAtomic` | `true` — multi-record `tx()` applies every op in a single synchronous burst |
+ * | `listVaults` | ✓ — iterates outer Map keys |
+ * | `listPage` | ✓ — cursor-based pagination over sorted id list |
+ * | `ping` | ✓ — always returns `true` |
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create an in-memory adapter backed by nested Maps.
+ * No persistence — data is lost when the process exits.
+ * Intended for testing and development.
+ */
+declare function memory(): NoydbStore;
+
+export { memory };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { NoydbStore } from '@noy-db/hub';
+
+/**
+ * **@noy-db/to-memory** — in-memory store for NOYDB (testing and development).
+ *
+ * Backed by nested `Map` objects: `vault → collection → id → envelope`.
+ * Data is lost when the process exits — this store is intentionally
+ * non-persistent.
+ *
+ * ## When to use
+ *
+ * - **Unit tests** — fast, zero I/O, works in any environment.
+ * - **In-memory caching layer** — pair with `routeStore` to keep a hot
+ *   copy of frequently-read collections in memory while persisting to
+ *   a durable backend.
+ * - **REPL / prototyping** — explore the NOYDB API without setting up
+ *   a backend.
+ *
+ * ## Capabilities
+ *
+ * | Capability | Value |
+ * |---|---|
+ * | `casAtomic` | `true` — Map operations are synchronous and inherently atomic |
+ * | `txAtomic` | `true` — multi-record `tx()` applies every op in a single synchronous burst |
+ * | `listVaults` | ✓ — iterates outer Map keys |
+ * | `listPage` | ✓ — cursor-based pagination over sorted id list |
+ * | `ping` | ✓ — always returns `true` |
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create an in-memory adapter backed by nested Maps.
+ * No persistence — data is lost when the process exits.
+ * Intended for testing and development.
+ */
+declare function memory(): NoydbStore;
+
+export { memory };

package/dist/index.js

@@ -0,0 +1,148 @@
+// src/index.ts
+import { ConflictError } from "@noy-db/hub";
+function memory() {
+  const store = /* @__PURE__ */ new Map();
+  function getCollection(vault, collection) {
+    let comp = store.get(vault);
+    if (!comp) {
+      comp = /* @__PURE__ */ new Map();
+      store.set(vault, comp);
+    }
+    let coll = comp.get(collection);
+    if (!coll) {
+      coll = /* @__PURE__ */ new Map();
+      comp.set(collection, coll);
+    }
+    return coll;
+  }
+  return {
+    name: "memory",
+    async get(vault, collection, id) {
+      return store.get(vault)?.get(collection)?.get(id) ?? null;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const coll = getCollection(vault, collection);
+      const existing = coll.get(id);
+      if (expectedVersion !== void 0 && existing) {
+        if (existing._v !== expectedVersion) {
+          throw new ConflictError(existing._v, `Version conflict: expected ${expectedVersion}, found ${existing._v}`);
+        }
+      }
+      coll.set(id, envelope);
+    },
+    async delete(vault, collection, id) {
+      store.get(vault)?.get(collection)?.delete(id);
+    },
+    async list(vault, collection) {
+      const coll = store.get(vault)?.get(collection);
+      return coll ? [...coll.keys()] : [];
+    },
+    async loadAll(vault) {
+      const comp = store.get(vault);
+      const snapshot = {};
+      if (comp) {
+        for (const [collName, coll] of comp) {
+          if (collName.startsWith("_")) continue;
+          const records = {};
+          for (const [id, envelope] of coll) {
+            records[id] = envelope;
+          }
+          snapshot[collName] = records;
+        }
+      }
+      return snapshot;
+    },
+    async saveAll(vault, data) {
+      const comp = store.get(vault);
+      if (comp) {
+        for (const key of [...comp.keys()]) {
+          if (!key.startsWith("_")) {
+            comp.delete(key);
+          }
+        }
+      }
+      for (const [collName, records] of Object.entries(data)) {
+        const coll = getCollection(vault, collName);
+        for (const [id, envelope] of Object.entries(records)) {
+          coll.set(id, envelope);
+        }
+      }
+    },
+    async ping() {
+      return true;
+    },
+    /**
+     * Enumerate every top-level vault held by this in-memory
+     * store. Used by `Noydb.listAccessibleVaults()`
+     * to get the universe of compartments before filtering down to
+     * the ones the calling principal can unwrap.
+     *
+     * Returns the outer Map's keys directly — O(compartments) and
+     * cheap. The result is intentionally unsorted; consumers that
+     * want a stable order should sort themselves.
+     */
+    async listVaults() {
+      return [...store.keys()];
+    },
+    /**
+     * Multi-record atomic transaction.
+     *
+     * Validates every op's `expectedVersion` against the current Map
+     * state, throws `ConflictError` on the first mismatch (nothing
+     * written), then applies every put/delete in one synchronous burst
+     * — the Map mutations are single-threaded in the JS event loop so
+     * no concurrent writer can interleave. Truly atomic.
+     */
+    async tx(ops) {
+      for (const op of ops) {
+        if (op.expectedVersion === void 0) continue;
+        const existing = store.get(op.vault)?.get(op.collection)?.get(op.id);
+        const actual = existing?._v ?? 0;
+        if (actual !== op.expectedVersion) {
+          throw new ConflictError(
+            actual,
+            `tx: ${op.vault}/${op.collection}/${op.id} expected v${op.expectedVersion}, found v${actual}`
+          );
+        }
+      }
+      for (const op of ops) {
+        if (op.type === "put") {
+          if (!op.envelope) {
+            throw new Error(`tx: put op for ${op.id} is missing envelope`);
+          }
+          getCollection(op.vault, op.collection).set(op.id, op.envelope);
+        } else {
+          store.get(op.vault)?.get(op.collection)?.delete(op.id);
+        }
+      }
+    },
+    /**
+     * Paginate over a collection. Cursor is a numeric offset (as a string)
+     * into the sorted id list — same ordering on every call so pages are
+     * stable across runs.
+     *
+     * The default `limit` is 100. Final page returns `nextCursor: null`.
+     */
+    async listPage(vault, collection, cursor, limit = 100) {
+      const coll = store.get(vault)?.get(collection);
+      if (!coll) return { items: [], nextCursor: null };
+      const ids = [...coll.keys()].sort();
+      const start = cursor ? parseInt(cursor, 10) : 0;
+      const end = Math.min(start + limit, ids.length);
+      const items = [];
+      for (let i = start; i < end; i++) {
+        const id = ids[i];
+        const envelope = coll.get(id);
+        if (envelope) items.push({ id, envelope });
+      }
+      return {
+        items,
+        nextCursor: end < ids.length ? String(end) : null
+      };
+    }
+  };
+}
+export {
+  memory
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * **@noy-db/to-memory** — in-memory store for NOYDB (testing and development).\n *\n * Backed by nested `Map` objects: `vault → collection → id → envelope`.\n * Data is lost when the process exits — this store is intentionally\n * non-persistent.\n *\n * ## When to use\n *\n * - **Unit tests** — fast, zero I/O, works in any environment.\n * - **In-memory caching layer** — pair with `routeStore` to keep a hot\n *   copy of frequently-read collections in memory while persisting to\n *   a durable backend.\n * - **REPL / prototyping** — explore the NOYDB API without setting up\n *   a backend.\n *\n * ## Capabilities\n *\n * | Capability | Value |\n * |---|---|\n * | `casAtomic` | `true` — Map operations are synchronous and inherently atomic |\n * | `txAtomic` | `true` — multi-record `tx()` applies every op in a single synchronous burst |\n * | `listVaults` | ✓ — iterates outer Map keys |\n * | `listPage` | ✓ — cursor-based pagination over sorted id list |\n * | `ping` | ✓ — always returns `true` |\n *\n * @packageDocumentation\n */\n\nimport type { NoydbStore, EncryptedEnvelope, VaultSnapshot, TxOp } from '@noy-db/hub'\nimport { ConflictError } from '@noy-db/hub'\n\n/**\n * Create an in-memory adapter backed by nested Maps.\n * No persistence — data is lost when the process exits.\n * Intended for testing and development.\n */\nexport function memory(): NoydbStore {\n  // vault -> collection -> id -> envelope\n  const store = new Map<string, Map<string, Map<string, EncryptedEnvelope>>>()\n\n  function getCollection(vault: string, collection: string): Map<string, EncryptedEnvelope> {\n    let comp = store.get(vault)\n    if (!comp) {\n      comp = new Map()\n      store.set(vault, comp)\n    }\n    let coll = comp.get(collection)\n    if (!coll) {\n      coll = new Map()\n      comp.set(collection, coll)\n    }\n    return coll\n  }\n\n  return {\n    name: 'memory',\n\n    async get(vault, collection, id) {\n      return store.get(vault)?.get(collection)?.get(id) ?? null\n    },\n\n    async put(vault, collection, id, envelope, expectedVersion) {\n      const coll = getCollection(vault, collection)\n      const existing = coll.get(id)\n\n      if (expectedVersion !== undefined && existing) {\n        if (existing._v !== expectedVersion) {\n          throw new ConflictError(existing._v, `Version conflict: expected ${expectedVersion}, found ${existing._v}`)\n        }\n      }\n\n      coll.set(id, envelope)\n    },\n\n    async delete(vault, collection, id) {\n      store.get(vault)?.get(collection)?.delete(id)\n    },\n\n    async list(vault, collection) {\n      const coll = store.get(vault)?.get(collection)\n      return coll ? [...coll.keys()] : []\n    },\n\n    async loadAll(vault) {\n      const comp = store.get(vault)\n      const snapshot: VaultSnapshot = {}\n      if (comp) {\n        for (const [collName, coll] of comp) {\n          if (collName.startsWith('_')) continue\n          const records: Record<string, EncryptedEnvelope> = {}\n          for (const [id, envelope] of coll) {\n            records[id] = envelope\n          }\n          snapshot[collName] = records\n        }\n      }\n      return snapshot\n    },\n\n    async saveAll(vault, data) {\n      const comp = store.get(vault)\n      if (comp) {\n        for (const key of [...comp.keys()]) {\n          if (!key.startsWith('_')) {\n            comp.delete(key)\n          }\n        }\n      }\n\n      for (const [collName, records] of Object.entries(data)) {\n        const coll = getCollection(vault, collName)\n        for (const [id, envelope] of Object.entries(records)) {\n          coll.set(id, envelope)\n        }\n      }\n    },\n\n    async ping() {\n      return true\n    },\n\n    /**\n     * Enumerate every top-level vault held by this in-memory\n     * store. Used by `Noydb.listAccessibleVaults()`\n     * to get the universe of compartments before filtering down to\n     * the ones the calling principal can unwrap.\n     *\n     * Returns the outer Map's keys directly — O(compartments) and\n     * cheap. The result is intentionally unsorted; consumers that\n     * want a stable order should sort themselves.\n     */\n    async listVaults() {\n      return [...store.keys()]\n    },\n\n    /**\n     * Multi-record atomic transaction.\n     *\n     * Validates every op's `expectedVersion` against the current Map\n     * state, throws `ConflictError` on the first mismatch (nothing\n     * written), then applies every put/delete in one synchronous burst\n     * — the Map mutations are single-threaded in the JS event loop so\n     * no concurrent writer can interleave. Truly atomic.\n     */\n    async tx(ops: readonly TxOp[]) {\n      // Phase 1 — validate every expectedVersion against current state.\n      // We read the state ONCE up front; subsequent ops that target the\n      // same (vault, coll, id) see the same snapshot, matching the\n      // atomicity guarantee callers expect from a storage-layer tx.\n      for (const op of ops) {\n        if (op.expectedVersion === undefined) continue\n        const existing = store.get(op.vault)?.get(op.collection)?.get(op.id)\n        const actual = existing?._v ?? 0\n        if (actual !== op.expectedVersion) {\n          throw new ConflictError(\n            actual,\n            `tx: ${op.vault}/${op.collection}/${op.id} expected v${op.expectedVersion}, found v${actual}`,\n          )\n        }\n      }\n      // Phase 2 — apply every op synchronously. No await between ops =\n      // no interleave window.\n      for (const op of ops) {\n        if (op.type === 'put') {\n          if (!op.envelope) {\n            throw new Error(`tx: put op for ${op.id} is missing envelope`)\n          }\n          getCollection(op.vault, op.collection).set(op.id, op.envelope)\n        } else {\n          store.get(op.vault)?.get(op.collection)?.delete(op.id)\n        }\n      }\n    },\n\n    /**\n     * Paginate over a collection. Cursor is a numeric offset (as a string)\n     * into the sorted id list — same ordering on every call so pages are\n     * stable across runs.\n     *\n     * The default `limit` is 100. Final page returns `nextCursor: null`.\n     */\n    async listPage(vault, collection, cursor, limit = 100) {\n      const coll = store.get(vault)?.get(collection)\n      if (!coll) return { items: [], nextCursor: null }\n\n      // Sorted ids for stable pagination — Map preserves insertion order\n      // but tests rely on lexicographic order across different inserts.\n      const ids = [...coll.keys()].sort()\n      const start = cursor ? parseInt(cursor, 10) : 0\n      const end = Math.min(start + limit, ids.length)\n\n      const items: Array<{ id: string; envelope: EncryptedEnvelope }> = []\n      for (let i = start; i < end; i++) {\n        const id = ids[i]!\n        const envelope = coll.get(id)\n        if (envelope) items.push({ id, envelope })\n      }\n\n      return {\n        items,\n        nextCursor: end < ids.length ? String(end) : null,\n      }\n    },\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@noy-db/to-memory",
+  "version": "0.1.0-pre.3",
+  "description": "In-memory adapter for noy-db — ideal for testing, development, and ephemeral workloads",
+  "license": "MIT",
+  "author": "vLannaAi <vicio@lanna.ai>",
+  "homepage": "https://github.com/vLannaAi/noy-db/tree/main/packages/to-memory#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vLannaAi/noy-db.git",
+    "directory": "packages/to-memory"
+  },
+  "bugs": {
+    "url": "https://github.com/vLannaAi/noy-db/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "@noy-db/hub": "0.1.0-pre.3"
+  },
+  "devDependencies": {
+    "@noy-db/hub": "0.1.0-pre.3",
+    "@noy-db/test-adapter-conformance": "0.0.0"
+  },
+  "keywords": [
+    "noy-db",
+    "adapter",
+    "in-memory",
+    "memory",
+    "storage",
+    "testing",
+    "encryption",
+    "zero-knowledge"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}