p2party 0.8.0 → 0.14.2

package/examples/standalone-e2ee.ts

@@ -0,0 +1,194 @@
+/**
+ * Public standalone E2EE API — no WebRTC, signaling, Redux, IndexedDB, OPFS,
+ * `window`, or `localStorage`.
+ *
+ * Run from this repository:
+ *   bun run examples/standalone-e2ee.ts
+ *
+ * Installed package:
+ *   import { createSession, generateSessionIdentity, restoreSession }
+ *     from "p2party/session";
+ *
+ * The packaged copy detects the missing repository source tree and exercises
+ * the installed public session entry point plus its release-matched WASM.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+
+import type { HandshakeTransport } from "../src/session";
+
+const sourceSessionUrl = new URL("../src/session.ts", import.meta.url);
+const installedSessionSpecifier: string = "p2party/session";
+const { createSession, generateSessionIdentity, restoreSession } = existsSync(
+  sourceSessionUrl,
+)
+  ? await import("../src/session")
+  : ((await import(
+      installedSessionSpecifier
+    )) as typeof import("../src/session"));
+
+const sourceWasmUrl = new URL(
+  "../src/cryptography/libcrypto.wasm",
+  import.meta.url,
+);
+const require = createRequire(import.meta.url);
+const wasmFile = readFileSync(
+  existsSync(sourceWasmUrl)
+    ? sourceWasmUrl
+    : require.resolve("p2party/libcrypto.wasm"),
+);
+const wasmBinary = wasmFile.buffer.slice(
+  wasmFile.byteOffset,
+  wasmFile.byteOffset + wasmFile.byteLength,
+) as ArrayBuffer;
+const cryptoOptions = { wasmBinary };
+
+// One one-way byte pipe. Two pipes form the full-duplex transport that carries
+// the triple-confirmation authenticated handshake; a network app sends these bytes over
+// its own socket/channel instead.
+const makeLink = () => {
+  const queued: Uint8Array[] = [];
+  const waiters: Array<(bytes: Uint8Array) => void> = [];
+  return {
+    send(bytes: Uint8Array): void {
+      const owned = Uint8Array.from(bytes);
+      const waiter = waiters.shift();
+      if (waiter) waiter(owned);
+      else queued.push(owned);
+    },
+    recv(): Promise<Uint8Array> {
+      const bytes = queued.shift();
+      return bytes
+        ? Promise.resolve(bytes)
+        : new Promise((resolve) => waiters.push(resolve));
+    },
+  };
+};
+
+const main = async () => {
+  // Long-term identities. Persist these securely in a real application.
+  const [aliceIdentity, bobIdentity] = await Promise.all([
+    generateSessionIdentity(cryptoOptions),
+    generateSessionIdentity(cryptoOptions),
+  ]);
+
+  const aliceToBob = makeLink();
+  const bobToAlice = makeLink();
+  const channelId = crypto.getRandomValues(new Uint8Array(16));
+  const aliceFingerprint = crypto.getRandomValues(new Uint8Array(32));
+  const bobFingerprint = crypto.getRandomValues(new Uint8Array(32));
+
+  const transport = (
+    send: (bytes: Uint8Array) => void,
+    recv: () => Promise<Uint8Array>,
+  ): HandshakeTransport => ({ send, recv });
+
+  // Both peers run concurrently. `x25519SecretKey` is the identity DH secret;
+  // the Ed25519 key anchors/cross-signs it and is never passed as idSelfSec.
+  const [alice, bob] = await Promise.all([
+    createSession({
+      role: "initiator",
+      identity: aliceIdentity,
+      peerIdentityEd25519PublicKey: bobIdentity.ed25519PublicKey,
+      channel: {
+        channelId,
+        localFingerprint: aliceFingerprint,
+        remoteFingerprint: bobFingerprint,
+      },
+      transport: transport(aliceToBob.send, bobToAlice.recv),
+      mode: "nopin",
+      crypto: cryptoOptions,
+    }),
+    createSession({
+      role: "responder",
+      identity: bobIdentity,
+      peerIdentityEd25519PublicKey: aliceIdentity.ed25519PublicKey,
+      channel: {
+        channelId,
+        localFingerprint: bobFingerprint,
+        remoteFingerprint: aliceFingerprint,
+      },
+      transport: transport(bobToAlice.send, aliceToBob.recv),
+      mode: "nopin",
+      crypto: cryptoOptions,
+    }),
+  ]);
+  console.log("handshake complete — protocol", alice.protocolVersion);
+  if (!alice.canEncrypt || !bob.canEncrypt)
+    throw new Error("both sessions must be ready to encrypt after handshake");
+
+  // The envelope carries the Merkle root once alongside uniform chunk frames.
+  // Produce both message-0 envelopes before either side decrypts: the handshake
+  // primes both ratchet directions, so responder-first and simultaneous sends
+  // need no application-level initiator-first ordering.
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const aliceMessage = encoder.encode("hello bob, from alice");
+  const bobMessage = encoder.encode("hi alice, bob here");
+  const [aliceEnvelope, bobEnvelope] = await Promise.all([
+    alice.encrypt(aliceMessage),
+    bob.encrypt(bobMessage),
+  ]);
+  const [receivedByBob, receivedByAlice] = await Promise.all([
+    bob.decrypt(aliceEnvelope),
+    alice.decrypt(bobEnvelope),
+  ]);
+  console.log("alice → bob:", decoder.decode(receivedByBob));
+  console.log("bob → alice:", decoder.decode(receivedByAlice));
+
+  // Snapshots are plaintext secrets: encrypt them at rest and protect against
+  // rollback. Restoration needs no Redux/DB and continues the same ratchet.
+  const aliceSnapshot = await alice.serialize();
+  const restoredAlice = await restoreSession(aliceSnapshot, cryptoOptions);
+  await alice.destroy();
+
+  const afterRestore = encoder.encode("still here after restore");
+  const restoredMessage = await restoredAlice.decrypt(
+    await bob.encrypt(afterRestore),
+  );
+  if (decoder.decode(restoredMessage) !== decoder.decode(afterRestore))
+    throw new Error("restore round-trip mismatch");
+
+  // Protocol-v4 sparse post-quantum healing over the store-free control API.
+  // The persist-before-send contract: whenever a call returns a frame, the
+  // caller must serialize() before delivering it so a crash cannot fork the
+  // OFFER/ADVANCE/ACK sequence. Drive one exchange to reach epoch 1.
+  for (let index = 0; index < 64; index += 1)
+    await bob.decrypt(await restoredAlice.encrypt(encoder.encode(`m${index}`)));
+  const offer = await restoredAlice.prepareHealing();
+  if (offer.frame) {
+    await restoredAlice.serialize();
+    const advance = await bob.acceptControlFrame(offer.frame);
+    if (!advance.frame) throw new Error("expected ADVANCE");
+    await bob.serialize();
+    const ack = await restoredAlice.acceptControlFrame(advance.frame);
+    if (!ack.frame) throw new Error("expected ACK");
+    await restoredAlice.serialize();
+    await bob.acceptControlFrame(ack.frame);
+    if (restoredAlice.pqEpoch !== 1n || bob.pqEpoch !== 1n)
+      throw new Error("sparse-PQ healing did not reach epoch 1");
+    const healed = encoder.encode("post-quantum healed");
+    const healedRoundTrip = await bob.decrypt(
+      await restoredAlice.encrypt(healed),
+    );
+    if (decoder.decode(healedRoundTrip) !== decoder.decode(healed))
+      throw new Error("post-heal round-trip mismatch");
+    console.log("sparse-PQ healing reached epoch:", String(bob.pqEpoch));
+  }
+
+  aliceIdentity.ed25519SecretKey.fill(0);
+  aliceIdentity.x25519SecretKey.fill(0);
+  bobIdentity.ed25519SecretKey.fill(0);
+  bobIdentity.x25519SecretKey.fill(0);
+  aliceSnapshot.fill(0);
+  await Promise.all([restoredAlice.destroy(), bob.destroy()]);
+
+  console.log(
+    "\nOK — public createSession E2EE + restore verified (no browser).",
+  );
+};
+
+main().catch((error) => {
+  console.error("FAILED:", error);
+  process.exit(1);
+});

package/lib/api/signalingServerApi.d.ts

@@ -1,16 +1,15 @@
 import type { BaseQueryFn } from "@reduxjs/toolkit/query";
-import type { WebSocketMessageCandidateSend, WebSocketMessageDescriptionSend, WebSocketMessageChallengeResponse, WebSocketMessageRoomIdRequest, WebSocketMessagePeersRequest, WebSocketMessageConnectionResponse, WebSocketMessagePongResponse, WebSocketMessageMessageSendRequest, WebSocketPeerConnectionParams } from "../utils/interfaces";
+import type { WebSocketMessageCandidateSend, WebSocketMessageDescriptionSend, WebSocketMessageChallengeResponse, WebSocketMessageRoomIdRequest, WebSocketMessagePeersRequest, WebSocketMessageConnectionResponse, WebSocketMessagePongResponse, WebSocketPeerConnectionParams } from "../utils/interfaces";
 export interface WebSocketParams {
     signalingServerUrl: string;
 }
 export interface WebSocketMessage {
-    content: WebSocketMessagePongResponse | WebSocketMessageCandidateSend | WebSocketMessageDescriptionSend | WebSocketMessageChallengeResponse | WebSocketMessageRoomIdRequest | WebSocketMessagePeersRequest | WebSocketMessageConnectionResponse | WebSocketMessageMessageSendRequest;
+    content: WebSocketMessagePongResponse | WebSocketMessageCandidateSend | WebSocketMessageDescriptionSend | WebSocketMessageChallengeResponse | WebSocketMessageRoomIdRequest | WebSocketMessagePeersRequest | WebSocketMessageConnectionResponse;
 }
 declare const signalingServerApi: import("@reduxjs/toolkit/query").Api<BaseQueryFn<WebSocketParams, undefined>, {
-    connectWebSocket: import("@reduxjs/toolkit/query").MutationDefinition<string, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
-    disconnectWebSocket: import("@reduxjs/toolkit/query").MutationDefinition<void, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
-    sendMessage: import("@reduxjs/toolkit/query").MutationDefinition<WebSocketMessage, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
-    connectWithPeer: import("@reduxjs/toolkit/query").MutationDefinition<WebSocketPeerConnectionParams, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
+    connectWebSocket: import("@reduxjs/toolkit/query").MutationDefinition<string, BaseQueryFn<WebSocketParams, undefined>, never, undefined, "signalingServerApi", undefined>;
+    disconnectWebSocket: import("@reduxjs/toolkit/query").MutationDefinition<undefined, BaseQueryFn<WebSocketParams, undefined>, never, undefined, "signalingServerApi", undefined>;
+    sendMessage: import("@reduxjs/toolkit/query").MutationDefinition<WebSocketMessage, BaseQueryFn<WebSocketParams, undefined>, never, undefined, "signalingServerApi", undefined>;
+    connectWithPeer: import("@reduxjs/toolkit/query").MutationDefinition<WebSocketPeerConnectionParams, BaseQueryFn<WebSocketParams, undefined>, never, undefined, "signalingServerApi", undefined>;
 }, "signalingServerApi", never, typeof import("@reduxjs/toolkit/query").coreModuleName>;
 export default signalingServerApi;
-//# sourceMappingURL=signalingServerApi.d.ts.map

package/lib/api/webrtc/baseQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCPeerConnectionParamsExtend extends RTCPeerConnectionParams {
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcBaseQuery: BaseQueryFn<RTCPeerConnectionParamsExtend, void, unknown>;
+declare const webrtcBaseQuery: BaseQueryFn<RTCPeerConnectionParamsExtend, undefined>;
 export default webrtcBaseQuery;
-//# sourceMappingURL=baseQuery.d.ts.map

package/lib/api/webrtc/disconnectFromAllRoomsQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCDisconnectFromAllRoomsParamsExtension extends RTCDisconnectF
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcDisconnectAllRoomsQuery: BaseQueryFn<RTCDisconnectFromAllRoomsParamsExtension, void, unknown>;
+declare const webrtcDisconnectAllRoomsQuery: BaseQueryFn<RTCDisconnectFromAllRoomsParamsExtension, undefined>;
 export default webrtcDisconnectAllRoomsQuery;
-//# sourceMappingURL=disconnectFromAllRoomsQuery.d.ts.map

package/lib/api/webrtc/disconnectFromChannelLabelQuery.d.ts

@@ -3,6 +3,5 @@ import type { IRTCDataChannel, RTCDisconnectFromChannelLabelParams } from "./int
 export interface RTCDisconnectFromChannelLabelParamsExtension extends RTCDisconnectFromChannelLabelParams {
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcDisconnectFromChannelLabelQuery: BaseQueryFn<RTCDisconnectFromChannelLabelParamsExtension, void, unknown>;
+declare const webrtcDisconnectFromChannelLabelQuery: BaseQueryFn<RTCDisconnectFromChannelLabelParamsExtension, undefined>;
 export default webrtcDisconnectFromChannelLabelQuery;
-//# sourceMappingURL=disconnectFromChannelLabelQuery.d.ts.map

package/lib/api/webrtc/disconnectFromPeerChannelLabelQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCDisconnectFromPeerChannelLabelParamsExtension extends RTCDis
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcDisconnectFromPeerChannelLabelQuery: BaseQueryFn<RTCDisconnectFromPeerChannelLabelParamsExtension, void, unknown>;
+declare const webrtcDisconnectFromPeerChannelLabelQuery: BaseQueryFn<RTCDisconnectFromPeerChannelLabelParamsExtension, undefined>;
 export default webrtcDisconnectFromPeerChannelLabelQuery;
-//# sourceMappingURL=disconnectFromPeerChannelLabelQuery.d.ts.map

package/lib/api/webrtc/disconnectFromPeerQuery.d.ts

@@ -1,9 +1,9 @@
 import type { BaseQueryFn } from "@reduxjs/toolkit/query";
-import type { IRTCDataChannel, IRTCPeerConnection, RTCDisconnectFromPeerParams } from "./interfaces";
+import type { IRTCDataChannel, IRTCIceCandidate, IRTCPeerConnection, RTCDisconnectFromPeerParams } from "./interfaces";
 export interface RTCDisconnectFromPeerParamsExtension extends RTCDisconnectFromPeerParams {
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
+    iceCandidates: IRTCIceCandidate[];
 }
-declare const webrtcDisconnectPeerQuery: BaseQueryFn<RTCDisconnectFromPeerParamsExtension, void, unknown>;
+declare const webrtcDisconnectPeerQuery: BaseQueryFn<RTCDisconnectFromPeerParamsExtension, undefined>;
 export default webrtcDisconnectPeerQuery;
-//# sourceMappingURL=disconnectFromPeerQuery.d.ts.map

package/lib/api/webrtc/disconnectFromRoomQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCDisconnectFromRoomParamsExtension extends RTCDisconnectFromR
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcDisconnectRoomQuery: BaseQueryFn<RTCDisconnectFromRoomParamsExtension, void, unknown>;
+declare const webrtcDisconnectRoomQuery: BaseQueryFn<RTCDisconnectFromRoomParamsExtension, undefined>;
 export default webrtcDisconnectRoomQuery;
-//# sourceMappingURL=disconnectFromRoomQuery.d.ts.map

package/lib/api/webrtc/disconnectQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCDisconnectParamsExtension extends RTCDisconnectParams {
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcDisconnectQuery: BaseQueryFn<RTCDisconnectParamsExtension, void, unknown>;
+declare const webrtcDisconnectQuery: BaseQueryFn<RTCDisconnectParamsExtension, undefined>;
 export default webrtcDisconnectQuery;
-//# sourceMappingURL=disconnectQuery.d.ts.map

package/lib/api/webrtc/iceGeneration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return every ICE username fragment advertised by the active remote SDP.
+ * Multiple values are legitimate when media sections are not bundled.
+ */
+export declare const remoteIceUsernameFragments: (description: RTCSessionDescription | RTCSessionDescriptionInit | null) => Set<string>;
+/**
+ * Prefer the structured usernameFragment, but recover the optional `ufrag`
+ * candidate extension when signaling supplied only a candidate string.
+ */
+export declare const candidateIceUsernameFragment: (candidate: RTCIceCandidateInit) => string | null;
+/**
+ * Reject a candidate that explicitly names an ICE generation absent from the
+ * active remote description. Candidates without a ufrag remain acceptable:
+ * older signaling payloads omit it and the browser can still route them by
+ * sdpMid/sdpMLineIndex.
+ */
+export declare const candidateMatchesRemoteIceGeneration: (candidate: RTCIceCandidateInit, remoteDescription: RTCSessionDescription | RTCSessionDescriptionInit | null) => boolean;

package/lib/api/webrtc/iceRepair.d.ts

@@ -0,0 +1,10 @@
+type IceRestartTarget = Pick<RTCPeerConnection, "connectionState" | "signalingState" | "restartIce">;
+export type IceCandidateRepairResult = "restarted" | "disconnected";
+/**
+ * Repair a candidate-add failure without ever calling restartIce() after
+ * teardown. Active PCs restart in place; closed PCs, or PCs whose restart
+ * throws because they closed concurrently, take the room-scoped disconnect
+ * path instead.
+ */
+export declare const repairIceTransportAfterCandidateFailure: (target: IceRestartTarget, disconnect: () => void | Promise<void>) => Promise<IceCandidateRepairResult>;
+export {};

package/lib/api/webrtc/index.d.ts

@@ -1,16 +1,16 @@
 import type { RTCPeerConnectionParams, RTCSendMessageParams, RTCSetDescriptionParams, RTCSetCandidateParams, RTCOpenChannelParams, RTCDisconnectFromRoomParams, RTCDisconnectFromAllRoomsParams, RTCDisconnectFromPeerParams, RTCDisconnectFromChannelLabelParams, RTCDisconnectFromPeerChannelLabelParams, RTCDisconnectParams } from "./interfaces";
-declare const webrtcApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, {
-    connectWithPeer: import("@reduxjs/toolkit/query").MutationDefinition<RTCPeerConnectionParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    setDescription: import("@reduxjs/toolkit/query").MutationDefinition<RTCSetDescriptionParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    setCandidate: import("@reduxjs/toolkit/query").MutationDefinition<RTCSetCandidateParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    openChannel: import("@reduxjs/toolkit/query").MutationDefinition<RTCOpenChannelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    sendMessage: import("@reduxjs/toolkit/query").MutationDefinition<RTCSendMessageParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    disconnect: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    disconnectFromRoom: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromRoomParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    disconnectFromAllRooms: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromAllRoomsParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    disconnectFromPeer: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromPeerParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    disconnectFromChannelLabel: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromChannelLabelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
-    disconnectFromPeerChannelLabel: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromPeerChannelLabelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+import type { SendMessageResult } from "../../handlers/handleSendMessage";
+declare const webrtcApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, {
+    connectWithPeer: import("@reduxjs/toolkit/query").MutationDefinition<RTCPeerConnectionParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    setDescription: import("@reduxjs/toolkit/query").MutationDefinition<RTCSetDescriptionParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    setCandidate: import("@reduxjs/toolkit/query").MutationDefinition<RTCSetCandidateParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    openChannel: import("@reduxjs/toolkit/query").MutationDefinition<RTCOpenChannelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    sendMessage: import("@reduxjs/toolkit/query").MutationDefinition<RTCSendMessageParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, SendMessageResult | undefined, "webrtcApi", undefined>;
+    disconnect: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    disconnectFromRoom: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromRoomParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    disconnectFromAllRooms: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromAllRoomsParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    disconnectFromPeer: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromPeerParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    disconnectFromChannelLabel: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromChannelLabelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
+    disconnectFromPeerChannelLabel: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromPeerChannelLabelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, undefined>, never, undefined, "webrtcApi", undefined>;
 }, "webrtcApi", never, typeof import("@reduxjs/toolkit/query").coreModuleName>;
 export default webrtcApi;
-//# sourceMappingURL=index.d.ts.map

package/lib/api/webrtc/interfaces.d.ts

@@ -1,18 +1,66 @@
 import type { LibCrypto } from "../../cryptography/libcrypto";
-export interface IRTCPeerConnectionRoomId {
-    roomId: string;
-    receiveMessageModule: LibCrypto;
-}
+import type { RatchetState } from "../../cryptography/ratchet";
+import type { RatchetGateLease } from "../../handlers/ratchetGate";
+import type { CoverRuntime } from "../../handlers/coverRuntime";
+import type { SparsePqHealingState } from "../../handlers/pqHealingRuntime";
 export interface IRTCPeerConnection extends RTCPeerConnection {
+    /** The room this transport belongs to. A room/peer pair owns one PC. */
+    roomId: string;
     withPeerId: string;
     withPeerPublicKey: string;
     makingOffer: boolean;
-    rooms: IRTCPeerConnectionRoomId[];
-    iceCandidates: RTCIceCandidate[];
+    ignoreOffer: boolean;
+    receiveMessageModule: LibCrypto;
+    iceCandidates: RTCIceCandidateInit[];
+    /** Persistent control channel for this room/peer transport. */
+    mainChannel?: IRTCDataChannel;
+    /** Gate ownership captured when this concrete transport is created. */
+    ratchetGateLease: RatchetGateLease;
+    /** Resolves once the per-transport WASM dependency is ready. */
+    initialization?: Promise<void>;
+    ratchetState?: RatchetState;
+    ratchetEstablished?: Promise<void>;
+    messageKeyCache?: Map<string, Uint8Array>;
+    /** Maps a live transfer root to its `(dhPub,N)` receive-cache key for cancel cleanup. */
+    messageKeyByMerkleRoot?: Map<string, string>;
+    /** All configured non-main channels, including connecting channels. */
+    messageChannels?: Set<IRTCDataChannel>;
+    /**
+     * Protocol-v4 atomic edge checkpoint hook. The PQ runtime installs this
+     * store-free serializer before the initial ratchet row is committed.
+     */
+    serializeEdgeCryptoState?: () => Uint8Array;
+    /**
+     * Protocol-v4 live sparse-PQ runtime for this authenticated edge. Installed
+     * synchronously with `ratchetState` after the initial row (ratchet + PQ
+     * checkpoint) is durable; destroyed with it on teardown/replacement.
+     */
+    pqHealingState?: SparsePqHealingState;
+    /**
+     * Protocol-v4 scheduled-cover runtime, present ONLY on edges of rooms whose
+     * authenticated policy selects `coverMode: "scheduled"`. Its presence is the
+     * scheduled-mode signal for the send/receive/receipt/cancel paths.
+     */
+    coverRuntime?: CoverRuntime;
+    /**
+     * Protocol-v4 scheduled-cover lanes for this edge (both the outbound lanes
+     * this peer opens and the inbound lanes the peer opens). Kept SEPARATE from
+     * `messageChannels` so continuous cover lanes never block healing quiescence
+     * or exhaust the per-edge message-channel budget; cells route purely by type.
+     */
+    coverChannels?: Set<IRTCDataChannel>;
 }
 export interface IRTCDataChannel extends RTCDataChannel {
     withPeerId: string;
-    roomIds: string[];
+    /** A data channel belongs to exactly one room. */
+    roomIds: [string];
+    /** Releases queue/channel accounting even when teardown nulls onclose. */
+    releaseProtocolResources?: () => void;
+    /**
+     * Abort an inbound message pipeline, retire its persisted receive key, and
+     * delete its storage artifacts after the active handler reaches quiescence.
+     */
+    cancelReceiveTransfer?: () => Promise<void>;
 }
 export interface IRTCMessage {
     id: string;
@@ -22,14 +70,14 @@ export interface IRTCMessage {
     channelLabel: string;
     timestamp: Date;
 }
-export interface IRTCIceCandidate extends RTCIceCandidate {
+export interface IRTCIceCandidate extends RTCIceCandidateInit {
+    roomId: string;
     withPeerId: string;
 }
 export interface RTCPeerConnectionParams {
     peerId: string;
     peerPublicKey: string;
     roomId: string;
-    initiator?: boolean;
     rtcConfig?: RTCConfiguration;
 }
 export interface RTCSetDescriptionParams {
@@ -41,7 +89,8 @@ export interface RTCSetDescriptionParams {
 }
 export interface RTCSetCandidateParams {
     peerId: string;
-    candidate: RTCIceCandidate;
+    roomId: string;
+    candidate: RTCIceCandidateInit | RTCIceCandidate;
 }
 export interface RTCOpenChannelParams {
     roomId: string;
@@ -52,6 +101,8 @@ export interface RTCOpenChannelParams {
     }[];
 }
 export interface RTCSendMessageParams {
+    /** Random 32-byte lowercase-hex identity allocated by the public API. */
+    transferId: string;
     data: string | File;
     label: string;
     roomId: string;
@@ -93,19 +144,24 @@ export interface RTCDisconnectFromAllRoomsParams {
 }
 export interface RTCDisconnectFromPeerParams {
     peerId: string;
+    /** When present, tear down only this room/peer transport. */
+    roomId?: string;
     alsoDeleteData?: boolean;
 }
 export interface RTCDisconnectFromChannelLabelParams {
+    roomId: string;
     label: string;
     messageHash?: Uint8Array;
     alsoDeleteData?: boolean;
     alsoSendFinishedMessage?: boolean;
 }
 export interface RTCDisconnectFromPeerChannelLabelParams {
+    roomId: string;
     peerId: string;
     label: string;
     messageHash?: Uint8Array;
     alsoDeleteData?: boolean;
     alsoSendFinishedMessage?: boolean;
+    /** Internal exact-object selector; prevents a stale callback closing a replacement. */
+    channel?: IRTCDataChannel;
 }
-//# sourceMappingURL=interfaces.d.ts.map

package/lib/api/webrtc/negotiationLock.d.ts

@@ -0,0 +1,12 @@
+import { AsyncMutex } from "../../utils/mutex";
+export declare const getRoomPeerMutex: (roomId: string, peerId: string) => AsyncMutex;
+/**
+ * Forget a terminal edge only after its current owner and queued signaling
+ * operations drain. Deleting a locked mutex would permit a second instance to
+ * enter the same critical section concurrently.
+ */
+export declare const releaseRoomPeerMutex: (roomId: string, peerId: string) => void;
+/** Narrow test visibility without exposing the mutable registry. */
+export declare const hasRoomPeerMutex: (roomId: string, peerId: string) => boolean;
+export declare const getRoomIdentityMutex: (roomId: string, peerPublicKey: string) => AsyncMutex;
+export declare const releaseRoomIdentityMutex: (roomId: string, peerPublicKey: string) => void;

package/lib/api/webrtc/openChannelQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCOpenChannelParamsExtention extends RTCOpenChannelParams {
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcOpenChannelQuery: BaseQueryFn<RTCOpenChannelParamsExtention, void, unknown>;
+declare const webrtcOpenChannelQuery: BaseQueryFn<RTCOpenChannelParamsExtention, undefined>;
 export default webrtcOpenChannelQuery;
-//# sourceMappingURL=openChannelQuery.d.ts.map

package/lib/api/webrtc/pendingIceCandidates.d.ts

@@ -0,0 +1,14 @@
+import type { IRTCIceCandidate } from "./interfaces";
+/** Bounds unauthenticated signaling state held before an SDP creates an edge. */
+export declare const MAX_PENDING_ICE_PER_EDGE = 64;
+export declare const MAX_PENDING_ICE_TOTAL = 1024;
+export declare const normalizeIceCandidate: (candidate: RTCIceCandidateInit | RTCIceCandidate) => RTCIceCandidateInit;
+export declare const enqueuePendingIceCandidate: (queue: IRTCIceCandidate[], roomId: string, peerId: string, candidate: RTCIceCandidateInit) => void;
+export declare const enqueueConnectionIceCandidate: (queue: RTCIceCandidateInit[], candidate: RTCIceCandidateInit) => void;
+export declare const takePendingIceCandidates: (queue: IRTCIceCandidate[], roomId: string, peerId: string) => RTCIceCandidateInit[];
+export declare const discardPendingIceCandidates: (queue: IRTCIceCandidate[], roomId: string, peerId: string) => void;
+/**
+ * Abandon one room/peer SDP attempt without disturbing the same peer's ICE
+ * candidates in another room.
+ */
+export declare const discardIceCandidatesForAttempt: (connectionQueue: RTCIceCandidateInit[], pendingQueue: IRTCIceCandidate[], roomId: string, peerId: string) => void;

package/lib/api/webrtc/roomPeer.d.ts

@@ -0,0 +1,11 @@
+import type { IRTCPeerConnection } from "./interfaces";
+export declare const isRoomPeerConnection: (connection: IRTCPeerConnection, roomId: string, peerId: string) => boolean;
+export declare const findRoomPeerConnectionIndex: (connections: IRTCPeerConnection[], roomId: string, peerId: string) => number;
+export declare const findRoomPeerConnection: (connections: IRTCPeerConnection[], roomId: string, peerId: string) => IRTCPeerConnection | undefined;
+/**
+ * A peerId is a transient signaling handle; the Ed25519 public key is the
+ * stable cryptographic identity. Return transports in this room which claim
+ * the same stable identity under a different peerId so callers can replace
+ * them before a second live ratchet owner is created.
+ */
+export declare const findRoomIdentityAliases: (connections: IRTCPeerConnection[], roomId: string, peerId: string, peerPublicKey: string) => IRTCPeerConnection[];

package/lib/api/webrtc/sendMessageQuery.d.ts

@@ -1,11 +1,14 @@
 import type { BaseQueryFn } from "@reduxjs/toolkit/query";
 import type { IRTCDataChannel, IRTCPeerConnection, RTCSendMessageParams } from "./interfaces";
+import type { SendMessageResult } from "../../handlers/handleSendMessage";
 export interface RTCChannelMessageParamsExtension extends RTCSendMessageParams {
     peerConnections: IRTCPeerConnection[];
     dataChannels: IRTCDataChannel[];
-    encryptionWasmMemory: WebAssembly.Memory;
-    merkleWasmMemory: WebAssembly.Memory;
 }
-declare const webrtcMessageQuery: BaseQueryFn<RTCChannelMessageParamsExtension, void, unknown>;
+/**
+ * Every logical send owns independent fixed WASM memories. Large-file hashing,
+ * per-message reconciliation, and reconnect waits therefore never hold a
+ * process-wide crypto mutex or block sends in another room.
+ */
+declare const webrtcMessageQuery: BaseQueryFn<RTCChannelMessageParamsExtension, SendMessageResult | undefined>;
 export default webrtcMessageQuery;
-//# sourceMappingURL=sendMessageQuery.d.ts.map

package/lib/api/webrtc/setCandidateQuery.d.ts

@@ -4,6 +4,5 @@ export interface RTCSetCandidateParamsExtention extends RTCSetCandidateParams {
     peerConnections: IRTCPeerConnection[];
     iceCandidates: IRTCIceCandidate[];
 }
-declare const webrtcSetIceCandidateQuery: BaseQueryFn<RTCSetCandidateParamsExtention, void, unknown>;
+declare const webrtcSetIceCandidateQuery: BaseQueryFn<RTCSetCandidateParamsExtention, undefined>;
 export default webrtcSetIceCandidateQuery;
-//# sourceMappingURL=setCandidateQuery.d.ts.map

package/lib/api/webrtc/setDescriptionQuery.d.ts

@@ -5,6 +5,5 @@ export interface RTCSetDescriptionParamsExtension extends RTCSetDescriptionParam
     iceCandidates: IRTCIceCandidate[];
     dataChannels: IRTCDataChannel[];
 }
-declare const webrtcSetDescriptionQuery: BaseQueryFn<RTCSetDescriptionParamsExtension, void, unknown>;
+declare const webrtcSetDescriptionQuery: BaseQueryFn<RTCSetDescriptionParamsExtension, undefined>;
 export default webrtcSetDescriptionQuery;
-//# sourceMappingURL=setDescriptionQuery.d.ts.map