@nebutra/collab 0.2.0

package/dist/chunk-6XHNO2RP.js

@@ -0,0 +1,24 @@
+// src/store/memory.ts
+import { InMemoryTenantStore } from "@nebutra/tenant-store";
+var InMemorySnapshotStore = class {
+  inner = new InMemoryTenantStore();
+  async load(tenantId, roomId) {
+    const row = await this.inner.read(tenantId, roomId);
+    return row ? row.state : null;
+  }
+  async save(tenantId, roomId, state) {
+    await this.inner.write(tenantId, roomId, {
+      tenantId,
+      state: Uint8Array.from(state)
+    });
+  }
+  /** Test helper. */
+  clear() {
+    this.inner.clear();
+  }
+};
+
+export {
+  InMemorySnapshotStore
+};
+//# sourceMappingURL=chunk-6XHNO2RP.js.map

package/dist/chunk-6XHNO2RP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/store/memory.ts"],"sourcesContent":["/**\n * Zero-config default `SnapshotStore`. The storage MECHANICS (composite-key\n * map, never returning rows across tenants) are NOT re-implemented here —\n * they are composed from `@nebutra/tenant-store`'s `InMemoryTenantStore`,\n * which already enforces tenant isolation structurally via its\n * `tenantId:id` key plus a defense-in-depth tenantId equality check.\n *\n * A production deployment swaps this for a Prisma/Redis adapter that\n * implements the same `SnapshotStore` interface; the README documents that\n * shape. The isolation property a Prisma adapter would get from RLS is here\n * provided by the borrowed composite key.\n */\n\nimport { InMemoryTenantStore, type TenantOwned } from \"@nebutra/tenant-store\";\nimport type { SnapshotStore } from \"../types\";\n\ninterface SnapshotRow extends TenantOwned {\n  readonly tenantId: string;\n  readonly state: Uint8Array;\n}\n\nexport class InMemorySnapshotStore implements SnapshotStore {\n  private readonly inner = new InMemoryTenantStore<SnapshotRow>();\n\n  async load(tenantId: string, roomId: string): Promise<Uint8Array | null> {\n    const row = await this.inner.read(tenantId, roomId);\n    return row ? row.state : null;\n  }\n\n  async save(tenantId: string, roomId: string, state: Uint8Array): Promise<void> {\n    // Copy so a later in-place mutation of the caller's buffer can't\n    // retroactively corrupt persisted state.\n    await this.inner.write(tenantId, roomId, {\n      tenantId,\n      state: Uint8Array.from(state),\n    });\n  }\n\n  /** Test helper. */\n  clear(): void {\n    this.inner.clear();\n  }\n}\n"],"mappings":";AAaA,SAAS,2BAA6C;AAQ/C,IAAM,wBAAN,MAAqD;AAAA,EACzC,QAAQ,IAAI,oBAAiC;AAAA,EAE9D,MAAM,KAAK,UAAkB,QAA4C;AACvE,UAAM,MAAM,MAAM,KAAK,MAAM,KAAK,UAAU,MAAM;AAClD,WAAO,MAAM,IAAI,QAAQ;AAAA,EAC3B;AAAA,EAEA,MAAM,KAAK,UAAkB,QAAgB,OAAkC;AAG7E,UAAM,KAAK,MAAM,MAAM,UAAU,QAAQ;AAAA,MACvC;AAAA,MACA,OAAO,WAAW,KAAK,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,MAAM,MAAM;AAAA,EACnB;AACF;","names":[]}

package/dist/chunk-S2HTNEZN.js

@@ -0,0 +1,32 @@
+// src/transport/loopback.ts
+function channel(tenantId, roomId) {
+  return `${tenantId}\0${roomId}`;
+}
+var LoopbackTransport = class {
+  channels = /* @__PURE__ */ new Map();
+  broadcast(tenantId, roomId, update) {
+    const set = this.channels.get(channel(tenantId, roomId));
+    if (!set) return;
+    for (const cb of [...set]) cb(update);
+  }
+  subscribe(tenantId, roomId, cb) {
+    const key = channel(tenantId, roomId);
+    let set = this.channels.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.channels.set(key, set);
+    }
+    set.add(cb);
+    return () => {
+      const s = this.channels.get(key);
+      if (!s) return;
+      s.delete(cb);
+      if (s.size === 0) this.channels.delete(key);
+    };
+  }
+};
+
+export {
+  LoopbackTransport
+};
+//# sourceMappingURL=chunk-S2HTNEZN.js.map

package/dist/chunk-S2HTNEZN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transport/loopback.ts"],"sourcesContent":["/**\n * Zero-config default `CollabTransport`. An in-process loopback bus keyed by\n * `tenantId\u0000roomId`, so a subscriber for tenant A's room can never be\n * reached by a broadcast for tenant B's room of the same id (the tenant is\n * part of the channel key, not trusted from payload).\n *\n * A real network transport (Pusher channels, a WebSocket relay) implements\n * the same `CollabTransport` interface and is injected via\n * `createCollab({ transport })`. This file intentionally ships NO network\n * code — only the loopback so zero-config single-process usage works.\n */\n\nimport type { CollabTransport } from \"../types\";\n\ntype Listener = (update: Uint8Array) => void;\n\nfunction channel(tenantId: string, roomId: string): string {\n  // NUL separator: cannot occur in normal ids, so \"a\",\"bc\" and \"ab\",\"c\"\n  // can never collide into the same channel.\n  return `${tenantId}\u0000${roomId}`;\n}\n\nexport class LoopbackTransport implements CollabTransport {\n  private readonly channels = new Map<string, Set<Listener>>();\n\n  broadcast(tenantId: string, roomId: string, update: Uint8Array): void {\n    const set = this.channels.get(channel(tenantId, roomId));\n    if (!set) return;\n    // Snapshot listeners so unsubscribing during dispatch is safe.\n    for (const cb of [...set]) cb(update);\n  }\n\n  subscribe(tenantId: string, roomId: string, cb: Listener): () => void {\n    const key = channel(tenantId, roomId);\n    let set = this.channels.get(key);\n    if (!set) {\n      set = new Set();\n      this.channels.set(key, set);\n    }\n    set.add(cb);\n    return () => {\n      const s = this.channels.get(key);\n      if (!s) return;\n      s.delete(cb);\n      if (s.size === 0) this.channels.delete(key);\n    };\n  }\n}\n"],"mappings":";AAgBA,SAAS,QAAQ,UAAkB,QAAwB;AAGzD,SAAO,GAAG,QAAQ,KAAI,MAAM;AAC9B;AAEO,IAAM,oBAAN,MAAmD;AAAA,EACvC,WAAW,oBAAI,IAA2B;AAAA,EAE3D,UAAU,UAAkB,QAAgB,QAA0B;AACpE,UAAM,MAAM,KAAK,SAAS,IAAI,QAAQ,UAAU,MAAM,CAAC;AACvD,QAAI,CAAC,IAAK;AAEV,eAAW,MAAM,CAAC,GAAG,GAAG,EAAG,IAAG,MAAM;AAAA,EACtC;AAAA,EAEA,UAAU,UAAkB,QAAgB,IAA0B;AACpE,UAAM,MAAM,QAAQ,UAAU,MAAM;AACpC,QAAI,MAAM,KAAK,SAAS,IAAI,GAAG;AAC/B,QAAI,CAAC,KAAK;AACR,YAAM,oBAAI,IAAI;AACd,WAAK,SAAS,IAAI,KAAK,GAAG;AAAA,IAC5B;AACA,QAAI,IAAI,EAAE;AACV,WAAO,MAAM;AACX,YAAM,IAAI,KAAK,SAAS,IAAI,GAAG;AAC/B,UAAI,CAAC,EAAG;AACR,QAAE,OAAO,EAAE;AACX,UAAI,EAAE,SAAS,EAAG,MAAK,SAAS,OAAO,GAAG;AAAA,IAC5C;AAAA,EACF;AACF;","names":[]}

package/dist/index.js

@@ -0,0 +1,220 @@
+import {
+  InMemorySnapshotStore
+} from "./chunk-6XHNO2RP.js";
+import {
+  LoopbackTransport
+} from "./chunk-S2HTNEZN.js";
+
+// src/errors.ts
+import { CapabilityError } from "@nebutra/capability-kit";
+var CollabError = class extends CapabilityError {
+  constructor(message, init) {
+    super(message, init, {
+      name: "CollabError",
+      emptySuggestionFallback: "No suggestion was provided. This is a bug in @nebutra/collab \u2014 report it with the failing operation."
+    });
+  }
+};
+
+// src/room.ts
+import { withTenantLock } from "@nebutra/tenant-store";
+import * as Y from "yjs";
+var REMOTE_ORIGIN = /* @__PURE__ */ Symbol("collab.remote");
+var Room = class {
+  constructor(tenantId, roomId, store, transport) {
+    this.tenantId = tenantId;
+    this.roomId = roomId;
+    this.store = store;
+    this.transport = transport;
+    this.doc = new Y.Doc();
+    this.doc.on("update", (update, origin) => {
+      for (const cb of [...this.listeners]) cb(update, origin);
+      if (origin !== REMOTE_ORIGIN) {
+        void Promise.resolve(this.transport.broadcast(this.tenantId, this.roomId, update)).catch(
+          () => {
+          }
+        );
+      }
+    });
+    this.unsubTransport = this.transport.subscribe(this.tenantId, this.roomId, (update) => {
+      if (this.destroyed) return;
+      Y.applyUpdate(this.doc, update, REMOTE_ORIGIN);
+    });
+  }
+  doc;
+  listeners = /* @__PURE__ */ new Set();
+  unsubTransport;
+  destroyed = false;
+  applyUpdate(update, origin) {
+    this.assertLive();
+    Y.applyUpdate(this.doc, update, origin);
+  }
+  encodeState() {
+    this.assertLive();
+    return Y.encodeStateAsUpdate(this.doc);
+  }
+  onUpdate(cb) {
+    this.assertLive();
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  }
+  async snapshot() {
+    this.assertLive();
+    const state = this.encodeState();
+    try {
+      await withTenantLock(
+        this.tenantId,
+        this.roomId,
+        () => this.store.save(this.tenantId, this.roomId, state)
+      );
+    } catch (cause) {
+      throw new CollabError(`Failed to persist snapshot for room "${this.roomId}".`, {
+        code: "COLLAB_SNAPSHOT_FAILED",
+        suggestion: "Verify the configured SnapshotStore is reachable (DB/Redis up, credentials valid). The in-memory default never fails; a custom adapter likely threw.",
+        cause
+      });
+    }
+  }
+  /** Hydrate this doc from persisted state, if any. Internal to the hub. */
+  async _restore() {
+    try {
+      const persisted = await this.store.load(this.tenantId, this.roomId);
+      if (persisted) Y.applyUpdate(this.doc, persisted, REMOTE_ORIGIN);
+    } catch (cause) {
+      throw new CollabError(`Failed to restore room "${this.roomId}" from snapshot store.`, {
+        code: "COLLAB_RESTORE_FAILED",
+        suggestion: "Check the SnapshotStore adapter's load() \u2014 it should resolve null (not throw) when no snapshot exists for the tenant+room.",
+        cause
+      });
+    }
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.unsubTransport();
+    this.listeners.clear();
+    this.doc.destroy();
+  }
+  assertLive() {
+    if (this.destroyed) {
+      throw new CollabError(`Room "${this.roomId}" was destroyed and can no longer be used.`, {
+        code: "COLLAB_DESTROYED",
+        suggestion: "Acquire a fresh room via hub.room(tenantId, roomId) instead of reusing a destroyed instance."
+      });
+    }
+  }
+};
+
+// src/hub.ts
+var KEY_SEP = "\0";
+function roomKey(tenantId, roomId) {
+  return `${tenantId}${KEY_SEP}${roomId}`;
+}
+function assertId(value, kind) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new CollabError(`A non-empty ${kind}Id is required.`, {
+      code: kind === "tenant" ? "COLLAB_INVALID_TENANT" : "COLLAB_INVALID_ROOM",
+      suggestion: kind === "tenant" ? "Pass the current tenant id, e.g. from getCurrentTenant().tenantId \u2014 never call room() without an explicit tenant." : "Pass a stable, non-empty roomId (document/canvas id)."
+    });
+  }
+}
+var Hub = class {
+  rooms = /* @__PURE__ */ new Map();
+  store;
+  transport;
+  constructor(config = {}) {
+    this.store = config.store ?? new InMemorySnapshotStore();
+    this.transport = config.transport ?? new LoopbackTransport();
+  }
+  room(tenantId, roomId) {
+    assertId(tenantId, "tenant");
+    assertId(roomId, "room");
+    const key = roomKey(tenantId, roomId);
+    let room = this.rooms.get(key);
+    if (!room) {
+      room = new Room(tenantId, roomId, this.store, this.transport);
+      this.rooms.set(key, room);
+    }
+    return room;
+  }
+  async roomRestored(tenantId, roomId) {
+    const key = roomKey(tenantId, roomId);
+    const existed = this.rooms.has(key);
+    const room = this.room(tenantId, roomId);
+    if (!existed) await room._restore();
+    return room;
+  }
+  async doctor() {
+    const start = Date.now();
+    let yjs = { ok: false, detail: "" };
+    try {
+      const Y2 = await import("yjs");
+      const probe = new Y2.Doc();
+      probe.getMap("p").set("k", 1);
+      const restored = new Y2.Doc();
+      Y2.applyUpdate(restored, Y2.encodeStateAsUpdate(probe));
+      const ok = restored.getMap("p").get("k") === 1;
+      probe.destroy();
+      restored.destroy();
+      yjs = {
+        ok,
+        detail: ok ? "Yjs encode/apply round-trip succeeded." : "Yjs round-trip produced unexpected state."
+      };
+    } catch (e) {
+      yjs = { ok: false, detail: `Yjs unavailable: ${String(e)}` };
+    }
+    let store = { ok: false, detail: "" };
+    try {
+      const probe = new Uint8Array([7, 7, 7]);
+      await this.store.save("__collab_doctor__", "__probe__", probe);
+      const back = await this.store.load("__collab_doctor__", "__probe__");
+      const ok = !!back && back.length === probe.length && back[0] === 7;
+      store = {
+        ok,
+        detail: ok ? "SnapshotStore save/load round-trip succeeded." : "SnapshotStore returned unexpected bytes."
+      };
+    } catch (e) {
+      store = { ok: false, detail: `SnapshotStore error: ${String(e)}` };
+    }
+    let transport = { ok: false, detail: "" };
+    try {
+      let received = false;
+      const off = this.transport.subscribe("__collab_doctor__", "__probe__", () => {
+        received = true;
+      });
+      await this.transport.broadcast("__collab_doctor__", "__probe__", new Uint8Array([1]));
+      off();
+      transport = {
+        ok: received,
+        detail: received ? "Transport broadcast/subscribe round-trip succeeded." : "Transport did not deliver the probe (network adapter may be async)."
+      };
+    } catch (e) {
+      transport = { ok: false, detail: `Transport error: ${String(e)}` };
+    }
+    return {
+      ok: yjs.ok && store.ok && transport.ok,
+      durationMs: Date.now() - start,
+      checks: { yjs, store, transport }
+    };
+  }
+  destroy() {
+    for (const room of this.rooms.values()) room.destroy();
+    this.rooms.clear();
+  }
+};
+function createCollab(config) {
+  return new Hub(config);
+}
+async function getCollab(config) {
+  return createCollab(config);
+}
+export {
+  CollabError,
+  InMemorySnapshotStore,
+  LoopbackTransport,
+  createCollab,
+  getCollab
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/room.ts","../src/hub.ts"],"sourcesContent":["/**\n * Every failure surfaced by this package is a `CollabError`. The contract is\n * deliberately strict: a machine-stable `code` and a human-actionable\n * `suggestion` are MANDATORY, so no code path can throw a bare `Error` that\n * leaves a caller without a remediation hint.\n *\n * Mechanics (code/suggestion/toJSON/empty-suggestion fallback) are inherited\n * from the shared `@nebutra/capability-kit` `CapabilityError`; this subclass\n * only pins collab's error name + its package-specific fallback wording, so\n * the observable contract is unchanged.\n */\n\nimport { CapabilityError } from \"@nebutra/capability-kit\";\n\nexport type CollabErrorCode =\n  | \"COLLAB_INVALID_TENANT\"\n  | \"COLLAB_INVALID_ROOM\"\n  | \"COLLAB_SNAPSHOT_FAILED\"\n  | \"COLLAB_RESTORE_FAILED\"\n  | \"COLLAB_DESTROYED\"\n  | \"COLLAB_TEST\"\n  | (string & {});\n\nexport interface CollabErrorInit {\n  readonly code: CollabErrorCode;\n  /** A non-empty, actionable remediation hint. */\n  readonly suggestion: string;\n  readonly cause?: unknown;\n}\n\nexport class CollabError extends CapabilityError {\n  declare readonly code: CollabErrorCode;\n\n  constructor(message: string, init: CollabErrorInit) {\n    super(message, init, {\n      name: \"CollabError\",\n      emptySuggestionFallback:\n        \"No suggestion was provided. This is a bug in @nebutra/collab — \" +\n        \"report it with the failing operation.\",\n    });\n  }\n}\n","/**\n * A single tenant-scoped CRDT room. One `Y.Doc` per (tenant, room). The hub\n * owns the partitioning; this class assumes its `tenantId`/`roomId` are\n * already the partition it belongs to and never reaches outside them.\n *\n * Snapshot persistence is serialized through `withTenantLock(tenantId,\n * roomId, ...)` borrowed from `@nebutra/tenant-store` rather than a\n * hand-rolled mutex — same primitive used by canvas/reel, so a future swap\n * to a distributed lock changes one place.\n */\n\nimport { withTenantLock } from \"@nebutra/tenant-store\";\nimport * as Y from \"yjs\";\nimport { CollabError } from \"./errors\";\nimport type { CollabRoom, CollabTransport, SnapshotStore, UpdateListener } from \"./types\";\n\n/** Origin tag used when applying remote updates so we don't echo them back. */\nconst REMOTE_ORIGIN = Symbol(\"collab.remote\");\n\nexport class Room implements CollabRoom {\n  readonly doc: Y.Doc;\n  private readonly listeners = new Set<UpdateListener>();\n  private readonly unsubTransport: () => void;\n  private destroyed = false;\n\n  constructor(\n    readonly tenantId: string,\n    readonly roomId: string,\n    private readonly store: SnapshotStore,\n    private readonly transport: CollabTransport,\n  ) {\n    this.doc = new Y.Doc();\n\n    // Fan local updates out to: registered listeners + the transport. The\n    // transport echo is guarded by origin so a remote-applied update is not\n    // re-broadcast into a loop.\n    this.doc.on(\"update\", (update: Uint8Array, origin: unknown) => {\n      for (const cb of [...this.listeners]) cb(update, origin);\n      if (origin !== REMOTE_ORIGIN) {\n        void Promise.resolve(this.transport.broadcast(this.tenantId, this.roomId, update)).catch(\n          () => {\n            // Transport delivery is best-effort; CRDT state stays correct and\n            // converges on the next exchanged update. Swallowing here avoids\n            // an unhandled rejection from a flaky network adapter.\n          },\n        );\n      }\n    });\n\n    // Remote updates for THIS tenant-scoped channel only.\n    this.unsubTransport = this.transport.subscribe(this.tenantId, this.roomId, (update) => {\n      if (this.destroyed) return;\n      Y.applyUpdate(this.doc, update, REMOTE_ORIGIN);\n    });\n  }\n\n  applyUpdate(update: Uint8Array, origin?: unknown): void {\n    this.assertLive();\n    Y.applyUpdate(this.doc, update, origin);\n  }\n\n  encodeState(): Uint8Array {\n    this.assertLive();\n    return Y.encodeStateAsUpdate(this.doc);\n  }\n\n  onUpdate(cb: UpdateListener): () => void {\n    this.assertLive();\n    this.listeners.add(cb);\n    return () => {\n      this.listeners.delete(cb);\n    };\n  }\n\n  async snapshot(): Promise<void> {\n    this.assertLive();\n    const state = this.encodeState();\n    try {\n      // Serialize concurrent snapshots of the SAME room; different rooms (or\n      // the same room under another tenant) persist in parallel.\n      await withTenantLock(this.tenantId, this.roomId, () =>\n        this.store.save(this.tenantId, this.roomId, state),\n      );\n    } catch (cause) {\n      throw new CollabError(`Failed to persist snapshot for room \"${this.roomId}\".`, {\n        code: \"COLLAB_SNAPSHOT_FAILED\",\n        suggestion:\n          \"Verify the configured SnapshotStore is reachable (DB/Redis up, \" +\n          \"credentials valid). The in-memory default never fails; a custom \" +\n          \"adapter likely threw.\",\n        cause,\n      });\n    }\n  }\n\n  /** Hydrate this doc from persisted state, if any. Internal to the hub. */\n  async _restore(): Promise<void> {\n    try {\n      const persisted = await this.store.load(this.tenantId, this.roomId);\n      if (persisted) Y.applyUpdate(this.doc, persisted, REMOTE_ORIGIN);\n    } catch (cause) {\n      throw new CollabError(`Failed to restore room \"${this.roomId}\" from snapshot store.`, {\n        code: \"COLLAB_RESTORE_FAILED\",\n        suggestion:\n          \"Check the SnapshotStore adapter's load() — it should resolve \" +\n          \"null (not throw) when no snapshot exists for the tenant+room.\",\n        cause,\n      });\n    }\n  }\n\n  destroy(): void {\n    if (this.destroyed) return;\n    this.destroyed = true;\n    this.unsubTransport();\n    this.listeners.clear();\n    this.doc.destroy();\n  }\n\n  private assertLive(): void {\n    if (this.destroyed) {\n      throw new CollabError(`Room \"${this.roomId}\" was destroyed and can no longer be used.`, {\n        code: \"COLLAB_DESTROYED\",\n        suggestion:\n          \"Acquire a fresh room via hub.room(tenantId, roomId) instead of \" +\n          \"reusing a destroyed instance.\",\n      });\n    }\n  }\n}\n","/**\n * `CollabHub` — the tenant-partition boundary.\n *\n * TENANT ISOLATION IS STRUCTURAL: rooms are stored in a `Map` keyed by a\n * composite `tenantId\u0000roomId` string with a NUL separator that cannot\n * appear in a normal id. There is no API that takes only a roomId, so a key\n * minted for tenant A is unreachable from tenant B — a room handle is only\n * ever produced by passing an explicit `tenantId`, and the snapshot store +\n * transport are likewise addressed by (tenantId, roomId). The same property\n * a Prisma adapter gets from RLS is enforced here by the composite key, with\n * no trust placed in caller-supplied payload.\n */\n\nimport { CollabError } from \"./errors\";\nimport { Room } from \"./room\";\nimport { InMemorySnapshotStore } from \"./store/memory\";\nimport { LoopbackTransport } from \"./transport/loopback\";\nimport type {\n  CollabConfig,\n  CollabHub,\n  CollabRoom,\n  CollabTransport,\n  DoctorReport,\n  SnapshotStore,\n} from \"./types\";\n\n// NUL separator: it cannot appear in a normal tenant/room id, so the pairs\n// (\"a\",\"bc\") and (\"ab\",\"c\") can never collide into the same room key — the\n// tenant partition is exact, not merely conventional.\nconst KEY_SEP = \"\u0000\";\n\nfunction roomKey(tenantId: string, roomId: string): string {\n  return `${tenantId}${KEY_SEP}${roomId}`;\n}\n\nfunction assertId(value: string, kind: \"tenant\" | \"room\"): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new CollabError(`A non-empty ${kind}Id is required.`, {\n      code: kind === \"tenant\" ? \"COLLAB_INVALID_TENANT\" : \"COLLAB_INVALID_ROOM\",\n      suggestion:\n        kind === \"tenant\"\n          ? \"Pass the current tenant id, e.g. from getCurrentTenant().tenantId — \" +\n            \"never call room() without an explicit tenant.\"\n          : \"Pass a stable, non-empty roomId (document/canvas id).\",\n    });\n  }\n}\n\nclass Hub implements CollabHub {\n  private readonly rooms = new Map<string, Room>();\n  private readonly store: SnapshotStore;\n  private readonly transport: CollabTransport;\n\n  constructor(config: CollabConfig = {}) {\n    this.store = config.store ?? new InMemorySnapshotStore();\n    this.transport = config.transport ?? new LoopbackTransport();\n  }\n\n  room(tenantId: string, roomId: string): CollabRoom {\n    assertId(tenantId, \"tenant\");\n    assertId(roomId, \"room\");\n    const key = roomKey(tenantId, roomId);\n    let room = this.rooms.get(key);\n    if (!room) {\n      room = new Room(tenantId, roomId, this.store, this.transport);\n      this.rooms.set(key, room);\n    }\n    return room;\n  }\n\n  async roomRestored(tenantId: string, roomId: string): Promise<CollabRoom> {\n    const key = roomKey(tenantId, roomId);\n    const existed = this.rooms.has(key);\n    const room = this.room(tenantId, roomId) as Room;\n    // Only hydrate a freshly created room; an already-live room is the\n    // authoritative in-memory state.\n    if (!existed) await room._restore();\n    return room;\n  }\n\n  async doctor(): Promise<DoctorReport> {\n    const start = Date.now();\n\n    // 1. Yjs presence + a real round-trip (not just \"is it imported\").\n    let yjs = { ok: false, detail: \"\" };\n    try {\n      const Y = await import(\"yjs\");\n      const probe = new Y.Doc();\n      probe.getMap(\"p\").set(\"k\", 1);\n      const restored = new Y.Doc();\n      Y.applyUpdate(restored, Y.encodeStateAsUpdate(probe));\n      const ok = restored.getMap(\"p\").get(\"k\") === 1;\n      probe.destroy();\n      restored.destroy();\n      yjs = {\n        ok,\n        detail: ok\n          ? \"Yjs encode/apply round-trip succeeded.\"\n          : \"Yjs round-trip produced unexpected state.\",\n      };\n    } catch (e) {\n      yjs = { ok: false, detail: `Yjs unavailable: ${String(e)}` };\n    }\n\n    // 2. Store health — write+read under a reserved diagnostic tenant.\n    let store = { ok: false, detail: \"\" };\n    try {\n      const probe = new Uint8Array([7, 7, 7]);\n      await this.store.save(\"__collab_doctor__\", \"__probe__\", probe);\n      const back = await this.store.load(\"__collab_doctor__\", \"__probe__\");\n      const ok = !!back && back.length === probe.length && back[0] === 7;\n      store = {\n        ok,\n        detail: ok\n          ? \"SnapshotStore save/load round-trip succeeded.\"\n          : \"SnapshotStore returned unexpected bytes.\",\n      };\n    } catch (e) {\n      store = { ok: false, detail: `SnapshotStore error: ${String(e)}` };\n    }\n\n    // 3. Transport health — subscribe, broadcast, observe, unsubscribe.\n    let transport = { ok: false, detail: \"\" };\n    try {\n      let received = false;\n      const off = this.transport.subscribe(\"__collab_doctor__\", \"__probe__\", () => {\n        received = true;\n      });\n      await this.transport.broadcast(\"__collab_doctor__\", \"__probe__\", new Uint8Array([1]));\n      off();\n      transport = {\n        ok: received,\n        detail: received\n          ? \"Transport broadcast/subscribe round-trip succeeded.\"\n          : \"Transport did not deliver the probe (network adapter may be async).\",\n      };\n    } catch (e) {\n      transport = { ok: false, detail: `Transport error: ${String(e)}` };\n    }\n\n    return {\n      ok: yjs.ok && store.ok && transport.ok,\n      durationMs: Date.now() - start,\n      checks: { yjs, store, transport },\n    };\n  }\n\n  destroy(): void {\n    for (const room of this.rooms.values()) room.destroy();\n    this.rooms.clear();\n  }\n}\n\n/** Synchronous factory. */\nexport function createCollab(config?: CollabConfig): CollabHub {\n  return new Hub(config);\n}\n\n/**\n * Async factory mirroring other Sailor integration packages. There is no\n * env/credential negotiation for the zero-config defaults, so this resolves\n * immediately — the async shape is reserved for future credentialed\n * store/transport providers without a breaking signature change.\n */\nexport async function getCollab(config?: CollabConfig): Promise<CollabHub> {\n  return createCollab(config);\n}\n"],"mappings":"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","names":["Y"]}

package/dist/store/memory.d.ts

@@ -0,0 +1,26 @@
+import { S as SnapshotStore } from '../types-68zA3h9k.js';
+import '@nebutra/capability-kit';
+import 'yjs';
+
+/**
+ * Zero-config default `SnapshotStore`. The storage MECHANICS (composite-key
+ * map, never returning rows across tenants) are NOT re-implemented here —
+ * they are composed from `@nebutra/tenant-store`'s `InMemoryTenantStore`,
+ * which already enforces tenant isolation structurally via its
+ * `tenantId:id` key plus a defense-in-depth tenantId equality check.
+ *
+ * A production deployment swaps this for a Prisma/Redis adapter that
+ * implements the same `SnapshotStore` interface; the README documents that
+ * shape. The isolation property a Prisma adapter would get from RLS is here
+ * provided by the borrowed composite key.
+ */
+
+declare class InMemorySnapshotStore implements SnapshotStore {
+    private readonly inner;
+    load(tenantId: string, roomId: string): Promise<Uint8Array | null>;
+    save(tenantId: string, roomId: string, state: Uint8Array): Promise<void>;
+    /** Test helper. */
+    clear(): void;
+}
+
+export { InMemorySnapshotStore };

package/dist/store/memory.js

@@ -0,0 +1,7 @@
+import {
+  InMemorySnapshotStore
+} from "../chunk-6XHNO2RP.js";
+export {
+  InMemorySnapshotStore
+};
+//# sourceMappingURL=memory.js.map

package/dist/store/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transport/loopback.js

@@ -0,0 +1,7 @@
+import {
+  LoopbackTransport
+} from "../chunk-S2HTNEZN.js";
+export {
+  LoopbackTransport
+};
+//# sourceMappingURL=loopback.js.map

package/dist/transport/loopback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/types-68zA3h9k.d.ts

@@ -0,0 +1,57 @@
+import { DoctorReportBase, DoctorCheck } from '@nebutra/capability-kit';
+import * as Y from 'yjs';
+
+/**
+ * Pluggable persistence for encoded room state. State is an opaque Yjs
+ * update (`Uint8Array`); this layer never interprets it. The tenant+room
+ * pair is the partition key — adapters MUST scope reads/writes by it and
+ * MUST NOT return one tenant's bytes for another's key.
+ */
+interface SnapshotStore {
+    load(tenantId: string, roomId: string): Promise<Uint8Array | null>;
+    save(tenantId: string, roomId: string, state: Uint8Array): Promise<void>;
+}
+/**
+ * Transport-agnostic fan-out seam. The default is an in-memory loopback;
+ * a Pusher / WebSocket adapter implements the same two methods and plugs in
+ * via `createCollab({ transport })`. Updates are opaque Yjs update bytes.
+ */
+interface CollabTransport {
+    broadcast(tenantId: string, roomId: string, update: Uint8Array): void | Promise<void>;
+    /** Subscribe to remote updates for one tenant-scoped room; returns unsub. */
+    subscribe(tenantId: string, roomId: string, cb: (update: Uint8Array) => void): () => void;
+}
+type UpdateListener = (update: Uint8Array, origin: unknown) => void;
+interface CollabConfig {
+    store?: SnapshotStore;
+    transport?: CollabTransport;
+}
+interface CollabRoom {
+    readonly tenantId: string;
+    readonly roomId: string;
+    readonly doc: Y.Doc;
+    applyUpdate(update: Uint8Array, origin?: unknown): void;
+    encodeState(): Uint8Array;
+    onUpdate(cb: UpdateListener): () => void;
+    snapshot(): Promise<void>;
+    destroy(): void;
+}
+
+interface DoctorReport extends DoctorReportBase {
+    readonly checks: {
+        readonly yjs: DoctorCheck;
+        readonly store: DoctorCheck;
+        readonly transport: DoctorCheck;
+    };
+}
+interface CollabHub {
+    /** Returns/creates a tenant-scoped CRDT room. Hard-partitioned by tenant. */
+    room(tenantId: string, roomId: string): CollabRoom;
+    /** Like `room`, but first hydrates from the snapshot store if present. */
+    roomRestored(tenantId: string, roomId: string): Promise<CollabRoom>;
+    doctor(): Promise<DoctorReport>;
+    /** Destroy every live room and release resources. */
+    destroy(): void;
+}
+
+export type { CollabConfig as C, DoctorReport as D, SnapshotStore as S, UpdateListener as U, CollabHub as a, CollabRoom as b, CollabTransport as c };

package/examples/snapshot-restore.ts

@@ -0,0 +1,39 @@
+/**
+ * Example 3 — snapshot + restore across hub lifetimes.
+ *
+ * Persist a room via the injected SnapshotStore, then hydrate a brand-new
+ * hub from the same store. Demonstrates the persist-then-reload contract
+ * used by long-lived documents/canvases.
+ *
+ * Run: pnpm --filter @nebutra/collab exec tsx examples/snapshot-restore.ts
+ */
+
+import { createCollab } from "../src/index";
+import { InMemorySnapshotStore } from "../src/store/memory";
+
+export async function main(): Promise<void> {
+  // A shared store stands in for Prisma/Redis in production.
+  const store = new InMemorySnapshotStore();
+
+  const hub1 = createCollab({ store });
+  const r1 = hub1.room("t1", "doc-1");
+  r1.doc.getText("body").insert(0, "persisted across restarts");
+  await r1.snapshot();
+  hub1.destroy();
+
+  // New process / new hub, same store.
+  const hub2 = createCollab({ store });
+  const r2 = await hub2.roomRestored("t1", "doc-1");
+  const restored = r2.doc.getText("body").toString();
+  if (restored !== "persisted across restarts") {
+    throw new Error(`restore failed, got: "${restored}"`);
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(`[collab] restored after reload: "${restored}"`);
+  hub2.destroy();
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  void main();
+}

package/examples/tenant-isolation.ts

@@ -0,0 +1,42 @@
+/**
+ * Example 2 — tenant isolation (security-critical).
+ *
+ * Two tenants use the SAME roomId. Their docs, snapshot state and transport
+ * channels are hard-partitioned: tenant A's edits are unreachable from
+ * tenant B even though the room id string is identical.
+ *
+ * Run: pnpm --filter @nebutra/collab exec tsx examples/tenant-isolation.ts
+ */
+
+import { getCollab } from "../src/index";
+
+export async function main(): Promise<void> {
+  const hub = await getCollab();
+
+  const roomId = "shared-room-id";
+  const a = hub.room("tenantA", roomId);
+  const b = hub.room("tenantB", roomId);
+
+  if (a.doc === b.doc) throw new Error("tenant partition breached: shared doc");
+
+  const leaked: unknown[] = [];
+  b.onUpdate((u) => leaked.push(u));
+
+  a.doc.getMap("m").set("secret", "A-only");
+  await a.snapshot();
+
+  if (b.doc.getMap("m").get("secret") !== undefined) {
+    throw new Error("tenant partition breached: B saw A's value");
+  }
+  if (leaked.length !== 0) {
+    throw new Error("tenant partition breached: B received A's update");
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn("[collab] tenant isolation holds: B never observed A");
+  hub.destroy();
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  void main();
+}

package/examples/zero-config-convergence.ts

@@ -0,0 +1,43 @@
+/**
+ * Example 1 — zero-config CRDT convergence.
+ *
+ * No env, no config, real (non-mock) Yjs behaviour. This file is also the
+ * in-package REAL CALLER of the exported `getCollab` factory that keeps
+ * `@nebutra/collab` in the `active` tier of the three-tier module lifecycle.
+ *
+ * Run: pnpm --filter @nebutra/collab exec tsx examples/zero-config-convergence.ts
+ */
+
+import * as Y from "yjs";
+import { getCollab } from "../src/index";
+
+export async function main(): Promise<void> {
+  const hub = await getCollab();
+
+  // Two clients on the SAME tenant + room.
+  const a = hub.room("t1", "doc-1");
+  const b = hub.room("t1", "doc-1");
+  if (a !== b) throw new Error("same (tenant,room) must yield same instance");
+
+  // A standalone peer doc simulating a second device.
+  const peer = new Y.Doc();
+  a.doc.getText("body").insert(0, "Hello ");
+  Y.applyUpdate(peer, a.encodeState());
+
+  peer.getText("body").insert(6, "collab");
+  a.applyUpdate(Y.encodeStateAsUpdate(peer));
+  Y.applyUpdate(peer, a.encodeState());
+
+  const converged = a.doc.getText("body").toString();
+  if (converged !== peer.getText("body").toString()) {
+    throw new Error("clients did not converge");
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(`[collab] converged text: "${converged}"`);
+  hub.destroy();
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  void main();
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@nebutra/collab",
+  "version": "0.2.0",
+  "description": "Multi-tenant, transport-agnostic real-time collaborative sync layer: tenant-partitioned CRDT rooms (Yjs) with pluggable snapshot store + transport seams",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "nebutra": {
+    "featureId": "collab",
+    "category": "integrations",
+    "summary": "Tenant-partitioned CRDT room manager (Yjs) with pluggable store + transport seams"
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./store/memory": "./src/store/memory.ts",
+    "./transport/loopback": "./src/transport/loopback.ts"
+  },
+  "dependencies": {
+    "yjs": "^13.6.30",
+    "@nebutra/capability-kit": "0.2.0",
+    "@nebutra/tenant-store": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.15",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "homepage": "https://github.com/Nebutra/Nebutra-Sailor/tree/main/packages/integrations/collab#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nebutra/Nebutra-Sailor.git",
+    "directory": "packages/integrations/collab"
+  },
+  "bugs": {
+    "url": "https://github.com/Nebutra/Nebutra-Sailor/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  }
+}