@oxidezap/baileyrs 0.0.29 → 0.0.30

package/lib/Compatibility/proto-runtime.js

@@ -199,15 +199,21 @@ class ProtoCompatibilityRuntime {
     makeConstructor(schemaId, fields, sourceCodec) {
         const convertToObject = (message) => this.toObject(schemaId, message, JSON_OPTIONS);
         const path = PROTO_MESSAGE_SCHEMAS[schemaId][0];
+        // Indexed loops: these run for every constructed instance and stay on
+        // the megamorphic path at runtime, where V8 does not elide for..of
+        // iterator allocations.
         const constructor = function (properties) {
-            for (const field of fields) {
+            for (let i = 0; i < fields.length; i++) {
+                const field = fields[i];
                 if (field[3] & PROTO_FIELD_FLAG.repeated)
                     this[field[0]] = [];
                 else if (field[3] & PROTO_FIELD_FLAG.map)
                     this[field[0]] = {};
             }
             if (properties) {
-                for (const key of Object.keys(properties)) {
+                const keys = Object.keys(properties);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
                     const value = properties[key];
                     if (value !== null && value !== undefined)
                         this[key] = value;
@@ -311,7 +317,12 @@ class ProtoCompatibilityRuntime {
             return input;
         const data = input;
         const instance = new constructor();
-        for (const field of PROTO_MESSAGE_SCHEMAS[schemaId][1]) {
+        // Indexed loop: this walks the full schema per converted node on the
+        // megamorphic path, where V8 does not elide for..of iterator
+        // allocations (~90 iterator results per WebMessageInfo envelope).
+        const fields = PROTO_MESSAGE_SCHEMAS[schemaId][1];
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
             const value = data[field[0]];
             if (value === null || value === undefined)
                 continue;

package/lib/Socket/events.js

@@ -6,7 +6,8 @@
  * mapped type so TS forces a handler per variant — a missing handler
  * is a compile error.
  */
-import { BinaryReader } from 'whatsapp-rust-bridge';
+import Long from 'long';
+import { BinaryReader, decodeMessageWireInfos, decodeReceiptWireBatch, decodeServerAckWireBatch } from 'whatsapp-rust-bridge';
 import { adaptBridgeEvent, adaptBridgeMessageWire } from '../Bridge/index.js';
 import { decodeHistorySyncWireBatch } from '../Bridge/history-sync-wire.js';
 import { bridgeGroupMetadataToBaileys } from '../Compatibility/group-metadata.js';
@@ -56,18 +57,29 @@ const emitCBEvents = (ctx, node) => {
  * bridge → canonical → Baileys pipeline. Adapters never reach for the proto.
  */
 const canonicalMessageToWAMessage = (m) => {
-    const wm = WAProto.WebMessageInfo.fromObject({
-        key: {
-            remoteJid: m.chatJid,
-            fromMe: m.isFromMe,
-            id: m.id,
-            participant: m.senderJid
-        },
-        message: m.messageProto,
-        messageTimestamp: m.timestamp,
-        pushName: m.pushName,
-        status: WAProto.WebMessageInfo.Status.SERVER_ACK
-    });
+    // Direct construction instead of a `WebMessageInfo.fromObject` envelope:
+    // every input is already in its wire-correct runtime type, so the schema
+    // walk would only re-derive them field by field on the hottest path. `new`
+    // keeps protobufjs parity (instanceof, prototype defaults and own
+    // repeated/map fields), and `Message.fromObject` still normalizes the
+    // payload while short-circuiting the already-decoded runtime instances.
+    const key = new WAProto.MessageKey();
+    key.remoteJid = m.chatJid;
+    key.fromMe = m.isFromMe;
+    key.id = m.id;
+    if (m.senderJid !== undefined)
+        key.participant = m.senderJid;
+    const wm = new WAProto.WebMessageInfo();
+    wm.key = key;
+    if (m.messageProto !== undefined)
+        wm.message = WAProto.Message.fromObject(m.messageProto);
+    // Source-side WAProto types 64-bit fields via the bridge shapes (plain
+    // number); the published facade and the previous fromObject path both
+    // carry a protobufjs `Long` here, so keep that runtime shape.
+    wm.messageTimestamp = Long.fromValue(m.timestamp);
+    if (m.pushName !== undefined)
+        wm.pushName = m.pushName;
+    wm.status = WAProto.WebMessageInfo.Status.SERVER_ACK;
     if (m.participantAlt)
         wm.key.participantAlt = m.participantAlt;
     if (m.remoteJidAlt)
@@ -784,8 +796,16 @@ export const makeEventHandlers = (ctx, callbacks) => {
             return;
         }
         const messageCount = batch.messageOffsets.length - MESSAGE_WIRE_OFFSET_SENTINEL_COUNT;
-        if (batch.infos.length !== messageCount) {
-            ctx.logger.error({ infoCount: batch.infos.length, messageCount }, 'message wire batch metadata count does not match its payload count');
+        let infos;
+        try {
+            infos = decodeMessageWireInfos(batch);
+        }
+        catch (err) {
+            ctx.logger.error({ err }, 'failed to decode message wire metadata records');
+            return;
+        }
+        if (infos.length !== messageCount) {
+            ctx.logger.error({ infoCount: infos.length, messageCount }, 'message wire batch metadata count does not match its payload count');
             return;
         }
         // Decode through the runtime facade so each payload materializes as a
@@ -808,17 +828,47 @@ export const makeEventHandlers = (ctx, callbacks) => {
                 ctx.logger.warn({ err, index }, 'skipping malformed wire message');
             }
         }
-        dispatchCanonicalBatch(ctx, dispatchCtx, messageCount, index => adaptBridgeMessageWire(messages[index], batch.infos[index], ctx.logger));
+        dispatchCanonicalBatch(ctx, dispatchCtx, messageCount, index => adaptBridgeMessageWire(messages[index], infos[index], ctx.logger));
     };
     const onHistorySyncBatch = (batch) => {
         const decoded = decodeHistorySyncWireBatch(batch, ctx.logger);
         onEvent(decoded.event);
         return decoded.skippedConversations;
     };
+    // Packed receipt/ack batches reconstruct the single-event wire shape and
+    // reuse the same adapter path, so transport is the only thing that changes.
+    const onReceiptBatch = (batch) => {
+        let receipts;
+        try {
+            receipts = decodeReceiptWireBatch(batch);
+        }
+        catch (err) {
+            ctx.logger.error({ err }, 'failed to decode receipt wire batch');
+            return;
+        }
+        // The decoded payload matches the single-event wire shape; the union's
+        // declared type is narrower than the adapter's tolerance.
+        for (const data of receipts)
+            onEvent({ type: 'receipt', data });
+    };
+    const onServerAckBatch = (batch) => {
+        let acks;
+        try {
+            acks = decodeServerAckWireBatch(batch);
+        }
+        catch (err) {
+            ctx.logger.error({ err }, 'failed to decode server-ack wire batch');
+            return;
+        }
+        for (const data of acks)
+            onEvent({ type: 'server_ack', data });
+    };
     return {
         onEvent,
         onMessageBatch,
         onHistorySyncBatch,
+        onReceiptBatch,
+        onServerAckBatch,
         historySyncConversationTypes: CONVERSATION_HISTORY_SYNC_TYPES
     };
 };

package/lib/Utils/messages.js

@@ -1,4 +1,5 @@
 import { Buffer } from 'node:buffer';
+import LongRuntime from 'long';
 import { Readable } from 'node:stream';
 import { toBridgeMediaType } from '../Compatibility/media-type.js';
 import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
@@ -261,7 +262,10 @@ export const generateWAMessageContent = async (message, options) => {
     if (hasNonNullishProperty(message, 'text')) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
-        if (typeof urlInfo === 'undefined') {
+        // Gate on the resolver before awaiting: without one the helper resolves
+        // to undefined anyway, and every plain text send would still pay for a
+        // promise plus a microtask turn.
+        if (typeof urlInfo === 'undefined' && options.getUrlInfo) {
             urlInfo = await generateLinkPreviewIfRequired(message.text, options.getUrlInfo, options.logger);
         }
         if (urlInfo) {
@@ -546,20 +550,32 @@ export const generateWAMessageFromContent = (jid, message, options) => {
             //ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
         };
     }
-    message = WAProto.Message.create(message);
-    const messageJSON = {
-        key: {
-            remoteJid: jid,
-            fromMe: true,
-            id: options?.messageId || '' // Rust generates the real message ID
-        },
-        message: message,
-        messageTimestamp: timestamp,
-        messageStubParameters: [],
-        participant: isJidGroup(jid) || isJidStatusBroadcast(jid) ? userJid : undefined, // TODO: Add support for LIDs
-        status: WAMessageStatus.PENDING
-    };
-    return WAProto.WebMessageInfo.fromObject(messageJSON);
+    // `create` copies into a fresh instance; content built by
+    // `generateWAMessageContent` already is one, and the branches above mutate
+    // it in place regardless, so copying it again only duplicates the tree.
+    if (!(message instanceof WAProto.Message))
+        message = WAProto.Message.create(message);
+    // Direct construction instead of a `WebMessageInfo.fromObject` envelope:
+    // every value is already in its runtime type (`message` came from
+    // `Message.create` above), so the schema walk would only re-derive them.
+    // `new` keeps protobufjs parity, including the constructor's own
+    // `messageStubParameters` array. The `Long` cast mirrors the published
+    // facade shape for 64-bit fields (source-side WAProto types them as plain
+    // numbers via the bridge shapes).
+    const messageKey = new WAProto.MessageKey();
+    messageKey.remoteJid = jid;
+    messageKey.fromMe = true;
+    messageKey.id = options?.messageId || ''; // Rust generates the real message ID
+    const wm = new WAProto.WebMessageInfo();
+    wm.key = messageKey;
+    wm.message = message;
+    wm.messageTimestamp = LongRuntime.fromValue(timestamp);
+    // TODO: Add support for LIDs
+    const participant = isJidGroup(jid) || isJidStatusBroadcast(jid) ? userJid : undefined;
+    if (participant !== undefined)
+        wm.participant = participant;
+    wm.status = WAMessageStatus.PENDING;
+    return wm;
 };
 export const generateWAMessage = async (jid, content, options) => {
     const contentOptions = options.messageId && options.logger

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -78,7 +78,7 @@
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5",
-    "whatsapp-rust-bridge": "0.6.0-alpha.39"
+    "whatsapp-rust-bridge": "0.6.0-alpha.40"
   },
   "devDependencies": {
     "@bufbuild/protobuf": "^2.13.0",