trellis 3.1.35 → 3.2.2

package/dist/sync/index.js

@@ -0,0 +1,617 @@
+import {
+  DEFAULT_SNAPSHOT_MAX_OPS,
+  MAX_SUPPORTED_VERSION,
+  MIN_SUPPORTED_VERSION,
+  PROTOCOL_VERSION,
+  PartyKitRoomTransport,
+  SyncEngine,
+  SyncRoomCore,
+  TrellisVcsSyncPeer
+} from "../chunk-RSWUFTO2.js";
+import {
+  findForkPoint,
+  init_reconciler,
+  reconcile
+} from "../chunk-4HYPLFJD.js";
+import "../chunk-GLM4HGN4.js";
+import "../chunk-KFQGP6VL.js";
+
+// src/sync/index.ts
+init_reconciler();
+
+// src/sync/memory-transport.ts
+var MemoryTransport = class {
+  peerId;
+  peerName;
+  handlers = [];
+  connectedPeers = /* @__PURE__ */ new Map();
+  constructor(peerId, peerName = peerId) {
+    this.peerId = peerId;
+    this.peerName = peerName;
+  }
+  /**
+   * Connect two transports so they can exchange messages.
+   */
+  static connect(a, b) {
+    a.connectedPeers.set(b.peerId, b);
+    b.connectedPeers.set(a.peerId, a);
+  }
+  /**
+   * Disconnect two transports.
+   */
+  static disconnect(a, b) {
+    a.connectedPeers.delete(b.peerId);
+    b.connectedPeers.delete(a.peerId);
+  }
+  async send(peerId, message) {
+    const peer = this.connectedPeers.get(peerId);
+    if (!peer) {
+      throw new Error(`Peer not connected: ${peerId}`);
+    }
+    for (const handler of peer.handlers) {
+      await handler(message);
+    }
+  }
+  onMessage(handler) {
+    this.handlers.push(handler);
+  }
+  peers() {
+    return [...this.connectedPeers.entries()].map(([id, transport]) => ({
+      id,
+      name: transport.peerName
+    }));
+  }
+  getPeerId() {
+    return this.peerId;
+  }
+};
+
+// src/sync/memory-room.ts
+var MemorySyncRoom = class {
+  core;
+  transports = /* @__PURE__ */ new Map();
+  constructor(roomId = "room", roomName = roomId) {
+    this.core = new SyncRoomCore(roomId, roomName);
+  }
+  connectPeer(peerId, peerName = peerId) {
+    this.core.connectPeer(peerId, peerName);
+    const transport = new MemoryRoomTransport(this, peerId, peerName);
+    this.transports.set(peerId, transport);
+    return transport;
+  }
+  disconnectPeer(peerId) {
+    this.core.disconnectPeer(peerId);
+    this.transports.delete(peerId);
+  }
+  getRoomPeer() {
+    return this.core.getRoomPeer();
+  }
+  peersFor(peerId) {
+    return this.core.peersFor(peerId);
+  }
+  getOps() {
+    return this.core.getOps();
+  }
+  getOpCount() {
+    return this.core.getOpCount();
+  }
+  async receive(fromPeerId, message) {
+    const deliveries = await this.core.receive(fromPeerId, message);
+    for (const delivery of deliveries) {
+      await this.deliver(delivery.peerId, delivery.message);
+    }
+  }
+  async deliver(peerId, message) {
+    const transport = this.transports.get(peerId);
+    if (!transport) {
+      throw new Error(`Peer not connected to room: ${peerId}`);
+    }
+    await transport.deliver(message);
+  }
+};
+var MemoryRoomTransport = class {
+  room;
+  peerId;
+  peerName;
+  handlers = [];
+  constructor(room, peerId, peerName = peerId) {
+    this.room = room;
+    this.peerId = peerId;
+    this.peerName = peerName;
+  }
+  async send(peerId, message) {
+    if (peerId !== this.room.getRoomPeer().id) {
+      throw new Error(`Peer not connected through room: ${peerId}`);
+    }
+    await this.room.receive(this.peerId, message);
+  }
+  onMessage(handler) {
+    this.handlers.push(handler);
+  }
+  peers() {
+    return this.room.peersFor(this.peerId);
+  }
+  getPeerId() {
+    return this.peerId;
+  }
+  getPeerName() {
+    return this.peerName;
+  }
+  async deliver(message) {
+    for (const handler of this.handlers) {
+      await handler(message);
+    }
+  }
+};
+
+// src/sync/sync-room-server.ts
+var SyncRoomServer = class {
+  core;
+  connections = /* @__PURE__ */ new Map();
+  welcomeSnapshot;
+  welcomeSnapshotMaxOps;
+  constructor(opts = {}) {
+    this.core = new SyncRoomCore(opts.roomId, opts.roomName);
+    this.welcomeSnapshot = opts.welcomeSnapshot !== false;
+    this.welcomeSnapshotMaxOps = opts.welcomeSnapshotMaxOps ?? DEFAULT_SNAPSHOT_MAX_OPS;
+  }
+  getRoomId() {
+    return this.core.getRoomPeer().id;
+  }
+  getOpCount() {
+    return this.core.getOpCount();
+  }
+  getOps() {
+    return this.core.getOps();
+  }
+  buildSnapshot(maxOps) {
+    return this.core.buildSnapshot(maxOps);
+  }
+  /** Register a connected peer and optionally send a welcome snapshot. */
+  async connect(conn) {
+    this.core.connectPeer(conn.peerId);
+    this.connections.set(conn.peerId, conn);
+    if (this.welcomeSnapshot) {
+      await this.sendSnapshot(conn.peerId, this.welcomeSnapshotMaxOps);
+    }
+  }
+  disconnect(peerId) {
+    this.core.disconnectPeer(peerId);
+    this.connections.delete(peerId);
+  }
+  /** Route an inbound sync message from a peer. */
+  async handleMessage(fromPeerId, message) {
+    const deliveries = await this.core.receive(fromPeerId, message);
+    await this.deliverAll(deliveries);
+  }
+  /** Push a tail snapshot to a peer without an inbound message. */
+  async sendSnapshot(peerId, maxOps = DEFAULT_SNAPSHOT_MAX_OPS) {
+    const deliveries = this.core.snapshotDeliveries(peerId, maxOps);
+    await this.deliverAll(deliveries);
+  }
+  async deliverAll(deliveries) {
+    for (const delivery of deliveries) {
+      const conn = this.connections.get(delivery.peerId);
+      if (!conn) continue;
+      await conn.send(delivery.message);
+    }
+  }
+};
+
+// src/sync/partykit-room.ts
+function createPartyKitRoomHandler(opts = {}) {
+  function getState(room) {
+    const bag = room;
+    if (!bag.trellis) {
+      bag.trellis = {
+        server: new SyncRoomServer({
+          roomId: "room",
+          roomName: room.id,
+          welcomeSnapshot: opts.welcomeSnapshot,
+          welcomeSnapshotMaxOps: opts.welcomeSnapshotMaxOps
+        })
+      };
+    }
+    return bag.trellis;
+  }
+  function peerIdFromConnection(connection, requestUrl) {
+    if (requestUrl) {
+      try {
+        const peer = new URL(requestUrl).searchParams.get("peerId");
+        if (peer) return peer;
+      } catch {
+      }
+    }
+    return connection.id;
+  }
+  return {
+    async onConnect(connection, room, request) {
+      const { server } = getState(room);
+      const peerId = peerIdFromConnection(connection, request?.url);
+      const conn = {
+        peerId,
+        send(message) {
+          connection.send(JSON.stringify(message));
+        }
+      };
+      await server.connect(conn);
+    },
+    async onMessage(message, connection, room, request) {
+      const { server } = getState(room);
+      const peerId = peerIdFromConnection(connection, request?.url);
+      const raw = typeof message === "string" ? message : new TextDecoder().decode(message);
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      if (!parsed || typeof parsed.type !== "string") return;
+      await server.handleMessage(peerId, parsed);
+    },
+    onClose(connection, room, request) {
+      const { server } = getState(room);
+      const peerId = peerIdFromConnection(connection, request?.url);
+      server.disconnect(peerId);
+    }
+  };
+}
+
+// src/sync/http-transport.ts
+var HttpSyncTransport = class {
+  localPeerId;
+  peerUrls = /* @__PURE__ */ new Map();
+  messageHandler = null;
+  knownPeers = /* @__PURE__ */ new Map();
+  constructor(localPeerId) {
+    this.localPeerId = localPeerId;
+  }
+  /**
+   * Add a remote peer by URL (e.g. "http://192.168.1.10:4200").
+   */
+  addPeer(peerId, url, name) {
+    this.peerUrls.set(peerId, url);
+    this.knownPeers.set(peerId, {
+      id: peerId,
+      name: name ?? peerId,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Remove a remote peer.
+   */
+  removePeer(peerId) {
+    this.peerUrls.delete(peerId);
+    this.knownPeers.delete(peerId);
+  }
+  async send(peerId, message) {
+    const url = this.peerUrls.get(peerId);
+    if (!url) throw new Error(`Unknown peer "${peerId}". Add it with addPeer() first.`);
+    const resp = await fetch(`${url}/sync/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    if (!resp.ok) {
+      throw new Error(`Sync message to ${peerId} failed: ${resp.status} ${resp.statusText}`);
+    }
+    const contentType = resp.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      const reply = await resp.json();
+      if (reply && reply.type && this.messageHandler) {
+        await this.messageHandler(reply);
+      }
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  /**
+   * Receive a message (called by the HTTP server handler).
+   */
+  async receiveMessage(message) {
+    this.knownPeers.set(message.peerId, {
+      id: message.peerId,
+      name: message.peerId,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.messageHandler) {
+      await this.messageHandler(message);
+    }
+  }
+  peers() {
+    return [...this.knownPeers.values()];
+  }
+  getLocalPeerId() {
+    return this.localPeerId;
+  }
+};
+function createSyncHandler(transport) {
+  return (req) => {
+    const url = new URL(req.url);
+    if (url.pathname === "/sync/message" && req.method === "POST") {
+      return new Response(
+        req.json().then(async (body) => {
+          await transport.receiveMessage(body);
+          return JSON.stringify({ ok: true });
+        }),
+        { headers: { "Content-Type": "application/json" } }
+      );
+    }
+    if (url.pathname === "/sync/peers" && req.method === "GET") {
+      return new Response(
+        JSON.stringify({
+          localPeerId: transport.getLocalPeerId(),
+          peers: transport.peers()
+        }),
+        { headers: { "Content-Type": "application/json" } }
+      );
+    }
+    return null;
+  };
+}
+
+// src/sync/ws-transport.ts
+var WebSocketSyncTransport = class {
+  localPeerId;
+  connections = /* @__PURE__ */ new Map();
+  knownPeers = /* @__PURE__ */ new Map();
+  messageHandler = null;
+  constructor(localPeerId) {
+    this.localPeerId = localPeerId;
+  }
+  /**
+   * Connect to a remote peer's WebSocket endpoint.
+   */
+  async connect(peerId, url, name) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      ws.onopen = () => {
+        this.connections.set(peerId, ws);
+        this.knownPeers.set(peerId, {
+          id: peerId,
+          name: name ?? peerId,
+          lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        resolve();
+      };
+      ws.onmessage = async (event) => {
+        try {
+          const msg = JSON.parse(String(event.data));
+          this.knownPeers.set(msg.peerId, {
+            id: msg.peerId,
+            name: msg.peerId,
+            lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (this.messageHandler) {
+            await this.messageHandler(msg);
+          }
+        } catch {
+        }
+      };
+      ws.onclose = () => {
+        this.connections.delete(peerId);
+      };
+      ws.onerror = (err) => {
+        reject(new Error(`WebSocket connection to ${peerId} failed`));
+      };
+    });
+  }
+  /**
+   * Accept an incoming WebSocket connection (server side).
+   */
+  acceptConnection(peerId, ws) {
+    this.connections.set(peerId, ws);
+    this.knownPeers.set(peerId, {
+      id: peerId,
+      name: peerId,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    ws.onmessage = async (event) => {
+      try {
+        const msg = JSON.parse(String(event.data));
+        this.knownPeers.set(msg.peerId, {
+          id: msg.peerId,
+          name: msg.peerId,
+          lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (this.messageHandler) {
+          await this.messageHandler(msg);
+        }
+      } catch {
+      }
+    };
+    ws.onclose = () => {
+      this.connections.delete(peerId);
+    };
+  }
+  async send(peerId, message) {
+    const ws = this.connections.get(peerId);
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      throw new Error(`No open connection to peer "${peerId}".`);
+    }
+    ws.send(JSON.stringify(message));
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  peers() {
+    return [...this.knownPeers.values()];
+  }
+  /**
+   * Disconnect from a peer.
+   */
+  disconnect(peerId) {
+    const ws = this.connections.get(peerId);
+    if (ws) {
+      ws.close();
+      this.connections.delete(peerId);
+    }
+  }
+  /**
+   * Disconnect from all peers.
+   */
+  disconnectAll() {
+    for (const [id, ws] of this.connections) {
+      ws.close();
+    }
+    this.connections.clear();
+  }
+  /**
+   * Check if connected to a specific peer.
+   */
+  isConnected(peerId) {
+    const ws = this.connections.get(peerId);
+    return ws !== void 0 && ws.readyState === WebSocket.OPEN;
+  }
+  getLocalPeerId() {
+    return this.localPeerId;
+  }
+};
+
+// src/sync/multi-repo.ts
+var MultiRepoManager = class {
+  kernel;
+  constructor(kernel) {
+    this.kernel = kernel;
+  }
+  /**
+   * Link a remote repository.
+   */
+  async linkRepo(alias, location, description) {
+    const id = `repo:${alias}`;
+    const existing = this.kernel.getEntity(id);
+    if (existing) {
+      throw new Error(`Repo alias "${alias}" is already linked to "${existing.facts.find((f) => f.a === "location")?.v}".`);
+    }
+    await this.kernel.createEntity(id, "LinkedRepo", {
+      alias,
+      location,
+      ...description ? { description } : {},
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Unlink a remote repository.
+   */
+  async unlinkRepo(alias) {
+    const id = `repo:${alias}`;
+    await this.kernel.deleteEntity(id);
+  }
+  /**
+   * List all linked repos.
+   */
+  listLinkedRepos() {
+    const entities = this.kernel.listEntities("LinkedRepo");
+    return entities.map((e) => {
+      const get = (a) => e.facts.find((f) => f.a === a)?.v;
+      return {
+        alias: String(get("alias") ?? ""),
+        location: String(get("location") ?? ""),
+        description: get("description"),
+        linkedAt: String(get("linkedAt") ?? ""),
+        lastSyncedAt: get("lastSyncedAt")
+      };
+    });
+  }
+  /**
+   * Get a linked repo by alias.
+   */
+  getLinkedRepo(alias) {
+    const entity = this.kernel.getEntity(`repo:${alias}`);
+    if (!entity) return null;
+    const get = (a) => entity.facts.find((f) => f.a === a)?.v;
+    return {
+      alias: String(get("alias") ?? ""),
+      location: String(get("location") ?? ""),
+      description: get("description"),
+      linkedAt: String(get("linkedAt") ?? ""),
+      lastSyncedAt: get("lastSyncedAt")
+    };
+  }
+  /**
+   * Create a cross-repo link: entity in this repo → entity in remote repo.
+   */
+  async addCrossRepoLink(sourceEntityId, attribute, targetRepoAlias, targetEntityId) {
+    const repo = this.getLinkedRepo(targetRepoAlias);
+    if (!repo) {
+      throw new Error(`Repo alias "${targetRepoAlias}" is not linked. Use linkRepo() first.`);
+    }
+    const crossRef = `@${targetRepoAlias}:${targetEntityId}`;
+    await this.kernel.addLink(sourceEntityId, attribute, crossRef);
+  }
+  /**
+   * Remove a cross-repo link.
+   */
+  async removeCrossRepoLink(sourceEntityId, attribute, targetRepoAlias, targetEntityId) {
+    const crossRef = `@${targetRepoAlias}:${targetEntityId}`;
+    await this.kernel.removeLink(sourceEntityId, attribute, crossRef);
+  }
+  /**
+   * Find all cross-repo references from a given entity.
+   */
+  getCrossRepoLinks(entityId) {
+    const store = this.kernel.getStore();
+    const links = store.getLinksByEntity(entityId);
+    const results = [];
+    for (const link of links) {
+      if (link.e1 !== entityId) continue;
+      const parsed = parseCrossRepoRef(link.e2);
+      if (parsed) {
+        results.push({ attribute: link.a, ref: parsed });
+      }
+    }
+    return results;
+  }
+  /**
+   * Find all cross-repo references pointing to a specific remote entity.
+   */
+  findReferencesTo(repoAlias, entityId) {
+    const crossRef = `@${repoAlias}:${entityId}`;
+    const store = this.kernel.getStore();
+    return store.getAllLinks().filter((l) => l.e2 === crossRef);
+  }
+  /**
+   * Update the lastSyncedAt timestamp for a linked repo.
+   */
+  async markSynced(alias) {
+    await this.kernel.updateEntity(`repo:${alias}`, {
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+function parseCrossRepoRef(ref) {
+  if (!ref.startsWith("@")) return null;
+  const colonIdx = ref.indexOf(":", 1);
+  if (colonIdx === -1) return null;
+  return {
+    repoAlias: ref.slice(1, colonIdx),
+    entityId: ref.slice(colonIdx + 1)
+  };
+}
+function formatCrossRepoRef(repoAlias, entityId) {
+  return `@${repoAlias}:${entityId}`;
+}
+export {
+  DEFAULT_SNAPSHOT_MAX_OPS,
+  HttpSyncTransport,
+  MAX_SUPPORTED_VERSION,
+  MIN_SUPPORTED_VERSION,
+  MemoryRoomTransport,
+  MemorySyncRoom,
+  MemoryTransport,
+  MultiRepoManager,
+  PROTOCOL_VERSION,
+  PartyKitRoomTransport,
+  SyncEngine,
+  SyncRoomCore,
+  SyncRoomServer,
+  TrellisVcsSyncPeer,
+  WebSocketSyncTransport,
+  createPartyKitRoomHandler,
+  createSyncHandler,
+  findForkPoint,
+  formatCrossRepoRef,
+  parseCrossRepoRef,
+  reconcile
+};

package/dist/sync/memory-room.d.ts

@@ -0,0 +1,37 @@
+import type { PeerId, SyncMessage, SyncMessageHandler, SyncTransport } from './types.js';
+import { type SyncRoomAppendRejection, type SyncRoomAppendResult } from './room-core.js';
+export type MemorySyncRoomAppendRejection = SyncRoomAppendRejection;
+export type MemorySyncRoomAppendResult = SyncRoomAppendResult;
+/**
+ * In-process room relay that models a PartyKit room for sync tests.
+ *
+ * The room keeps a canonical catch-up log, asks clients for missing ops,
+ * serves catch-up requests, and broadcasts newly accepted ops.
+ */
+export declare class MemorySyncRoom {
+    private core;
+    private transports;
+    constructor(roomId?: string, roomName?: string);
+    connectPeer(peerId: string, peerName?: string): MemoryRoomTransport;
+    disconnectPeer(peerId: string): void;
+    getRoomPeer(): PeerId;
+    peersFor(peerId: string): PeerId[];
+    getOps(): import("../index.js").VcsOp[];
+    getOpCount(): number;
+    receive(fromPeerId: string, message: SyncMessage): Promise<void>;
+    private deliver;
+}
+export declare class MemoryRoomTransport implements SyncTransport {
+    private room;
+    private peerId;
+    private peerName;
+    private handlers;
+    constructor(room: MemorySyncRoom, peerId: string, peerName?: string);
+    send(peerId: string, message: SyncMessage): Promise<void>;
+    onMessage(handler: SyncMessageHandler): void;
+    peers(): PeerId[];
+    getPeerId(): string;
+    getPeerName(): string;
+    deliver(message: SyncMessage): Promise<void>;
+}
+//# sourceMappingURL=memory-room.d.ts.map

package/dist/sync/memory-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-room.d.ts","sourceRoot":"","sources":["../../src/sync/memory-room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,WAAW,EACX,kBAAkB,EAClB,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,6BAA6B,GAAG,uBAAuB,CAAC;AACpE,MAAM,MAAM,0BAA0B,GAAG,oBAAoB,CAAC;AAE9D;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,UAAU,CAA0C;gBAEhD,MAAM,SAAS,EAAE,QAAQ,SAAS;IAI9C,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAS,GAAG,mBAAmB;IAOnE,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKpC,WAAW,IAAI,MAAM;IAIrB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAIlC,MAAM;IAIN,UAAU,IAAI,MAAM;IAId,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;YAOxD,OAAO;CAOtB;AAED,qBAAa,mBAAoB,YAAW,aAAa;IACvD,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAA4B;gBAEhC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAS;IAM7D,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/D,SAAS,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAI5C,KAAK,IAAI,MAAM,EAAE;IAIjB,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;IAIf,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAKnD"}

package/dist/sync/memory-transport.d.ts

@@ -2,9 +2,9 @@
  * In-Memory Sync Transport
  *
  * A simple in-memory transport for testing and local multi-engine sync.
- * Messages are delivered synchronously between connected peers.
+ * Messages are delivered in-process and await each peer handler.
  */
-import type { SyncTransport, SyncMessage, PeerId } from './types.js';
+import type { SyncTransport, SyncMessage, SyncMessageHandler, PeerId } from './types.js';
 export declare class MemoryTransport implements SyncTransport {
     private peerId;
     private peerName;
@@ -20,7 +20,7 @@ export declare class MemoryTransport implements SyncTransport {
      */
     static disconnect(a: MemoryTransport, b: MemoryTransport): void;
     send(peerId: string, message: SyncMessage): Promise<void>;
-    onMessage(handler: (message: SyncMessage) => void): void;
+    onMessage(handler: SyncMessageHandler): void;
     peers(): PeerId[];
     getPeerId(): string;
 }

package/dist/sync/memory-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-transport.d.ts","sourceRoot":"","sources":["../../src/sync/memory-transport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAMrE,qBAAa,eAAgB,YAAW,aAAa;IACnD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAA0C;IAC1D,OAAO,CAAC,cAAc,CAA2C;gBAErD,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAe;IAKrD;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,IAAI;IAK5D;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,IAAI;IAKzD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/D,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI;IAIxD,KAAK,IAAI,MAAM,EAAE;IAOjB,SAAS,IAAI,MAAM;CAGpB"}
+{"version":3,"file":"memory-transport.d.ts","sourceRoot":"","sources":["../../src/sync/memory-transport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,MAAM,EACP,MAAM,YAAY,CAAC;AAMpB,qBAAa,eAAgB,YAAW,aAAa;IACnD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,cAAc,CAA2C;gBAErD,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAe;IAKrD;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,IAAI;IAK5D;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,IAAI;IAKzD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/D,SAAS,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAI5C,KAAK,IAAI,MAAM,EAAE;IAOjB,SAAS,IAAI,MAAM;CAGpB"}