@muhkoo/connect 0.14.0-alpha.8 → 0.15.0-alpha.0

package/dist/connect.workers.d.ts

@@ -514,20 +514,51 @@ interface DehydratedKeys {
     ecdsaPub: string;
     ecdsaPriv: string;
 }
+/** A member's own ECDH and ECDSA pairs, held outside the store until {@link KeyStore.replaceOwnKeyPair}. */
+interface OwnKeyPair {
+    ecdh: KeyPair;
+    ecdsa: AuthKeyPair;
+}
 declare class KeyStore {
     private static instance;
     private _keys;
     private _authKeys;
+    /** The exact pairs marked vault-backed, so a pair written over them later is never taken for them. */
+    private _vaultBacked;
     private constructor();
     static getInstance(): KeyStore;
     get keys(): Map<string, KeyPair>;
     get authKeys(): Map<string, AuthKeyPair>;
     generateOwnKeyPair(id: string): Promise<KeyPair>;
     storeRemotePublicKeys(id: string, ecdhPublicKey: CryptoKey, ecdsaPublicKey: CryptoKey): Promise<void>;
+    /** Generate an own pair without touching the store; {@link replaceOwnKeyPair} puts it in place. */
+    generateKeyPair(): Promise<OwnKeyPair>;
     hydrateKeyPair(id: string, dehydrated: DehydratedKeys): Promise<void>;
+    /** Import a dehydrated pair without touching the store; {@link replaceOwnKeyPair} puts it in place. */
+    importKeyPair(dehydrated: DehydratedKeys): Promise<OwnKeyPair>;
     getKeyPair(id: string): KeyPair | null;
     getAuthKeyPair(id: string): AuthKeyPair | null;
+    /** Record that the pair `id` holds now came from the seed-wrapped vault (ChatKeyVault). */
+    markVaultBacked(id: string): void;
+    /**
+     * Put `pair` in place as `id`'s own pair and mark it vault-backed, in one
+     * synchronous step: whatever `id` held before is dropped, so a pair minted
+     * while the vault pair was being fetched or generated is never kept and
+     * marked in its place (design §3.3).
+     */
+    replaceOwnKeyPair(id: string, pair: OwnKeyPair): void;
+    /**
+     * Whether `id`'s own pair was loaded from, or persisted to, the vault in this
+     * tab, and is still the very pair that was marked. A Space identity must be
+     * vault-backed (design §3.3): any other pair, such as one minted by a locked
+     * DM subscription, never takes part, even one that lands over the marked pair.
+     */
+    isVaultBacked(id: string): boolean;
+    /** Drop every key held for `id` (SpecA §6.4 `KeyStore.forget`). */
+    forget(id: string): void;
     dehydrateKeyPair(id: string): Promise<DehydratedKeys>;
+    /** Dehydrate a pair that is not (yet) in the store, in the same format as {@link dehydrateKeyPair}. */
+    exportKeyPair(pair: OwnKeyPair): Promise<DehydratedKeys>;
     getRawEcdsaPublicKey(id: string): Promise<Uint8Array | null>;
     packDehydratedKeys(id: string): Promise<string>;
     hydrateFromPacked(id: string, masterKey: string): Promise<void>;
@@ -602,7 +633,6 @@ declare class DoubleRatchet {
     private sessionType;
     private maxSkip;
     private overlapPeriod;
-    private windowSize;
     constructor(senderId: string, recipientId: string, sessionType: 'global' | 'specific', isClient?: boolean);
     private hkdf;
     initializeSession(isClient?: boolean): Promise<void>;
@@ -965,6 +995,8 @@ interface WSTransportOptions {
      * auto-response. Default `"pong"`.
      */
     pongFrame?: string;
+    /** A close with one of these codes is terminal: no reconnect, `DISCONNECTED` carries `{code, reason}`; `resume()` restarts. */
+    terminalCloseCodes?: number[];
 }
 declare class WSTransport extends EventCore {
     /**
@@ -997,11 +1029,14 @@ declare class WSTransport extends EventCore {
     private pongFrame;
     private heartbeatTimer;
     private pongTimer;
+    private readonly terminalCloseCodes;
     constructor(opts: WSTransportOptions);
     /** Open the socket. Resolves when CONNECTED fires. Rejects on first error. */
     connect(): Promise<void>;
     /** Close the socket and stop reconnecting. */
     disconnect(): void;
+    /** Restart reconnecting after a terminal close or `disconnect()`; the next URL comes from `urlProvider`. */
+    resume(): void;
     /**
      * Send a raw frame. If currently disconnected, the frame is queued and sent
      * after the next successful reconnect (up to `maxQueueSize`).
@@ -1115,6 +1150,8 @@ declare class BroadcastChannel {
     connect(): Promise<void>;
     /** Close the WebSocket and stop reconnecting. */
     disconnect(): void;
+    /** Reconnect after a terminal close (see `terminalCloseCodes`) or `disconnect()`, on a fresh `urlProvider` URL. */
+    resume(): void;
     /**
      * Send our `keyExchange` frame to the room. Idempotent — only sends on the
      * first call. Call this once your higher-level handshake (e.g. sending a