@noy-db/by-peer 0.1.0-pre.10

package/dist/index.js

@@ -0,0 +1,457 @@
+// src/channel.ts
+function pairInMemory() {
+  function make() {
+    const listeners = { message: /* @__PURE__ */ new Set(), close: /* @__PURE__ */ new Set() };
+    const closed = { v: false };
+    const ch = {
+      get isOpen() {
+        return !closed.v;
+      },
+      send() {
+      },
+      on(event, listener) {
+        if (event === "message") {
+          listeners.message.add(listener);
+          return () => listeners.message.delete(listener);
+        }
+        listeners.close.add(listener);
+        return () => listeners.close.delete(listener);
+      },
+      close() {
+        if (closed.v) return;
+        closed.v = true;
+        for (const fn of listeners.close) fn();
+      }
+    };
+    return { ch, listeners, closed };
+  }
+  const a = make();
+  const b = make();
+  function closeBoth() {
+    if (!a.closed.v) {
+      a.closed.v = true;
+      for (const fn of a.listeners.close) fn();
+    }
+    if (!b.closed.v) {
+      b.closed.v = true;
+      for (const fn of b.listeners.close) fn();
+    }
+  }
+  a.ch.send = (payload) => {
+    if (b.closed.v) throw new Error("PeerChannel closed");
+    queueMicrotask(() => {
+      for (const fn of b.listeners.message) fn(payload);
+    });
+  };
+  b.ch.send = (payload) => {
+    if (a.closed.v) throw new Error("PeerChannel closed");
+    queueMicrotask(() => {
+      for (const fn of a.listeners.message) fn(payload);
+    });
+  };
+  a.ch.close = closeBoth;
+  b.ch.close = closeBoth;
+  return [a.ch, b.ch];
+}
+function fromDataChannel(dc) {
+  const listeners = { message: /* @__PURE__ */ new Set(), close: /* @__PURE__ */ new Set() };
+  let closed = false;
+  dc.addEventListener("message", (ev) => {
+    if (typeof ev.data !== "string") return;
+    for (const fn of listeners.message) fn(ev.data);
+  });
+  dc.addEventListener("close", () => {
+    if (closed) return;
+    closed = true;
+    for (const fn of listeners.close) fn();
+  });
+  return {
+    get isOpen() {
+      return !closed && dc.readyState === "open";
+    },
+    send(payload) {
+      if (closed || dc.readyState !== "open") {
+        throw new Error(`PeerChannel not open (readyState: ${dc.readyState})`);
+      }
+      dc.send(payload);
+    },
+    on(event, listener) {
+      if (event === "message") {
+        listeners.message.add(listener);
+        return () => listeners.message.delete(listener);
+      }
+      listeners.close.add(listener);
+      return () => listeners.close.delete(listener);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      try {
+        dc.close();
+      } catch {
+      }
+      for (const fn of listeners.close) fn();
+    }
+  };
+}
+
+// src/rpc.ts
+function createRpcClient(channel, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const pending = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const offMessage = channel.on("message", (payload) => {
+    let msg;
+    try {
+      msg = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    if (msg.t !== "res") return;
+    const entry = pending.get(msg.id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    pending.delete(msg.id);
+    if (msg.ok) {
+      entry.resolve(msg.result);
+    } else {
+      const e = msg.error ?? { name: "Error", message: "unknown remote error" };
+      const err = new Error(e.message);
+      err.name = e.name;
+      if (typeof e.version === "number") {
+        ;
+        err.version = e.version;
+      }
+      entry.reject(err);
+    }
+  });
+  const offClose = channel.on("close", () => {
+    for (const [, entry] of pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("PeerChannel closed before response"));
+    }
+    pending.clear();
+  });
+  return {
+    async call(method, args) {
+      const id = `${Date.now().toString(36)}-${(++counter).toString(36)}`;
+      const req = { t: "req", id, method, args };
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`RPC ${method} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        pending.set(id, {
+          resolve,
+          reject,
+          timer
+        });
+        try {
+          channel.send(JSON.stringify(req));
+        } catch (err) {
+          clearTimeout(timer);
+          pending.delete(id);
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      });
+    },
+    dispose() {
+      offMessage();
+      offClose();
+      for (const [, entry] of pending) {
+        clearTimeout(entry.timer);
+        entry.reject(new Error("RPC client disposed"));
+      }
+      pending.clear();
+    }
+  };
+}
+function serveRpc(channel, handler) {
+  async function handle(payload) {
+    let msg;
+    try {
+      msg = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    if (msg.t !== "req") return;
+    let response;
+    try {
+      const result = await handler(msg.method, msg.args);
+      response = { t: "res", id: msg.id, ok: true, result };
+    } catch (err) {
+      const e = err;
+      response = {
+        t: "res",
+        id: msg.id,
+        ok: false,
+        error: {
+          name: e.name ?? "Error",
+          message: e.message ?? String(err),
+          ...typeof e.version === "number" && { version: e.version }
+        }
+      };
+    }
+    if (!channel.isOpen) return;
+    try {
+      channel.send(JSON.stringify(response));
+    } catch {
+    }
+  }
+  const offMessage = channel.on("message", (payload) => {
+    void handle(payload);
+  });
+  return () => offMessage();
+}
+
+// src/peer-store.ts
+import { ConflictError } from "@noy-db/hub";
+function peerStore(opts) {
+  const rpc = createRpcClient(opts.channel, { timeoutMs: opts.timeoutMs ?? 3e4 });
+  async function call(method, args) {
+    try {
+      return await rpc.call(method, args);
+    } catch (err) {
+      const e = err;
+      if (e.name === "ConflictError" && typeof e.version === "number") {
+        throw new ConflictError(e.version, e.message);
+      }
+      throw err;
+    }
+  }
+  return {
+    name: opts.name ?? "by-peer",
+    async get(vault, collection, id) {
+      return call("get", [vault, collection, id]);
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      await call("put", [vault, collection, id, envelope, expectedVersion]);
+    },
+    async delete(vault, collection, id) {
+      await call("delete", [vault, collection, id]);
+    },
+    async list(vault, collection) {
+      return call("list", [vault, collection]);
+    },
+    async loadAll(vault) {
+      return call("loadAll", [vault]);
+    },
+    async saveAll(vault, data) {
+      await call("saveAll", [vault, data]);
+    },
+    async ping() {
+      try {
+        return await call("ping", []);
+      } catch {
+        return false;
+      }
+    },
+    dispose() {
+      rpc.dispose();
+    }
+  };
+}
+
+// src/serve.ts
+var CORE_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "put",
+  "delete",
+  "list",
+  "loadAll",
+  "saveAll",
+  "ping",
+  "listSince",
+  "listPage",
+  "listVaults"
+]);
+function servePeerStore(opts) {
+  if (!opts.leaderElection) {
+    return startServing(opts);
+  }
+  return startServingWithLeaderElection(opts);
+}
+function startServing(opts) {
+  const { store, channel, allow } = opts;
+  return serveRpc(channel, async (method, args) => {
+    if (!CORE_METHODS.has(method)) {
+      throw new Error(`Unknown RPC method: ${method}`);
+    }
+    if (allow && !allow.has(method)) {
+      throw new Error(`Method not allowed: ${method}`);
+    }
+    switch (method) {
+      case "get": {
+        const [vault, collection, id] = args;
+        return store.get(vault, collection, id);
+      }
+      case "put": {
+        const [vault, collection, id, envelope, expectedVersion] = args;
+        await store.put(vault, collection, id, envelope, expectedVersion);
+        return null;
+      }
+      case "delete": {
+        const [vault, collection, id] = args;
+        await store.delete(vault, collection, id);
+        return null;
+      }
+      case "list": {
+        const [vault, collection] = args;
+        return store.list(vault, collection);
+      }
+      case "loadAll": {
+        const [vault] = args;
+        return store.loadAll(vault);
+      }
+      case "saveAll": {
+        const [vault, data] = args;
+        await store.saveAll(vault, data);
+        return null;
+      }
+      case "ping": {
+        if (!store.ping) return true;
+        return store.ping();
+      }
+      case "listSince": {
+        if (!store.listSince) throw new Error("listSince not supported by remote store");
+        const [vault, collection, since] = args;
+        return store.listSince(vault, collection, since);
+      }
+      case "listPage": {
+        if (!store.listPage) throw new Error("listPage not supported by remote store");
+        const [vault, collection, cursor, limit] = args;
+        return store.listPage(vault, collection, cursor, limit);
+      }
+      case "listVaults": {
+        if (!store.listVaults) throw new Error("listVaults not supported by remote store");
+        return store.listVaults();
+      }
+    }
+    throw new Error(`Unhandled method: ${method}`);
+  });
+}
+function startServingWithLeaderElection(opts) {
+  const leader = opts.leaderElection;
+  const locks = leader.locks ?? getDefaultLocks();
+  const ac = new AbortController();
+  let stopServing = null;
+  let releaseLock = null;
+  let disposed = false;
+  void locks.request(leader.lockName, { mode: "exclusive", signal: ac.signal }, () => {
+    if (disposed) return Promise.resolve();
+    stopServing = startServing(opts);
+    return new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+  }).catch((err) => {
+    if (err?.name === "AbortError") return;
+    queueMicrotask(() => {
+      throw err;
+    });
+  });
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    if (stopServing) {
+      stopServing();
+      stopServing = null;
+    }
+    if (releaseLock) {
+      releaseLock();
+      releaseLock = null;
+    } else {
+      ac.abort();
+    }
+  };
+}
+function getDefaultLocks() {
+  const nav = globalThis.navigator;
+  if (nav && nav.locks) return nav.locks;
+  throw new Error(
+    "leaderElection requires the Web Locks API (navigator.locks). Use Chrome 69+, Firefox 96+, Safari 15.4+, or pass `leaderElection.locks: <stub>` for tests / non-browser hosts."
+  );
+}
+
+// src/webrtc.ts
+function requireRTC() {
+  const g = globalThis;
+  if (!g.RTCPeerConnection) {
+    throw new Error(
+      "[@noy-db/by-peer] globalThis.RTCPeerConnection is undefined \u2014 use this module in a browser, or polyfill with @roamhq/wrtc in Node"
+    );
+  }
+  return g.RTCPeerConnection;
+}
+async function createOffer(opts = {}) {
+  const RTC = requireRTC();
+  const pc = new RTC({
+    ...opts.iceServers && { iceServers: opts.iceServers }
+  });
+  const dc = pc.createDataChannel(opts.label ?? "noydb", {
+    ordered: true
+  });
+  const channelPromise = new Promise((resolve, reject) => {
+    dc.addEventListener("open", () => resolve(fromDataChannel(dc)));
+    dc.addEventListener("error", () => reject(new Error("DataChannel error")));
+  });
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  await waitForIceComplete(pc);
+  return {
+    offer: pc.localDescription ?? offer,
+    connection: pc,
+    channel: channelPromise,
+    async accept(answer) {
+      await pc.setRemoteDescription(answer);
+    }
+  };
+}
+async function acceptOffer(offer, opts = {}) {
+  const RTC = requireRTC();
+  const pc = new RTC({
+    ...opts.iceServers && { iceServers: opts.iceServers }
+  });
+  const channelPromise = new Promise((resolve, reject) => {
+    pc.addEventListener("datachannel", (ev) => {
+      const dc = ev.channel;
+      if (dc.readyState === "open") {
+        resolve(fromDataChannel(dc));
+      } else {
+        dc.addEventListener("open", () => resolve(fromDataChannel(dc)));
+        dc.addEventListener("error", () => reject(new Error("DataChannel error")));
+      }
+    });
+  });
+  await pc.setRemoteDescription(offer);
+  const answer = await pc.createAnswer();
+  await pc.setLocalDescription(answer);
+  await waitForIceComplete(pc);
+  return {
+    answer: pc.localDescription ?? answer,
+    connection: pc,
+    channel: channelPromise
+  };
+}
+function waitForIceComplete(pc) {
+  if (pc.iceGatheringState === "complete") return Promise.resolve();
+  return new Promise((resolve) => {
+    const check = () => {
+      if (pc.iceGatheringState === "complete") {
+        pc.removeEventListener("icegatheringstatechange", check);
+        resolve();
+      }
+    };
+    pc.addEventListener("icegatheringstatechange", check);
+  });
+}
+export {
+  acceptOffer,
+  createOffer,
+  createRpcClient,
+  fromDataChannel,
+  pairInMemory,
+  peerStore,
+  servePeerStore,
+  serveRpc
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/channel.ts","../src/rpc.ts","../src/peer-store.ts","../src/serve.ts","../src/webrtc.ts"],"sourcesContent":["/**\n * `PeerChannel` — the minimal duplex message primitive used by the p2p\n * NoydbStore wrapper. Any transport that can deliver UTF-8 strings\n * reliably and in-order qualifies: WebRTC DataChannel, BroadcastChannel,\n * MessagePort, WebSocket, even postMessage pairs.\n *\n * Keeping the transport abstract has three payoffs:\n *\n *   1. **Tests run without a WebRTC polyfill.** `pairInMemory()` returns\n *      two wired channels for conformance tests against `to-memory`.\n *   2. **Consumers pick their signaling story.** Matrix rooms, QR codes,\n *      pastebin, Firebase Realtime DB — the handshake is out of scope.\n *   3. **Future transports slot in cheaply.** WebTransport (HTTP/3),\n *      libp2p, Iroh, or a plain relay WebSocket become additional\n *      bindings without touching the RPC layer.\n *\n * @module\n */\n\n/**\n * Minimal duplex message primitive.\n *\n * Implementations MUST deliver every `send` payload in order exactly\n * once to every live `on('message')` subscriber. `close()` is best-effort\n * — once called, further `send()` calls MAY throw and `on('close')` MUST\n * fire once.\n */\nexport interface PeerChannel {\n  /** Enqueue a payload for delivery to the remote end. */\n  send(payload: string): void\n  /** Subscribe to incoming payloads or lifecycle events. Returns unsubscribe. */\n  on(event: 'message', listener: (payload: string) => void): () => void\n  on(event: 'close', listener: () => void): () => void\n  /** Close the channel. Idempotent. */\n  close(): void\n  /** True once the channel is ready for `send`. */\n  readonly isOpen: boolean\n}\n\n/**\n * Create a pair of in-memory `PeerChannel`s wired to each other.\n * Intended for tests and multi-tab simulations inside a single process.\n */\nexport function pairInMemory(): [PeerChannel, PeerChannel] {\n  type Listeners = {\n    message: Set<(p: string) => void>\n    close: Set<() => void>\n  }\n\n  function make(): { ch: PeerChannel; listeners: Listeners; closed: { v: boolean } } {\n    const listeners: Listeners = { message: new Set(), close: new Set() }\n    const closed = { v: false }\n    const ch: PeerChannel = {\n      get isOpen() {\n        return !closed.v\n      },\n      send() {\n        // Placeholder — wired below.\n      },\n      on(event: 'message' | 'close', listener: ((payload: string) => void) | (() => void)): () => void {\n        if (event === 'message') {\n          listeners.message.add(listener as (p: string) => void)\n          return () => listeners.message.delete(listener as (p: string) => void)\n        }\n        listeners.close.add(listener as () => void)\n        return () => listeners.close.delete(listener as () => void)\n      },\n      close() {\n        if (closed.v) return\n        closed.v = true\n        for (const fn of listeners.close) fn()\n      },\n    } as PeerChannel\n    return { ch, listeners, closed }\n  }\n\n  const a = make()\n  const b = make()\n\n  function closeBoth(): void {\n    if (!a.closed.v) {\n      a.closed.v = true\n      for (const fn of a.listeners.close) fn()\n    }\n    if (!b.closed.v) {\n      b.closed.v = true\n      for (const fn of b.listeners.close) fn()\n    }\n  }\n\n  a.ch.send = (payload) => {\n    if (b.closed.v) throw new Error('PeerChannel closed')\n    queueMicrotask(() => {\n      for (const fn of b.listeners.message) fn(payload)\n    })\n  }\n  b.ch.send = (payload) => {\n    if (a.closed.v) throw new Error('PeerChannel closed')\n    queueMicrotask(() => {\n      for (const fn of a.listeners.message) fn(payload)\n    })\n  }\n  a.ch.close = closeBoth\n  b.ch.close = closeBoth\n\n  return [a.ch, b.ch]\n}\n\n/**\n * Wrap a WebRTC `RTCDataChannel` as a `PeerChannel`.\n *\n * Browser-only — the caller is responsible for establishing the\n * `RTCPeerConnection`, exchanging SDP offers/answers out of band, and\n * passing the opened DataChannel here. When the remote peer is only\n * reachable via TURN, the relay sees DTLS-wrapped ciphertext (noy-db\n * already encrypts at rest, so even a TURN compromise leaks nothing).\n */\nexport function fromDataChannel(dc: RTCDataChannel): PeerChannel {\n  type Listeners = {\n    message: Set<(p: string) => void>\n    close: Set<() => void>\n  }\n  const listeners: Listeners = { message: new Set(), close: new Set() }\n  let closed = false\n\n  dc.addEventListener('message', (ev: MessageEvent) => {\n    if (typeof ev.data !== 'string') return\n    for (const fn of listeners.message) fn(ev.data)\n  })\n  dc.addEventListener('close', () => {\n    if (closed) return\n    closed = true\n    for (const fn of listeners.close) fn()\n  })\n\n  return {\n    get isOpen() {\n      return !closed && dc.readyState === 'open'\n    },\n    send(payload) {\n      if (closed || dc.readyState !== 'open') {\n        throw new Error(`PeerChannel not open (readyState: ${dc.readyState})`)\n      }\n      dc.send(payload)\n    },\n    on(event: 'message' | 'close', listener: ((payload: string) => void) | (() => void)): () => void {\n      if (event === 'message') {\n        listeners.message.add(listener as (p: string) => void)\n        return () => listeners.message.delete(listener as (p: string) => void)\n      }\n      listeners.close.add(listener as () => void)\n      return () => listeners.close.delete(listener as () => void)\n    },\n    close() {\n      if (closed) return\n      closed = true\n      try {\n        dc.close()\n      } catch {\n        // ignore — channel already torn down\n      }\n      for (const fn of listeners.close) fn()\n    },\n  } as PeerChannel\n}\n","/**\n * JSON-RPC protocol over a `PeerChannel`.\n *\n * Request shape:\n *   `{ t: 'req', id, method, args }`\n * Response shape (success):\n *   `{ t: 'res', id, ok: true, result }`\n * Response shape (error):\n *   `{ t: 'res', id, ok: false, error: { name, message, version? } }`\n *\n * Why not reuse msgpack/protobuf? The payloads are already base64-encoded\n * ciphertext — further binary packing saves ~8-12% at a large dependency\n * cost. JSON over UTF-8 is inspectable, fits the zero-dependency ethos,\n * and WebRTC DataChannel string mode already frames for us.\n *\n * @module\n */\n\nimport type { PeerChannel } from './channel.js'\n\n/** Wire format discriminator for RPC messages. */\nexport type RpcMessage = RpcRequest | RpcResponse\n\nexport interface RpcRequest {\n  readonly t: 'req'\n  readonly id: string\n  readonly method: string\n  readonly args: readonly unknown[]\n}\n\nexport interface RpcResponse {\n  readonly t: 'res'\n  readonly id: string\n  readonly ok: boolean\n  readonly result?: unknown\n  readonly error?: { name: string; message: string; version?: number }\n}\n\n/** Handler invoked when an RPC request arrives. Return value is serialized as `result`. */\nexport type RpcHandler = (method: string, args: readonly unknown[]) => Promise<unknown>\n\n/** Options for a client-side RPC caller. */\nexport interface RpcClientOptions {\n  /** Max milliseconds to wait for a response before rejecting. */\n  timeoutMs?: number\n}\n\n/** Client: wrap a `PeerChannel` in a `call(method, args)` helper. */\nexport function createRpcClient(channel: PeerChannel, opts: RpcClientOptions = {}) {\n  const timeoutMs = opts.timeoutMs ?? 30_000\n  type Pending = {\n    resolve: (v: unknown) => void\n    reject: (err: Error) => void\n    timer: ReturnType<typeof setTimeout>\n  }\n  const pending = new Map<string, Pending>()\n  let counter = 0\n\n  const offMessage = channel.on('message', (payload) => {\n    let msg: RpcMessage\n    try {\n      msg = JSON.parse(payload) as RpcMessage\n    } catch {\n      return\n    }\n    if (msg.t !== 'res') return\n    const entry = pending.get(msg.id)\n    if (!entry) return\n    clearTimeout(entry.timer)\n    pending.delete(msg.id)\n    if (msg.ok) {\n      entry.resolve(msg.result)\n    } else {\n      const e = msg.error ?? { name: 'Error', message: 'unknown remote error' }\n      const err = new Error(e.message)\n      err.name = e.name\n      if (typeof e.version === 'number') {\n        ;(err as Error & { version?: number }).version = e.version\n      }\n      entry.reject(err)\n    }\n  })\n\n  const offClose = channel.on('close', () => {\n    for (const [, entry] of pending) {\n      clearTimeout(entry.timer)\n      entry.reject(new Error('PeerChannel closed before response'))\n    }\n    pending.clear()\n  })\n\n  return {\n    async call<T = unknown>(method: string, args: readonly unknown[]): Promise<T> {\n      const id = `${Date.now().toString(36)}-${(++counter).toString(36)}`\n      const req: RpcRequest = { t: 'req', id, method, args }\n      return new Promise<T>((resolve, reject) => {\n        const timer = setTimeout(() => {\n          pending.delete(id)\n          reject(new Error(`RPC ${method} timed out after ${timeoutMs}ms`))\n        }, timeoutMs)\n        pending.set(id, {\n          resolve: resolve as (v: unknown) => void,\n          reject,\n          timer,\n        })\n        try {\n          channel.send(JSON.stringify(req))\n        } catch (err) {\n          clearTimeout(timer)\n          pending.delete(id)\n          reject(err instanceof Error ? err : new Error(String(err)))\n        }\n      })\n    },\n    dispose() {\n      offMessage()\n      offClose()\n      for (const [, entry] of pending) {\n        clearTimeout(entry.timer)\n        entry.reject(new Error('RPC client disposed'))\n      }\n      pending.clear()\n    },\n  }\n}\n\n/** Server: dispatch incoming RPC requests through a handler. Returns a dispose fn. */\nexport function serveRpc(channel: PeerChannel, handler: RpcHandler): () => void {\n  async function handle(payload: string): Promise<void> {\n    let msg: RpcMessage\n    try {\n      msg = JSON.parse(payload) as RpcMessage\n    } catch {\n      return\n    }\n    if (msg.t !== 'req') return\n\n    let response: RpcResponse\n    try {\n      const result = await handler(msg.method, msg.args)\n      response = { t: 'res', id: msg.id, ok: true, result }\n    } catch (err) {\n      const e = err as Error & { version?: number }\n      response = {\n        t: 'res',\n        id: msg.id,\n        ok: false,\n        error: {\n          name: e.name ?? 'Error',\n          message: e.message ?? String(err),\n          ...(typeof e.version === 'number' && { version: e.version }),\n        },\n      }\n    }\n\n    if (!channel.isOpen) return\n    try {\n      channel.send(JSON.stringify(response))\n    } catch {\n      // Channel closed mid-response — nothing to do.\n    }\n  }\n\n  const offMessage = channel.on('message', (payload) => {\n    void handle(payload)\n  })\n\n  return () => offMessage()\n}\n","/**\n * `peerStore()` — a `NoydbStore` backed by RPC calls over a `PeerChannel`.\n *\n * The local peer calls `get`/`put`/`delete`/… against this store as if\n * it were any other backend; every call is serialized as an RPC request\n * to the remote peer, which runs `servePeerStore()` to funnel the RPCs\n * into its own local `NoydbStore`.\n *\n * Error re-hydration: the remote handler re-throws `ConflictError` with\n * a `.version` field when a CAS check fails. The RPC layer carries\n * `version` in the error envelope so the local caller can catch\n * `ConflictError` with the same semantics as a direct store call.\n *\n * @module\n */\n\nimport type { NoydbStore, EncryptedEnvelope, VaultSnapshot } from '@noy-db/hub'\nimport { ConflictError } from '@noy-db/hub'\nimport type { PeerChannel } from './channel.js'\nimport { createRpcClient } from './rpc.js'\n\nexport interface PeerStoreOptions {\n  /** The duplex channel to the remote peer. */\n  readonly channel: PeerChannel\n  /** Max ms to wait for any single RPC response. Default 30s. */\n  readonly timeoutMs?: number\n  /** Optional display name used in diagnostics. Default `'by-peer'`. */\n  readonly name?: string\n}\n\n/**\n * Create a `NoydbStore` that forwards every operation to a remote peer\n * over the supplied `PeerChannel`. The remote peer must be running\n * `servePeerStore()` against its own local store.\n */\nexport function peerStore(opts: PeerStoreOptions): NoydbStore & { dispose: () => void } {\n  const rpc = createRpcClient(opts.channel, { timeoutMs: opts.timeoutMs ?? 30_000 })\n\n  async function call<T>(method: string, args: readonly unknown[]): Promise<T> {\n    try {\n      return await rpc.call<T>(method, args)\n    } catch (err) {\n      // Re-hydrate ConflictError so CAS semantics survive the wire hop.\n      const e = err as Error & { version?: number }\n      if (e.name === 'ConflictError' && typeof e.version === 'number') {\n        throw new ConflictError(e.version, e.message)\n      }\n      throw err\n    }\n  }\n\n  return {\n    name: opts.name ?? 'by-peer',\n\n    async get(vault, collection, id) {\n      return call<EncryptedEnvelope | null>('get', [vault, collection, id])\n    },\n\n    async put(vault, collection, id, envelope, expectedVersion) {\n      await call<void>('put', [vault, collection, id, envelope, expectedVersion])\n    },\n\n    async delete(vault, collection, id) {\n      await call<void>('delete', [vault, collection, id])\n    },\n\n    async list(vault, collection) {\n      return call<string[]>('list', [vault, collection])\n    },\n\n    async loadAll(vault) {\n      return call<VaultSnapshot>('loadAll', [vault])\n    },\n\n    async saveAll(vault, data) {\n      await call<void>('saveAll', [vault, data])\n    },\n\n    async ping() {\n      try {\n        return await call<boolean>('ping', [])\n      } catch {\n        return false\n      }\n    },\n\n    dispose() {\n      rpc.dispose()\n    },\n  }\n}\n","/**\n * `servePeerStore()` — runs on the peer that owns the data. Listens on\n * a `PeerChannel` for RPC requests from a remote `peerStore()` client\n * and executes each one against the local `NoydbStore`.\n *\n * The 6 core methods plus the optional `ping` / `listSince` / `listPage`\n * extensions are exposed. Unknown methods surface as a remote Error.\n *\n * **Leader-election (issue #3).** When a `BroadcastChannel`-backed\n * `PeerChannel` is shared by 3+ tabs each running `servePeerStore`,\n * every non-sending tab responds to every RPC — producing duplicate\n * responses for the same request id and O(N²) channel traffic at scale.\n * Pass `leaderElection: { lockName, locks? }` to gate serving on the\n * Web Locks API: only the lock-holding tab registers an RPC handler;\n * others queue and take over when the holder's tab closes (lock auto-\n * releases). Default behaviour (no `leaderElection`) is unchanged for\n * the 2-tab case.\n *\n * @module\n */\n\nimport type { NoydbStore, EncryptedEnvelope, VaultSnapshot } from '@noy-db/hub'\nimport type { PeerChannel } from './channel.js'\nimport { serveRpc } from './rpc.js'\n\n/**\n * Minimal subset of the Web Locks API used by leader-election. The\n * browser's `navigator.locks` satisfies this; tests inject a stub.\n *\n * @public\n */\nexport interface MinimalLockManager {\n  request<T>(\n    name: string,\n    options: { mode?: 'exclusive' | 'shared'; signal?: AbortSignal },\n    callback: (lock: unknown) => Promise<T>,\n  ): Promise<T>\n}\n\nexport interface ServePeerStoreOptions {\n  /** The duplex channel from the remote peer. */\n  readonly channel: PeerChannel\n  /** The local store to serve. */\n  readonly store: NoydbStore\n  /**\n   * Optional method whitelist. When provided, any method not in the set\n   * is rejected with \"method not allowed\". Useful for read-only peers.\n   */\n  readonly allow?: ReadonlySet<string>\n  /**\n   * Opt in to leader-election semantics for cross-tab coordination via\n   * the Web Locks API. Required when 3+ tabs share a `BroadcastChannel`-\n   * backed `PeerChannel` — without leader election, every non-sending tab\n   * responds to every RPC, producing duplicate responses (issue #3).\n   *\n   * Browser support: Chrome 69+, Firefox 96+, Safari 15.4+.\n   *\n   * - `lockName` — globally unique lock name. Convention:\n   *   `noy-db:peer-server:<channel-name>`. The same `lockName` MUST be\n   *   used by every tab that wants to share the leader role.\n   * - `locks` — defaults to `navigator.locks` in browsers. Pass a stub\n   *   for tests or for non-browser hosts that polyfill the Web Locks API.\n   *\n   * Behaviour: at most one tab holds the lock at a time. Only that tab\n   * registers an RPC handler on the channel; other tabs queue (their\n   * `servePeerStore` call returns a working dispose function but does\n   * not respond to incoming RPCs). When the holder's tab closes (or its\n   * `servePeerStore` is disposed), the next queued tab takes over.\n   */\n  readonly leaderElection?: {\n    readonly lockName: string\n    readonly locks?: MinimalLockManager\n  }\n}\n\nconst CORE_METHODS = new Set<string>([\n  'get',\n  'put',\n  'delete',\n  'list',\n  'loadAll',\n  'saveAll',\n  'ping',\n  'listSince',\n  'listPage',\n  'listVaults',\n])\n\n/**\n * Start serving the local store on the channel. Returns a dispose\n * function that stops the RPC listener. The underlying channel is NOT\n * closed by dispose — ownership stays with the caller.\n *\n * When `leaderElection` is set, the RPC handler is only registered while\n * this tab holds the named Web Lock. The returned dispose function\n * always works: if called before the lock is acquired, it cancels the\n * wait; if called while holding the lock, it releases the lock and\n * stops serving.\n */\nexport function servePeerStore(opts: ServePeerStoreOptions): () => void {\n  if (!opts.leaderElection) {\n    return startServing(opts)\n  }\n  return startServingWithLeaderElection(opts)\n}\n\n/**\n * Register the RPC handler immediately. Used when leader-election is off,\n * and inside the lock callback when on.\n */\nfunction startServing(opts: ServePeerStoreOptions): () => void {\n  const { store, channel, allow } = opts\n\n  return serveRpc(channel, async (method, args) => {\n    if (!CORE_METHODS.has(method)) {\n      throw new Error(`Unknown RPC method: ${method}`)\n    }\n    if (allow && !allow.has(method)) {\n      throw new Error(`Method not allowed: ${method}`)\n    }\n\n    switch (method) {\n      case 'get': {\n        const [vault, collection, id] = args as [string, string, string]\n        return store.get(vault, collection, id)\n      }\n      case 'put': {\n        const [vault, collection, id, envelope, expectedVersion] = args as [\n          string,\n          string,\n          string,\n          EncryptedEnvelope,\n          number | undefined,\n        ]\n        await store.put(vault, collection, id, envelope, expectedVersion)\n        return null\n      }\n      case 'delete': {\n        const [vault, collection, id] = args as [string, string, string]\n        await store.delete(vault, collection, id)\n        return null\n      }\n      case 'list': {\n        const [vault, collection] = args as [string, string]\n        return store.list(vault, collection)\n      }\n      case 'loadAll': {\n        const [vault] = args as [string]\n        return store.loadAll(vault)\n      }\n      case 'saveAll': {\n        const [vault, data] = args as [string, VaultSnapshot]\n        await store.saveAll(vault, data)\n        return null\n      }\n      case 'ping': {\n        if (!store.ping) return true\n        return store.ping()\n      }\n      case 'listSince': {\n        if (!store.listSince) throw new Error('listSince not supported by remote store')\n        const [vault, collection, since] = args as [string, string, string]\n        return store.listSince(vault, collection, since)\n      }\n      case 'listPage': {\n        if (!store.listPage) throw new Error('listPage not supported by remote store')\n        const [vault, collection, cursor, limit] = args as [\n          string,\n          string,\n          string | undefined,\n          number | undefined,\n        ]\n        return store.listPage(vault, collection, cursor, limit)\n      }\n      case 'listVaults': {\n        if (!store.listVaults) throw new Error('listVaults not supported by remote store')\n        return store.listVaults()\n      }\n    }\n    /* istanbul ignore next — CORE_METHODS gate makes this unreachable */\n    throw new Error(`Unhandled method: ${method}`)\n  })\n}\n\n/**\n * Acquire a Web Lock first; only register the RPC listener while\n * holding it. Returns a dispose that cancels the wait (if not yet\n * acquired) or releases the lock (if held).\n */\nfunction startServingWithLeaderElection(opts: ServePeerStoreOptions): () => void {\n  // Asserted by the caller branch in `servePeerStore`.\n  const leader = opts.leaderElection as { lockName: string; locks?: MinimalLockManager }\n  const locks = leader.locks ?? getDefaultLocks()\n  const ac = new AbortController()\n  let stopServing: (() => void) | null = null\n  let releaseLock: (() => void) | null = null\n  let disposed = false\n\n  void locks\n    .request(leader.lockName, { mode: 'exclusive', signal: ac.signal }, () => {\n      if (disposed) return Promise.resolve()\n      stopServing = startServing(opts)\n      // Hold the lock for the lifetime of this tab's leadership. The\n      // returned promise stays pending until `releaseLock` is called by\n      // the dispose function.\n      return new Promise<void>((resolve) => {\n        releaseLock = resolve\n      })\n    })\n    .catch((err: unknown) => {\n      // AbortError is the expected cancellation when dispose runs before\n      // the lock was acquired. Anything else is unexpected — surface it\n      // at the next tick so the host can observe it.\n      if ((err as { name?: string } | null)?.name === 'AbortError') return\n      queueMicrotask(() => {\n        throw err\n      })\n    })\n\n  return () => {\n    if (disposed) return\n    disposed = true\n    if (stopServing) {\n      stopServing()\n      stopServing = null\n    }\n    if (releaseLock) {\n      releaseLock()\n      releaseLock = null\n    } else {\n      ac.abort()\n    }\n  }\n}\n\nfunction getDefaultLocks(): MinimalLockManager {\n  const nav = (globalThis as { navigator?: { locks?: MinimalLockManager } }).navigator\n  if (nav && nav.locks) return nav.locks\n  throw new Error(\n    'leaderElection requires the Web Locks API (navigator.locks). ' +\n    'Use Chrome 69+, Firefox 96+, Safari 15.4+, or pass `leaderElection.locks: <stub>` ' +\n    'for tests / non-browser hosts.',\n  )\n}\n","/**\n * WebRTC handshake helper — opinionated wrapper around\n * `RTCPeerConnection` that produces a ready-to-use `PeerChannel`.\n *\n * The handshake is split into two halves so the caller can ferry the\n * SDP blobs over whatever signaling channel they prefer (QR code,\n * Matrix room, pastebin, Firebase, signed URL…). Signaling is\n * intentionally out of scope — noy-db has no opinion on how peers\n * discover each other, only on what flows once they do.\n *\n * ```ts\n * // Peer A (initiator)\n * const a = await createOffer({ iceServers })\n * send(a.offer)                           // → signaling channel\n * const answer = await receive()          // ← signaling channel\n * await a.accept(answer)\n * const channel = await a.channel         // ready PeerChannel\n *\n * // Peer B (responder)\n * const offer = await receive()           // ← signaling channel\n * const b = await acceptOffer(offer, { iceServers })\n * send(b.answer)                          // → signaling channel\n * const channel = await b.channel         // ready PeerChannel\n * ```\n *\n * Browser-only. Node consumers who want to interconnect with browsers\n * can plug `@roamhq/wrtc` into the global `RTCPeerConnection` slot; this\n * module does not pull it in so the package has zero runtime deps.\n *\n * @module\n */\n\nimport type { PeerChannel } from './channel.js'\nimport { fromDataChannel } from './channel.js'\n\ntype PeerConnection = RTCPeerConnection\ntype SessionDescription = RTCSessionDescriptionInit\n\nexport interface WebRTCOptions {\n  /** Optional ICE servers (STUN / TURN). */\n  readonly iceServers?: RTCIceServer[]\n  /** Label for the `RTCDataChannel`. Default `'noydb'`. */\n  readonly label?: string\n}\n\nexport interface Initiator {\n  readonly offer: SessionDescription\n  /** Feed in the remote peer's SDP answer to complete the handshake. */\n  accept(answer: SessionDescription): Promise<void>\n  /** Resolves with the opened `PeerChannel` once the DataChannel is live. */\n  readonly channel: Promise<PeerChannel>\n  readonly connection: PeerConnection\n}\n\nexport interface Responder {\n  readonly answer: SessionDescription\n  /** Resolves with the opened `PeerChannel` once the DataChannel is live. */\n  readonly channel: Promise<PeerChannel>\n  readonly connection: PeerConnection\n}\n\nfunction requireRTC(): typeof RTCPeerConnection {\n  const g = globalThis as { RTCPeerConnection?: typeof RTCPeerConnection }\n  if (!g.RTCPeerConnection) {\n    throw new Error(\n      '[@noy-db/by-peer] globalThis.RTCPeerConnection is undefined — use this module in a browser, or polyfill with @roamhq/wrtc in Node',\n    )\n  }\n  return g.RTCPeerConnection\n}\n\n/**\n * Build an offer as the initiating peer. Returns the SDP offer to send\n * to the remote peer and a promise for the opened `PeerChannel`.\n */\nexport async function createOffer(opts: WebRTCOptions = {}): Promise<Initiator> {\n  const RTC = requireRTC()\n  const pc = new RTC({\n    ...(opts.iceServers && { iceServers: opts.iceServers }),\n  })\n\n  const dc = pc.createDataChannel(opts.label ?? 'noydb', {\n    ordered: true,\n  })\n\n  const channelPromise = new Promise<PeerChannel>((resolve, reject) => {\n    dc.addEventListener('open', () => resolve(fromDataChannel(dc)))\n    dc.addEventListener('error', () => reject(new Error('DataChannel error')))\n  })\n\n  const offer = await pc.createOffer()\n  await pc.setLocalDescription(offer)\n  await waitForIceComplete(pc)\n\n  return {\n    offer: pc.localDescription ?? offer,\n    connection: pc,\n    channel: channelPromise,\n    async accept(answer) {\n      await pc.setRemoteDescription(answer)\n    },\n  }\n}\n\n/**\n * Accept an incoming offer as the responding peer. Returns the SDP\n * answer to send back to the initiator and a promise for the opened\n * `PeerChannel`.\n */\nexport async function acceptOffer(\n  offer: SessionDescription,\n  opts: WebRTCOptions = {},\n): Promise<Responder> {\n  const RTC = requireRTC()\n  const pc = new RTC({\n    ...(opts.iceServers && { iceServers: opts.iceServers }),\n  })\n\n  const channelPromise = new Promise<PeerChannel>((resolve, reject) => {\n    pc.addEventListener('datachannel', (ev) => {\n      const dc = ev.channel\n      if (dc.readyState === 'open') {\n        resolve(fromDataChannel(dc))\n      } else {\n        dc.addEventListener('open', () => resolve(fromDataChannel(dc)))\n        dc.addEventListener('error', () => reject(new Error('DataChannel error')))\n      }\n    })\n  })\n\n  await pc.setRemoteDescription(offer)\n  const answer = await pc.createAnswer()\n  await pc.setLocalDescription(answer)\n  await waitForIceComplete(pc)\n\n  return {\n    answer: pc.localDescription ?? answer,\n    connection: pc,\n    channel: channelPromise,\n  }\n}\n\n/**\n * Resolve once ICE gathering reaches `'complete'`. Using non-trickle ICE\n * keeps the signaling exchange to a single round-trip — at the cost of\n * a slightly longer initial handshake. Consumers that want trickle ICE\n * can bypass this helper and drive `RTCPeerConnection` directly.\n */\nfunction waitForIceComplete(pc: PeerConnection): Promise<void> {\n  if (pc.iceGatheringState === 'complete') return Promise.resolve()\n  return new Promise((resolve) => {\n    const check = () => {\n      if (pc.iceGatheringState === 'complete') {\n        pc.removeEventListener('icegatheringstatechange', check)\n        resolve()\n      }\n    }\n    pc.addEventListener('icegatheringstatechange', check)\n  })\n}\n"],"mappings":";AA2CO,SAAS,eAA2C;AAMzD,WAAS,OAA0E;AACjF,UAAM,YAAuB,EAAE,SAAS,oBAAI,IAAI,GAAG,OAAO,oBAAI,IAAI,EAAE;AACpE,UAAM,SAAS,EAAE,GAAG,MAAM;AAC1B,UAAM,KAAkB;AAAA,MACtB,IAAI,SAAS;AACX,eAAO,CAAC,OAAO;AAAA,MACjB;AAAA,MACA,OAAO;AAAA,MAEP;AAAA,MACA,GAAG,OAA4B,UAAkE;AAC/F,YAAI,UAAU,WAAW;AACvB,oBAAU,QAAQ,IAAI,QAA+B;AACrD,iBAAO,MAAM,UAAU,QAAQ,OAAO,QAA+B;AAAA,QACvE;AACA,kBAAU,MAAM,IAAI,QAAsB;AAC1C,eAAO,MAAM,UAAU,MAAM,OAAO,QAAsB;AAAA,MAC5D;AAAA,MACA,QAAQ;AACN,YAAI,OAAO,EAAG;AACd,eAAO,IAAI;AACX,mBAAW,MAAM,UAAU,MAAO,IAAG;AAAA,MACvC;AAAA,IACF;AACA,WAAO,EAAE,IAAI,WAAW,OAAO;AAAA,EACjC;AAEA,QAAM,IAAI,KAAK;AACf,QAAM,IAAI,KAAK;AAEf,WAAS,YAAkB;AACzB,QAAI,CAAC,EAAE,OAAO,GAAG;AACf,QAAE,OAAO,IAAI;AACb,iBAAW,MAAM,EAAE,UAAU,MAAO,IAAG;AAAA,IACzC;AACA,QAAI,CAAC,EAAE,OAAO,GAAG;AACf,QAAE,OAAO,IAAI;AACb,iBAAW,MAAM,EAAE,UAAU,MAAO,IAAG;AAAA,IACzC;AAAA,EACF;AAEA,IAAE,GAAG,OAAO,CAAC,YAAY;AACvB,QAAI,EAAE,OAAO,EAAG,OAAM,IAAI,MAAM,oBAAoB;AACpD,mBAAe,MAAM;AACnB,iBAAW,MAAM,EAAE,UAAU,QAAS,IAAG,OAAO;AAAA,IAClD,CAAC;AAAA,EACH;AACA,IAAE,GAAG,OAAO,CAAC,YAAY;AACvB,QAAI,EAAE,OAAO,EAAG,OAAM,IAAI,MAAM,oBAAoB;AACpD,mBAAe,MAAM;AACnB,iBAAW,MAAM,EAAE,UAAU,QAAS,IAAG,OAAO;AAAA,IAClD,CAAC;AAAA,EACH;AACA,IAAE,GAAG,QAAQ;AACb,IAAE,GAAG,QAAQ;AAEb,SAAO,CAAC,EAAE,IAAI,EAAE,EAAE;AACpB;AAWO,SAAS,gBAAgB,IAAiC;AAK/D,QAAM,YAAuB,EAAE,SAAS,oBAAI,IAAI,GAAG,OAAO,oBAAI,IAAI,EAAE;AACpE,MAAI,SAAS;AAEb,KAAG,iBAAiB,WAAW,CAAC,OAAqB;AACnD,QAAI,OAAO,GAAG,SAAS,SAAU;AACjC,eAAW,MAAM,UAAU,QAAS,IAAG,GAAG,IAAI;AAAA,EAChD,CAAC;AACD,KAAG,iBAAiB,SAAS,MAAM;AACjC,QAAI,OAAQ;AACZ,aAAS;AACT,eAAW,MAAM,UAAU,MAAO,IAAG;AAAA,EACvC,CAAC;AAED,SAAO;AAAA,IACL,IAAI,SAAS;AACX,aAAO,CAAC,UAAU,GAAG,eAAe;AAAA,IACtC;AAAA,IACA,KAAK,SAAS;AACZ,UAAI,UAAU,GAAG,eAAe,QAAQ;AACtC,cAAM,IAAI,MAAM,qCAAqC,GAAG,UAAU,GAAG;AAAA,MACvE;AACA,SAAG,KAAK,OAAO;AAAA,IACjB;AAAA,IACA,GAAG,OAA4B,UAAkE;AAC/F,UAAI,UAAU,WAAW;AACvB,kBAAU,QAAQ,IAAI,QAA+B;AACrD,eAAO,MAAM,UAAU,QAAQ,OAAO,QAA+B;AAAA,MACvE;AACA,gBAAU,MAAM,IAAI,QAAsB;AAC1C,aAAO,MAAM,UAAU,MAAM,OAAO,QAAsB;AAAA,IAC5D;AAAA,IACA,QAAQ;AACN,UAAI,OAAQ;AACZ,eAAS;AACT,UAAI;AACF,WAAG,MAAM;AAAA,MACX,QAAQ;AAAA,MAER;AACA,iBAAW,MAAM,UAAU,MAAO,IAAG;AAAA,IACvC;AAAA,EACF;AACF;;;ACpHO,SAAS,gBAAgB,SAAsB,OAAyB,CAAC,GAAG;AACjF,QAAM,YAAY,KAAK,aAAa;AAMpC,QAAM,UAAU,oBAAI,IAAqB;AACzC,MAAI,UAAU;AAEd,QAAM,aAAa,QAAQ,GAAG,WAAW,CAAC,YAAY;AACpD,QAAI;AACJ,QAAI;AACF,YAAM,KAAK,MAAM,OAAO;AAAA,IAC1B,QAAQ;AACN;AAAA,IACF;AACA,QAAI,IAAI,MAAM,MAAO;AACrB,UAAM,QAAQ,QAAQ,IAAI,IAAI,EAAE;AAChC,QAAI,CAAC,MAAO;AACZ,iBAAa,MAAM,KAAK;AACxB,YAAQ,OAAO,IAAI,EAAE;AACrB,QAAI,IAAI,IAAI;AACV,YAAM,QAAQ,IAAI,MAAM;AAAA,IAC1B,OAAO;AACL,YAAM,IAAI,IAAI,SAAS,EAAE,MAAM,SAAS,SAAS,uBAAuB;AACxE,YAAM,MAAM,IAAI,MAAM,EAAE,OAAO;AAC/B,UAAI,OAAO,EAAE;AACb,UAAI,OAAO,EAAE,YAAY,UAAU;AACjC;AAAC,QAAC,IAAqC,UAAU,EAAE;AAAA,MACrD;AACA,YAAM,OAAO,GAAG;AAAA,IAClB;AAAA,EACF,CAAC;AAED,QAAM,WAAW,QAAQ,GAAG,SAAS,MAAM;AACzC,eAAW,CAAC,EAAE,KAAK,KAAK,SAAS;AAC/B,mBAAa,MAAM,KAAK;AACxB,YAAM,OAAO,IAAI,MAAM,oCAAoC,CAAC;AAAA,IAC9D;AACA,YAAQ,MAAM;AAAA,EAChB,CAAC;AAED,SAAO;AAAA,IACL,MAAM,KAAkB,QAAgB,MAAsC;AAC5E,YAAM,KAAK,GAAG,KAAK,IAAI,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;AACjE,YAAM,MAAkB,EAAE,GAAG,OAAO,IAAI,QAAQ,KAAK;AACrD,aAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACzC,cAAM,QAAQ,WAAW,MAAM;AAC7B,kBAAQ,OAAO,EAAE;AACjB,iBAAO,IAAI,MAAM,OAAO,MAAM,oBAAoB,SAAS,IAAI,CAAC;AAAA,QAClE,GAAG,SAAS;AACZ,gBAAQ,IAAI,IAAI;AAAA,UACd;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AACD,YAAI;AACF,kBAAQ,KAAK,KAAK,UAAU,GAAG,CAAC;AAAA,QAClC,SAAS,KAAK;AACZ,uBAAa,KAAK;AAClB,kBAAQ,OAAO,EAAE;AACjB,iBAAO,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAAA,QAC5D;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA,UAAU;AACR,iBAAW;AACX,eAAS;AACT,iBAAW,CAAC,EAAE,KAAK,KAAK,SAAS;AAC/B,qBAAa,MAAM,KAAK;AACxB,cAAM,OAAO,IAAI,MAAM,qBAAqB,CAAC;AAAA,MAC/C;AACA,cAAQ,MAAM;AAAA,IAChB;AAAA,EACF;AACF;AAGO,SAAS,SAAS,SAAsB,SAAiC;AAC9E,iBAAe,OAAO,SAAgC;AACpD,QAAI;AACJ,QAAI;AACF,YAAM,KAAK,MAAM,OAAO;AAAA,IAC1B,QAAQ;AACN;AAAA,IACF;AACA,QAAI,IAAI,MAAM,MAAO;AAErB,QAAI;AACJ,QAAI;AACF,YAAM,SAAS,MAAM,QAAQ,IAAI,QAAQ,IAAI,IAAI;AACjD,iBAAW,EAAE,GAAG,OAAO,IAAI,IAAI,IAAI,IAAI,MAAM,OAAO;AAAA,IACtD,SAAS,KAAK;AACZ,YAAM,IAAI;AACV,iBAAW;AAAA,QACT,GAAG;AAAA,QACH,IAAI,IAAI;AAAA,QACR,IAAI;AAAA,QACJ,OAAO;AAAA,UACL,MAAM,EAAE,QAAQ;AAAA,UAChB,SAAS,EAAE,WAAW,OAAO,GAAG;AAAA,UAChC,GAAI,OAAO,EAAE,YAAY,YAAY,EAAE,SAAS,EAAE,QAAQ;AAAA,QAC5D;AAAA,MACF;AAAA,IACF;AAEA,QAAI,CAAC,QAAQ,OAAQ;AACrB,QAAI;AACF,cAAQ,KAAK,KAAK,UAAU,QAAQ,CAAC;AAAA,IACvC,QAAQ;AAAA,IAER;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,GAAG,WAAW,CAAC,YAAY;AACpD,SAAK,OAAO,OAAO;AAAA,EACrB,CAAC;AAED,SAAO,MAAM,WAAW;AAC1B;;;ACvJA,SAAS,qBAAqB;AAkBvB,SAAS,UAAU,MAA8D;AACtF,QAAM,MAAM,gBAAgB,KAAK,SAAS,EAAE,WAAW,KAAK,aAAa,IAAO,CAAC;AAEjF,iBAAe,KAAQ,QAAgB,MAAsC;AAC3E,QAAI;AACF,aAAO,MAAM,IAAI,KAAQ,QAAQ,IAAI;AAAA,IACvC,SAAS,KAAK;AAEZ,YAAM,IAAI;AACV,UAAI,EAAE,SAAS,mBAAmB,OAAO,EAAE,YAAY,UAAU;AAC/D,cAAM,IAAI,cAAc,EAAE,SAAS,EAAE,OAAO;AAAA,MAC9C;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM,KAAK,QAAQ;AAAA,IAEnB,MAAM,IAAI,OAAO,YAAY,IAAI;AAC/B,aAAO,KAA+B,OAAO,CAAC,OAAO,YAAY,EAAE,CAAC;AAAA,IACtE;AAAA,IAEA,MAAM,IAAI,OAAO,YAAY,IAAI,UAAU,iBAAiB;AAC1D,YAAM,KAAW,OAAO,CAAC,OAAO,YAAY,IAAI,UAAU,eAAe,CAAC;AAAA,IAC5E;AAAA,IAEA,MAAM,OAAO,OAAO,YAAY,IAAI;AAClC,YAAM,KAAW,UAAU,CAAC,OAAO,YAAY,EAAE,CAAC;AAAA,IACpD;AAAA,IAEA,MAAM,KAAK,OAAO,YAAY;AAC5B,aAAO,KAAe,QAAQ,CAAC,OAAO,UAAU,CAAC;AAAA,IACnD;AAAA,IAEA,MAAM,QAAQ,OAAO;AACnB,aAAO,KAAoB,WAAW,CAAC,KAAK,CAAC;AAAA,IAC/C;AAAA,IAEA,MAAM,QAAQ,OAAO,MAAM;AACzB,YAAM,KAAW,WAAW,CAAC,OAAO,IAAI,CAAC;AAAA,IAC3C;AAAA,IAEA,MAAM,OAAO;AACX,UAAI;AACF,eAAO,MAAM,KAAc,QAAQ,CAAC,CAAC;AAAA,MACvC,QAAQ;AACN,eAAO;AAAA,MACT;AAAA,IACF;AAAA,IAEA,UAAU;AACR,UAAI,QAAQ;AAAA,IACd;AAAA,EACF;AACF;;;ACfA,IAAM,eAAe,oBAAI,IAAY;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAaM,SAAS,eAAe,MAAyC;AACtE,MAAI,CAAC,KAAK,gBAAgB;AACxB,WAAO,aAAa,IAAI;AAAA,EAC1B;AACA,SAAO,+BAA+B,IAAI;AAC5C;AAMA,SAAS,aAAa,MAAyC;AAC7D,QAAM,EAAE,OAAO,SAAS,MAAM,IAAI;AAElC,SAAO,SAAS,SAAS,OAAO,QAAQ,SAAS;AAC/C,QAAI,CAAC,aAAa,IAAI,MAAM,GAAG;AAC7B,YAAM,IAAI,MAAM,uBAAuB,MAAM,EAAE;AAAA,IACjD;AACA,QAAI,SAAS,CAAC,MAAM,IAAI,MAAM,GAAG;AAC/B,YAAM,IAAI,MAAM,uBAAuB,MAAM,EAAE;AAAA,IACjD;AAEA,YAAQ,QAAQ;AAAA,MACd,KAAK,OAAO;AACV,cAAM,CAAC,OAAO,YAAY,EAAE,IAAI;AAChC,eAAO,MAAM,IAAI,OAAO,YAAY,EAAE;AAAA,MACxC;AAAA,MACA,KAAK,OAAO;AACV,cAAM,CAAC,OAAO,YAAY,IAAI,UAAU,eAAe,IAAI;AAO3D,cAAM,MAAM,IAAI,OAAO,YAAY,IAAI,UAAU,eAAe;AAChE,eAAO;AAAA,MACT;AAAA,MACA,KAAK,UAAU;AACb,cAAM,CAAC,OAAO,YAAY,EAAE,IAAI;AAChC,cAAM,MAAM,OAAO,OAAO,YAAY,EAAE;AACxC,eAAO;AAAA,MACT;AAAA,MACA,KAAK,QAAQ;AACX,cAAM,CAAC,OAAO,UAAU,IAAI;AAC5B,eAAO,MAAM,KAAK,OAAO,UAAU;AAAA,MACrC;AAAA,MACA,KAAK,WAAW;AACd,cAAM,CAAC,KAAK,IAAI;AAChB,eAAO,MAAM,QAAQ,KAAK;AAAA,MAC5B;AAAA,MACA,KAAK,WAAW;AACd,cAAM,CAAC,OAAO,IAAI,IAAI;AACtB,cAAM,MAAM,QAAQ,OAAO,IAAI;AAC/B,eAAO;AAAA,MACT;AAAA,MACA,KAAK,QAAQ;AACX,YAAI,CAAC,MAAM,KAAM,QAAO;AACxB,eAAO,MAAM,KAAK;AAAA,MACpB;AAAA,MACA,KAAK,aAAa;AAChB,YAAI,CAAC,MAAM,UAAW,OAAM,IAAI,MAAM,yCAAyC;AAC/E,cAAM,CAAC,OAAO,YAAY,KAAK,IAAI;AACnC,eAAO,MAAM,UAAU,OAAO,YAAY,KAAK;AAAA,MACjD;AAAA,MACA,KAAK,YAAY;AACf,YAAI,CAAC,MAAM,SAAU,OAAM,IAAI,MAAM,wCAAwC;AAC7E,cAAM,CAAC,OAAO,YAAY,QAAQ,KAAK,IAAI;AAM3C,eAAO,MAAM,SAAS,OAAO,YAAY,QAAQ,KAAK;AAAA,MACxD;AAAA,MACA,KAAK,cAAc;AACjB,YAAI,CAAC,MAAM,WAAY,OAAM,IAAI,MAAM,0CAA0C;AACjF,eAAO,MAAM,WAAW;AAAA,MAC1B;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,qBAAqB,MAAM,EAAE;AAAA,EAC/C,CAAC;AACH;AAOA,SAAS,+BAA+B,MAAyC;AAE/E,QAAM,SAAS,KAAK;AACpB,QAAM,QAAQ,OAAO,SAAS,gBAAgB;AAC9C,QAAM,KAAK,IAAI,gBAAgB;AAC/B,MAAI,cAAmC;AACvC,MAAI,cAAmC;AACvC,MAAI,WAAW;AAEf,OAAK,MACF,QAAQ,OAAO,UAAU,EAAE,MAAM,aAAa,QAAQ,GAAG,OAAO,GAAG,MAAM;AACxE,QAAI,SAAU,QAAO,QAAQ,QAAQ;AACrC,kBAAc,aAAa,IAAI;AAI/B,WAAO,IAAI,QAAc,CAAC,YAAY;AACpC,oBAAc;AAAA,IAChB,CAAC;AAAA,EACH,CAAC,EACA,MAAM,CAAC,QAAiB;AAIvB,QAAK,KAAkC,SAAS,aAAc;AAC9D,mBAAe,MAAM;AACnB,YAAM;AAAA,IACR,CAAC;AAAA,EACH,CAAC;AAEH,SAAO,MAAM;AACX,QAAI,SAAU;AACd,eAAW;AACX,QAAI,aAAa;AACf,kBAAY;AACZ,oBAAc;AAAA,IAChB;AACA,QAAI,aAAa;AACf,kBAAY;AACZ,oBAAc;AAAA,IAChB,OAAO;AACL,SAAG,MAAM;AAAA,IACX;AAAA,EACF;AACF;AAEA,SAAS,kBAAsC;AAC7C,QAAM,MAAO,WAA8D;AAC3E,MAAI,OAAO,IAAI,MAAO,QAAO,IAAI;AACjC,QAAM,IAAI;AAAA,IACR;AAAA,EAGF;AACF;;;ACtLA,SAAS,aAAuC;AAC9C,QAAM,IAAI;AACV,MAAI,CAAC,EAAE,mBAAmB;AACxB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO,EAAE;AACX;AAMA,eAAsB,YAAY,OAAsB,CAAC,GAAuB;AAC9E,QAAM,MAAM,WAAW;AACvB,QAAM,KAAK,IAAI,IAAI;AAAA,IACjB,GAAI,KAAK,cAAc,EAAE,YAAY,KAAK,WAAW;AAAA,EACvD,CAAC;AAED,QAAM,KAAK,GAAG,kBAAkB,KAAK,SAAS,SAAS;AAAA,IACrD,SAAS;AAAA,EACX,CAAC;AAED,QAAM,iBAAiB,IAAI,QAAqB,CAAC,SAAS,WAAW;AACnE,OAAG,iBAAiB,QAAQ,MAAM,QAAQ,gBAAgB,EAAE,CAAC,CAAC;AAC9D,OAAG,iBAAiB,SAAS,MAAM,OAAO,IAAI,MAAM,mBAAmB,CAAC,CAAC;AAAA,EAC3E,CAAC;AAED,QAAM,QAAQ,MAAM,GAAG,YAAY;AACnC,QAAM,GAAG,oBAAoB,KAAK;AAClC,QAAM,mBAAmB,EAAE;AAE3B,SAAO;AAAA,IACL,OAAO,GAAG,oBAAoB;AAAA,IAC9B,YAAY;AAAA,IACZ,SAAS;AAAA,IACT,MAAM,OAAO,QAAQ;AACnB,YAAM,GAAG,qBAAqB,MAAM;AAAA,IACtC;AAAA,EACF;AACF;AAOA,eAAsB,YACpB,OACA,OAAsB,CAAC,GACH;AACpB,QAAM,MAAM,WAAW;AACvB,QAAM,KAAK,IAAI,IAAI;AAAA,IACjB,GAAI,KAAK,cAAc,EAAE,YAAY,KAAK,WAAW;AAAA,EACvD,CAAC;AAED,QAAM,iBAAiB,IAAI,QAAqB,CAAC,SAAS,WAAW;AACnE,OAAG,iBAAiB,eAAe,CAAC,OAAO;AACzC,YAAM,KAAK,GAAG;AACd,UAAI,GAAG,eAAe,QAAQ;AAC5B,gBAAQ,gBAAgB,EAAE,CAAC;AAAA,MAC7B,OAAO;AACL,WAAG,iBAAiB,QAAQ,MAAM,QAAQ,gBAAgB,EAAE,CAAC,CAAC;AAC9D,WAAG,iBAAiB,SAAS,MAAM,OAAO,IAAI,MAAM,mBAAmB,CAAC,CAAC;AAAA,MAC3E;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAED,QAAM,GAAG,qBAAqB,KAAK;AACnC,QAAM,SAAS,MAAM,GAAG,aAAa;AACrC,QAAM,GAAG,oBAAoB,MAAM;AACnC,QAAM,mBAAmB,EAAE;AAE3B,SAAO;AAAA,IACL,QAAQ,GAAG,oBAAoB;AAAA,IAC/B,YAAY;AAAA,IACZ,SAAS;AAAA,EACX;AACF;AAQA,SAAS,mBAAmB,IAAmC;AAC7D,MAAI,GAAG,sBAAsB,WAAY,QAAO,QAAQ,QAAQ;AAChE,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,QAAQ,MAAM;AAClB,UAAI,GAAG,sBAAsB,YAAY;AACvC,WAAG,oBAAoB,2BAA2B,KAAK;AACvD,gBAAQ;AAAA,MACV;AAAA,IACF;AACA,OAAG,iBAAiB,2BAA2B,KAAK;AAAA,EACtD,CAAC;AACH;","names":[]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@noy-db/by-peer",
+  "version": "0.1.0-pre.10",
+  "description": "WebRTC peer-to-peer transport for noy-db — direct browser-to-browser channel with signaling-agnostic handshake",
+  "license": "MIT",
+  "author": "vLannaAi <vicio@lanna.ai>",
+  "homepage": "https://github.com/vLannaAi/noy-db/tree/main/packages/by-peer#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vLannaAi/noy-db.git",
+    "directory": "packages/by-peer"
+  },
+  "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.10"
+  },
+  "devDependencies": {
+    "@noy-db/hub": "0.1.0-pre.10",
+    "@noy-db/to-memory": "0.1.0-pre.10"
+  },
+  "keywords": [
+    "noy-db",
+    "by-peer",
+    "p2p",
+    "webrtc",
+    "realtime",
+    "sync",
+    "peer-to-peer",
+    "encryption",
+    "zero-knowledge"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}