@intent-systems/nexus 2026.1.5-3

package/dist/web/login-qr.js

@@ -0,0 +1,230 @@
+import { randomUUID } from "node:crypto";
+import { DisconnectReason } from "@whiskeysockets/baileys";
+import { loadConfig } from "../config/config.js";
+import { danger, info, success } from "../globals.js";
+import { logInfo } from "../logger.js";
+import { defaultRuntime } from "../runtime.js";
+import { resolveWhatsAppAccount } from "./accounts.js";
+import { renderQrPngBase64 } from "./qr-image.js";
+import { createWaSocket, formatError, getStatusCode, logoutWeb, readWebSelfId, waitForWaConnection, webAuthExists, } from "./session.js";
+const ACTIVE_LOGIN_TTL_MS = 3 * 60_000;
+const activeLogins = new Map();
+function closeSocket(sock) {
+    try {
+        sock.ws?.close();
+    }
+    catch {
+        // ignore
+    }
+}
+async function resetActiveLogin(accountId, reason) {
+    const login = activeLogins.get(accountId);
+    if (login) {
+        closeSocket(login.sock);
+        activeLogins.delete(accountId);
+    }
+    if (reason) {
+        logInfo(reason);
+    }
+}
+function isLoginFresh(login) {
+    return Date.now() - login.startedAt < ACTIVE_LOGIN_TTL_MS;
+}
+function attachLoginWaiter(accountId, login) {
+    login.waitPromise = waitForWaConnection(login.sock)
+        .then(() => {
+        const current = activeLogins.get(accountId);
+        if (current?.id === login.id)
+            current.connected = true;
+    })
+        .catch((err) => {
+        const current = activeLogins.get(accountId);
+        if (current?.id !== login.id)
+            return;
+        current.error = formatError(err);
+        current.errorStatus = getStatusCode(err);
+    });
+}
+async function restartLoginSocket(login, runtime) {
+    if (login.restartAttempted)
+        return false;
+    login.restartAttempted = true;
+    runtime.log(info("WhatsApp asked for a restart after pairing (code 515); retrying connection once…"));
+    closeSocket(login.sock);
+    try {
+        const sock = await createWaSocket(false, login.verbose, {
+            authDir: login.authDir,
+        });
+        login.sock = sock;
+        login.connected = false;
+        login.error = undefined;
+        login.errorStatus = undefined;
+        attachLoginWaiter(login.accountId, login);
+        return true;
+    }
+    catch (err) {
+        login.error = formatError(err);
+        login.errorStatus = getStatusCode(err);
+        return false;
+    }
+}
+export async function startWebLoginWithQr(opts = {}) {
+    const runtime = opts.runtime ?? defaultRuntime;
+    const cfg = loadConfig();
+    const account = resolveWhatsAppAccount({ cfg, accountId: opts.accountId });
+    const hasWeb = await webAuthExists(account.authDir);
+    const selfId = readWebSelfId(account.authDir);
+    if (hasWeb && !opts.force) {
+        const who = selfId.e164 ?? selfId.jid ?? "unknown";
+        return {
+            message: `WhatsApp is already linked (${who}). Say “relink” if you want a fresh QR.`,
+        };
+    }
+    const existing = activeLogins.get(account.accountId);
+    if (existing && isLoginFresh(existing) && existing.qrDataUrl) {
+        return {
+            qrDataUrl: existing.qrDataUrl,
+            message: "QR already active. Scan it in WhatsApp → Linked Devices.",
+        };
+    }
+    await resetActiveLogin(account.accountId);
+    let resolveQr = null;
+    let rejectQr = null;
+    const qrPromise = new Promise((resolve, reject) => {
+        resolveQr = resolve;
+        rejectQr = reject;
+    });
+    const qrTimer = setTimeout(() => {
+        rejectQr?.(new Error("Timed out waiting for WhatsApp QR"));
+    }, Math.max(opts.timeoutMs ?? 30_000, 5000));
+    let sock;
+    let pendingQr = null;
+    try {
+        sock = await createWaSocket(false, Boolean(opts.verbose), {
+            authDir: account.authDir,
+            onQr: (qr) => {
+                if (pendingQr)
+                    return;
+                pendingQr = qr;
+                const current = activeLogins.get(account.accountId);
+                if (current && !current.qr)
+                    current.qr = qr;
+                clearTimeout(qrTimer);
+                runtime.log(info("WhatsApp QR received."));
+                resolveQr?.(qr);
+            },
+        });
+    }
+    catch (err) {
+        clearTimeout(qrTimer);
+        await resetActiveLogin(account.accountId);
+        return {
+            message: `Failed to start WhatsApp login: ${String(err)}`,
+        };
+    }
+    const login = {
+        accountId: account.accountId,
+        authDir: account.authDir,
+        isLegacyAuthDir: account.isLegacyAuthDir,
+        id: randomUUID(),
+        sock,
+        startedAt: Date.now(),
+        connected: false,
+        waitPromise: Promise.resolve(),
+        restartAttempted: false,
+        verbose: Boolean(opts.verbose),
+    };
+    activeLogins.set(account.accountId, login);
+    if (pendingQr && !login.qr)
+        login.qr = pendingQr;
+    attachLoginWaiter(account.accountId, login);
+    let qr;
+    try {
+        qr = await qrPromise;
+    }
+    catch (err) {
+        clearTimeout(qrTimer);
+        await resetActiveLogin(account.accountId);
+        return {
+            message: `Failed to get QR: ${String(err)}`,
+        };
+    }
+    const base64 = await renderQrPngBase64(qr);
+    login.qrDataUrl = `data:image/png;base64,${base64}`;
+    return {
+        qrDataUrl: login.qrDataUrl,
+        message: "Scan this QR in WhatsApp → Linked Devices.",
+    };
+}
+export async function waitForWebLogin(opts = {}) {
+    const runtime = opts.runtime ?? defaultRuntime;
+    const cfg = loadConfig();
+    const account = resolveWhatsAppAccount({ cfg, accountId: opts.accountId });
+    const activeLogin = activeLogins.get(account.accountId);
+    if (!activeLogin) {
+        return {
+            connected: false,
+            message: "No active WhatsApp login in progress.",
+        };
+    }
+    const login = activeLogin;
+    if (!isLoginFresh(login)) {
+        await resetActiveLogin(account.accountId);
+        return {
+            connected: false,
+            message: "The login QR expired. Ask me to generate a new one.",
+        };
+    }
+    const timeoutMs = Math.max(opts.timeoutMs ?? 120_000, 1000);
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            return {
+                connected: false,
+                message: "Still waiting for the QR scan. Let me know when you’ve scanned it.",
+            };
+        }
+        const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), remaining));
+        const result = await Promise.race([
+            login.waitPromise.then(() => "done"),
+            timeout,
+        ]);
+        if (result === "timeout") {
+            return {
+                connected: false,
+                message: "Still waiting for the QR scan. Let me know when you’ve scanned it.",
+            };
+        }
+        if (login.error) {
+            if (login.errorStatus === DisconnectReason.loggedOut) {
+                await logoutWeb({
+                    authDir: login.authDir,
+                    isLegacyAuthDir: login.isLegacyAuthDir,
+                    runtime,
+                });
+                const message = "WhatsApp reported the session is logged out. Cleared cached web session; please scan a new QR.";
+                await resetActiveLogin(account.accountId, message);
+                runtime.log(danger(message));
+                return { connected: false, message };
+            }
+            if (login.errorStatus === 515) {
+                const restarted = await restartLoginSocket(login, runtime);
+                if (restarted && isLoginFresh(login)) {
+                    continue;
+                }
+            }
+            const message = `WhatsApp login failed: ${login.error}`;
+            await resetActiveLogin(account.accountId, message);
+            runtime.log(danger(message));
+            return { connected: false, message };
+        }
+        if (login.connected) {
+            const message = "✅ Linked! WhatsApp is ready.";
+            runtime.log(success(message));
+            await resetActiveLogin(account.accountId);
+            return { connected: true, message };
+        }
+        return { connected: false, message: "Login ended without a connection." };
+    }
+}

package/dist/web/login.js

@@ -0,0 +1,71 @@
+import { DisconnectReason } from "@whiskeysockets/baileys";
+import { loadConfig } from "../config/config.js";
+import { danger, info, success } from "../globals.js";
+import { logInfo } from "../logger.js";
+import { defaultRuntime } from "../runtime.js";
+import { resolveWhatsAppAccount } from "./accounts.js";
+import { createWaSocket, formatError, logoutWeb, waitForWaConnection, } from "./session.js";
+export async function loginWeb(verbose, provider = "whatsapp", waitForConnection, runtime = defaultRuntime, accountId) {
+    if (provider !== "whatsapp" && provider !== "web") {
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+    const wait = waitForConnection ?? waitForWaConnection;
+    const cfg = loadConfig();
+    const account = resolveWhatsAppAccount({ cfg, accountId });
+    const sock = await createWaSocket(true, verbose, {
+        authDir: account.authDir,
+    });
+    logInfo("Waiting for WhatsApp connection...", runtime);
+    try {
+        await wait(sock);
+        console.log(success("✅ Linked! Credentials saved for future sends."));
+    }
+    catch (err) {
+        const code = err?.error?.output
+            ?.statusCode ??
+            err?.output?.statusCode;
+        if (code === 515) {
+            console.log(info("WhatsApp asked for a restart after pairing (code 515); creds are saved. Restarting connection once…"));
+            try {
+                sock.ws?.close();
+            }
+            catch {
+                // ignore
+            }
+            const retry = await createWaSocket(false, verbose, {
+                authDir: account.authDir,
+            });
+            try {
+                await wait(retry);
+                console.log(success("✅ Linked after restart; web session ready. You can now send with provider=web."));
+                return;
+            }
+            finally {
+                setTimeout(() => retry.ws?.close(), 500);
+            }
+        }
+        if (code === DisconnectReason.loggedOut) {
+            await logoutWeb({
+                authDir: account.authDir,
+                isLegacyAuthDir: account.isLegacyAuthDir,
+                runtime,
+            });
+            console.error(danger("WhatsApp reported the session is logged out. Cleared cached web session; please rerun nexus login and scan the QR again."));
+            throw new Error("Session logged out; cache cleared. Re-run login.");
+        }
+        const formatted = formatError(err);
+        console.error(danger(`WhatsApp Web connection ended before fully opening. ${formatted}`));
+        throw new Error(formatted);
+    }
+    finally {
+        // Let Baileys flush any final events before closing the socket.
+        setTimeout(() => {
+            try {
+                sock.ws?.close();
+            }
+            catch {
+                // ignore
+            }
+        }, 500);
+    }
+}

package/dist/web/media.js

@@ -0,0 +1,175 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { maxBytesForKind, mediaKindFromMime, } from "../media/constants.js";
+import { resizeToJpeg } from "../media/image-ops.js";
+import { detectMime, extensionForMime } from "../media/mime.js";
+function stripQuotes(value) {
+    return value.replace(/^["']|["']$/g, "");
+}
+function parseContentDispositionFileName(header) {
+    if (!header)
+        return undefined;
+    const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
+    if (starMatch?.[1]) {
+        const cleaned = stripQuotes(starMatch[1].trim());
+        const encoded = cleaned.split("''").slice(1).join("''") || cleaned;
+        try {
+            return path.basename(decodeURIComponent(encoded));
+        }
+        catch {
+            return path.basename(encoded);
+        }
+    }
+    const match = /filename\s*=\s*([^;]+)/i.exec(header);
+    if (match?.[1])
+        return path.basename(stripQuotes(match[1].trim()));
+    return undefined;
+}
+async function loadWebMediaInternal(mediaUrl, options = {}) {
+    const { maxBytes, optimizeImages = true } = options;
+    if (mediaUrl.startsWith("file://")) {
+        mediaUrl = mediaUrl.replace("file://", "");
+    }
+    const optimizeAndClampImage = async (buffer, cap) => {
+        const originalSize = buffer.length;
+        const optimized = await optimizeImageToJpeg(buffer, cap);
+        if (optimized.optimizedSize < originalSize && shouldLogVerbose()) {
+            logVerbose(`Optimized media from ${(originalSize / (1024 * 1024)).toFixed(2)}MB to ${(optimized.optimizedSize / (1024 * 1024)).toFixed(2)}MB (side≤${optimized.resizeSide}px, q=${optimized.quality})`);
+        }
+        if (optimized.buffer.length > cap) {
+            throw new Error(`Media could not be reduced below ${(cap / (1024 * 1024)).toFixed(0)}MB (got ${(optimized.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
+        }
+        return {
+            buffer: optimized.buffer,
+            contentType: "image/jpeg",
+            kind: "image",
+        };
+    };
+    if (/^https?:\/\//i.test(mediaUrl)) {
+        let fileNameFromUrl;
+        try {
+            const url = new URL(mediaUrl);
+            const base = path.basename(url.pathname);
+            fileNameFromUrl = base || undefined;
+        }
+        catch {
+            // ignore parse errors; leave undefined
+        }
+        const res = await fetch(mediaUrl);
+        if (!res.ok || !res.body) {
+            throw new Error(`Failed to fetch media: HTTP ${res.status}`);
+        }
+        const array = Buffer.from(await res.arrayBuffer());
+        const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+        let fileName = headerFileName || fileNameFromUrl || undefined;
+        const filePathForMime = headerFileName && path.extname(headerFileName)
+            ? headerFileName
+            : mediaUrl;
+        const contentType = await detectMime({
+            buffer: array,
+            headerMime: res.headers.get("content-type"),
+            filePath: filePathForMime,
+        });
+        if (fileName && !path.extname(fileName) && contentType) {
+            const ext = extensionForMime(contentType);
+            if (ext)
+                fileName = `${fileName}${ext}`;
+        }
+        const kind = mediaKindFromMime(contentType);
+        const cap = Math.min(maxBytes ?? maxBytesForKind(kind), maxBytesForKind(kind));
+        if (kind === "image") {
+            // Skip optimization for GIFs to preserve animation.
+            if (contentType === "image/gif" || !optimizeImages) {
+                if (array.length > cap) {
+                    throw new Error(`${contentType === "image/gif" ? "GIF" : "Media"} exceeds ${(cap / (1024 * 1024)).toFixed(0)}MB limit (got ${(array.length / (1024 * 1024)).toFixed(2)}MB)`);
+                }
+                return { buffer: array, contentType, kind, fileName };
+            }
+            return { ...(await optimizeAndClampImage(array, cap)), fileName };
+        }
+        if (array.length > cap) {
+            throw new Error(`Media exceeds ${(cap / (1024 * 1024)).toFixed(0)}MB limit (got ${(array.length / (1024 * 1024)).toFixed(2)}MB)`);
+        }
+        return {
+            buffer: array,
+            contentType: contentType ?? undefined,
+            kind,
+            fileName,
+        };
+    }
+    // Local path
+    const data = await fs.readFile(mediaUrl);
+    const mime = await detectMime({ buffer: data, filePath: mediaUrl });
+    const kind = mediaKindFromMime(mime);
+    let fileName = path.basename(mediaUrl) || undefined;
+    if (fileName && !path.extname(fileName) && mime) {
+        const ext = extensionForMime(mime);
+        if (ext)
+            fileName = `${fileName}${ext}`;
+    }
+    const cap = Math.min(maxBytes ?? maxBytesForKind(kind), maxBytesForKind(kind));
+    if (kind === "image") {
+        // Skip optimization for GIFs to preserve animation.
+        if (mime === "image/gif" || !optimizeImages) {
+            if (data.length > cap) {
+                throw new Error(`${mime === "image/gif" ? "GIF" : "Media"} exceeds ${(cap / (1024 * 1024)).toFixed(0)}MB limit (got ${(data.length / (1024 * 1024)).toFixed(2)}MB)`);
+            }
+            return { buffer: data, contentType: mime, kind, fileName };
+        }
+        return { ...(await optimizeAndClampImage(data, cap)), fileName };
+    }
+    if (data.length > cap) {
+        throw new Error(`Media exceeds ${(cap / (1024 * 1024)).toFixed(0)}MB limit (got ${(data.length / (1024 * 1024)).toFixed(2)}MB)`);
+    }
+    return { buffer: data, contentType: mime, kind, fileName };
+}
+export async function loadWebMedia(mediaUrl, maxBytes) {
+    return await loadWebMediaInternal(mediaUrl, {
+        maxBytes,
+        optimizeImages: true,
+    });
+}
+export async function loadWebMediaRaw(mediaUrl, maxBytes) {
+    return await loadWebMediaInternal(mediaUrl, {
+        maxBytes,
+        optimizeImages: false,
+    });
+}
+export async function optimizeImageToJpeg(buffer, maxBytes) {
+    // Try a grid of sizes/qualities until under the limit.
+    const sides = [2048, 1536, 1280, 1024, 800];
+    const qualities = [80, 70, 60, 50, 40];
+    let smallest = null;
+    for (const side of sides) {
+        for (const quality of qualities) {
+            const out = await resizeToJpeg({
+                buffer,
+                maxSide: side,
+                quality,
+                withoutEnlargement: true,
+            });
+            const size = out.length;
+            if (!smallest || size < smallest.size) {
+                smallest = { buffer: out, size, resizeSide: side, quality };
+            }
+            if (size <= maxBytes) {
+                return {
+                    buffer: out,
+                    optimizedSize: size,
+                    resizeSide: side,
+                    quality,
+                };
+            }
+        }
+    }
+    if (smallest) {
+        return {
+            buffer: smallest.buffer,
+            optimizedSize: smallest.size,
+            resizeSide: smallest.resizeSide,
+            quality: smallest.quality,
+        };
+    }
+    throw new Error("Failed to optimize image");
+}

package/dist/web/outbound.js

@@ -0,0 +1,102 @@
+import { randomUUID } from "node:crypto";
+import { createSubsystemLogger, getChildLogger } from "../logging.js";
+import { normalizePollInput } from "../polls.js";
+import { toWhatsappJid } from "../utils.js";
+import { getActiveWebListener, } from "./active-listener.js";
+import { loadWebMedia } from "./media.js";
+const outboundLog = createSubsystemLogger("gateway/providers/whatsapp").child("outbound");
+export async function sendMessageWhatsApp(to, body, options) {
+    let text = body;
+    const correlationId = randomUUID();
+    const startedAt = Date.now();
+    const active = getActiveWebListener(options.accountId);
+    if (!active) {
+        throw new Error("No active gateway listener. Start the gateway before sending WhatsApp messages.");
+    }
+    const logger = getChildLogger({
+        module: "web-outbound",
+        correlationId,
+        to,
+    });
+    try {
+        const jid = toWhatsappJid(to);
+        let mediaBuffer;
+        let mediaType;
+        if (options.mediaUrl) {
+            const media = await loadWebMedia(options.mediaUrl);
+            const caption = text || undefined;
+            mediaBuffer = media.buffer;
+            mediaType = media.contentType;
+            if (media.kind === "audio") {
+                // WhatsApp expects explicit opus codec for PTT voice notes.
+                mediaType =
+                    media.contentType === "audio/ogg"
+                        ? "audio/ogg; codecs=opus"
+                        : (media.contentType ?? "application/octet-stream");
+            }
+            else if (media.kind === "video") {
+                text = caption ?? "";
+            }
+            else if (media.kind === "image") {
+                text = caption ?? "";
+            }
+            else {
+                text = caption ?? "";
+            }
+        }
+        outboundLog.info(`Sending message -> ${jid}${options.mediaUrl ? " (media)" : ""}`);
+        logger.info({ jid, hasMedia: Boolean(options.mediaUrl) }, "sending message");
+        if (!active)
+            throw new Error("Active web listener missing");
+        await active.sendComposingTo(to);
+        const sendOptions = options.gifPlayback
+            ? { gifPlayback: true }
+            : undefined;
+        const result = sendOptions
+            ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions)
+            : await active.sendMessage(to, text, mediaBuffer, mediaType);
+        const messageId = result?.messageId ?? "unknown";
+        const durationMs = Date.now() - startedAt;
+        outboundLog.info(`Sent message ${messageId} -> ${jid}${options.mediaUrl ? " (media)" : ""} (${durationMs}ms)`);
+        logger.info({ jid, messageId }, "sent message");
+        return { messageId, toJid: jid };
+    }
+    catch (err) {
+        logger.error({ err: String(err), to, hasMedia: Boolean(options.mediaUrl) }, "failed to send via web session");
+        throw err;
+    }
+}
+export async function sendPollWhatsApp(to, poll, options) {
+    const correlationId = randomUUID();
+    const startedAt = Date.now();
+    const active = getActiveWebListener(options.accountId);
+    if (!active) {
+        throw new Error("No active gateway listener. Start the gateway before sending WhatsApp polls.");
+    }
+    const logger = getChildLogger({
+        module: "web-outbound",
+        correlationId,
+        to,
+    });
+    try {
+        const jid = toWhatsappJid(to);
+        const normalized = normalizePollInput(poll, { maxOptions: 12 });
+        outboundLog.info(`Sending poll -> ${jid}: "${normalized.question}"`);
+        logger.info({
+            jid,
+            question: normalized.question,
+            optionCount: normalized.options.length,
+            maxSelections: normalized.maxSelections,
+        }, "sending poll");
+        const result = await active.sendPoll(to, normalized);
+        const messageId = result?.messageId ?? "unknown";
+        const durationMs = Date.now() - startedAt;
+        outboundLog.info(`Sent poll ${messageId} -> ${jid} (${durationMs}ms)`);
+        logger.info({ jid, messageId }, "sent poll");
+        return { messageId, toJid: jid };
+    }
+    catch (err) {
+        logger.error({ err: String(err), to, question: poll.question }, "failed to send poll via web session");
+        throw err;
+    }
+}

package/dist/web/qr-image.js

@@ -0,0 +1,97 @@
+import { deflateSync } from "node:zlib";
+import QRCodeModule from "qrcode-terminal/vendor/QRCode/index.js";
+import QRErrorCorrectLevelModule from "qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js";
+const QRCode = QRCodeModule;
+const QRErrorCorrectLevel = QRErrorCorrectLevelModule;
+function createQrMatrix(input) {
+    const qr = new QRCode(-1, QRErrorCorrectLevel.L);
+    qr.addData(input);
+    qr.make();
+    return qr;
+}
+function fillPixel(buf, x, y, width, r, g, b, a = 255) {
+    const idx = (y * width + x) * 4;
+    buf[idx] = r;
+    buf[idx + 1] = g;
+    buf[idx + 2] = b;
+    buf[idx + 3] = a;
+}
+function crcTable() {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        let c = i;
+        for (let k = 0; k < 8; k += 1) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[i] = c >>> 0;
+    }
+    return table;
+}
+const CRC_TABLE = crcTable();
+function crc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i += 1) {
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function pngChunk(type, data) {
+    const typeBuf = Buffer.from(type, "ascii");
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length, 0);
+    const crc = crc32(Buffer.concat([typeBuf, data]));
+    const crcBuf = Buffer.alloc(4);
+    crcBuf.writeUInt32BE(crc, 0);
+    return Buffer.concat([len, typeBuf, data, crcBuf]);
+}
+function encodePngRgba(buffer, width, height) {
+    const stride = width * 4;
+    const raw = Buffer.alloc((stride + 1) * height);
+    for (let row = 0; row < height; row += 1) {
+        const rawOffset = row * (stride + 1);
+        raw[rawOffset] = 0; // filter: none
+        buffer.copy(raw, rawOffset + 1, row * stride, row * stride + stride);
+    }
+    const compressed = deflateSync(raw);
+    const signature = Buffer.from([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+    ]);
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 6; // color type RGBA
+    ihdr[10] = 0; // compression
+    ihdr[11] = 0; // filter
+    ihdr[12] = 0; // interlace
+    return Buffer.concat([
+        signature,
+        pngChunk("IHDR", ihdr),
+        pngChunk("IDAT", compressed),
+        pngChunk("IEND", Buffer.alloc(0)),
+    ]);
+}
+export async function renderQrPngBase64(input, opts = {}) {
+    const { scale = 6, marginModules = 4 } = opts;
+    const qr = createQrMatrix(input);
+    const modules = qr.getModuleCount();
+    const size = (modules + marginModules * 2) * scale;
+    const buf = Buffer.alloc(size * size * 4, 255);
+    for (let row = 0; row < modules; row += 1) {
+        for (let col = 0; col < modules; col += 1) {
+            if (!qr.isDark(row, col))
+                continue;
+            const startX = (col + marginModules) * scale;
+            const startY = (row + marginModules) * scale;
+            for (let y = 0; y < scale; y += 1) {
+                const pixelY = startY + y;
+                for (let x = 0; x < scale; x += 1) {
+                    const pixelX = startX + x;
+                    fillPixel(buf, pixelX, pixelY, size, 0, 0, 0, 255);
+                }
+            }
+        }
+    }
+    const png = encodePngRgba(buf, size, size);
+    return png.toString("base64");
+}