@oxidezap/whatsapp-rust-bridge 0.6.4 → 0.6.5

package/dist/whatsapp_rust_bridge.d.ts

@@ -1557,20 +1557,66 @@ export interface WhatsAppEventCallbacks {
      * with `decodeServerAckWireBatch`. Without it, acks use `onEvent`.
      */
     onServerAckBatch?(batch: ServerAckWireBatch): void;
+    /**
+     * Borrowing form of `onReceiptBatch`, and the whole of the opt-in: declaring
+     * it replaces `onReceiptBatch` as the receipt sink and lets the bridge hand
+     * every batch out of one buffer it reuses.
+     *
+     * The batch is therefore a window on shared memory, valid ONLY for the
+     * synchronous duration of the call: implementations MUST decode or copy it
+     * before returning, and MUST NOT retain it, pass it to an async consumer, or
+     * return a Promise. `decodeReceiptWireBatch` satisfies that on its own, since
+     * it materializes every field and keeps no view over the buffer, so the usual
+     * body is a decode plus whatever the host does with the result. A callback
+     * caught handing back something promise-like, or letting an exception escape,
+     * drops every borrowing callback of every packed kind back to a buffer per
+     * batch for the rest of the session, before the buffer is reused, so the
+     * window it kept stays intact.
+     *
+     * `onReceiptBatch` remains the copying path for every host that does not opt
+     * in, and a batch too large for the shared buffer gets its own regardless.
+     * There is no borrowing form of `onMessageBatch`: `decodeMessageWireBatch`
+     * returns views over the batch, so reuse there would alias the decoded result
+     * and not just the buffer.
+     */
+    onReceiptBatchBorrowed?(batch: ReceiptWireBatch): void;
+    /** Borrowing form of `onServerAckBatch`, under the contract above. */
+    onServerAckBatchBorrowed?(batch: ServerAckWireBatch): void;
+    /**
+     * Optional coalescing path. A live message produces up to three batches (its
+     * own, its receipt, its ack); with this method the ones the dispatch loop
+     * already holds cross together as one envelope of tagged segments instead of
+     * one crossing each. Split it with `decodeEventWireEnvelope` and hand each
+     * segment to the codec its kind names, in order. Nothing is ever held back
+     * waiting for a companion event, so a batch with no company still arrives
+     * through its own callback above, in the buffer that callback negotiated.
+     *
+     * There is no borrowing form, for the reason `onMessageBatch` has none: an
+     * envelope may carry a message segment, whose decode returns views over the
+     * buffer.
+     */
+    onEventBatch?(batch: EventWireEnvelope): void;
 }
 
 /**
  * A packed batch is one flat buffer: header, records and string bytes. Decode it
  * with the matching codec (`decodeMessageWireBatch`, `decodeReceiptWireBatch`,
  * `decodeServerAckWireBatch`), which reads views over the buffer instead of
- * copying. The bare typed array crosses rather than a wrapper object: one
- * message produces three batches, so an object per batch is three constructions
+ * copying. The bare typed array crosses rather than a wrapper object: a message
+ * produces up to three batches, so an object per batch is three constructions
  * and three property writes of pure overhead.
  */
 export type MessageWireBatch = Uint8Array;
 export type ReceiptWireBatch = Uint8Array;
 export type ServerAckWireBatch = Uint8Array;
 
+/**
+ * Several packed batches in one buffer, each tagged with the kind that names
+ * its codec. Split it with `decodeEventWireEnvelope`; every segment is byte for
+ * byte the batch its own callback would have received.
+ */
+export type EventWireEnvelope = Uint8Array;
+
 export type HistorySyncWireBatch = {
     /** Concatenated Conversation protobuf payloads for this bounded batch. */
     conversationData: Uint8Array;
@@ -3767,12 +3813,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_3793: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_24626: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_24628: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_8210: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_3792: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_3791: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_3812: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_24668: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_24670: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_8238: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_3811: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_3810: (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/dist/wire-info.d.ts

@@ -105,3 +105,21 @@ export declare function decodeServerAckWireBatch(batch: PackedWireBatch): Server
 export declare function encodeReceiptWireBatch(receipts: readonly ReceiptWireData[]): PackedWireBatch;
 /** Inverse of `decodeServerAckWireBatch`, for tests and replay tooling. */
 export declare function encodeServerAckWireBatch(acks: readonly ServerAckWireData[]): PackedWireBatch;
+/** Segment tags, mirroring the Rust writer in `src/wire_batch.rs`. */
+export declare const EVENT_SEGMENT_KIND_MESSAGE = 1;
+export declare const EVENT_SEGMENT_KIND_RECEIPT = 2;
+export declare const EVENT_SEGMENT_KIND_SERVER_ACK = 3;
+/** One packed batch inside an envelope. */
+export interface EventWireSegment {
+    /** One of the `EVENT_SEGMENT_KIND_*` tags; names the codec for `batch`. */
+    kind: number;
+    /** Exactly the bytes the segment's own callback would have received. */
+    batch: PackedWireBatch;
+}
+/**
+ * Split an envelope into its segments, in the order the events arrived. Decode
+ * each with the codec its kind names and deliver them in that order.
+ */
+export declare function decodeEventWireEnvelope(envelope: Uint8Array): EventWireSegment[];
+/** Inverse of `decodeEventWireEnvelope`, for tests and replay tooling. */
+export declare function encodeEventWireEnvelope(segments: readonly EventWireSegment[]): Uint8Array;

package/package.json

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