trellis 3.1.35 → 3.2.0

package/dist/chunk-RSWUFTO2.js

@@ -0,0 +1,857 @@
+import {
+  init_reconciler,
+  reconcile
+} from "./chunk-4HYPLFJD.js";
+import {
+  init_ops,
+  isVcsOpKind,
+  verifyVcsOpHash
+} from "./chunk-GLM4HGN4.js";
+
+// src/sync/types.ts
+var PROTOCOL_VERSION = 1;
+var MIN_SUPPORTED_VERSION = 1;
+var MAX_SUPPORTED_VERSION = 1;
+
+// src/sync/room-core.ts
+init_ops();
+var DEFAULT_SNAPSHOT_MAX_OPS = 500;
+var SyncRoomCore = class {
+  roomPeer;
+  peers = /* @__PURE__ */ new Map();
+  ops = [];
+  constructor(roomId = "room", roomName = roomId) {
+    this.roomPeer = {
+      id: roomId,
+      name: roomName
+    };
+  }
+  connectPeer(peerId, peerName = peerId) {
+    this.peers.set(peerId, {
+      id: peerId,
+      name: peerName,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  disconnectPeer(peerId) {
+    this.peers.delete(peerId);
+  }
+  getRoomPeer() {
+    return { ...this.roomPeer };
+  }
+  peersFor(peerId) {
+    return [
+      this.getRoomPeer(),
+      ...[...this.peers.values()].filter((peer) => peer.id !== peerId).map((peer) => ({ ...peer }))
+    ];
+  }
+  getOps() {
+    return [...this.ops];
+  }
+  getOpCount() {
+    return this.ops.length;
+  }
+  /** Build a tail snapshot for late-joiner catch-up. */
+  buildSnapshot(maxOps = DEFAULT_SNAPSHOT_MAX_OPS) {
+    const opCount = this.ops.length;
+    const headHash = this.ops.at(-1)?.hash;
+    if (opCount <= maxOps) {
+      return {
+        headHash,
+        opCount,
+        truncated: false,
+        ops: [...this.ops]
+      };
+    }
+    return {
+      headHash,
+      opCount,
+      truncated: true,
+      ops: this.ops.slice(-maxOps)
+    };
+  }
+  /** Deliver a snapshot message to a connected peer. */
+  snapshotDeliveries(peerId, maxOps = DEFAULT_SNAPSHOT_MAX_OPS) {
+    const snap = this.buildSnapshot(maxOps);
+    return [
+      {
+        peerId,
+        message: {
+          version: PROTOCOL_VERSION,
+          type: "snapshot",
+          peerId: this.roomPeer.id,
+          headHash: snap.headHash,
+          opCount: snap.opCount,
+          truncated: snap.truncated,
+          ops: snap.ops
+        }
+      }
+    ];
+  }
+  async receive(fromPeerId, message) {
+    const peer = this.peers.get(fromPeerId);
+    if (peer) {
+      peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (typeof message.version !== "number" || message.version < MIN_SUPPORTED_VERSION || message.version > MAX_SUPPORTED_VERSION) {
+      return [
+        {
+          peerId: fromPeerId,
+          message: {
+            version: PROTOCOL_VERSION,
+            type: "nack",
+            peerId: this.roomPeer.id,
+            refs: [],
+            reason: "protocol-version",
+            details: `Unsupported protocol version ${message.version}; supported range is ${MIN_SUPPORTED_VERSION}-${MAX_SUPPORTED_VERSION}.`
+          }
+        }
+      ];
+    }
+    switch (message.type) {
+      case "have":
+        return this.handleHave(fromPeerId, message);
+      case "want":
+        return this.handleWant(fromPeerId, message);
+      case "sync-snapshot":
+        return this.snapshotDeliveries(
+          fromPeerId,
+          message.maxOps ?? DEFAULT_SNAPSHOT_MAX_OPS
+        );
+      case "ops":
+        return this.handleOps(fromPeerId, message.ops);
+      case "ack":
+      case "nack":
+      case "snapshot":
+        return [];
+    }
+  }
+  async handleHave(peerId, message) {
+    const deliveries = this.roomOpsDeliveries(peerId, message.heads.main);
+    const roomHashes = new Set(this.ops.map((op) => op.hash));
+    const peerHead = message.heads.main;
+    if (message.opCount > this.ops.length || peerHead && !roomHashes.has(peerHead)) {
+      deliveries.push({
+        peerId,
+        message: {
+          version: PROTOCOL_VERSION,
+          type: "want",
+          peerId: this.roomPeer.id,
+          wantHashes: []
+        }
+      });
+    } else if (!deliveries.some(
+      (d) => d.message.type === "want" || d.message.type === "ops"
+    )) {
+      deliveries.push({
+        peerId,
+        message: {
+          version: PROTOCOL_VERSION,
+          type: "want",
+          peerId: this.roomPeer.id,
+          wantHashes: []
+        }
+      });
+    }
+    return deliveries;
+  }
+  async handleWant(peerId, message) {
+    if (message.wantHashes.length > 0) {
+      const wanted = new Set(message.wantHashes);
+      return this.opsDelivery(
+        peerId,
+        this.ops.filter((op) => wanted.has(op.hash))
+      );
+    }
+    if (message.maxOps !== void 0 && message.maxOps > 0 && !message.afterHash) {
+      return this.snapshotDeliveries(peerId, message.maxOps);
+    }
+    return this.roomOpsDeliveries(peerId, message.afterHash);
+  }
+  async handleOps(peerId, ops) {
+    const result = await this.appendOps(ops);
+    const accepted = ops.filter(
+      (op) => this.ops.some((roomOp) => roomOp.hash === op.hash)
+    );
+    const deliveries = [];
+    if (accepted.length > 0) {
+      deliveries.push({
+        peerId,
+        message: {
+          version: PROTOCOL_VERSION,
+          type: "ack",
+          peerId: this.roomPeer.id,
+          integrated: accepted.map((op) => op.hash)
+        }
+      });
+    }
+    if (result.acceptedOps.length > 0) {
+      deliveries.push(...this.broadcastOps(peerId, result.acceptedOps));
+    }
+    return deliveries;
+  }
+  async appendOps(incomingOps) {
+    const known = new Set(this.ops.map((op) => op.hash));
+    const pendingByHash = /* @__PURE__ */ new Map();
+    const rejected = [];
+    const acceptedOps = [];
+    let skipped = 0;
+    let applied = 0;
+    for (const op of incomingOps) {
+      if (known.has(op.hash) || pendingByHash.has(op.hash)) {
+        skipped++;
+        continue;
+      }
+      if (!isVcsOpKind(op.kind)) {
+        rejected.push({
+          op,
+          reason: "invalid-kind",
+          message: `Rejected non-VCS op kind '${op.kind}'.`
+        });
+        continue;
+      }
+      if (!await verifyVcsOpHash(op)) {
+        rejected.push({
+          op,
+          reason: "hash-mismatch",
+          message: `Rejected op with mismatched hash '${op.hash}'.`
+        });
+        continue;
+      }
+      pendingByHash.set(op.hash, op);
+    }
+    let pending = [...pendingByHash.values()];
+    while (pending.length > 0) {
+      const nextPending = [];
+      let progressed = false;
+      for (const op of pending) {
+        if (op.previousHash && !known.has(op.previousHash)) {
+          nextPending.push(op);
+          continue;
+        }
+        this.ops.push(op);
+        known.add(op.hash);
+        acceptedOps.push(op);
+        applied++;
+        progressed = true;
+      }
+      if (!progressed) {
+        for (const op of nextPending) {
+          rejected.push({
+            op,
+            reason: "missing-dependency",
+            message: `Missing previousHash '${op.previousHash}' for op '${op.hash}'.`
+          });
+        }
+        break;
+      }
+      pending = nextPending;
+    }
+    return { applied, skipped, rejected, acceptedOps };
+  }
+  roomOpsDeliveries(peerId, afterHash) {
+    let ops = this.ops;
+    if (afterHash) {
+      const index = this.ops.findIndex((op) => op.hash === afterHash);
+      ops = index >= 0 ? this.ops.slice(index + 1) : this.ops;
+    }
+    return this.opsDelivery(peerId, ops);
+  }
+  opsDelivery(peerId, ops) {
+    if (ops.length === 0) return [];
+    return [
+      {
+        peerId,
+        message: {
+          version: PROTOCOL_VERSION,
+          type: "ops",
+          peerId: this.roomPeer.id,
+          ops
+        }
+      }
+    ];
+  }
+  broadcastOps(fromPeerId, ops) {
+    const deliveries = [];
+    for (const peerId of this.peers.keys()) {
+      if (peerId === fromPeerId) continue;
+      deliveries.push(...this.opsDelivery(peerId, ops));
+    }
+    return deliveries;
+  }
+};
+
+// src/sync/sync-engine.ts
+init_reconciler();
+var SyncEngine = class {
+  localPeerId;
+  state;
+  transport;
+  getLocalOps;
+  onOpsReceived;
+  onNackReceived;
+  branchPolicy;
+  constructor(opts) {
+    this.localPeerId = opts.localPeerId;
+    this.transport = opts.transport;
+    this.getLocalOps = opts.getLocalOps;
+    this.onOpsReceived = opts.onOpsReceived;
+    this.onNackReceived = opts.onNackReceived;
+    this.branchPolicy = opts.branchPolicy ?? { linear: true };
+    this.state = {
+      localPeerId: opts.localPeerId,
+      peerHeads: /* @__PURE__ */ new Map(),
+      pendingAcks: /* @__PURE__ */ new Set(),
+      lastSync: /* @__PURE__ */ new Map()
+    };
+    this.transport.onMessage((msg) => this.handleMessage(msg));
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Initiate a sync with a specific peer.
+   * Sends a 'have' message advertising our heads.
+   */
+  async pushTo(peerId) {
+    const ops = this.getLocalOps();
+    const heads = {};
+    if (ops.length > 0) {
+      heads["main"] = ops[ops.length - 1].hash;
+    }
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "have",
+      peerId: this.localPeerId,
+      heads,
+      opCount: ops.length
+    });
+  }
+  /**
+   * Request ops from a peer.
+   */
+  async pullFrom(peerId) {
+    const ops = this.getLocalOps();
+    const lastHash = ops.length > 0 ? ops[ops.length - 1].hash : void 0;
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "want",
+      peerId: this.localPeerId,
+      wantHashes: [],
+      afterHash: lastHash
+    });
+  }
+  /**
+   * Request the peer's complete op set and rely on hash dedupe during ingest.
+   */
+  async pullAllFrom(peerId) {
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "want",
+      peerId: this.localPeerId,
+      wantHashes: []
+    });
+  }
+  /**
+   * Request a truncated tail snapshot from a room peer (late-joiner catch-up).
+   * The room replies with a `snapshot` message handled like `ops`.
+   */
+  async requestSnapshot(peerId, maxOps = DEFAULT_SNAPSHOT_MAX_OPS) {
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "sync-snapshot",
+      peerId: this.localPeerId,
+      maxOps
+    });
+  }
+  /**
+   * Send all our ops to a peer (full push).
+   */
+  async sendOps(peerId, ops) {
+    const opsToSend = ops ?? this.getLocalOps();
+    await this.sendOpsMessage(peerId, opsToSend);
+  }
+  /**
+   * Internal: send an `ops` message and track outbound hashes in
+   * `pendingAcks` until the receiver acks or nacks them. All three sites
+   * that emit `ops` (sendOps, handleHave, handleWant) route through here so
+   * pendingAcks reflects every outbound op uniformly.
+   */
+  async sendOpsMessage(peerId, ops) {
+    if (ops.length === 0) return;
+    for (const op of ops) {
+      this.state.pendingAcks.add(op.hash);
+    }
+    await this.transport.send(peerId, {
+      version: PROTOCOL_VERSION,
+      type: "ops",
+      peerId: this.localPeerId,
+      ops
+    });
+  }
+  /**
+   * Reconcile our ops with a remote peer's ops.
+   */
+  reconcileWith(remoteOps) {
+    const localOps = this.getLocalOps();
+    return reconcile(localOps, remoteOps);
+  }
+  /**
+   * Get current sync state.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get branch policy.
+   */
+  getBranchPolicy() {
+    return this.branchPolicy;
+  }
+  /**
+   * Set branch policy.
+   */
+  setBranchPolicy(policy) {
+    this.branchPolicy = policy;
+  }
+  /**
+   * List known peers.
+   */
+  listPeers() {
+    return this.transport.peers();
+  }
+  // -------------------------------------------------------------------------
+  // Message handling
+  // -------------------------------------------------------------------------
+  async handleMessage(msg) {
+    if (typeof msg.version !== "number" || msg.version < MIN_SUPPORTED_VERSION || msg.version > MAX_SUPPORTED_VERSION) {
+      await this.transport.send(msg.peerId, {
+        version: PROTOCOL_VERSION,
+        type: "nack",
+        peerId: this.localPeerId,
+        refs: [],
+        reason: "protocol-version",
+        details: `Unsupported protocol version ${msg.version}; supported range is ${MIN_SUPPORTED_VERSION}-${MAX_SUPPORTED_VERSION}.`
+      });
+      return;
+    }
+    switch (msg.type) {
+      case "have":
+        await this.handleHave(msg);
+        break;
+      case "want":
+        await this.handleWant(msg);
+        break;
+      case "ops":
+        await this.handleOps(msg);
+        break;
+      case "ack":
+        this.handleAck(msg);
+        break;
+      case "nack":
+        await this.handleNack(msg);
+        break;
+      case "snapshot":
+        await this.handleSnapshot(msg);
+        break;
+      case "sync-snapshot":
+        break;
+    }
+  }
+  async handleSnapshot(msg) {
+    if (msg.ops.length === 0) return;
+    await this.handleOps({
+      version: msg.version,
+      type: "ops",
+      peerId: msg.peerId,
+      ops: msg.ops
+    });
+  }
+  async handleHave(msg) {
+    this.state.peerHeads.set(msg.peerId, msg.heads);
+    const localOps = this.getLocalOps();
+    const localHashes = new Set(localOps.map((o) => o.hash));
+    for (const [, hash] of Object.entries(msg.heads)) {
+      if (!localHashes.has(hash)) {
+        const afterHash = msg.opCount > localOps.length ? void 0 : localOps.length > 0 ? localOps[localOps.length - 1].hash : void 0;
+        await this.transport.send(msg.peerId, {
+          version: PROTOCOL_VERSION,
+          type: "want",
+          peerId: this.localPeerId,
+          wantHashes: [],
+          afterHash
+        });
+        return;
+      }
+    }
+    if (msg.opCount > localOps.length) {
+      await this.transport.send(msg.peerId, {
+        version: PROTOCOL_VERSION,
+        type: "want",
+        peerId: this.localPeerId,
+        wantHashes: []
+      });
+      return;
+    }
+    const peerOpCount = msg.opCount;
+    if (localOps.length > peerOpCount) {
+      await this.sendOpsMessage(msg.peerId, localOps.slice(peerOpCount));
+    }
+  }
+  async handleWant(msg) {
+    const localOps = this.getLocalOps();
+    let opsToSend;
+    if (msg.afterHash) {
+      const idx = localOps.findIndex((o) => o.hash === msg.afterHash);
+      opsToSend = idx >= 0 ? localOps.slice(idx + 1) : localOps;
+    } else if (msg.wantHashes.length > 0) {
+      const wanted = new Set(msg.wantHashes);
+      opsToSend = localOps.filter((o) => wanted.has(o.hash));
+    } else {
+      opsToSend = localOps;
+    }
+    await this.sendOpsMessage(msg.peerId, opsToSend);
+  }
+  async handleOps(msg) {
+    if (msg.ops.length === 0) return;
+    let result;
+    if (this.branchPolicy.linear) {
+      const localOps = this.getLocalOps();
+      const localHashes = new Set(localOps.map((o) => o.hash));
+      const newOps = msg.ops.filter((o) => !localHashes.has(o.hash));
+      if (newOps.length > 0) {
+        result = await this.onOpsReceived(newOps) ?? void 0;
+      }
+    } else {
+      const reconciled = this.reconcileWith(msg.ops);
+      if (reconciled.uniqueToB.length > 0) {
+        result = await this.onOpsReceived(reconciled.uniqueToB) ?? void 0;
+      }
+    }
+    const rejections = result?.rejections ?? [];
+    if (rejections.length > 0) {
+      const byReason = /* @__PURE__ */ new Map();
+      for (const r of rejections) {
+        const entry = byReason.get(r.reason) ?? {
+          refs: [],
+          details: r.details
+        };
+        entry.refs.push(r.hash);
+        byReason.set(r.reason, entry);
+      }
+      for (const [reason, entry] of byReason) {
+        await this.transport.send(msg.peerId, {
+          version: PROTOCOL_VERSION,
+          type: "nack",
+          peerId: this.localPeerId,
+          refs: entry.refs,
+          reason,
+          details: entry.details
+        });
+      }
+    }
+    const rejectedSet = new Set(rejections.map((r) => r.hash));
+    const ackHashes = msg.ops.map((o) => o.hash).filter((h) => !rejectedSet.has(h));
+    if (ackHashes.length > 0) {
+      await this.transport.send(msg.peerId, {
+        version: PROTOCOL_VERSION,
+        type: "ack",
+        peerId: this.localPeerId,
+        integrated: ackHashes
+      });
+    }
+    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  handleAck(msg) {
+    for (const hash of msg.integrated) {
+      this.state.pendingAcks.delete(hash);
+    }
+    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async handleNack(msg) {
+    for (const ref of msg.refs) {
+      this.state.pendingAcks.delete(ref);
+    }
+    this.state.lastSync.set(msg.peerId, (/* @__PURE__ */ new Date()).toISOString());
+    if (this.onNackReceived) {
+      await this.onNackReceived(msg);
+    }
+  }
+};
+
+// src/sync/vcs-sync-peer.ts
+var TrellisVcsSyncPeer = class {
+  engine;
+  syncEngine;
+  transport;
+  integrationResults = [];
+  remoteNacks = [];
+  constructor(opts) {
+    this.engine = opts.engine;
+    this.transport = opts.transport;
+    this.syncEngine = new SyncEngine({
+      localPeerId: opts.peerId,
+      transport: opts.transport,
+      getLocalOps: () => this.engine.getOps(),
+      onOpsReceived: async (ops) => {
+        const result = await this.engine.integrateOps(ops);
+        this.integrationResults.push(result);
+        await opts.onIntegrate?.(result);
+        const rejections = result.rejected.map(
+          (r) => ({
+            hash: r.op.hash,
+            reason: r.reason,
+            details: r.message
+          })
+        );
+        return { rejections };
+      },
+      onNackReceived: async (nack) => {
+        const info = {
+          peerId: nack.peerId,
+          reason: nack.reason,
+          refs: nack.refs,
+          details: nack.details
+        };
+        this.remoteNacks.push(info);
+        await opts.onRemoteNack?.(nack);
+      },
+      branchPolicy: opts.branchPolicy
+    });
+  }
+  async pushTo(peerId) {
+    return this.captureSync(peerId, () => this.syncEngine.pushTo(peerId));
+  }
+  async pullFrom(peerId) {
+    return this.captureSync(peerId, () => this.syncEngine.pullAllFrom(peerId));
+  }
+  async syncWith(peerId) {
+    return this.captureSync(peerId, async () => {
+      await this.syncEngine.pushTo(peerId);
+      await this.syncEngine.pullAllFrom(peerId);
+    });
+  }
+  /** Request a tail snapshot before a full sync (room peers only). */
+  async requestSnapshot(peerId, maxOps) {
+    await this.syncEngine.requestSnapshot(peerId, maxOps);
+  }
+  listPeers() {
+    return this.syncEngine.listPeers();
+  }
+  getSyncEngine() {
+    return this.syncEngine;
+  }
+  /**
+   * Cumulative nacks received from remote peers since construction.
+   * Useful for tests and for consumers that want to inspect the full history.
+   * Sync results returned by `pushTo`/`pullFrom`/`syncWith` already include
+   * the per-session slice in `remoteRejected`.
+   */
+  getRemoteNacks() {
+    return this.remoteNacks;
+  }
+  /** Underlying transport (for connect/close in client wrappers). */
+  getTransport() {
+    return this.transport;
+  }
+  /** Tear down the transport connection if supported. */
+  close() {
+    if ("close" in this.transport && typeof this.transport.close === "function") {
+      this.transport.close();
+    }
+  }
+  async captureSync(peerId, run) {
+    const beforeOpCount = this.engine.getOpCount();
+    const start = this.integrationResults.length;
+    const nackStart = this.remoteNacks.length;
+    await run();
+    const batches = this.integrationResults.slice(start);
+    const remoteRejected = this.remoteNacks.slice(nackStart);
+    const afterOpCount = this.engine.getOpCount();
+    return {
+      peerId,
+      beforeOpCount,
+      afterOpCount,
+      batches,
+      applied: batches.reduce((sum, batch) => sum + batch.applied, 0),
+      skipped: batches.reduce((sum, batch) => sum + batch.skipped, 0),
+      rejected: batches.reduce(
+        (sum, batch) => sum + batch.rejected.length,
+        0
+      ),
+      remoteRejected
+    };
+  }
+};
+
+// src/sync/partykit-transport.ts
+var DEFAULT_RECONNECT = {
+  baseDelayMs: 500,
+  maxDelayMs: 3e4
+};
+var PartyKitRoomTransport = class _PartyKitRoomTransport {
+  peerId;
+  room;
+  roomUrl;
+  WebSocketImpl;
+  ws = null;
+  messageHandler = null;
+  intentionalClose = false;
+  reconnectEnabled;
+  reconnectOpts;
+  reconnectAttempt = 0;
+  reconnectTimer;
+  connectPromise = null;
+  onReconnect;
+  onDisconnect;
+  constructor(opts) {
+    this.peerId = opts.peerId;
+    this.roomUrl = _PartyKitRoomTransport.withAuth(opts.roomUrl, opts.auth);
+    this.room = {
+      id: opts.roomId ?? "room",
+      name: opts.roomName ?? opts.roomId ?? "room"
+    };
+    this.onReconnect = opts.onReconnect;
+    this.onDisconnect = opts.onDisconnect;
+    const reconnect = opts.reconnect ?? true;
+    this.reconnectEnabled = reconnect !== false;
+    this.reconnectOpts = {
+      ...DEFAULT_RECONNECT,
+      ...reconnect === true ? {} : reconnect
+    };
+    const WebSocketGlobal = globalThis.WebSocket;
+    const WebSocketImpl = opts.WebSocketImpl ?? WebSocketGlobal;
+    if (!WebSocketImpl) {
+      throw new Error(
+        "PartyKitRoomTransport requires WebSocket or opts.WebSocketImpl."
+      );
+    }
+    this.WebSocketImpl = WebSocketImpl;
+  }
+  async connect() {
+    if (this.ws?.readyState === 1) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = this.openSocket();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  async send(peerId, message) {
+    if (peerId !== this.room.id) {
+      throw new Error(`PartyKitRoomTransport can only send to ${this.room.id}.`);
+    }
+    await this.connect();
+    this.ws.send(JSON.stringify(message));
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  peers() {
+    return [this.room];
+  }
+  close() {
+    this.intentionalClose = true;
+    if (this.reconnectTimer !== void 0) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    this.ws?.close();
+    this.ws = null;
+  }
+  getPeerId() {
+    return this.peerId;
+  }
+  getRoomPeer() {
+    return { ...this.room };
+  }
+  /** Whether the WebSocket is open. */
+  isConnected() {
+    return this.ws?.readyState === 1;
+  }
+  openSocket() {
+    return new Promise((resolve, reject) => {
+      const ws = new this.WebSocketImpl(this.roomUrl);
+      this.ws = ws;
+      ws.onopen = () => {
+        this.reconnectAttempt = 0;
+        resolve();
+      };
+      ws.onerror = (event) => {
+        reject(new Error(`PartyKit room connection failed: ${String(event)}`));
+      };
+      ws.onmessage = async (event) => {
+        const message = this.parseMessage(event.data);
+        if (!message || !this.messageHandler) return;
+        await this.messageHandler(message);
+      };
+      ws.onclose = () => {
+        if (this.ws === ws) {
+          this.ws = null;
+        }
+        this.onDisconnect?.("closed");
+        if (!this.intentionalClose && this.reconnectEnabled) {
+          this.scheduleReconnect();
+        }
+      };
+    });
+  }
+  scheduleReconnect() {
+    const max = this.reconnectOpts.maxAttempts ?? 0;
+    if (max > 0 && this.reconnectAttempt >= max) return;
+    const base = this.reconnectOpts.baseDelayMs ?? 500;
+    const cap = this.reconnectOpts.maxDelayMs ?? 3e4;
+    const delay = Math.min(base * 2 ** this.reconnectAttempt, cap);
+    this.reconnectAttempt++;
+    if (this.reconnectTimer !== void 0) {
+      clearTimeout(this.reconnectTimer);
+    }
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      void this.tryReconnect();
+    }, delay);
+  }
+  async tryReconnect() {
+    if (this.intentionalClose) return;
+    try {
+      await this.connect();
+      await this.onReconnect?.();
+    } catch {
+      if (!this.intentionalClose && this.reconnectEnabled) {
+        this.scheduleReconnect();
+      }
+    }
+  }
+  static withAuth(roomUrl, auth) {
+    if (!auth) return roomUrl;
+    try {
+      const url = new URL(roomUrl);
+      url.searchParams.set("token", auth);
+      return url.toString();
+    } catch {
+      const sep = roomUrl.includes("?") ? "&" : "?";
+      return `${roomUrl}${sep}token=${encodeURIComponent(auth)}`;
+    }
+  }
+  parseMessage(data) {
+    try {
+      const raw = typeof data === "string" ? data : String(data);
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed.type === "string" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  PROTOCOL_VERSION,
+  MIN_SUPPORTED_VERSION,
+  MAX_SUPPORTED_VERSION,
+  DEFAULT_SNAPSHOT_MAX_OPS,
+  SyncRoomCore,
+  SyncEngine,
+  TrellisVcsSyncPeer,
+  PartyKitRoomTransport
+};