p2party 0.8.0 → 0.14.2

package/lib/libcrypto.provenance.json

@@ -0,0 +1,45 @@
+{
+  "schemaVersion": 1,
+  "sources": {
+    "libsodium": {
+      "releaseLine": "1.0.22-stable",
+      "commit": "2ce4d906a68eae82b27b4867f3d4172ec508cb27",
+      "tree": "2dabe17c708edd7334e3316b5094b753859395d9",
+      "extraction": "git-archive",
+      "configuredBuild": true
+    },
+    "mlkemNative": {
+      "release": "v1.2.0",
+      "commit": "0ba906cb14b1c241476134d7403a811b382ca498",
+      "sourceTreeSha256": "a2e15382a8dc0207752b3f5cdfc907886505fe304948183b4b61e99e7cb92ac6",
+      "wrapperSha256": "181160a16f22e30eafc85d7be7a3be47be41026da14b0488f120ededc36ea072",
+      "backend": "portable-c",
+      "parameterSets": [
+        512,
+        768,
+        1024
+      ],
+      "multilevel": {
+        "shared": 768,
+        "noShared": [
+          512,
+          1024
+        ]
+      }
+    }
+  },
+  "toolchain": {
+    "emscripten": "6.0.3"
+  },
+  "build": {
+    "mode": "production",
+    "linkTimeOptimization": false,
+    "publicSodiumApi": true
+  },
+  "artifact": {
+    "file": "libcrypto.wasm",
+    "bytes": 209081,
+    "sha256": "7eea31157e69ac61f3a512b624d5c210296302fd289fc2b65c63ecc31a056267",
+    "sri": "sha384-pBMyUqQ3KBztxgeJMgDFZeohfj9QlAFNwt4/gRlqT0vlZ2kbkKxv+q5DwbZOBuUP"
+  }
+}

package/lib/middleware/keyPairListenerMiddleware.d.ts

@@ -1,3 +1,2 @@
 declare const keyPairListenerMiddleware: import("@reduxjs/toolkit").ListenerMiddlewareInstance<unknown, import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction>, unknown>;
 export default keyPairListenerMiddleware;
-//# sourceMappingURL=keyPairListenerMiddleware.d.ts.map

package/lib/middleware/roomListenerMiddleware.d.ts

@@ -1,3 +1,2 @@
 declare const roomListenerMiddleware: import("@reduxjs/toolkit").ListenerMiddlewareInstance<unknown, import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction>, unknown>;
 export default roomListenerMiddleware;
-//# sourceMappingURL=roomListenerMiddleware.d.ts.map

package/lib/reducers/commonSlice.d.ts

@@ -6,4 +6,3 @@ export declare const setCurrentRoomUrl: import("@reduxjs/toolkit").ActionCreator
 export declare const commonStateSelector: (state: State) => CommonState;
 declare const _default: import("redux").Reducer<CommonState>;
 export default _default;
-//# sourceMappingURL=commonSlice.d.ts.map

package/lib/reducers/keyPairSlice.d.ts

@@ -30,4 +30,3 @@ export declare const setKeyPair: import("@reduxjs/toolkit").ActionCreatorWithPay
 export declare const keyPairSelector: (state: State) => KeyPair;
 declare const _default: import("redux").Reducer<KeyPair>;
 export default _default;
-//# sourceMappingURL=keyPairSlice.d.ts.map

package/lib/reducers/roomSlice.d.ts

@@ -1,4 +1,6 @@
 import type { State } from "../store";
+import type { RoomPolicyV1 } from "../roomPolicy";
+import type { CoverSchedulerStatus } from "../handlers/coverScheduler";
 export interface Channel {
     label: string;
     peerIds: string[];
@@ -8,6 +10,8 @@ export interface Peer {
     peerPublicKey: string;
 }
 export interface Message {
+    /** Sender-only random identity for one logical outbound transfer. */
+    transferId?: string;
     merkleRootHex: string;
     sha512Hex: string;
     fromPeerId: string;
@@ -19,6 +23,16 @@ export interface Message {
     totalChunks: number;
     channelLabel: string;
     timestamp: number;
+    chunksReceivedTotal?: number;
+    chunksReceivedReal?: number;
+    retransmits?: number;
+}
+export interface IncrementMessageStatsArgs {
+    roomId: string;
+    merkleRootHex?: string;
+    sha512Hex?: string;
+    real?: boolean;
+    retransmit?: boolean;
 }
 export interface SetRoomArgs {
     url: string;
@@ -26,6 +40,12 @@ export interface SetRoomArgs {
     canBeConnectionRelay?: boolean;
     onlyConnectWithKnownPeers?: boolean;
     rtcConfig?: RTCConfiguration;
+    /** Public/authenticated room settings only. PIN bytes never enter Redux. */
+    policy?: RoomPolicyV1;
+}
+export interface SetRoomPolicyArgs {
+    roomContext: string;
+    policy: RoomPolicyV1;
 }
 export interface SetPeerArgs extends Peer {
     roomId: string;
@@ -36,6 +56,7 @@ export interface SetIceServersArgs {
 }
 export interface SetMessageArgs {
     roomId: string;
+    transferId?: string;
     merkleRootHex: string;
     sha512Hex: string;
     chunkSize: number;
@@ -50,6 +71,7 @@ export interface SetMessageArgs {
 }
 export interface SetMessageAllChunksArgs {
     roomId: string;
+    transferId?: string;
     merkleRootHex: string;
     sha512Hex: string;
     fromPeerId: string;
@@ -73,10 +95,13 @@ export interface SetChannelArgs {
     label: string;
 }
 export interface DeleteMessageArgs {
+    roomId: string;
+    transferId?: string;
     merkleRootHex?: string;
     hashHex?: string;
 }
 export interface DeleteChannelArgs {
+    roomId?: string;
     peerId?: string;
     label?: string;
 }
@@ -84,7 +109,30 @@ export interface SetCanOnlyConnectWithKnownPeers {
     roomId: string;
     onlyConnectWithKnownPeers: boolean;
 }
+export interface SetPeerCoverStatusArgs {
+    roomId: string;
+    peerId: string;
+    status: CoverSchedulerStatus;
+}
+/**
+ * Why the authenticated edge is not (yet) up. "pin-mismatch" also covers a
+ * differing room policy on a PIN room — the confirmation transcript cannot
+ * distinguish them; "policy" is a nopin-room confirmation failure, which can
+ * only be a policy/transcript mismatch.
+ */
+export type PeerHandshakeFailureReason = "pin-mismatch" | "pin-throttled" | "policy" | "transport";
+export interface PeerHandshakeStatus {
+    status: "authenticating" | "authenticated" | "failed";
+    reason?: PeerHandshakeFailureReason;
+    /** Absolute epoch ms after which a throttled PIN retry may succeed. */
+    retryAfter?: number;
+}
+export interface SetPeerHandshakeStatusArgs extends PeerHandshakeStatus {
+    roomId: string;
+    peerId: string;
+}
 export interface Room extends SetRoomArgs {
+    policy: RoomPolicyV1;
     connectingToPeers: boolean;
     connectedToPeers: boolean;
     canBeConnectionRelay: boolean;
@@ -93,9 +141,23 @@ export interface Room extends SetRoomArgs {
     peers: Peer[];
     channels: Channel[];
     messages: Message[];
+    /**
+     * protocol-v4: live scheduled-cover status per authenticated peer edge
+     * (peerId → status). Absent means no cover claim may ever be made for that
+     * edge — only an explicit "active" from the runtime is a cover claim, so a
+     * browser gap ("suspended") or teardown ("stopped") is always visible.
+     */
+    coverStatusByPeer?: Record<string, CoverSchedulerStatus>;
+    /**
+     * Live authenticated-handshake state per peer edge (peerId → status), so a
+     * UI can distinguish "still authenticating" from "PIN did not match" from
+     * "PIN retries throttled until T" instead of showing an eternal
+     * waiting-for-peers state.
+     */
+    handshakeStatusByPeer?: Record<string, PeerHandshakeStatus>;
 }
 export declare const defaultRTCConfig: RTCConfiguration;
-export declare const setRoom: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetRoomArgs, "rooms/setRoom">, setConnectingToPeers: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+export declare const setRoom: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetRoomArgs, "rooms/setRoom">, setRoomPolicy: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetRoomPolicyArgs, "rooms/setRoomPolicy">, setConnectingToPeers: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     roomId: string;
     connectingToPeers: boolean;
 }, "rooms/setConnectingToPeers">, setConnectedToPeers: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
@@ -104,10 +166,10 @@ export declare const setRoom: import("@reduxjs/toolkit").ActionCreatorWithPayloa
 }, "rooms/setConnectedToPeers">, setConnectionRelay: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     roomId: string;
     canBeConnectionRelay: boolean;
-}, "rooms/setConnectionRelay">, setOnlyConnectWithKnownPeers: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetCanOnlyConnectWithKnownPeers, "rooms/setOnlyConnectWithKnownPeers">, setPeer: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetPeerArgs, "rooms/setPeer">, setChannel: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetChannelArgs, "rooms/setChannel">, setIceServers: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetIceServersArgs, "rooms/setIceServers">, setMessage: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMessageArgs, "rooms/setMessage">, setMessageAllChunks: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMessageAllChunksArgs, "rooms/setMessageAllChunks">, deletePeer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+}, "rooms/setConnectionRelay">, setOnlyConnectWithKnownPeers: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetCanOnlyConnectWithKnownPeers, "rooms/setOnlyConnectWithKnownPeers">, setPeer: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetPeerArgs, "rooms/setPeer">, setPeerCoverStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetPeerCoverStatusArgs, "rooms/setPeerCoverStatus">, setPeerHandshakeStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetPeerHandshakeStatusArgs, "rooms/setPeerHandshakeStatus">, setChannel: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetChannelArgs, "rooms/setChannel">, setIceServers: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetIceServersArgs, "rooms/setIceServers">, setMessage: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMessageArgs, "rooms/setMessage">, setMessageAllChunks: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMessageAllChunksArgs, "rooms/setMessageAllChunks">, incrementMessageStats: import("@reduxjs/toolkit").ActionCreatorWithPayload<IncrementMessageStatsArgs, "rooms/incrementMessageStats">, deletePeer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     peerId: string;
+    roomId?: string;
 }, "rooms/deletePeer">, deleteChannel: import("@reduxjs/toolkit").ActionCreatorWithPayload<DeleteChannelArgs, "rooms/deleteChannel">, deleteMessage: import("@reduxjs/toolkit").ActionCreatorWithPayload<DeleteMessageArgs, "rooms/deleteMessage">, deleteRoom: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "rooms/deleteRoom">;
 export declare const roomSelector: (state: State) => Room[];
 declare const _default: import("redux").Reducer<Room[]>;
 export default _default;
-//# sourceMappingURL=roomSlice.d.ts.map

package/lib/reducers/signalingServerSlice.d.ts

@@ -3,14 +3,35 @@ import type { State } from "../store";
 export interface SignalingState {
     isEstablishingConnection: boolean;
     isConnected: boolean;
+    isVerified: boolean;
     serverUrl: string;
 }
 export declare const signalingServerActions: import("@reduxjs/toolkit").CaseReducerActions<{
-    startConnecting: (state: import("immer").WritableDraft<SignalingState>, action: PayloadAction<string | undefined>) => void;
-    connectionEstablished: (state: import("immer").WritableDraft<SignalingState>) => void;
-    disconnect: (state: import("immer").WritableDraft<SignalingState>) => void;
+    startConnecting: (state: {
+        isEstablishingConnection: boolean;
+        isConnected: boolean;
+        isVerified: boolean;
+        serverUrl: string;
+    }, action: PayloadAction<string | undefined>) => void;
+    connectionEstablished: (state: {
+        isEstablishingConnection: boolean;
+        isConnected: boolean;
+        isVerified: boolean;
+        serverUrl: string;
+    }) => void;
+    connectionVerified: (state: {
+        isEstablishingConnection: boolean;
+        isConnected: boolean;
+        isVerified: boolean;
+        serverUrl: string;
+    }) => void;
+    disconnect: (state: {
+        isEstablishingConnection: boolean;
+        isConnected: boolean;
+        isVerified: boolean;
+        serverUrl: string;
+    }) => void;
 }, "signalingServer">;
 export declare const signalingServerSelector: (state: State) => SignalingState;
 declare const _default: import("redux").Reducer<SignalingState>;
 export default _default;
-//# sourceMappingURL=signalingServerSlice.d.ts.map

package/lib/roomInvite.d.ts

@@ -0,0 +1,18 @@
+export declare const ROOM_CAPABILITY_BYTES = 32;
+export declare const ROOM_CAPABILITY_HEX_CHARS: number;
+export declare const ROOM_CAPABILITY_BASE64URL_CHARS = 43;
+export declare const ROOM_INVITE_WORDS = 24;
+export declare const ROOM_INVITE_VERSION = 1;
+export declare const ROOM_INVITE_PREFIX: string;
+export declare const ROOM_INVITE_WORDLIST_ID = "p2party-invite-en-v1";
+export declare const generateRoomCapability: () => Uint8Array;
+export declare const encodeRoomCapabilityBase64Url: (capability: Uint8Array) => string;
+export declare const decodeRoomCapabilityBase64Url: (encoded: string) => Uint8Array;
+/** Accept the compact representation or the legacy hex migration form. */
+export declare const decodeRoomCapability: (encoded: string) => Uint8Array;
+/** Canonical internal/server representation while the legacy signaling path exists. */
+export declare const normalizeRoomCapability: (encoded: string) => string;
+export declare const encodeRoomInviteFragment: (capability: Uint8Array) => string;
+export declare const decodeRoomInviteFragment: (fragment: string) => Uint8Array;
+export declare const encodeRoomCapabilityWords: (capability: Uint8Array) => Promise<string>;
+export declare const decodeRoomCapabilityWords: (encoded: string) => Promise<Uint8Array>;

package/lib/roomPinAttempts.d.ts

@@ -0,0 +1,12 @@
+export declare const MAX_PIN_ATTEMPTS = 3;
+export declare const PIN_BACKOFF_BASE_MS = 500;
+export declare const PIN_BACKOFF_MAX_MS: number;
+export declare const ROOM_PIN_FAILURE_WINDOW_MS: number;
+export declare const MAX_ROOM_PIN_FAILURES_PER_WINDOW = 30;
+export declare const assertRoomPinAggregateAllowed: (roomId: string, now?: number) => void;
+export declare const recordRoomPinAggregateFailure: (roomId: string, now?: number) => void;
+export declare const clearRoomPinAggregateFailures: (roomId: string) => void;
+export declare const pinBackoffMs: (failures: number) => number;
+export declare const assertPinAttemptAllowed: (roomId: string, peerIdentityEd25519: string, now?: number) => Promise<void>;
+export declare const recordPinFailure: (roomId: string, peerIdentityEd25519: string, now?: number) => Promise<void>;
+export declare const clearPinAttempts: (roomId: string, peerIdentityEd25519?: string) => Promise<void>;

package/lib/roomPinVault.d.ts

@@ -0,0 +1,26 @@
+type PinZeroizer = (pin: Uint8Array) => void;
+/**
+ * In-memory-only PIN owner. The production instance below is module-scoped;
+ * this class is exported only so its copy/zeroization contract can be tested
+ * without exposing the production map.
+ *
+ * No Redux, database, localStorage, logging, or serialization path touches
+ * these bytes. Callers receive copies and should wipe them after handshake use.
+ *
+ * @internal
+ */
+export declare class TransientRoomPinVault {
+    #private;
+    constructor(zeroize?: PinZeroizer);
+    put(roomContext: string, pin: Uint8Array): void;
+    get(roomContext: string): Uint8Array | undefined;
+    has(roomContext: string): boolean;
+    delete(roomContext: string): boolean;
+    clear(): void;
+}
+export declare const putRoomPin: (roomContext: string, pin: Uint8Array) => void;
+export declare const getRoomPin: (roomContext: string) => Uint8Array | undefined;
+export declare const hasRoomPin: (roomContext: string) => boolean;
+export declare const deleteRoomPin: (roomContext: string) => boolean;
+export declare const clearRoomPins: () => void;
+export {};

package/lib/roomPolicy.d.ts

@@ -0,0 +1,60 @@
+import type { RatchetRootSuite } from "./utils/constants";
+/**
+ * Canonical, non-secret room policy descriptor.
+ *
+ * The PIN is deliberately not a field: only the fact that CPace/PIN
+ * authentication is required is authenticated with the policy. PIN bytes live
+ * exclusively in the transient roomPinVault module.
+ */
+export type RoomAuthMode = "nopin" | "pin";
+/**
+ * The room creator fixes one authenticated hybrid bootstrap suite for every
+ * edge in the room. Peers never negotiate, downgrade, or fall back: a policy
+ * mismatch changes the transcript and makes the handshake fail closed.
+ */
+export type RoomPqMode = "hybrid-mlkem512" | "hybrid-mlkem768" | "hybrid-mlkem1024";
+export type RoomRendezvousMode = "legacy-signaling" | "opaque-token" | "blind-meeting-point";
+export type RoomCoverMode = "immediate" | "scheduled";
+export declare const roomPqModeToParameterSet: (mode: RoomPqMode) => 512 | 768 | 1024;
+export declare const roomPqModeToRootSuite: (mode: RoomPqMode) => RatchetRootSuite;
+export declare const rootSuiteToRoomPqMode: (suite: RatchetRootSuite) => RoomPqMode;
+export interface RoomPolicyV1 {
+    version: 1;
+    revision: number;
+    wireVersion: 4;
+    authMode: RoomAuthMode;
+    pqMode: RoomPqMode;
+    rendezvousMode: RoomRendezvousMode;
+    coverMode: RoomCoverMode;
+    coverCadenceMs: number;
+    coverLanes: number;
+    coverFramesPerCell: number;
+    coverDurationEpochs: number;
+}
+export declare const ROOM_POLICY_V1_ENCODED_LEN = 32;
+export declare const ROOM_POLICY_V1_HASH_LEN = 32;
+export declare const MIN_COVER_CADENCE_MS = 1000;
+export declare const MAX_COVER_CADENCE_MS = 3600000;
+export declare const MAX_COVER_LANES = 16;
+export declare const MAX_COVER_FRAMES_PER_CELL = 1024;
+export declare const MIN_COVER_SLOT_MS = 25;
+export declare const validateRoomPolicyV1: (policy: RoomPolicyV1) => void;
+/**
+ * Fixed-width V1 wire form (all integers big-endian):
+ *
+ *   magic(4) | format(1) | wire(1) | auth(1) | pq(1) |
+ *   rendezvous(1) | cover(1) | revision(4) | cadence_ms(4) |
+ *   lanes(2) | frames_per_cell(2) | duration_epochs(2) | reserved_zero(8)
+ */
+export declare const encodeRoomPolicyV1: (policy: RoomPolicyV1) => Uint8Array;
+export declare const decodeRoomPolicyV1: (encoded: Uint8Array) => RoomPolicyV1;
+/** Validate and return a detached plain-object copy suitable for Redux state. */
+export declare const canonicalizeRoomPolicyV1: (policy: RoomPolicyV1) => RoomPolicyV1;
+export declare const roomPoliciesEqualV1: (left: RoomPolicyV1, right: RoomPolicyV1) => boolean;
+/** SHA-256(domain || canonical fixed-width policy); suitable for transcript CI. */
+export declare const hashRoomPolicyV1: (policy: RoomPolicyV1) => Promise<Uint8Array>;
+/**
+ * Current v3 behavior: no PIN, mandatory hybrid ML-KEM-768, legacy
+ * signaling rendezvous, and immediate/no-cover delivery.
+ */
+export declare const DEFAULT_ROOM_POLICY_V1: Readonly<RoomPolicyV1>;

package/lib/session.d.ts

@@ -0,0 +1,110 @@
+import { type HandshakeTransport } from "./handlers/handshakeCore";
+import { PROTOCOL_VERSION, WIRE_CHUNK_FRAME_LEN } from "./utils/constants";
+import type { RoomPqMode } from "./roomPolicy";
+export type { HandshakeTransport };
+export type { RoomPqMode } from "./roomPolicy";
+/**
+ * The wire constants a caller needs to build its own outer framing. The
+ * session hands back opaque fixed-size frames and expects the same back, so an
+ * adapter has to length-check and version-check records itself; re-exporting
+ * these keeps it from hardcoding values that a wire break would silently
+ * invalidate.
+ */
+export { PROTOCOL_VERSION, WIRE_CHUNK_FRAME_LEN };
+export interface LocalSessionIdentity {
+    ed25519PublicKey: Uint8Array;
+    x25519PublicKey: Uint8Array;
+    /** The X25519 identity secret used by interactive 3DH; never Ed25519. */
+    x25519SecretKey: Uint8Array;
+    x25519CrossSignature: Uint8Array;
+}
+export interface GeneratedSessionIdentity extends LocalSessionIdentity {
+    ed25519SecretKey: Uint8Array;
+}
+export interface SessionChannelBinding {
+    channelId: Uint8Array;
+    localFingerprint: Uint8Array;
+    remoteFingerprint: Uint8Array;
+}
+export interface SessionCryptoOptions {
+    /**
+     * Local/self-hosted libcrypto.wasm bytes. Supply this in Node/Bun or offline
+     * deployments; when omitted the versioned p2party CDN loader is used.
+     */
+    wasmBinary?: ArrayBuffer | Uint8Array;
+}
+export type SessionAuth = {
+    mode: "nopin";
+    pin?: never;
+} | {
+    mode: "pin";
+    pin: Uint8Array;
+};
+export type CreateSessionOptions = {
+    transport: HandshakeTransport;
+    role: "initiator" | "responder";
+    identity: LocalSessionIdentity;
+    /** Externally pinned (or explicitly TOFU-accepted) peer Ed25519 identity. */
+    peerIdentityEd25519PublicKey: Uint8Array;
+    channel: SessionChannelBinding;
+    /** Exact suite chosen out-of-band for both peers; defaults to ML-KEM-768. */
+    pqMode?: RoomPqMode;
+    crypto?: SessionCryptoOptions;
+} & SessionAuth;
+export interface EncryptedSessionMessage {
+    protocolVersion: 4;
+    /** The message Merkle root; authenticated as AEAD additional data. */
+    root: Uint8Array;
+    /** Uniform protocol-v3 chunk frames. */
+    frames: Uint8Array[];
+}
+/**
+ * One exact sealed sparse-PQ control cell to dispatch after the caller has
+ * persisted the mutated session, plus whether a durable write is required
+ * before sending (false for an exact duplicate response).
+ */
+export interface SessionControlOutput {
+    readonly frame: Uint8Array | null;
+    readonly requiresPersistBeforeSend: boolean;
+}
+export interface P2PartySession {
+    readonly protocolVersion: 4;
+    readonly pqMode: RoomPqMode;
+    /** True for either role after a successful handshake; false after destroy. */
+    readonly canEncrypt: boolean;
+    /** Current authenticated PQ epoch; 0 before any healing exchange. */
+    readonly pqEpoch: bigint;
+    /** True while a sparse-PQ healing exchange blocks application traffic. */
+    readonly healingInProgress: boolean;
+    encrypt(plaintext: Uint8Array): Promise<EncryptedSessionMessage>;
+    decrypt(message: EncryptedSessionMessage): Promise<Uint8Array>;
+    /**
+     * Store-free sparse-PQ healing for custom transports. Contract: after any of
+     * these returns a frame, the caller MUST persist `serialize()` BEFORE
+     * sending that frame, so a crash cannot fork the OFFER/ADVANCE/ACK sequence.
+     *
+     * `prepareHealing` starts a due local exchange (returns null when not due or
+     * not this side's turn). `acceptControlFrame` processes an inbound OFFER,
+     * ADVANCE, or ACK and returns the exact response to send. `pendingControl`
+     * returns the exact frame to retransmit for a dropped flight.
+     */
+    prepareHealing(): Promise<SessionControlOutput>;
+    acceptControlFrame(frame: Uint8Array): Promise<SessionControlOutput>;
+    pendingControl(): Promise<Uint8Array | null>;
+    /**
+     * Plaintext secret snapshot (Double Ratchet + PQ machine/root/epoch/turn/
+     * counters + active combined receive keys). Store only under authenticated
+     * encryption with rollback protection; never send this blob to the peer.
+     */
+    serialize(): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+export interface GenerateSessionIdentityOptions extends SessionCryptoOptions {
+    ed25519KeyPair?: {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+}
+export declare const generateSessionIdentity: (options?: GenerateSessionIdentityOptions) => Promise<GeneratedSessionIdentity>;
+export declare const createSession: (options: CreateSessionOptions) => Promise<P2PartySession>;
+export declare const restoreSession: (snapshot: Uint8Array, crypto?: SessionCryptoOptions) => Promise<P2PartySession>;