@oxidezap/whatsapp-rust-bridge 0.16.0 → 0.17.0

package/dist/whatsapp_rust_bridge.d.ts

@@ -2655,7 +2655,7 @@ export type PresenceStatus = "available" | "unavailable";
  * `From` impls below by walking the source chain. This keeps the JS object
  * shape predictable and the codegen / `Tsify` output simple.
  */
-export type BridgeError = { kind: "server"; serverCode: number; serverText: string; errorType?: string; backoffSeconds?: number } | { kind: "timeout" } | { kind: "not-connected" } | { kind: "disconnected"; reason: string } | { kind: "invalid-argument"; field: string; reason: string } | { kind: "protocol-violation"; reason: string } | { kind: "crypto"; operation: string } | { kind: "storage"; operation: string } | { kind: "no-recipient-device"; attempted: number } | { kind: "internal"; message: string };
+export type BridgeError = { kind: "server"; serverCode: number; serverText: string; errorType?: string; backoffSeconds?: number } | { kind: "timeout" } | { kind: "not-connected" } | { kind: "withdrawn" } | { kind: "disconnected"; reason: string } | { kind: "invalid-argument"; field: string; reason: string } | { kind: "protocol-violation"; reason: string } | { kind: "crypto"; operation: string } | { kind: "storage"; operation: string } | { kind: "no-recipient-device"; attempted: number } | { kind: "internal"; message: string };
 
 /**
  * Public portion of one pre-key in a supplied pairwise session bundle.
@@ -3031,6 +3031,21 @@ export interface CoverPhotoUploadInput {
     timestamp: string;
 }
 
+/**
+ * What the client\'s connection state means for work handed to it now.
+ *
+ * The core\'s `Reachability`, carried across unflattened. A refused call says
+ * what happened to that attempt; this says what the client is, which is the
+ * only thing that answers whether asking again is worth it — so it is read
+ * when the question comes up rather than stamped onto an error that is a fact
+ * about one instant.
+ *
+ * `unknown` is not one of the core\'s: the enum is `#[non_exhaustive]`, and a
+ * state added upstream has no name here yet. Naming the gap beats reporting it
+ * as one of its neighbours.
+ */
+export type Reachability = "reachable" | "reconnecting" | "paused" | "unsupervised" | "finished" | "unknown";
+
 export interface AllocationBucketSnapshot {
     allocatedBytes: number;
     allocations: number;
@@ -4023,8 +4038,27 @@ export class WasmWhatsAppClient {
      * neither constructs protocol nodes nor translates consumer-facing names.
      */
     queryUsync(query: UsyncQuery): Promise<UsyncResponse>;
+    /**
+     * What work handed to the client right now can expect.
+     *
+     * `isConnected()` and `isLoggedIn()` each answer half of it; this answers
+     * the question a refused caller actually has, which is whether asking
+     * again is worth it. `reconnecting` comes back on its own, `paused` comes
+     * back on `resume`, `unsupervised` needs a `run()`, and `finished` needs a
+     * new client.
+     *
+     * Read when the question comes up rather than carried on the error: a
+     * refusal is a fact about one instant, and a connection can be lost right
+     * after a call was admitted or restored right after one was refused.
+     */
+    reachability(): Reachability;
     /**
      * Mark messages as read by sending read receipts.
+     *
+     * Held per chat rather than once for the batch: the core stamps the
+     * receipt's timestamp inside `mark_as_read`, so each one is sampled after
+     * its own wait rather than at the call the host made. Only the first of
+     * them can be withdrawn — after that the call has already sent something.
      */
     readMessages(keys: ReadMessageKey[]): Promise<void>;
     /**
@@ -4410,6 +4444,45 @@ export class WasmWhatsAppClient {
      * `kind === 'timeout'`.
      */
     waitForSocket(timeout_ms: number): Promise<void>;
+    /**
+     * Wait until the client can reach the server again, and report what ended
+     * the wait.
+     *
+     * Never resolves to `reconnecting` — that is the one state it waits out.
+     * Bounded by the client's lifetime rather than a duration, because the
+     * reconnect backoff is jittered and followed by a handshake; a caller that
+     * wants a deadline races this against one of its own.
+     *
+     * The calls that hold themselves need none of this. It is for the ones
+     * that do not — `sendNode`, `queryNode`, `sendRawMessage` — where only the
+     * caller knows whether the node it is holding survives a new socket.
+     *
+     * It is also how a caller bounds work rather than waiting. Racing a
+     * parked call against a timer abandons the promise but not the call, so a
+     * send still goes out when the reconnect lands; racing this instead
+     * leaves the decision to issue it with the caller.
+     *
+     * Not from an event handler: the core dispatches on its read loop, so a
+     * handler that waits here waits on the connection it is blocking.
+     */
+    waitUntilReachable(): Promise<Reachability>;
+    /**
+     * Let go of every call waiting out a reconnect right now, and return how
+     * many were let go.
+     *
+     * A held call cannot be taken back by dropping its promise: wasm-bindgen
+     * drives the method to completion either way, so racing it against a
+     * deadline bounds the waiting and not the call — it still goes out when
+     * the reconnect lands, and asking again sends the same thing twice. This
+     * is how giving up is said instead: each released call rejects with
+     * `kind: 'withdrawn'` without reaching the core, so nothing it was about
+     * to do happened and re-issuing it is not a repeat.
+     *
+     * Releases what is waiting at the moment of the call and nothing else. It
+     * is not a mode — the next call waits like any other — and it does not
+     * touch the calls that never wait.
+     */
+    withdrawParkedCalls(): number;
 }
 
 /**
@@ -4624,6 +4697,7 @@ export interface InitOutput {
     readonly wasmwhatsappclient_profilePictureUrl: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly wasmwhatsappclient_queryNode: (a: number, b: number, c: number, d: number) => number;
     readonly wasmwhatsappclient_queryUsync: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_reachability: (a: number) => number;
     readonly wasmwhatsappclient_readMessages: (a: number, b: number) => number;
     readonly wasmwhatsappclient_reconnect: (a: number) => number;
     readonly wasmwhatsappclient_refreshPreKeys: (a: number, b: number) => number;
@@ -4693,6 +4767,8 @@ export interface InitOutput {
     readonly wasmwhatsappclient_votePoll: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
     readonly wasmwhatsappclient_waitForConnected: (a: number, b: number) => number;
     readonly wasmwhatsappclient_waitForSocket: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_waitUntilReachable: (a: number) => number;
+    readonly wasmwhatsappclient_withdrawParkedCalls: (a: number) => number;
     readonly getWasmMemoryBytes: () => number;
     readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
     readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
@@ -4707,12 +4783,12 @@ export interface InitOutput {
     readonly intounderlyingsink_write: (a: number, b: number) => number;
     readonly intounderlyingsource_cancel: (a: number) => void;
     readonly intounderlyingsource_pull: (a: number, b: number) => number;
-    readonly __wasm_bindgen_func_elem_4358: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_26619: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_26621: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_9303: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_4357: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_4356: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_4419: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_26634: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_26636: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_9404: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_4418: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_4417: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@oxidezap/whatsapp-rust-bridge",
-    "version": "0.16.0",
+    "version": "0.17.0",
     "description": "A high-performance utilities for WhatsApp, powered by Rust and WebAssembly.",
     "author": "João Lucas <jlucaso@hotmail.com>",
     "license": "MIT",