@lazily-hub/lazily-js 0.4.0 → 0.5.0

package/.github/workflows/release.yml

@@ -24,6 +24,15 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+        with:
+          path: lazily-js
+
+      # The conformance / schema tests replay fixtures from the lazily-spec sibling
+      # (../lazily-spec). Check it out alongside so `npm test` passes in CI.
+      - uses: actions/checkout@v4
+        with:
+          repository: lazily-hub/lazily-spec
+          path: lazily-spec
 
       - uses: actions/setup-node@v4
         with:
@@ -35,9 +44,11 @@ jobs:
         run: npm install -g npm@latest
 
       - name: Install dependencies
+        working-directory: lazily-js
         run: npm ci || npm install
 
       - name: Test
+        working-directory: lazily-js
         run: npm test --if-present
 
       # Published under the `prev` dist-tag so this v0.x line does not steal
@@ -45,4 +56,14 @@ jobs:
       # (`npm dist-tag add @lazily-hub/lazily-js@<v> latest`) once the accidental
       # v1.x releases are removed.
       - name: Publish
-        run: npm publish --access public --tag prev
+        working-directory: lazily-js
+        run: |
+          version="$(node -p "require('./package.json').version")"
+          if npm publish --access public --tag prev; then
+            echo "published @lazily-hub/lazily-js@${version}"
+          elif npm view "@lazily-hub/lazily-js@${version}" version >/dev/null 2>&1; then
+            echo "@lazily-hub/lazily-js@${version} already published — idempotent no-op"
+          else
+            echo "publish failed for a reason other than already-published" >&2
+            exit 1
+          fi

package/README.md

@@ -6,6 +6,9 @@ is the JavaScript/TypeScript binding alongside [`lazily-rs`][rs],
 [`lazily-dart`][dart]. It ships:
 
 - a full reactive graph (`Context`, `Cell`, `Slot`, `Signal`, `Effect`);
+- an async reactive graph (`AsyncContext`) for Promise-driven derivations, with
+  revision-guarded stale-completion discard, in-flight deduplication, and
+  cancellation;
 - the [`lazily-spec`][spec] IPC wire types (`Snapshot`, `Delta`, `CrdtSync`,
   capability negotiation, and default-deny peer permissions);
 - keyed cell collections, move-minimized reconciliation, and a memoized
@@ -13,6 +16,9 @@ is the JavaScript/TypeScript binding alongside [`lazily-rs`][rs],
 - move-aware sequence CRDT, Fugue/RGA text CRDT, and manufactured text identity;
 - a Cell-backed flat state machine plus a full Harel/SCXML state-chart
   interpreter with the typed `ChartBuilder` API;
+- the distributed plane — the WebSocket signaling protocol + client, a
+  `DataChannel` transport seam with permission-filtering sink/source, a browser
+  `RTCPeerConnection` adapter, and the `CrdtPlaneRuntime` anti-entropy engine;
 - a koffi-backed state-projection consumer for agent-doc host projections.
 
 > **Package note.** Earlier `@lazily-hub/js` releases were only a state-projection
@@ -24,26 +30,34 @@ the FFI projection transport is used.
 
 ## Feature Set
 
-The full `lazily` capability set and its cross-language coverage (`lazily-rs`,
-`lazily-kt`, `lazily-js`). `✅` shipped, `~` partial, `—` not applicable/absent.
-
-| Feature | Rust | Kotlin | JS |
-|---------|:----:|:------:|:--:|
-| Reactive graph — `Context`, `Slot`, `Cell`, `memo`, `Signal` (eager), `Effect`, `batch` | ✅ | ✅ | ✅ |
-| Thread-safe `Context` (`Send + Sync`, lock-backed) | ✅ | ✅ | — |
-| Async reactive `Context` | ✅ | ✅ | — |
-| Statechart (Harel) + state machine | ✅ | ✅ | ✅ |
-| Keyed cell collections + `reconcile` + `SemTree` (keyed tree) | ✅ | ✅ | ✅ |
-| Stable-id alignment (manufactured identity) | ✅ | ✅ | ✅ |
-| Free-text character CRDT (`TextCrdt`) | ✅ | ✅ | ✅ |
-| **`TextCrdt` delta sync — `version_vector` / `delta_since` / `apply_delta` (`#lztextsync`)** | ✅ | ✅ | ✅ |
-| Move-aware sequence CRDT (`SeqCrdt`) | ✅ | ✅ | ✅ |
-| Registers (LWW / MV), `PnCounter`, `CellCrdt` | ✅ | ✅ | ✅ |
-| IPC wire — `Snapshot` + `Delta` + `CrdtSync` + shared-memory blobs | ✅ | ✅ | ~ |
-| State projection / mirror | ✅ | ✅ | ✅ |
-| FFI boundary | ✅ | ✅ | n/a |
-| Distributed plane (WebRTC transport + signaling) | ✅ | — | — |
-| Instrumentation / benchmarks | ✅ | — | — |
+The full `lazily` capability set across every binding. Legend: ✅ shipped ·
+`~` partial · `—` absent or not applicable. The canonical matrix with per-cell
+notes and platform carve-outs lives in
+[`lazily-spec` § Cross-Language Coverage](../lazily-spec/docs/coverage.md).
+
+| Feature | Rust | Python | Kotlin | JS | Dart | Zig |
+|---------|:----:|:------:|:------:|:--:|:----:|:---:|
+| Reactive graph — `Cell` / `Slot` / `Signal` / `Effect` / memo / batch | ✅ | ~ | ✅ | ✅ | ~ | ~ |
+| Thread-safe context (lock-backed) | ✅ | ✅ | ✅ | — | — | ✅ |
+| Async reactive context | ✅ | ✅ | ✅ | ✅ | ✅ | — |
+| Flat state machine | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Harel state charts | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Keyed cell collections (`CellMap` / `CellTree`) + reconcile | ✅ | ✅ | ✅ | ✅ | ✅ | ~ |
+| Memoized semantic tree (`SemTree`) | ✅ | — | ✅ | ✅ | — | — |
+| Stable-id alignment (manufactured identity) | ✅ | — | ✅ | ✅ | — | — |
+| Free-text character CRDT (`TextCrdt`) | ✅ | — | ✅ | ✅ | — | — |
+| `TextCrdt` delta sync (`version_vector` / `delta_since` / `apply_delta`) | ✅ | — | ✅ | ✅ | — | — |
+| Move-aware sequence CRDT (`SeqCrdt`) | ✅ | — | ✅ | ✅ | — | — |
+| Registers (LWW / MV) + `PnCounter` + `CellCrdt` | ✅ | — | ✅ | ✅ | — | — |
+| IPC wire — `Snapshot` + `Delta` + `CrdtSync` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Shared-memory blob path (`ShmBlobArena`) | ✅ | ✅ | ✅ | ~ | ~ | ✅ |
+| Distributed CRDT plane (`CrdtPlaneRuntime` / anti-entropy) | ✅ | — | ✅ | ✅ | ~ | — |
+| Distributed plane — WebRTC transport + signaling | ✅ | — | ✅ | ✅ | — | — |
+| State projection / mirror | ✅ | — | ✅ | ✅ | — | — |
+| C-ABI FFI boundary | ✅ | ✅ | ✅ | — | ✅ | ✅ |
+| Permission boundary (`PeerPermissions` / `RemoteOp`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Capability negotiation (`SessionHandshake`) | ✅ | — | ✅ | ✅ | ✅ | ✅ |
+| Instrumentation / benchmarks | ✅ | — | — | — | — | — |
 
 CRDT convergence and the wire protocol are pinned by the shared conformance fixtures
 and JSON Schemas in `lazily-spec` and the Lean models in `lazily-formal`.
@@ -53,6 +67,7 @@ and JSON Schemas in `lazily-spec` and the Lean models in `lazily-formal`.
 |--------|------------|
 | `@lazily-hub/lazily-js` | `lazily-spec` IPC wire types: `Snapshot`, `Delta`, `DeltaOp`, `IpcMessage` (`Snapshot` / `Delta` / `CrdtSync`), `NodeState`, `IpcValue`, `PeerPermissions`, `SessionHandshake`, `BINDING_CAPABILITIES` |
 | `@lazily-hub/lazily-js/reactive` | Reactive dependency graph: `Context`, `Cell`, `Slot`, `Signal`, `Effect` |
+| `@lazily-hub/lazily-js/reactive-async` | Async reactive graph: `AsyncContext` — Promise-driven slots/effects with revision-guarded stale-completion discard, in-flight dedup, and cancellation |
 | `@lazily-hub/lazily-js/state-machine` | Flat finite-state-machine kernel backed by a reactive `Cell` |
 | `@lazily-hub/lazily-js/statechart` | Harel/SCXML chart interpreter plus `ChartBuilder`, `StateBuilder`, `TransitionBuilder` |
 | `@lazily-hub/lazily-js/collections` | `CellMap`, `CellTree`, keyed reconciliation, and LIS move minimization |
@@ -60,6 +75,8 @@ and JSON Schemas in `lazily-spec` and the Lean models in `lazily-formal`.
 | `@lazily-hub/lazily-js/seq-crdt` | Move-aware sequence CRDT using independent LWW value / position / deletion registers |
 | `@lazily-hub/lazily-js/text-crdt` | Fugue/RGA character CRDT |
 | `@lazily-hub/lazily-js/stable-id` | Manufactured text identity: anchors, content hashes, similarity alignment |
+| `@lazily-hub/lazily-js/signaling` | WebSocket signaling protocol: `ClientMessage` / `ServerMessage`, `SignalingClient`, `SignalingRoom` routing (anti-spoof, roster), `SignalingPermissions` |
+| `@lazily-hub/lazily-js/distributed` | Distributed plane: `DataChannel` seam + `InMemoryDataChannel`, `WebRtcSink` / `WebRtcSource`, `CrdtPlaneRuntime` anti-entropy, and the browser `RTCPeerConnection` adapter |
 | `@lazily-hub/lazily-js/state-projection` | koffi FFI consumer for agent-doc `DocumentStateProjection` |
 
 ## Reactive graph
@@ -96,6 +113,40 @@ ctx.setCell(a, 11);
 ctx.getSignal(parity); // "odd", already materialized
 ```
 
+## Async reactive context
+
+`AsyncContext` (from `@lazily-hub/lazily-js/reactive-async`) is a **separate**
+reactive surface for derivations whose values are produced by `async` functions.
+It is not an overload of the synchronous `Context`: futures introduce in-flight
+state, stale completion, cancellation, and dependency tracking across `await`
+that the synchronous graph does not have. Cells remain the synchronous input
+layer; computed slots, memos, and effects are async.
+
+Each async slot runs an `Empty → Computing → Resolved/Error` state machine with
+**revision-guarded publish** (a completion is published only if the slot's
+revision is still current, so a stale result is discarded), **in-flight
+deduplication** (concurrent `getAsync` callers share one compute), and
+cooperative cancellation. Async effects serialize reruns and always run the
+previous cleanup before the next body.
+
+```js
+import { AsyncContext } from "@lazily-hub/lazily-js/reactive-async";
+
+const ctx = new AsyncContext();
+const userId = ctx.cell(1);
+
+const profile = ctx.computedAsync(async (cctx) => {
+  const id = cctx.getCell(userId); // dependency registered before the await
+  return await fetchProfile(id);
+});
+
+await ctx.getAsync(profile); // spawns the compute, awaits the value
+ctx.get(profile); // synchronous cached read once resolved (undefined while pending)
+
+ctx.setCell(userId, 2); // supersedes any in-flight compute; slot re-resolves
+await ctx.getAsync(profile); // the profile for user 2
+```
+
 ## State machine and state charts
 
 `StateMachine` is the flat finite-state-machine kernel: a pure
@@ -280,18 +331,54 @@ snapshot.filterReadable(permissions, 11).nodes.length; // 0
 
 `BINDING_CAPABILITIES` advertises the JS binding truthfully: reactive core,
 IPC, CRDT, keyed collections, semantic tree, sequence/text CRDT, stable-id,
-state machine, state charts, permissions, and capability negotiation are
-shipped; C-ABI FFI is `none` because browser/Worker JS cannot host a native
-in-process ABI; async context, signaling, and WebRTC transports are not shipped
-by this package. The same payload types can still be carried by any transport a
-host application owns.
+state machine, state charts, permissions, capability negotiation, async context,
+signaling, and the WebRTC transport are shipped; C-ABI FFI is `none` because
+browser/Worker JS cannot host a native in-process ABI. The same payload types
+can still be carried by any transport a host application owns.
+
+## Distributed plane
+
+The `@lazily-hub/lazily-js/signaling` and `@lazily-hub/lazily-js/distributed`
+entry points ship the distributed plane. Signaling is the kebab-tagged discovery
+wire protocol (`ClientMessage` / `ServerMessage`), a transport-agnostic
+`SignalingRoom` that enforces the anti-spoof forwarded-`from` invariant, and a
+`SignalingClient` over a pluggable socket seam. The distributed module is the
+WebRTC DataChannel IPC transport (`WebRtcSink` / `WebRtcSource` with outbound
+permission filtering, over any `DataChannel`) plus `CrdtPlaneRuntime`, the CRDT
+anti-entropy runtime. Both are koffi-free and testable over an in-memory loopback
+with zero network; "real" WebRTC is reached through a browser platform adapter
+(`RtcPeerChannel` / `RtcPeerConnector`) that wraps the `RTCDataChannel` /
+`RTCPeerConnection` globals with no npm dependency.
+
+```js
+import { CrdtPlaneRuntime, InMemoryDataChannel, WebRtcSink, WebRtcSource } from "@lazily-hub/lazily-js/distributed";
+import { SignalingRoom, ClientMessage } from "@lazily-hub/lazily-js/signaling";
+import { IpcMessage, IpcValue, PeerPermissions, OpKind, Snapshot, NodeSnapshot } from "@lazily-hub/lazily-js";
+
+// Route a signaling handshake with server-stamped `from` (anti-spoof).
+const room = new SignalingRoom();
+room.receive("a", ClientMessage.join(1));
+room.receive("b", ClientMessage.join(2));
+room.receive("a", ClientMessage.offer(2, "SDP-A")); // -> { to: "b", message: offer{ from: 1, sdp: "SDP-A" } }
+
+// Two replicas converge over an anti-entropy exchange.
+const alice = new CrdtPlaneRuntime(1);
+const bob = new CrdtPlaneRuntime(2);
+alice.register(1, "doc/title");
+bob.register(1, "doc/title");
+const op = alice.localUpdate(1, Date.now() * 1000, IpcValue.inline([66]));
+bob.ingest(alice.syncFrame(), Date.now() * 1000); // 1 op applied; re-ingest applies 0
+```
 
 ## Conformance
 
 lazily-js replays the shared `lazily-spec` fixtures for IPC, agent-doc state,
 keyed collections (`CellMap`, `CellTree`, LIS reconciliation), semantic tree,
-sequence and text CRDTs, manufactured text identity, and Harel state charts.
-It also validates generated wire values against the canonical JSON Schemas.
+sequence and text CRDTs, manufactured text identity, Harel state charts, the
+signaling protocol (`signaling/frames.json`, `signaling/anti_spoof_session.json`),
+and the distributed CRDT plane (`distributed/crdt_sync_frames.json`,
+`distributed/anti_entropy_converge.json`). It also validates generated wire
+values against the canonical JSON Schemas.
 
 `npm test` builds the [`lazily-formal`][formal] Lean 4 model when that sibling
 checkout and the `lake` toolchain are present. The script exits successfully
@@ -309,9 +396,15 @@ names the Lean theorems it mirrors:
 | `Collection` | `collection-properties.test.js` | `setEntryValue_preserves_{membership,order,siblings}`, `moveKey_preserves_{membership,values}`, `moveKey_advances_order`, `addKey_advances_membership_and_order`, `Family.get_idempotent_after_first` |
 | `Tree` | `tree-properties.test.js` | `setNodeValue_preserves_{other_nodes,node_signals}`, `moveChild_preserves_{non_parent,parent_value}`, `moveChild_advances_order_signal_only` |
 | `Reconciliation` | `reconciliation-properties.test.js` | `lisBy_longest`, `reconcile_move_minimized`, `reconcile_stable_not_invalidated` |
+| `AsyncSlotState` | `reactive-async.test.js` | `stale_completeOk_discarded`, `current_completeOk_publishes`, `current_completeErr_to_error` |
+| `AsyncEffect` | `reactive-async.test.js` | `fire_blocked_during_cleanup`, `invalidate_from_idle_schedules`, `cleanupDone_resumes_deferred`, `dispose_absorbing`, `disposed_terminal` |
 
-`AsyncSlotState`, `AsyncEffect`, and thread-safe context theorems are not mirrored
-because lazily-js does not ship async or thread-safe context surfaces.
+Thread-safe context theorems are not mirrored because JavaScript is
+single-threaded (one event loop): a lock-backed context has no meaning on this
+runtime — the concurrency-layer platform carve-out. The `Signaling` /
+`SignalingRoster` formal models are exercised through the `SignalingRoom`
+fixture replay (`signaling/anti_spoof_session.json`) rather than a named-theorem
+property test.
 
 ## The lazily family
 
@@ -319,7 +412,7 @@ because lazily-js does not ship async or thread-safe context surfaces.
 |---------|----------|----------------|
 | [`lazily-rs`][rs] | Rust | `lazily` on crates.io; single-threaded, thread-safe, and async context layers |
 | [`lazily-py`][py] | Python | `lazily` on PyPI; dict-backed context plus IPC/shared-blob host types |
-| **`lazily-js`** | JavaScript / TypeScript | `@lazily-hub/lazily-js`; reactive core, spec wire types, state charts, CRDTs |
+| **`lazily-js`** | JavaScript / TypeScript | `@lazily-hub/lazily-js`; reactive core + async context, spec wire types, state charts, CRDTs, distributed plane (signaling + WebRTC) |
 | [`lazily-zig`][zig] | Zig | Zig library / FFI-oriented embedding surface |
 | [`lazily-kt`][kt] | Kotlin/JVM | Kotlin reactive core plus typed state charts |
 | [`lazily-dart`][dart] | Dart | Dart binding with statechart conformance |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazily-hub/lazily-js",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Native JavaScript port of the lazily reactive core: a full reactive graph (Cell/Slot/Signal/Effect), the lazily-spec IPC wire types, keyed cell collections + LIS reconciliation, the memoized semantic tree, the move-aware sequence CRDT, the Fugue/RGA text CRDT, manufactured text identity, full-Harel state charts, and an FFI state-projection consumer.",
   "type": "module",
   "main": "src/index.js",
@@ -14,6 +14,10 @@
       "types": "./src/reactive.d.ts",
       "default": "./src/reactive.js"
     },
+    "./reactive-async": {
+      "types": "./src/reactive-async.d.ts",
+      "default": "./src/reactive-async.js"
+    },
     "./state-machine": {
       "types": "./src/state-machine.d.ts",
       "default": "./src/state-machine.js"
@@ -45,10 +49,18 @@
     "./state-projection": {
       "types": "./src/state-projection.d.ts",
       "default": "./src/state-projection.js"
+    },
+    "./signaling": {
+      "types": "./src/signaling.d.ts",
+      "default": "./src/signaling.js"
+    },
+    "./distributed": {
+      "types": "./src/distributed.d.ts",
+      "default": "./src/distributed.js"
     }
   },
   "scripts": {
-    "build": "node --check src/index.js && node --check src/reactive.js && node --check src/state-machine.js && node --check src/statechart.js && node --check src/collections.js && node --check src/sem-tree.js && node --check src/stable-id.js && node --check src/seq-crdt.js && node --check src/text-crdt.js && node --check src/state-projection.js",
+    "build": "node --check src/index.js && node --check src/reactive.js && node --check src/reactive-async.js && node --check src/state-machine.js && node --check src/statechart.js && node --check src/collections.js && node --check src/sem-tree.js && node --check src/stable-id.js && node --check src/seq-crdt.js && node --check src/text-crdt.js && node --check src/state-projection.js && node --check src/signaling.js && node --check src/distributed.js",
     "test:formal": "node scripts/formal-check.mjs",
     "test": "npm run test:formal && node --test test/*.test.js"
   },

package/src/distributed.d.ts

@@ -0,0 +1,136 @@
+import type {
+  CrdtOp,
+  CrdtSync,
+  IpcMessage,
+  IpcValueInline,
+  IpcValueSharedBlob,
+  PeerPermissions,
+  WireStamp,
+} from "./index.js";
+import type { SignalingClient } from "./signaling.js";
+
+export type PeerId = number;
+export type NodeId = number;
+export type IpcValue = IpcValueInline | IpcValueSharedBlob;
+
+// --- DataChannel transport ---
+
+/**
+ * Minimal ordered, reliable, bidirectional byte-frame channel. One frame is one
+ * serialized IpcMessage; the methods are non-blocking.
+ */
+export interface DataChannel {
+  sendFrame(frame: Uint8Array): void;
+  tryRecvFrame(): Uint8Array | null;
+  isOpen(): boolean;
+  close(): void;
+}
+
+export const WebRtcTransportErrorKind: {
+  readonly Closed: "Closed";
+  readonly Encode: "Encode";
+  readonly Decode: "Decode";
+  readonly Channel: "Channel";
+};
+
+export class WebRtcTransportError extends Error {
+  readonly name: "WebRtcTransportError";
+  readonly kind: "Closed" | "Encode" | "Decode" | "Channel";
+  readonly cause?: unknown;
+  constructor(kind: "Closed" | "Encode" | "Decode" | "Channel", cause?: unknown);
+  static closed(): WebRtcTransportError;
+  static encode(cause: unknown): WebRtcTransportError;
+  static decode(cause: unknown): WebRtcTransportError;
+  static channel(cause: unknown): WebRtcTransportError;
+}
+
+export class InMemoryDataChannel implements DataChannel {
+  static pair(): [InMemoryDataChannel, InMemoryDataChannel];
+  sendFrame(frame: Uint8Array): void;
+  tryRecvFrame(): Uint8Array | null;
+  isOpen(): boolean;
+  close(): void;
+}
+
+export class WebRtcSink {
+  constructor(channel: DataChannel, permissions: PeerPermissions, peer: PeerId);
+  readonly channel: DataChannel;
+  send(message: IpcMessage): void;
+}
+
+export class WebRtcSource {
+  constructor(channel: DataChannel);
+  readonly channel: DataChannel;
+  recv(): IpcMessage | null;
+}
+
+// --- CRDT anti-entropy runtime ---
+
+export interface PlaneCell {
+  merge(op: CrdtOp): boolean;
+  readonly value: IpcValue | undefined;
+}
+
+export interface FrontierEntry {
+  peer: PeerId;
+  stamp: WireStamp;
+}
+
+export interface ConvergedEntry {
+  node: NodeId;
+  key?: string;
+  state: unknown;
+}
+
+export class CrdtPlaneRuntime {
+  constructor(peer: PeerId);
+  readonly peer: PeerId;
+  readonly size: number;
+  isEmpty(): boolean;
+  register(node: NodeId, key?: string | null, cell?: PlaneCell | null): this;
+  value(node: NodeId): IpcValue | undefined;
+  winningOp(node: NodeId): CrdtOp | undefined;
+  nodes(): NodeId[];
+  converged(): ConvergedEntry[];
+  localUpdate(node: NodeId, nowMicros: number, state: IpcValue | Uint8Array): CrdtOp | null;
+  ingest(sync: CrdtSync, nowMicros: number): number;
+  frontierEntries(): FrontierEntry[];
+  wireFrontier(): Array<[PeerId, unknown]>;
+  membership(): PeerId[];
+  membershipCount(): number;
+  syncFrame(): CrdtSync;
+  syncFrameSince(
+    since: Iterable<FrontierEntry | [PeerId, WireStamp | unknown]>,
+  ): CrdtSync;
+  syncReply(request: CrdtSync): CrdtSync;
+}
+
+// --- Browser WebRTC platform adapter ---
+
+export function isWebRtcAvailable(): boolean;
+
+export class RtcPeerChannel implements DataChannel {
+  constructor(dataChannel: RTCDataChannel);
+  sendFrame(frame: Uint8Array): void;
+  tryRecvFrame(): Uint8Array | null;
+  isOpen(): boolean;
+  close(): void;
+}
+
+export interface RtcPeerConnectorOptions {
+  rtcConfig?: RTCConfiguration;
+  remote?: PeerId | null;
+}
+
+export class RtcPeerConnector {
+  constructor(signalingClient: SignalingClient, options?: RtcPeerConnectorOptions);
+  readonly connection: RTCPeerConnection;
+  set remote(peer: PeerId);
+  createDataChannel(label?: string, options?: RTCDataChannelInit): RtcPeerChannel;
+  onDataChannel(): Promise<RtcPeerChannel>;
+  createOffer(to: PeerId): Promise<RTCSessionDescriptionInit>;
+  acceptOffer(from: PeerId, sdp: string): Promise<RTCSessionDescriptionInit>;
+  acceptAnswer(sdp: string): Promise<void>;
+  addIceCandidate(candidate: string | RTCIceCandidateInit): Promise<void>;
+  close(): void;
+}