@kyneta/webrtc-transport 1.3.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,180 @@
+# @kyneta/webrtc-transport
+
+BYODC (Bring Your Own Data Channel) WebRTC transport for `@kyneta/exchange`. Your application manages WebRTC connections — signaling, ICE, media streams — and this transport attaches to data channels for kyneta document synchronization.
+
+The key design decision is `DataChannelLike`: a 5-member minimal interface that native `RTCDataChannel` satisfies structurally and that libraries like simple-peer can bridge in ~20 lines.
+
+## Overview
+
+- **BYODC design** — no signaling, no ICE, no connection management. The application establishes WebRTC connections however it likes; this transport hooks into the resulting data channels for sync.
+- **Binary CBOR encoding** with transport-level fragmentation — the same `@kyneta/wire` pipeline used by the WebSocket transport.
+- **`DataChannelLike` interface** — 5 members out of the ~30-member `RTCDataChannel` API. Native data channels conform structurally (zero wrapper code). Library bridges are trivial.
+- **Single export** — no client/server split. Both peers use the same `WebrtcTransport` class.
+
+## Install
+
+```/dev/null/install.sh#L1
+pnpm add @kyneta/webrtc-transport
+```
+
+## Quick Start
+
+### With native RTCDataChannel
+
+Native `RTCDataChannel` satisfies `DataChannelLike` structurally — pass it directly:
+
+```/dev/null/native-example.ts#L1-14
+import { Exchange } from "@kyneta/exchange"
+import { createWebrtcTransport, WebrtcTransport } from "@kyneta/webrtc-transport"
+
+const exchange = new Exchange({
+  identity: { peerId: "alice", name: "Alice" },
+  transports: [createWebrtcTransport()],
+})
+
+// When a WebRTC connection is established:
+const transport = exchange.getTransport("webrtc-datachannel") as WebrtcTransport
+const cleanup = transport.attachDataChannel(remotePeerId, dataChannel)
+
+// When done:
+cleanup()
+```
+
+### With simple-peer (bridge function)
+
+simple-peer uses an EventEmitter API instead of `addEventListener`. A ~20-line bridge maps it to `DataChannelLike`:
+
+```/dev/null/simple-peer-bridge.ts#L1-39
+import type { DataChannelLike } from "@kyneta/webrtc-transport"
+
+function fromSimplePeer(peer: SimplePeer.Instance): DataChannelLike {
+  const eventMap: Record<string, string> = {
+    open: "connect", close: "close", error: "error", message: "data",
+  }
+  const wrapperMap = new Map<Function, Function>()
+  return {
+    get readyState() { return peer.connected ? "open" : "connecting" },
+    binaryType: "arraybuffer",
+    send(data) { peer.send(data) },
+    addEventListener(type, listener) {
+      const peerEvent = eventMap[type]
+      if (!peerEvent) return
+      const wrapped = type === "message"
+        ? (data: any) => listener({ data })
+        : () => listener({})
+      wrapperMap.set(listener, wrapped)
+      peer.on(peerEvent, wrapped as any)
+    },
+    removeEventListener(type, listener) {
+      const peerEvent = eventMap[type]
+      if (!peerEvent) return
+      const wrapped = wrapperMap.get(listener)
+      if (wrapped) { peer.off(peerEvent, wrapped as any); wrapperMap.delete(listener) }
+    },
+  }
+}
+
+// Usage:
+const channel = fromSimplePeer(peer)
+transport.attachDataChannel(remotePeerId, channel)
+```
+
+## API Reference
+
+### `createWebrtcTransport(options?)`
+
+Factory function returning a `TransportFactory`. Pass directly to `Exchange({ transports: [...] })`.
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `fragmentThreshold` | `204800` (200KB) | Payload size threshold in bytes for SCTP fragmentation. |
+
+```/dev/null/factory-example.ts#L1-3
+const exchange = new Exchange({
+  transports: [createWebrtcTransport({ fragmentThreshold: 100 * 1024 })],
+})
+```
+
+To access the transport instance after creation:
+
+```/dev/null/get-transport.ts#L1
+const transport = exchange.getTransport("webrtc-datachannel") as WebrtcTransport
+```
+
+### `WebrtcTransport`
+
+The transport class. Extends `Transport` from `@kyneta/exchange`.
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `attachDataChannel` | `(remotePeerId: string, channel: DataChannelLike) => () => void` | Attach a data channel. Returns a cleanup function. If a channel is already attached for this peer, the old one is detached first. |
+| `detachDataChannel` | `(remotePeerId: string) => void` | Detach a data channel. Removes event listeners but does **not** close the data channel. |
+| `hasDataChannel` | `(remotePeerId: string) => boolean` | Check if a data channel is attached for a peer. |
+| `getAttachedPeerIds` | `() => string[]` | List all peer IDs with attached data channels. |
+
+### `DataChannelLike`
+
+The minimal interface — 5 members:
+
+```/dev/null/data-channel-like.ts#L1-7
+interface DataChannelLike {
+  readonly readyState: string     // transport checks === "open"
+  binaryType: string              // transport writes "arraybuffer" on attach
+  send(data: Uint8Array): void
+  addEventListener(type: string, listener: (event: any) => void): void
+  removeEventListener(type: string, listener: (event: any) => void): void
+}
+```
+
+The transport listens for four event types: `"open"`, `"close"`, `"error"`, `"message"`. For `"message"` events, it reads `event.data` (accepting both `ArrayBuffer` and `Uint8Array`).
+
+## `DataChannelLike` Interface
+
+The full `RTCDataChannel` interface has ~30 members. This transport uses exactly 5. By accepting `DataChannelLike` instead of `RTCDataChannel`:
+
+- **No DOM type dependency** — the interface uses `string` for `readyState` and `any` for event parameters, so there's no import of `lib.dom.d.ts` types like `Event`, `MessageEvent`, or `RTCDataChannelState`.
+- **No wrapper for native WebRTC** — `RTCDataChannel` satisfies `DataChannelLike` structurally. Pass it directly.
+- **Library bridges are trivial** — simple-peer, `werift`, `node-datachannel`, etc. can be bridged in ~20 lines by mapping their EventEmitter API to `addEventListener`/`removeEventListener`.
+- **No double-casts** — without this design you'd need `channel as unknown as RTCDataChannel` to satisfy the type checker when using non-native implementations.
+
+The type is intentionally loose: `readyState` is `string` (not a union), `binaryType` is `string` (not `"arraybuffer" | "blob"`), and event listeners take `any`. This maximizes the set of objects that conform structurally.
+
+## Ownership Contract
+
+The transport does **not** own the data channel.
+
+- `attachDataChannel()` registers event listeners and creates an internal sync channel.
+- `detachDataChannel()` removes event listeners and tears down the sync channel.
+- Neither method closes the `DataChannelLike` or the peer connection.
+
+The application manages the WebRTC connection lifecycle independently. This means you can:
+
+- Share a peer connection across multiple transports
+- Detach and reattach data channels without renegotiation
+- Close data channels on your own schedule
+
+## Fragmentation
+
+SCTP (the underlying transport for WebRTC data channels) has a message size limit of approximately 256KB. The transport fragments messages that exceed the configured threshold using the same binary fragmentation pipeline as the WebSocket transport (`@kyneta/wire`).
+
+| Setting | Value | Notes |
+|---------|-------|-------|
+| Default threshold | 200KB | Safe margin below SCTP's ~256KB limit |
+| Disable | `fragmentThreshold: 0` | Not recommended — large messages will fail silently |
+
+This differs from the WebSocket transport's 100KB default, which targets AWS API Gateway's 128KB frame limit. WebRTC has no such gateway constraint.
+
+## Peer Dependencies
+
+```/dev/null/package.json#L1-6
+{
+  "peerDependencies": {
+    "@kyneta/exchange": "^1.1.0",
+    "@kyneta/wire": "^1.1.0"
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,232 @@
+import { Transport, GeneratedChannel, TransportFactory } from '@kyneta/transport';
+
+/**
+ * Minimal interface for a WebRTC-style data channel.
+ *
+ * Native `RTCDataChannel` satisfies this structurally (no wrapper needed).
+ * Libraries like simple-peer can conform via a ~20-line bridge function
+ * that maps EventEmitter events to addEventListener calls.
+ *
+ * The transport uses exactly these members — nothing else. This is
+ * intentional: the narrower the interface, the easier it is to bridge
+ * from any WebRTC library.
+ *
+ * ## Event types used
+ *
+ * The transport registers listeners for exactly four event types:
+ * - `"open"` — data channel became ready for sending
+ * - `"close"` — data channel was closed
+ * - `"error"` — data channel encountered an error
+ * - `"message"` — data arrived; the transport reads `event.data`
+ *
+ * ## Ownership contract
+ *
+ * The transport does NOT own the data channel. Calling
+ * `detachDataChannel()` removes the sync channel but does not close
+ * the data channel or the peer connection. The application manages
+ * the WebRTC connection lifecycle independently.
+ */
+interface DataChannelLike {
+    /**
+     * Current state of the data channel.
+     *
+     * The transport treats `"open"` as sendable; all other values
+     * (including `"connecting"`, `"closing"`, `"closed"`) as not sendable.
+     *
+     * For native `RTCDataChannel`, this is one of:
+     * `"connecting" | "open" | "closing" | "closed"`.
+     *
+     * Wrappers may return any string — the transport only checks `=== "open"`.
+     */
+    readonly readyState: string;
+    /**
+     * Binary type hint for incoming data.
+     *
+     * The transport writes `"arraybuffer"` on attach as a best-effort hint.
+     * It does NOT depend on this being respected — the message handler
+     * accepts both `ArrayBuffer` and `Uint8Array` data regardless.
+     *
+     * For native `RTCDataChannel`, this controls whether `MessageEvent.data`
+     * is an `ArrayBuffer` or a `Blob`. For wrappers that ignore this
+     * property (e.g. simple-peer bridges), the write is harmless.
+     */
+    binaryType: string;
+    /**
+     * Send binary data through the data channel.
+     *
+     * The transport always sends `Uint8Array` instances (CBOR-encoded
+     * wire frames, optionally fragmented). Native `RTCDataChannel.send`
+     * accepts `ArrayBufferView` (which `Uint8Array` satisfies), so
+     * conformance is structural.
+     */
+    send(data: Uint8Array): void;
+    /**
+     * Register an event listener.
+     *
+     * The transport uses this for `"open"`, `"close"`, `"error"`, and
+     * `"message"` events. For `"message"` events, the transport reads
+     * `event.data` and handles both `ArrayBuffer` and `Uint8Array`.
+     *
+     * @param type - Event type string
+     * @param listener - Callback. The `event` parameter is untyped to
+     *   avoid coupling to DOM `Event` / `MessageEvent` types.
+     */
+    addEventListener(type: string, listener: (event: any) => void): void;
+    /**
+     * Remove a previously registered event listener.
+     *
+     * Called during `detachDataChannel()` to clean up all four event
+     * listeners. The transport always passes the same function reference
+     * that was used in `addEventListener`.
+     */
+    removeEventListener(type: string, listener: (event: any) => void): void;
+}
+
+/**
+ * Default fragment threshold in bytes.
+ *
+ * SCTP (the underlying transport for WebRTC data channels) has a message
+ * size limit of approximately 256KB. 200KB provides a safe margin.
+ *
+ * This differs from the WebSocket transport's 100KB default, which
+ * targets AWS API Gateway's 128KB limit. WebRTC has no such gateway.
+ */
+declare const DEFAULT_FRAGMENT_THRESHOLD: number;
+/**
+ * Configuration options for the WebRTC transport.
+ */
+interface WebrtcTransportOptions {
+    /**
+     * Fragment threshold in bytes. Messages larger than this are fragmented
+     * for SCTP compatibility. Set to 0 to disable fragmentation (not recommended).
+     *
+     * @default 204800 (200KB)
+     */
+    fragmentThreshold?: number;
+}
+/**
+ * Context for each attached data channel — stored per remotePeerId.
+ */
+type DataChannelContext = {
+    remotePeerId: string;
+    channel: DataChannelLike;
+};
+/**
+ * WebRTC data channel transport for @kyneta/exchange.
+ *
+ * Follows a "Bring Your Own Data Channel" (BYODC) design — the application
+ * manages WebRTC connections and attaches data channels to this transport
+ * for kyneta document synchronization.
+ *
+ * Uses binary CBOR encoding with transport-level fragmentation via
+ * `@kyneta/wire` — the same pipeline as the WebSocket transport.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { Exchange } from "@kyneta/exchange"
+ * import { createWebrtcTransport } from "@kyneta/webrtc-transport"
+ *
+ * const webrtcTransport = createWebrtcTransport()
+ *
+ * const exchange = new Exchange({
+ *   identity: { peerId: "alice", name: "Alice" },
+ *   transports: [webrtcTransport],
+ * })
+ *
+ * // When a WebRTC connection is established:
+ * const cleanup = transport.attachDataChannel(remotePeerId, dataChannel)
+ *
+ * // When done:
+ * cleanup() // or transport.detachDataChannel(remotePeerId)
+ * ```
+ *
+ * ## Ownership
+ *
+ * The transport does NOT own the data channel. `detachDataChannel()`
+ * removes the sync channel and event listeners but does not close the
+ * data channel or the peer connection. The application manages the
+ * WebRTC connection lifecycle independently.
+ */
+declare class WebrtcTransport extends Transport<DataChannelContext> {
+    #private;
+    constructor(options?: WebrtcTransportOptions);
+    /**
+     * Generate a channel for a data channel context.
+     *
+     * Called internally by the `Transport` base class when `addChannel()` is
+     * invoked. Users never call this directly — use `attachDataChannel()`.
+     */
+    protected generate(context: DataChannelContext): GeneratedChannel;
+    /**
+     * Called when the transport starts.
+     *
+     * No-op for WebRTC — channels are added dynamically via
+     * `attachDataChannel()`, not at start time.
+     */
+    onStart(): Promise<void>;
+    /**
+     * Called when the transport stops.
+     *
+     * Detaches all attached data channels and cleans up resources.
+     */
+    onStop(): Promise<void>;
+    /**
+     * Attach a data channel for a remote peer.
+     *
+     * Creates an internal sync channel when the data channel is open
+     * (or waits for the `"open"` event if still connecting). The sync
+     * channel triggers the establishment handshake with the remote peer.
+     *
+     * If a data channel is already attached for this peer, the old one
+     * is detached first.
+     *
+     * @param remotePeerId - The stable peer ID of the remote peer
+     * @param channel - Any object satisfying `DataChannelLike`
+     * @returns A cleanup function that calls `detachDataChannel(remotePeerId)`
+     */
+    attachDataChannel(remotePeerId: string, channel: DataChannelLike): () => void;
+    /**
+     * Detach a data channel for a remote peer.
+     *
+     * Removes the sync channel, cleans up event listeners, and disposes
+     * the reassembler. Does NOT close the data channel — the application
+     * manages the WebRTC connection lifecycle.
+     *
+     * @param remotePeerId - The peer ID to detach
+     */
+    detachDataChannel(remotePeerId: string): void;
+    /**
+     * Check if a data channel is attached for a peer.
+     */
+    hasDataChannel(remotePeerId: string): boolean;
+    /**
+     * Get all peer IDs with attached data channels.
+     */
+    getAttachedPeerIds(): string[];
+}
+/**
+ * Create a WebRTC transport factory for use with `Exchange`.
+ *
+ * Returns a `TransportFactory` — pass directly to
+ * `Exchange({ transports: [...] })`. The returned transport instance
+ * exposes `attachDataChannel()` / `detachDataChannel()` for BYODC
+ * data channel management.
+ *
+ * To access the transport instance after creation, use
+ * `exchange.getTransport("webrtc-datachannel")`.
+ *
+ * @example
+ * ```typescript
+ * import { Exchange } from "@kyneta/exchange"
+ * import { createWebrtcTransport } from "@kyneta/webrtc-transport"
+ *
+ * const exchange = new Exchange({
+ *   identity: { peerId: "alice", name: "Alice" },
+ *   transports: [createWebrtcTransport()],
+ * })
+ * ```
+ */
+declare function createWebrtcTransport(options?: WebrtcTransportOptions): TransportFactory;
+
+export { DEFAULT_FRAGMENT_THRESHOLD, type DataChannelLike, WebrtcTransport, type WebrtcTransportOptions, createWebrtcTransport };

package/dist/index.js

@@ -0,0 +1,228 @@
+// src/webrtc-transport.ts
+import { Transport } from "@kyneta/transport";
+import {
+  decodeBinaryMessages,
+  encodeBinaryAndSend,
+  FragmentReassembler
+} from "@kyneta/wire";
+var DEFAULT_FRAGMENT_THRESHOLD = 200 * 1024;
+var WebrtcTransport = class extends Transport {
+  /**
+   * Map of remotePeerId → attached channel tracking.
+   */
+  #attachedChannels = /* @__PURE__ */ new Map();
+  /**
+   * Fragment threshold in bytes.
+   */
+  #fragmentThreshold;
+  constructor(options) {
+    super({ transportType: "webrtc-datachannel" });
+    this.#fragmentThreshold = options?.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD;
+  }
+  // ==========================================================================
+  // Transport abstract method implementations
+  // ==========================================================================
+  /**
+   * Generate a channel for a data channel context.
+   *
+   * Called internally by the `Transport` base class when `addChannel()` is
+   * invoked. Users never call this directly — use `attachDataChannel()`.
+   */
+  generate(context) {
+    const { channel } = context;
+    return {
+      transportType: this.transportType,
+      send: (msg) => {
+        if (channel.readyState !== "open") {
+          return;
+        }
+        encodeBinaryAndSend(
+          msg,
+          this.#fragmentThreshold,
+          (data) => channel.send(data)
+        );
+      },
+      stop: () => {
+      }
+    };
+  }
+  /**
+   * Called when the transport starts.
+   *
+   * No-op for WebRTC — channels are added dynamically via
+   * `attachDataChannel()`, not at start time.
+   */
+  async onStart() {
+  }
+  /**
+   * Called when the transport stops.
+   *
+   * Detaches all attached data channels and cleans up resources.
+   */
+  async onStop() {
+    for (const remotePeerId of [...this.#attachedChannels.keys()]) {
+      this.detachDataChannel(remotePeerId);
+    }
+  }
+  // ==========================================================================
+  // Public API — data channel management
+  // ==========================================================================
+  /**
+   * Attach a data channel for a remote peer.
+   *
+   * Creates an internal sync channel when the data channel is open
+   * (or waits for the `"open"` event if still connecting). The sync
+   * channel triggers the establishment handshake with the remote peer.
+   *
+   * If a data channel is already attached for this peer, the old one
+   * is detached first.
+   *
+   * @param remotePeerId - The stable peer ID of the remote peer
+   * @param channel - Any object satisfying `DataChannelLike`
+   * @returns A cleanup function that calls `detachDataChannel(remotePeerId)`
+   */
+  attachDataChannel(remotePeerId, channel) {
+    if (this.#attachedChannels.has(remotePeerId)) {
+      this.detachDataChannel(remotePeerId);
+    }
+    channel.binaryType = "arraybuffer";
+    const reassembler = new FragmentReassembler({ timeoutMs: 1e4 });
+    const onOpen = () => {
+      this.#createSyncChannel(remotePeerId);
+    };
+    const onClose = () => {
+      this.#removeSyncChannel(remotePeerId);
+    };
+    const onError = () => {
+      this.#removeSyncChannel(remotePeerId);
+    };
+    const onMessage = (event) => {
+      this.#handleMessage(remotePeerId, event);
+    };
+    const cleanup = () => {
+      channel.removeEventListener("open", onOpen);
+      channel.removeEventListener("close", onClose);
+      channel.removeEventListener("error", onError);
+      channel.removeEventListener("message", onMessage);
+    };
+    channel.addEventListener("open", onOpen);
+    channel.addEventListener("close", onClose);
+    channel.addEventListener("error", onError);
+    channel.addEventListener("message", onMessage);
+    const attached = {
+      remotePeerId,
+      channel,
+      channelId: null,
+      reassembler,
+      cleanup
+    };
+    this.#attachedChannels.set(remotePeerId, attached);
+    if (channel.readyState === "open") {
+      this.#createSyncChannel(remotePeerId);
+    }
+    return () => this.detachDataChannel(remotePeerId);
+  }
+  /**
+   * Detach a data channel for a remote peer.
+   *
+   * Removes the sync channel, cleans up event listeners, and disposes
+   * the reassembler. Does NOT close the data channel — the application
+   * manages the WebRTC connection lifecycle.
+   *
+   * @param remotePeerId - The peer ID to detach
+   */
+  detachDataChannel(remotePeerId) {
+    const attached = this.#attachedChannels.get(remotePeerId);
+    if (!attached) return;
+    this.#removeSyncChannel(remotePeerId);
+    attached.reassembler.dispose();
+    attached.cleanup();
+    this.#attachedChannels.delete(remotePeerId);
+  }
+  /**
+   * Check if a data channel is attached for a peer.
+   */
+  hasDataChannel(remotePeerId) {
+    return this.#attachedChannels.has(remotePeerId);
+  }
+  /**
+   * Get all peer IDs with attached data channels.
+   */
+  getAttachedPeerIds() {
+    return [...this.#attachedChannels.keys()];
+  }
+  // ==========================================================================
+  // Internal — sync channel lifecycle
+  // ==========================================================================
+  /**
+   * Create an internal sync channel for an attached data channel.
+   *
+   * Called when the data channel's `"open"` event fires (or immediately
+   * if already open on attach). The sync channel is registered with the
+   * Transport base class, which triggers the establishment handshake.
+   */
+  #createSyncChannel(remotePeerId) {
+    const attached = this.#attachedChannels.get(remotePeerId);
+    if (!attached) return;
+    if (attached.channelId !== null) return;
+    const syncChannel = this.addChannel({
+      remotePeerId,
+      channel: attached.channel
+    });
+    attached.channelId = syncChannel.channelId;
+    this.establishChannel(syncChannel.channelId);
+  }
+  /**
+   * Remove the internal sync channel for a peer.
+   */
+  #removeSyncChannel(remotePeerId) {
+    const attached = this.#attachedChannels.get(remotePeerId);
+    if (!attached || attached.channelId === null) return;
+    this.removeChannel(attached.channelId);
+    attached.channelId = null;
+  }
+  // ==========================================================================
+  // Internal — message handling
+  // ==========================================================================
+  /**
+   * Handle an incoming message from a data channel.
+   *
+   * Extracts binary data from the event, feeding both `ArrayBuffer`
+   * (native RTCDataChannel with binaryType "arraybuffer") and
+   * `Uint8Array` (simple-peer and other wrappers) into the shared
+   * decode pipeline.
+   */
+  #handleMessage(remotePeerId, event) {
+    const attached = this.#attachedChannels.get(remotePeerId);
+    if (!attached || attached.channelId === null) return;
+    const syncChannel = this.channels.get(attached.channelId);
+    if (!syncChannel) return;
+    const raw = event.data;
+    const bytes = raw instanceof ArrayBuffer ? new Uint8Array(raw) : raw instanceof Uint8Array ? raw : null;
+    if (!bytes) {
+      return;
+    }
+    try {
+      const messages = decodeBinaryMessages(bytes, attached.reassembler);
+      if (messages) {
+        for (const msg of messages) {
+          syncChannel.onReceive(msg);
+        }
+      }
+    } catch (error) {
+      console.error(
+        `[webrtc-transport] Failed to decode message from peer ${remotePeerId}:`,
+        error
+      );
+    }
+  }
+};
+function createWebrtcTransport(options) {
+  return () => new WebrtcTransport(options);
+}
+export {
+  DEFAULT_FRAGMENT_THRESHOLD,
+  WebrtcTransport,
+  createWebrtcTransport
+};
+//# sourceMappingURL=index.js.map