zapo-js 1.8.1 → 1.8.2

package/dist/client/coordinators/WaOfflineResumeCoordinator.d.ts

@@ -15,6 +15,11 @@ export declare class WaOfflineResumeCoordinator {
     private state;
     private totalStanzas;
     private pendingStanzas;
+    private batchInFlight;
+    private batchRetries;
+    private resumeGeneration;
+    private lastBatchRequestMs;
+    private batchTimeout;
     private stanzaTimeout;
     constructor(options: WaOfflineResumeCoordinatorOptions);
     get isComplete(): boolean;
@@ -24,6 +29,23 @@ export declare class WaOfflineResumeCoordinator {
     trackOfflineStanza(): void;
     reset(): void;
     private completeResume;
+    /**
+     * Ask the server for the next window of queued stanzas, at most one request
+     * per `REQUEST_DEBOUNCE_MS` and never while one is still outstanding. Only a
+     * delivered stanza schedules a request, so the loop winds down on its own
+     * once the queue dries up; the resume itself ends on the terminal `offline`
+     * bulletin or on the stanza timeout, never on the preview counter, which is
+     * a progress estimate rather than an authoritative total.
+     */
+    private scheduleNextBatch;
+    private requestOfflineBatch;
+    /**
+     * A rejected request delivers no stanza, and only a delivered stanza
+     * schedules the next one, so without a retry here a single transport blip
+     * strands the whole queue until the stanza timeout. `generation` pins the
+     * outcome to the resume that issued it: a rejection from a torn-down resume
+     * must not clear the current one's in-flight flag or retry on its behalf.
+     */
     private sendOfflineBatch;
     private resetStanzaTimeout;
     private clearTimers;

package/dist/client/coordinators/WaOfflineResumeCoordinator.js

@@ -5,6 +5,8 @@ const offline_1 = require("../../transport/node/builders/offline");
 const primitives_1 = require("../../util/primitives");
 const WA_OFFLINE_RESUME = Object.freeze({
     BATCH_SIZE: 200,
+    REQUEST_DEBOUNCE_MS: 100,
+    MAX_BATCH_RETRIES: 3,
     STANZA_TIMEOUT_MS: 60000
 });
 const WA_OFFLINE_RESUME_STATE = Object.freeze({
@@ -19,6 +21,11 @@ class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration = 0;
+        this.lastBatchRequestMs = 0;
+        this.batchTimeout = null;
         this.stanzaTimeout = null;
     }
     get isComplete() {
@@ -32,6 +39,10 @@ class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
         this.totalStanzas = stanzaCount;
         this.pendingStanzas = stanzaCount;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
         this.logger.info('offline resume started', {
             totalStanzas: stanzaCount
         });
@@ -41,7 +52,7 @@ class WaOfflineResumeCoordinator {
             remainingStanzas: stanzaCount,
             forced: false
         });
-        void this.sendOfflineBatch();
+        this.requestOfflineBatch();
         this.resetStanzaTimeout();
     }
     handleOfflineComplete(serverStanzaCount) {
@@ -55,17 +66,24 @@ class WaOfflineResumeCoordinator {
             return;
         }
         this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.batchInFlight = false;
         this.resetStanzaTimeout();
+        this.scheduleNextBatch();
     }
     reset() {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
     }
     completeResume(forced, serverStanzaCount) {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.batchInFlight = false;
         this.logger.info('offline resume complete', {
             totalStanzas: this.totalStanzas,
             remainingStanzas: this.pendingStanzas,
@@ -79,14 +97,73 @@ class WaOfflineResumeCoordinator {
             forced
         });
     }
-    async sendOfflineBatch() {
+    /**
+     * Ask the server for the next window of queued stanzas, at most one request
+     * per `REQUEST_DEBOUNCE_MS` and never while one is still outstanding. Only a
+     * delivered stanza schedules a request, so the loop winds down on its own
+     * once the queue dries up; the resume itself ends on the terminal `offline`
+     * bulletin or on the stanza timeout, never on the preview counter, which is
+     * a progress estimate rather than an authoritative total.
+     */
+    scheduleNextBatch() {
+        if (this.batchInFlight || this.batchTimeout !== null) {
+            return;
+        }
+        const elapsedMs = Date.now() - this.lastBatchRequestMs;
+        if (elapsedMs >= WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS) {
+            this.requestOfflineBatch();
+            return;
+        }
+        this.batchTimeout = setTimeout(() => {
+            this.batchTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.scheduleNextBatch();
+            }
+        }, WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS - elapsedMs);
+    }
+    requestOfflineBatch() {
+        this.batchInFlight = true;
+        this.lastBatchRequestMs = Date.now();
+        this.logger.debug('offline batch requested', {
+            batchSize: WA_OFFLINE_RESUME.BATCH_SIZE,
+            remainingStanzas: this.pendingStanzas
+        });
+        void this.sendOfflineBatch(this.resumeGeneration);
+    }
+    /**
+     * A rejected request delivers no stanza, and only a delivered stanza
+     * schedules the next one, so without a retry here a single transport blip
+     * strands the whole queue until the stanza timeout. `generation` pins the
+     * outcome to the resume that issued it: a rejection from a torn-down resume
+     * must not clear the current one's in-flight flag or retry on its behalf.
+     */
+    async sendOfflineBatch(generation) {
         try {
             await this.runtime.sendNode((0, offline_1.buildOfflineBatchNode)(WA_OFFLINE_RESUME.BATCH_SIZE));
+            if (generation === this.resumeGeneration) {
+                this.batchRetries = 0;
+            }
         }
         catch (err) {
-            this.logger.warn('offline batch request failed', {
+            if (generation !== this.resumeGeneration ||
+                this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+                return;
+            }
+            this.batchInFlight = false;
+            this.batchRetries += 1;
+            if (this.batchRetries > WA_OFFLINE_RESUME.MAX_BATCH_RETRIES) {
+                this.logger.warn('offline batch request failed, giving up', {
+                    attempts: this.batchRetries,
+                    remainingStanzas: this.pendingStanzas,
+                    message: (0, primitives_1.toError)(err).message
+                });
+                return;
+            }
+            this.logger.debug('offline batch request failed, retrying', {
+                attempt: this.batchRetries,
                 message: (0, primitives_1.toError)(err).message
             });
+            this.scheduleNextBatch();
         }
     }
     resetStanzaTimeout() {
@@ -109,6 +186,10 @@ class WaOfflineResumeCoordinator {
             clearTimeout(this.stanzaTimeout);
             this.stanzaTimeout = null;
         }
+        if (this.batchTimeout !== null) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
     }
 }
 exports.WaOfflineResumeCoordinator = WaOfflineResumeCoordinator;

package/dist/client/types.d.ts

@@ -1458,9 +1458,19 @@ export interface WaClientEventMap {
 export interface WaOfflineResumeEvent {
     readonly status: 'resuming' | 'complete';
     readonly totalStanzas: number;
-    /** `0` on the terminal `'complete'` event. */
+    /**
+     * Stanzas still outstanding against `totalStanzas`, counted down from the
+     * server's preview figure. That figure is an estimate, so a clean finish
+     * can still report a small non-zero remainder. Read it together with
+     * `forced`: a remainder alongside `forced: true` is the case where the
+     * flush was cut short and the rest stays queued for the next connection.
+     */
     readonly remainingStanzas: number;
-    /** `true` when triggered by an explicit catch-up request rather than auto-resume on reconnect. */
+    /**
+     * `true` when the resume was closed by the client because the server went
+     * quiet for 60s instead of by the server's terminal `offline` bulletin.
+     * Pair with `remainingStanzas` to tell a clean finish from a cut-short one.
+     */
     readonly forced: boolean;
 }
 export interface WaOfflineThreadPreview {

package/dist/esm/client/coordinators/WaOfflineResumeCoordinator.js

@@ -2,6 +2,8 @@ import { buildOfflineBatchNode } from '../../transport/node/builders/offline.js'
 import { toError } from '../../util/primitives.js';
 const WA_OFFLINE_RESUME = Object.freeze({
     BATCH_SIZE: 200,
+    REQUEST_DEBOUNCE_MS: 100,
+    MAX_BATCH_RETRIES: 3,
     STANZA_TIMEOUT_MS: 60000
 });
 const WA_OFFLINE_RESUME_STATE = Object.freeze({
@@ -16,6 +18,11 @@ export class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration = 0;
+        this.lastBatchRequestMs = 0;
+        this.batchTimeout = null;
         this.stanzaTimeout = null;
     }
     get isComplete() {
@@ -29,6 +36,10 @@ export class WaOfflineResumeCoordinator {
         this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
         this.totalStanzas = stanzaCount;
         this.pendingStanzas = stanzaCount;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
         this.logger.info('offline resume started', {
             totalStanzas: stanzaCount
         });
@@ -38,7 +49,7 @@ export class WaOfflineResumeCoordinator {
             remainingStanzas: stanzaCount,
             forced: false
         });
-        void this.sendOfflineBatch();
+        this.requestOfflineBatch();
         this.resetStanzaTimeout();
     }
     handleOfflineComplete(serverStanzaCount) {
@@ -52,17 +63,24 @@ export class WaOfflineResumeCoordinator {
             return;
         }
         this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.batchInFlight = false;
         this.resetStanzaTimeout();
+        this.scheduleNextBatch();
     }
     reset() {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.INIT;
         this.totalStanzas = 0;
         this.pendingStanzas = 0;
+        this.batchInFlight = false;
+        this.batchRetries = 0;
+        this.resumeGeneration += 1;
+        this.lastBatchRequestMs = 0;
     }
     completeResume(forced, serverStanzaCount) {
         this.clearTimers();
         this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.batchInFlight = false;
         this.logger.info('offline resume complete', {
             totalStanzas: this.totalStanzas,
             remainingStanzas: this.pendingStanzas,
@@ -76,14 +94,73 @@ export class WaOfflineResumeCoordinator {
             forced
         });
     }
-    async sendOfflineBatch() {
+    /**
+     * Ask the server for the next window of queued stanzas, at most one request
+     * per `REQUEST_DEBOUNCE_MS` and never while one is still outstanding. Only a
+     * delivered stanza schedules a request, so the loop winds down on its own
+     * once the queue dries up; the resume itself ends on the terminal `offline`
+     * bulletin or on the stanza timeout, never on the preview counter, which is
+     * a progress estimate rather than an authoritative total.
+     */
+    scheduleNextBatch() {
+        if (this.batchInFlight || this.batchTimeout !== null) {
+            return;
+        }
+        const elapsedMs = Date.now() - this.lastBatchRequestMs;
+        if (elapsedMs >= WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS) {
+            this.requestOfflineBatch();
+            return;
+        }
+        this.batchTimeout = setTimeout(() => {
+            this.batchTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.scheduleNextBatch();
+            }
+        }, WA_OFFLINE_RESUME.REQUEST_DEBOUNCE_MS - elapsedMs);
+    }
+    requestOfflineBatch() {
+        this.batchInFlight = true;
+        this.lastBatchRequestMs = Date.now();
+        this.logger.debug('offline batch requested', {
+            batchSize: WA_OFFLINE_RESUME.BATCH_SIZE,
+            remainingStanzas: this.pendingStanzas
+        });
+        void this.sendOfflineBatch(this.resumeGeneration);
+    }
+    /**
+     * A rejected request delivers no stanza, and only a delivered stanza
+     * schedules the next one, so without a retry here a single transport blip
+     * strands the whole queue until the stanza timeout. `generation` pins the
+     * outcome to the resume that issued it: a rejection from a torn-down resume
+     * must not clear the current one's in-flight flag or retry on its behalf.
+     */
+    async sendOfflineBatch(generation) {
         try {
             await this.runtime.sendNode(buildOfflineBatchNode(WA_OFFLINE_RESUME.BATCH_SIZE));
+            if (generation === this.resumeGeneration) {
+                this.batchRetries = 0;
+            }
         }
         catch (err) {
-            this.logger.warn('offline batch request failed', {
+            if (generation !== this.resumeGeneration ||
+                this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+                return;
+            }
+            this.batchInFlight = false;
+            this.batchRetries += 1;
+            if (this.batchRetries > WA_OFFLINE_RESUME.MAX_BATCH_RETRIES) {
+                this.logger.warn('offline batch request failed, giving up', {
+                    attempts: this.batchRetries,
+                    remainingStanzas: this.pendingStanzas,
+                    message: toError(err).message
+                });
+                return;
+            }
+            this.logger.debug('offline batch request failed, retrying', {
+                attempt: this.batchRetries,
                 message: toError(err).message
             });
+            this.scheduleNextBatch();
         }
     }
     resetStanzaTimeout() {
@@ -106,5 +183,9 @@ export class WaOfflineResumeCoordinator {
             clearTimeout(this.stanzaTimeout);
             this.stanzaTimeout = null;
         }
+        if (this.batchTimeout !== null) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
     }
 }

package/dist/esm/message/crypto/phash.js

@@ -9,39 +9,84 @@ const CHAR_AT = 0x40;
 const CHAR_C = 0x63;
 const CHAR_U = 0x75;
 const CHAR_S = 0x73;
-const MAX_PARTICIPANTS = 2048;
-const PER_WID_BYTES = 96;
-const SCRATCH = new Uint8Array(MAX_PARTICIPANTS * PER_WID_BYTES);
-const OFFSETS = new Uint32Array(MAX_PARTICIPANTS + 1);
-const ORDER = new Uint32Array(MAX_PARTICIPANTS);
+/**
+ * Upper bound on the bytes the canonical rewrite can add to a single jid: the
+ * `.0:` agent marker plus a device digit when the input carries neither, plus
+ * the `c.us` server substitution.
+ */
+const CANONICAL_GROWTH_BYTES = 4 + WA_DEFAULTS.HOST_DOMAIN.length;
+/**
+ * Largest canonical buffer kept alive between calls (the index arrays scale
+ * with it). Lists above this bound are rare enough that a throwaway allocation
+ * beats holding the memory for the life of the process.
+ */
+const RETAINED_SCRATCH_BYTES = 1024 * 1024;
+const RETAINED = {
+    scratch: new Uint8Array(0),
+    offsets: new Uint32Array(0),
+    order: new Uint32Array(0)
+};
+/**
+ * Computes the v2 participant hash (`2:<base64>`) attached to group and
+ * broadcast-list fanouts.
+ *
+ * Every participant is canonicalized to `<user>.0:<device>@<server>`, the set
+ * is sorted bytewise and hashed as a single SHA-256 stream. There is no
+ * participant ceiling: the canonical buffer grows to fit the list, so a group
+ * whose members resolve to tens of thousands of devices still hashes.
+ *
+ * @param participants device jids, in any order
+ * @returns the `2:`-prefixed phash, or `'2:'` when the list is empty
+ */
 export function computePhashV2(participants) {
-    if (participants.length === 0)
-        return '2:';
     const n = participants.length;
-    if (n > MAX_PARTICIPANTS) {
-        throw new Error(`phash participant count ${n} exceeds MAX_PARTICIPANTS ${MAX_PARTICIPANTS}`);
+    if (n === 0)
+        return '2:';
+    let requiredBytes = 0;
+    for (let i = 0; i < n; i += 1) {
+        requiredBytes += participants[i].length + CANONICAL_GROWTH_BYTES;
     }
+    const { scratch, offsets, order } = acquireBuffers(n, requiredBytes);
     let off = 0;
     for (let i = 0; i < n; i += 1) {
-        OFFSETS[i] = off;
-        const nextOff = writeCanonicalUtf8(SCRATCH, off, participants[i]);
-        if (nextOff > SCRATCH.length) {
-            throw new Error(`phash canonical buffer overflow at participant ${i}: needs ${nextOff} bytes, scratch is ${SCRATCH.length}`);
-        }
-        off = nextOff;
+        offsets[i] = off;
+        off = writeCanonicalUtf8(scratch, off, participants[i]);
+    }
+    offsets[n] = off;
+    if (off > scratch.length) {
+        throw new Error(`phash canonical buffer overflow: needs ${off} bytes, scratch is ${scratch.length}`);
     }
-    OFFSETS[n] = off;
     for (let i = 0; i < n; i += 1)
-        ORDER[i] = i;
-    ORDER.subarray(0, n).sort((a, b) => compareScratchSlice(SCRATCH, OFFSETS, a, b));
+        order[i] = i;
+    const ranked = order.subarray(0, n);
+    ranked.sort((a, b) => compareScratchSlice(scratch, offsets, a, b));
     const parts = new Array(n);
     for (let i = 0; i < n; i += 1) {
-        const idx = ORDER[i];
-        parts[i] = SCRATCH.subarray(OFFSETS[idx], OFFSETS[idx + 1]);
+        const idx = ranked[i];
+        parts[i] = scratch.subarray(offsets[idx], offsets[idx + 1]);
     }
     const digest = sha256(parts);
     return `2:${bytesToBase64(digest.subarray(0, PHASH_DIGEST_PREFIX))}`;
 }
+function acquireBuffers(participantCount, requiredBytes) {
+    if (requiredBytes > RETAINED_SCRATCH_BYTES) {
+        return {
+            scratch: new Uint8Array(requiredBytes),
+            offsets: new Uint32Array(participantCount + 1),
+            order: new Uint32Array(participantCount)
+        };
+    }
+    if (RETAINED.scratch.length < requiredBytes) {
+        const nextBytes = Math.max(requiredBytes, RETAINED.scratch.length * 2);
+        RETAINED.scratch = new Uint8Array(Math.min(RETAINED_SCRATCH_BYTES, nextBytes));
+    }
+    if (RETAINED.order.length < participantCount) {
+        const capacity = Math.max(participantCount, RETAINED.order.length * 2);
+        RETAINED.offsets = new Uint32Array(capacity + 1);
+        RETAINED.order = new Uint32Array(capacity);
+    }
+    return RETAINED;
+}
 function writeCanonicalUtf8(out, start, jid) {
     const atIndex = jid.indexOf('@');
     if (atIndex < 1 || atIndex >= jid.length - 1) {

package/dist/message/crypto/phash.d.ts

@@ -1 +1,13 @@
+/**
+ * Computes the v2 participant hash (`2:<base64>`) attached to group and
+ * broadcast-list fanouts.
+ *
+ * Every participant is canonicalized to `<user>.0:<device>@<server>`, the set
+ * is sorted bytewise and hashed as a single SHA-256 stream. There is no
+ * participant ceiling: the canonical buffer grows to fit the list, so a group
+ * whose members resolve to tens of thousands of devices still hashes.
+ *
+ * @param participants device jids, in any order
+ * @returns the `2:`-prefixed phash, or `'2:'` when the list is empty
+ */
 export declare function computePhashV2(participants: readonly string[]): string;

package/dist/message/crypto/phash.js

@@ -12,39 +12,84 @@ const CHAR_AT = 0x40;
 const CHAR_C = 0x63;
 const CHAR_U = 0x75;
 const CHAR_S = 0x73;
-const MAX_PARTICIPANTS = 2048;
-const PER_WID_BYTES = 96;
-const SCRATCH = new Uint8Array(MAX_PARTICIPANTS * PER_WID_BYTES);
-const OFFSETS = new Uint32Array(MAX_PARTICIPANTS + 1);
-const ORDER = new Uint32Array(MAX_PARTICIPANTS);
+/**
+ * Upper bound on the bytes the canonical rewrite can add to a single jid: the
+ * `.0:` agent marker plus a device digit when the input carries neither, plus
+ * the `c.us` server substitution.
+ */
+const CANONICAL_GROWTH_BYTES = 4 + constants_1.WA_DEFAULTS.HOST_DOMAIN.length;
+/**
+ * Largest canonical buffer kept alive between calls (the index arrays scale
+ * with it). Lists above this bound are rare enough that a throwaway allocation
+ * beats holding the memory for the life of the process.
+ */
+const RETAINED_SCRATCH_BYTES = 1024 * 1024;
+const RETAINED = {
+    scratch: new Uint8Array(0),
+    offsets: new Uint32Array(0),
+    order: new Uint32Array(0)
+};
+/**
+ * Computes the v2 participant hash (`2:<base64>`) attached to group and
+ * broadcast-list fanouts.
+ *
+ * Every participant is canonicalized to `<user>.0:<device>@<server>`, the set
+ * is sorted bytewise and hashed as a single SHA-256 stream. There is no
+ * participant ceiling: the canonical buffer grows to fit the list, so a group
+ * whose members resolve to tens of thousands of devices still hashes.
+ *
+ * @param participants device jids, in any order
+ * @returns the `2:`-prefixed phash, or `'2:'` when the list is empty
+ */
 function computePhashV2(participants) {
-    if (participants.length === 0)
-        return '2:';
     const n = participants.length;
-    if (n > MAX_PARTICIPANTS) {
-        throw new Error(`phash participant count ${n} exceeds MAX_PARTICIPANTS ${MAX_PARTICIPANTS}`);
+    if (n === 0)
+        return '2:';
+    let requiredBytes = 0;
+    for (let i = 0; i < n; i += 1) {
+        requiredBytes += participants[i].length + CANONICAL_GROWTH_BYTES;
     }
+    const { scratch, offsets, order } = acquireBuffers(n, requiredBytes);
     let off = 0;
     for (let i = 0; i < n; i += 1) {
-        OFFSETS[i] = off;
-        const nextOff = writeCanonicalUtf8(SCRATCH, off, participants[i]);
-        if (nextOff > SCRATCH.length) {
-            throw new Error(`phash canonical buffer overflow at participant ${i}: needs ${nextOff} bytes, scratch is ${SCRATCH.length}`);
-        }
-        off = nextOff;
+        offsets[i] = off;
+        off = writeCanonicalUtf8(scratch, off, participants[i]);
+    }
+    offsets[n] = off;
+    if (off > scratch.length) {
+        throw new Error(`phash canonical buffer overflow: needs ${off} bytes, scratch is ${scratch.length}`);
     }
-    OFFSETS[n] = off;
     for (let i = 0; i < n; i += 1)
-        ORDER[i] = i;
-    ORDER.subarray(0, n).sort((a, b) => compareScratchSlice(SCRATCH, OFFSETS, a, b));
+        order[i] = i;
+    const ranked = order.subarray(0, n);
+    ranked.sort((a, b) => compareScratchSlice(scratch, offsets, a, b));
     const parts = new Array(n);
     for (let i = 0; i < n; i += 1) {
-        const idx = ORDER[i];
-        parts[i] = SCRATCH.subarray(OFFSETS[idx], OFFSETS[idx + 1]);
+        const idx = ranked[i];
+        parts[i] = scratch.subarray(offsets[idx], offsets[idx + 1]);
     }
     const digest = (0, core_1.sha256)(parts);
     return `2:${(0, bytes_1.bytesToBase64)(digest.subarray(0, PHASH_DIGEST_PREFIX))}`;
 }
+function acquireBuffers(participantCount, requiredBytes) {
+    if (requiredBytes > RETAINED_SCRATCH_BYTES) {
+        return {
+            scratch: new Uint8Array(requiredBytes),
+            offsets: new Uint32Array(participantCount + 1),
+            order: new Uint32Array(participantCount)
+        };
+    }
+    if (RETAINED.scratch.length < requiredBytes) {
+        const nextBytes = Math.max(requiredBytes, RETAINED.scratch.length * 2);
+        RETAINED.scratch = new Uint8Array(Math.min(RETAINED_SCRATCH_BYTES, nextBytes));
+    }
+    if (RETAINED.order.length < participantCount) {
+        const capacity = Math.max(participantCount, RETAINED.order.length * 2);
+        RETAINED.offsets = new Uint32Array(capacity + 1);
+        RETAINED.order = new Uint32Array(capacity);
+    }
+    return RETAINED;
+}
 function writeCanonicalUtf8(out, start, jid) {
     const atIndex = jid.indexOf('@');
     if (atIndex < 1 || atIndex >= jid.length - 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zapo-js",
-    "version": "1.8.1",
+    "version": "1.8.2",
     "description": "High-performance WhatsApp Web TypeScript library",
     "license": "MIT",
     "author": "vinikjkkj <contact@vinicius.email> (https://github.com/vinikjkkj)",