p2party 0.14.2 → 0.14.7

package/lib/utils/signalingPeerRequestDebouncer.d.ts

@@ -0,0 +1,13 @@
+export type SignalingPeerRequestKind = "join" | "empty-roster" | "redial" | "reconcile";
+/**
+ * Bounds repeated peer-list requests only within one socket lifecycle.
+ *
+ * A reconnect must never inherit the previous socket's timestamp: the first
+ * post-proof request is what rebuilds all WebRTC edges after teardown.
+ */
+export declare class SignalingPeerRequestDebouncer {
+    #private;
+    shouldSend(kind: SignalingPeerRequestKind, roomId: string, minimumIntervalMs: number, now?: number): boolean;
+    resetSocketLifecycle(): void;
+}
+export declare const signalingPeerRequestDebouncer: SignalingPeerRequestDebouncer;

package/lib/utils/signalingRoomLifecycle.d.ts

@@ -0,0 +1,7 @@
+export interface SignalingRoomStatus {
+    readonly url: string;
+    readonly id?: string;
+    readonly signalingActive?: boolean;
+}
+/** Inbound signaling is routable only to an exact, locally active room id. */
+export declare const findActiveSignalingRoomIndex: (rooms: readonly SignalingRoomStatus[], roomId: string) => number;

package/lib/utils/signalingRoomOperationLifecycle.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One invocation-order boundary for signaling joins, disconnects, and purges.
+ *
+ * A join places all awaited prework inside this boundary. A later terminal
+ * action therefore runs after it and owns the final state; a later invalid
+ * join never cancels an earlier valid one before its own validation succeeds.
+ */
+export declare class SignalingRoomOperationLifecycle {
+    #private;
+    runJoin<T>(operation: () => Promise<T>): Promise<T>;
+    runRoomTerminal<T>(_roomUrl: string, operation: () => Promise<T>): Promise<T>;
+    runGlobalTerminal<T>(operation: () => Promise<T>): Promise<T>;
+}
+export declare const signalingRoomOperationLifecycle: SignalingRoomOperationLifecycle;

package/lib/utils/signalingServerBoundary.d.ts

@@ -0,0 +1,11 @@
+export declare const canonicalSignalingServerUrl: (value: string) => string;
+export declare const buildSignalingWebSocketUrl: (signalingServerUrl: string, publicKey: string) => string;
+export interface SignalingServerSelection {
+    requestedServerUrl: string;
+    currentServerUrl: string;
+    hasActiveRooms: boolean;
+    isConnected: boolean;
+    isEstablishingConnection: boolean;
+}
+/** Enforce the SDK's one-server provenance for every retained active room. */
+export declare const selectSignalingServerUrl: ({ requestedServerUrl, currentServerUrl, hasActiveRooms, isConnected, isEstablishingConnection, }: SignalingServerSelection) => string;

package/lib/utils/terminalSettlement.d.ts

@@ -0,0 +1,53 @@
+export type TerminalSettlementStep = () => void | Promise<void>;
+/**
+ * Run every fail-closed teardown step in order, even when an earlier storage or
+ * transport cleanup fails. The caller receives all failures only after the
+ * local terminal state has been attempted everywhere.
+ */
+export declare const runTerminalSettlement: (message: string, steps: readonly TerminalSettlementStep[]) => Promise<void>;
+export interface IdentityPurgeSettlement {
+    readonly disconnectSignaling: TerminalSettlementStep;
+    readonly clearRoomPins: TerminalSettlementStep;
+    readonly resetIdentity: TerminalSettlementStep;
+    /**
+     * Close every authenticated WebRTC transport before awaiting either identity
+     * deletion. A slow or failed database worker must never leave a live channel
+     * able to receive under already-reset identity state.
+     */
+    readonly teardownRooms: TerminalSettlementStep;
+    readonly deleteIdentityX25519: TerminalSettlementStep;
+    readonly deleteIdentityEd25519: TerminalSettlementStep;
+    /**
+     * The non-secret record of how the purged identity was created. It describes
+     * a key that no longer exists, so leaving it behind would let the next
+     * identity inherit a stale claim about whether it can be backed up.
+     */
+    readonly deleteIdentityDerivation: TerminalSettlementStep;
+}
+/**
+ * SSOT for identity-purge ordering. The X25519 wrapper is still removed before
+ * the Ed25519 identity that authenticates it, but transport termination comes
+ * first and every step settles even when another one fails.
+ */
+export declare const runIdentityPurgeSettlement: (steps: IdentityPurgeSettlement) => Promise<void>;
+export interface RoomPurgeSettlement {
+    /**
+     * Tombstoning happens before this orchestrator. Close local RTC first; this
+     * step is awaited before any network revocation attempt begins.
+     */
+    readonly closeLocalTransport: TerminalSettlementStep;
+    /**
+     * Starts immediately after local transport termination and may remain
+     * pending while durable local cleanup proceeds.
+     */
+    readonly startRemoteRevocation: () => Promise<void>;
+    readonly deleteLocalData: TerminalSettlementStep;
+    readonly clearPinAttempts: TerminalSettlementStep;
+}
+/**
+ * SSOT for a single-room purge completion boundary. Every local terminal step
+ * settles even on storage/network failure; a lone typed remote-revocation
+ * error is rethrown directly so callers can narrow it without unpacking an
+ * AggregateError.
+ */
+export declare const runRoomPurgeSettlement: (steps: RoomPurgeSettlement) => Promise<void>;

package/lib/utils/transportIdentity.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Final transport-construction gate after every preceding async operation.
+ * A purge/reset or identity rotation invalidates the captured constructor.
+ */
+export declare const assertTransportIdentityCurrent: (initialPublicKey: string, currentPublicKey: string) => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "p2party",
   "description": "Protocol-v4 end-to-end encryption and reliable file transfer over a WebRTC room mesh",
-  "version": "0.14.2",
+  "version": "0.14.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/p2party/p2party-js.git"