debounceKey?: string;

durableId?: string;

readReceipt?: WhatsAppReadReceiptTarget;

receiveOrder?: number;

};

const durableInboundJournal = createWhatsAppDurableInboundReceiveJournal(options.accountId);

const inboundDebounceMs = Math.max(0, Math.trunc(options.debounceMs ?? 0));

};

const shouldDebounceInboundMessage = (msg: WebInboundMessage): boolean =>

options.shouldDebounce?.(msg) ?? true;

const orderDebouncedInboundEntries = (entries: QueuedInboundMessage[]) =>

entries.toSorted((a, b) => {

const timestampDiff = (a.timestamp ?? 0) - (b.timestamp ?? 0);

if (timestampDiff !== 0) {

return timestampDiff;

}

return (a.receiveOrder ?? 0) - (b.receiveOrder ?? 0);

});

const finalizeInboundDelivery = async (

entries: QueuedInboundMessage[],

});

activeInboundFlushes.add(flushTask);

try {

const last = entries.at(-1);

const orderedEntries = orderDebouncedInboundEntries(entries);

const last = orderedEntries.at(-1);

if (!last) {

return;

}

try {

if (entries.length === 1) {

if (orderedEntries.length === 1) {

await options.onMessage(last);

await finalizeInboundDelivery(entries);

await finalizeInboundDelivery(orderedEntries);

return;

}

const mentioned = new Set<string>();

for (const entry of entries) {

for (const entry of orderedEntries) {

for (const jid of entry.mentions ?? entry.mentionedJids ?? []) {

mentioned.add(jid);

}

}

const combinedBody = entries

const combinedBody = orderedEntries

.map((entry) => entry.body)

.filter(Boolean)

.join("\n");

isBatched: true,

};

await options.onMessage(combinedMessage);

await finalizeInboundDelivery(entries);

await finalizeInboundDelivery(orderedEntries);

} catch (error) {

await finalizeInboundDelivery(entries, error);

await finalizeInboundDelivery(orderedEntries, error);

throw error;

}

} finally {

const processDurableInboundMessage = async (

msg: WAMessage,

upsertType: string | undefined,

receiveOrder: number | undefined,

stored?: {

id: string;

payload: WhatsAppDurableInboundPayload;

await enqueueInboundMessage(msg, inbound, enriched, {

durableId,

readReceipt: deliveryReadReceipt,

receiveOrder,

});

};

await processDurableInboundMessage(

deserializeWhatsAppDurableInboundMessage(record.payload.message),

record.payload.upsertType,

record.payload.receivedAt,

{

id: record.id,

payload: record.payload,

durable: {

durableId?: string;

readReceipt?: WhatsAppReadReceiptTarget;

receiveOrder?: number;

},

) => {

const chatJid = inbound.remoteJid;

dedupeKey: inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : undefined,

durableId: durable.durableId,

readReceipt: durable.readReceipt,

receiveOrder: durable.receiveOrder,

};

const debounceKey = buildInboundDebounceKey(inboundMessage);

if (debounceKey) {

};

const pendingMessageHandlers = new Set<Promise<void>>();

let nextReceiveOrder = 0;

const handleMessagesUpsert = async (upsert: { type?: string; messages?: Array<WAMessage> }) => {

if (upsert.type !== "notify" && upsert.type !== "append") {

return;

}

for (const msg of upsert.messages ?? []) {

const receiveOrder = nextReceiveOrder++;

if (

await maybeResolveWhatsAppApprovalReaction({

cfg: options.loadConfig?.() ?? options.cfg,

continue;

}

await processDurableInboundMessage(msg, upsert.type);

await processDurableInboundMessage(msg, upsert.type, receiveOrder);

}

};

const handleMessagesUpsertEvent = (upsert: { type?: string; messages?: Array<WAMessage> }) => {