@oxidezap/baileyrs 0.2.0 → 0.2.2

package/lib/Compatibility/all-encryptions-failed.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The rejection Baileys code expects, or the original error untouched.
+ *
+ * Narrow on purpose: only the engine's own `no-recipient-device` is rewritten,
+ * so every other failure still reaches the caller with the shape the bridge
+ * gave it.
+ */
+export declare const asAllEncryptionsFailed: (error: unknown) => unknown;
+/** Run a send, translating only that one rejection. */
+export declare const sendReportingUpstreamFailure: <T>(send: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=all-encryptions-failed.d.ts.map

package/lib/Compatibility/all-encryptions-failed.js

@@ -0,0 +1,49 @@
+import { Boom } from '../Utils/boom.js';
+/**
+ * A send that produced no ciphertext for its recipient.
+ *
+ * Upstream Baileys drops a device it cannot encrypt for and, when that leaves
+ * nothing, throws `Boom('All encryptions failed', { statusCode: 500 })`
+ * (`Socket/messages-send.ts`, in `createParticipantNodes`). The engine reached
+ * the same conclusion later: until `whatsapp-rust-bridge` 0.13.0 it returned a
+ * message id for a send that was never transmitted, and it now rejects with
+ * `no-recipient-device` instead.
+ *
+ * Same condition, different spelling, so it is translated here rather than
+ * left for the caller: Baileys code that branches on `statusCode === 500` or
+ * matches the message keeps working, and `attempted` rides along as extra
+ * data upstream has no way to carry.
+ */
+const NO_RECIPIENT_DEVICE = 'no-recipient-device';
+/** How many recipient devices the engine tried, when it said. */
+const attemptedFrom = (error) => {
+    const { attempted } = error;
+    return typeof attempted === 'number' ? attempted : undefined;
+};
+/**
+ * The rejection Baileys code expects, or the original error untouched.
+ *
+ * Narrow on purpose: only the engine's own `no-recipient-device` is rewritten,
+ * so every other failure still reaches the caller with the shape the bridge
+ * gave it.
+ */
+export const asAllEncryptionsFailed = (error) => {
+    if (typeof error !== 'object' || error === null)
+        return error;
+    if (error.kind !== NO_RECIPIENT_DEVICE)
+        return error;
+    return new Boom('All encryptions failed', {
+        statusCode: 500,
+        data: { attempted: attemptedFrom(error) }
+    });
+};
+/** Run a send, translating only that one rejection. */
+export const sendReportingUpstreamFailure = async (send) => {
+    try {
+        return await send();
+    }
+    catch (error) {
+        throw asAllEncryptionsFailed(error);
+    }
+};
+//# sourceMappingURL=all-encryptions-failed.js.map

package/lib/Socket/messages.js

@@ -1,3 +1,4 @@
+import { sendReportingUpstreamFailure } from '../Compatibility/all-encryptions-failed.js';
 import { sendDroppingDerivedNodes } from '../Compatibility/derived-stanza-nodes.js';
 import { encodeProtoCompat } from '../Compatibility/encode-proto.js';
 import { planMessageRelay } from '../Compatibility/message-relay.js';
@@ -69,14 +70,10 @@ export const makeMessageMethods = (ctx) => ({
                 return fullMsg;
             }
         }
-        let msgId;
         const msgBytes = encodeProtoCompat('Message', msg);
-        if (jid === 'status@broadcast' && options?.statusJidList?.length) {
-            msgId = await client.sendStatusMessageBytes(msgBytes, options.statusJidList);
-        }
-        else {
-            msgId = await client.sendMessageBytes(jid, msgBytes);
-        }
+        const msgId = await sendReportingUpstreamFailure(() => jid === 'status@broadcast' && options?.statusJidList?.length
+            ? client.sendStatusMessageBytes(msgBytes, options.statusJidList)
+            : client.sendMessageBytes(jid, msgBytes));
         fullMsg.key.id = msgId || fullMsg.key.id;
         // Local echo of the message we just sent. Suppressed when
         // `emitOwnEvents=false` so callers that explicitly opted out of seeing
@@ -150,9 +147,9 @@ export const makeMessageMethods = (ctx) => ({
         // either way.
         const drop = (tag) => ctx.logger.debug({ jid, messageId: plan.messageId, tag }, 'dropped an additionalNodes entry the engine derives from the message');
         if (plan.kind === 'status') {
-            return sendDroppingDerivedNodes(plan.nodes, nodes => client.sendStatusMessageBytesWithOptions(bytes, plan.recipients, plan.messageId, nodes, plan.refreshDevices), drop);
+            return sendReportingUpstreamFailure(() => sendDroppingDerivedNodes(plan.nodes, nodes => client.sendStatusMessageBytesWithOptions(bytes, plan.recipients, plan.messageId, nodes, plan.refreshDevices), drop));
         }
-        return sendDroppingDerivedNodes(plan.nodes, nodes => client.relayMessageBytesWithOptions(jid, bytes, plan.messageId, nodes, plan.refreshGroupMetadata, plan.refreshDevices), drop);
+        return sendReportingUpstreamFailure(() => sendDroppingDerivedNodes(plan.nodes, nodes => client.relayMessageBytesWithOptions(jid, bytes, plan.messageId, nodes, plan.refreshGroupMetadata, plan.refreshDevices), drop));
     },
     readMessages: async (keys) => {
         const receiptKeys = receiptMessageKeys(keys);

package/lib/Socket/transport.js

@@ -1,6 +1,26 @@
-const asWebSocketPayload = (data) => data.buffer instanceof ArrayBuffer
-    ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-    : new Uint8Array(data);
+/**
+ * `WebSocket.send()` takes a `BufferSource`, which is `ArrayBufferView<ArrayBuffer>
+ * | ArrayBuffer` — a `SharedArrayBuffer`-backed view is outside that contract.
+ * The bridge hands us the wider `Uint8Array<ArrayBufferLike>`, so the backing
+ * buffer has to be discriminated at runtime; this predicate is what carries that
+ * runtime check into the type system.
+ */
+const isArrayBufferBacked = (data) => data.buffer instanceof ArrayBuffer;
+/**
+ * Narrows an outgoing frame to what `WebSocket.send()` accepts.
+ *
+ * The `ArrayBuffer` case returns the caller's view as-is. Rebuilding it — the
+ * `new Uint8Array(data.buffer, data.byteOffset, data.byteLength)` this used to
+ * do — produced a view over the same buffer at the same offset and length: an
+ * allocation per outgoing frame that existed only to restate the type. It also
+ * did not detach the view from WASM memory growth, so returning the original
+ * gives the payload exactly the lifetime it had before; both are aliases of the
+ * same linear memory, consumed synchronously by the `ws.send()` on the next line.
+ *
+ * The `SharedArrayBuffer` case still copies: that one is not a type formality,
+ * the send API genuinely cannot take a view over shared memory.
+ */
+const asWebSocketPayload = (data) => isArrayBufferBacked(data) ? data : new Uint8Array(data);
 export const makeTransport = (config) => {
     const { waWebSocketUrl, logger } = config;
     let ws;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -82,7 +82,7 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
-    "@oxidezap/whatsapp-rust-bridge": "0.11.0",
+    "@oxidezap/whatsapp-rust-bridge": "0.13.0",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"