@oxidezap/whatsapp-rust-bridge 0.10.0 → 0.12.0

package/dist/whatsapp_rust_bridge.d.ts

@@ -272,7 +272,7 @@ export interface CallLogSync {
     call_creator_jid: Jid;
     /** The call's identifier, from the mutation's index (the same value `record.call_id` carries when the record carries one). */
     call_id: string;
-    /** Whether *this account* placed the call.  Read this rather than `record.is_incoming`, which despite its name holds the same thing rather than its opposite: WA Web writes the record with `isIncoming: fromMe`, so a consumer taking the field at its word files every call backwards. */
+    /** Whether *this account* placed the call, from [`call_creator_jid`](Self::call_creator_jid) compared against this account.  Read this rather than `record.is_incoming`, which is not reliable in either direction: it means the opposite of its name in mutations WA Web wrote and exactly its name in ones the phone wrote, so a consumer taking it at its word files some calls backwards. */
     from_me: boolean;
     /** When the mutation was written, not when the call happened — the call's own time is `record.start_time`.  This is the field WA Web measures against the pairing timestamp to decide whether a record predates the device, so it is worth having; it is not a time to file the call under. A mutation that arrives without one falls back to the moment it was received, as every other app-state event does. */
     timestamp: string;
@@ -1649,6 +1649,24 @@ export interface WhatsAppEventCallbacks {
      * Protobuf-wire message path. The bridge packs a bounded ordered group of
      * messages — payloads and metadata alike — into one flat buffer. Decode it
      * with `decodeMessageWireBatch`.
+     *
+     * Decode every batch, exactly once, in the order it arrives, before calling
+     * back into the client: addresses and push names repeat, so a batch defines
+     * them once and later batches reference the table the decoder is holding.
+     * A batch skipped or decoded out of order leaves that table describing a
+     * history the records do not have.
+     *
+     * The return type is `void` and TypeScript lets an `async` method satisfy
+     * it, so this is checked rather than trusted: a callback that hands back
+     * anything promise-like has not decoded inside its call, and the bridge
+     * gives up the cross-batch table for the rest of the session — every batch
+     * then carries every value it names, which decodes the same in any order.
+     * Keeping the buffer is fine; decoding it later is what costs the table.
+     *
+     * The check runs after the batch has been handed over, so the batch that
+     * revealed the violation is the one it cannot save: decoded after a later
+     * one, it reads that one's table. Every batch after it is safe whenever it
+     * is decoded.
      */
     onMessageBatch(batch: MessageWireBatch): void;
     /**
@@ -4636,12 +4654,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_4319: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_26158: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_26160: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_9212: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_4318: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_4317: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_4333: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_26257: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_26259: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_9236: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_4332: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_4331: (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

@@ -2,10 +2,19 @@
  * Packed wire-batch codecs (message metadata, receipts, server acks).
  *
  * The bridge crosses hot per-event metadata as fixed-width numeric records
- * plus a per-batch deduplicated string table: repeated addresses, push names
- * and ack classes pay one decode per batch instead of one FFI object build
- * per event. This module is the single host-side owner of every record
- * layout; the Rust writers live in `src/wasm_client.rs`.
+ * plus a string table that outlives the batch: repeated addresses, push names
+ * and ack classes are materialized once per process and referenced by index
+ * afterwards, instead of one FFI object build per event. This module is the
+ * single host-side owner of every record layout; the Rust writers live in
+ * `src/wire_batch.rs`.
+ *
+ * A table that outlives a batch only works while both sides agree on when it
+ * is dropped, so every codec here speaks one invalidation protocol: the writer
+ * sets `PACKED_FLAG_RESET_CACHES` in a batch's header and the reader clears
+ * before reading it. That makes every decoder here **stateful**. Decode each
+ * batch exactly once, in the order the bridge delivered it; a batch decoded
+ * twice, out of order, or not at all leaves the table describing a history the
+ * records do not have.
  */
 /** Serde shape of the core's `Jid` as carried by bridge events. */
 export interface WireJid {
@@ -54,8 +63,44 @@ export interface MessageWireEntry {
     info: MessageWireInfo;
 }
 /**
- * Inverse of `decodeMessageWireBatch`, for hosts that need to fabricate batches
- * (tests, replay tooling). Mirrors the Rust writer byte for byte.
+ * Build-side mirror of the Rust `MessageWireBatch`, for hosts that need to
+ * fabricate batches (tests, replay tooling).
+ *
+ * One encoder is one writer: it keeps the table across `encode` calls exactly
+ * as the bridge's does, so a run of batches decodes the way a run from the
+ * bridge decodes — later batches defining nothing and indexing what earlier
+ * ones defined. Its first batch always asks the reader to clear, so a run
+ * starts from a table it owns rather than one someone else left behind.
+ *
+ * Deliberately not re-exported from the package root. There is one standing
+ * table per realm, so a second live run has nowhere of its own to decode
+ * against: its reset batch would take the first run's entries with it. That
+ * makes this safe for a test or a replay that owns the process and unsafe as
+ * a public API. Hosts get `encodeMessageWireBatch`, whose batches are
+ * self-contained.
+ */
+export declare class MessageWireBatchEncoder {
+    private readonly cache;
+    /** Entries the reader holds, and so the index the next definition takes. */
+    private held;
+    private cacheBytes;
+    private flags;
+    /**
+     * Encode one batch, as `MessageWireBatch::write_flat` writes one.
+     *
+     * A throw part-way leaves the encoder holding cache entries whose definitions
+     * were never written, so it gives the whole table up rather than hand the
+     * next batch indices the reader has no entries for — the same thing the Rust
+     * writer does with a batch it abandons.
+     */
+    encode(entries: readonly MessageWireEntry[]): PackedWireBatch;
+    private encodeBatch;
+}
+/**
+ * Inverse of `decodeMessageWireBatch` for a single standalone batch: it carries
+ * its own table definitions and asks the reader to clear, so it decodes the
+ * same whatever ran before it. Use `MessageWireBatchEncoder` to fabricate a run
+ * of batches that share a table the way the bridge's do.
  */
 export declare function encodeMessageWireBatch(entries: readonly MessageWireEntry[]): PackedWireBatch;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@oxidezap/whatsapp-rust-bridge",
-    "version": "0.10.0",
+    "version": "0.12.0",
     "description": "A high-performance utilities for WhatsApp, powered by Rust and WebAssembly.",
     "author": "João Lucas <jlucaso@hotmail.com>",
     "license": "MIT",
@@ -31,6 +31,12 @@
         "bench": "bun run build && bun run benches/binary.ts && bun run benches/signal.ts && bun run benches/curve.ts && bun run benches/crypto.ts",
         "bench:node": "bun run build && node --expose-gc benches/binary.ts && node --expose-gc benches/signal.ts && node --expose-gc benches/curve.ts && node --expose-gc benches/crypto.ts",
         "bench:proto": "bun run benches/proto-encode.ts",
+        "bench:wire": "bun run benches/wire-batch-decode.ts",
+        "bench:wire:message": "bun run benches/message-wire-batch.ts",
+        "bench:codec-memory": "bun run benches/codec-memory/codec-count.ts",
+        "bench:codec-memory:in-situ": "bun run benches/codec-memory/in-situ.ts",
+        "bench:codec-memory:equivalence": "node --stack-size=4000 benches/codec-memory/equivalence.mjs",
+        "bench:codec-memory:import-stages": "bun run benches/codec-memory/import-stages.ts",
         "gen:bridge-types": "cargo fetch && cd codegen && cargo run -q --bin gen-types --target $(rustc -vV | grep host | cut -d' ' -f2) > ../src/generated_types.rs.tmp && mv ../src/generated_types.rs.tmp ../src/generated_types.rs",
         "gen:proto-codec": "bun run scripts/gen-ts-proto.ts",
         "gen:proto-types": "bun run scripts/gen-protobufjs-dts.ts",
@@ -47,6 +53,9 @@
         "example": "NODE_TLS_REJECT_UNAUTHORIZED=0 bun run examples/connect.ts",
         "test:rust": "wasm-pack test --node",
         "check:size": "bun run scripts/check-size.ts",
+        "check:wasm-shape": "node scripts/check-wasm-shape.mjs",
+        "measure:fn-sizes": "node scripts/wasm-fn-sizes.mjs pkg/whatsapp_rust_bridge_bg.wasm",
+        "measure:zone-peak": "node scripts/wasm-zone-peak.mjs pkg/whatsapp_rust_bridge_bg.wasm",
         "prepack": "bun run scripts/check-pack.ts",
         "prepublishOnly": "bun run build"
     },