@ardennguyen/zalo-agent-cli 2.5.8 → 3.0.0

package/src/utils/atomic-file.js

@@ -1,209 +0,0 @@
-/**
- * Two small guarantees for the files that more than one process shares or that must never be half
- * written: an atomic replace, and a cross-process lock for read-modify-write.
- *
- * `accounts.json` is written by every login, `account` command and name refresh, and a fleet of
- * daemons refreshes names concurrently. It used to be read, changed in memory and written back with a
- * plain `writeFileSync`: two writers silently lost each other's change, a reader could see a file
- * the writer had truncated and not yet filled (and took it for "no accounts"), and a crash mid-write
- * left JSON that the next `login` replaced with a one-account registry. Credentials had the same
- * truncate-then-write window, plus a moment at default permissions before `chmod`.
- *
- *  - {@link writeFileAtomic}: write a temp file beside the target, flush it, rename it over the
- *    target. A reader sees the old file or the new one, never a mix; a crash leaves the old one.
- *  - {@link withFileLock}: `O_EXCL` lock file with the holder's pid; a lock whose holder died, or that
- *    is older than any real critical section, is taken over.
- *
- * Both are synchronous because their callers are (the registry API is sync throughout).
- */
-
-import {
-    closeSync,
-    fsyncSync,
-    mkdirSync,
-    openSync,
-    readdirSync,
-    readFileSync,
-    renameSync,
-    statSync,
-    unlinkSync,
-    writeSync,
-} from "node:fs";
-import { randomBytes } from "node:crypto";
-import { basename, dirname, join } from "node:path";
-
-/** Errors a rename can raise on Windows while another process has the target open for reading. */
-const TRANSIENT = new Set(["EPERM", "EBUSY", "EACCES"]);
-
-/**
- * Block this thread for `ms` without spinning.
- * @param {number} ms
- */
-export function sleepSync(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-/**
- * Replace `file` with `data` so no reader and no crash ever sees a partial write.
- *
- * The temp file is created exclusively with `mode` (so a secret is never readable by others, not
- * even briefly), flushed to disk, then renamed over the target. On Windows a rename can fail while a
- * reader has the target open, so it is retried for a second or two (a reader holds the file for
- * microseconds, but a tight loop of them can keep one in the way for a while).
- *
- * @param {string} file
- * @param {string|Buffer} data
- * @param {{ mode?: number, durable?: boolean }} [options] - `mode`: file mode of the result (default 0o600).
- *   `durable: false` skips the flush to disk for a copy that is only a convenience (the registry's `.bak`)
- */
-export function writeFileAtomic(file, data, { mode = 0o600, durable = true } = {}) {
-    mkdirSync(dirname(file), { recursive: true });
-    const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-    const fd = openSync(tmp, "wx", mode);
-    try {
-        writeSync(fd, data);
-        if (durable) fsyncSync(fd);
-    } catch (e) {
-        closeSync(fd);
-        try {
-            unlinkSync(tmp);
-        } catch {
-            /* nothing to clean */
-        }
-        throw e;
-    }
-    closeSync(fd);
-
-    for (let attempt = 0; ; attempt++) {
-        try {
-            renameSync(tmp, file);
-            return;
-        } catch (e) {
-            if (!TRANSIENT.has(e.code) || attempt >= 60) {
-                try {
-                    unlinkSync(tmp);
-                } catch {
-                    /* already gone */
-                }
-                throw e;
-            }
-            sleepSync(10 + Math.floor(Math.random() * 40));
-        }
-    }
-}
-
-/**
- * Delete the temp files that `writeFileAtomic(file, ...)` left when its process was killed between
- * creating the temp file and renaming it. Only a temp file whose pid is dead is removed.
- *
- * @param {string} file - The target the temp files belong to
- * @returns {number} How many were removed
- */
-export function sweepStaleTemps(file) {
-    const prefix = `${basename(file)}.`;
-    let removed = 0;
-    try {
-        for (const name of readdirSync(dirname(file))) {
-            const m = name.startsWith(prefix) && /^(\d+)\.[0-9a-f]{8}\.tmp$/.exec(name.slice(prefix.length));
-            if (!m || alive(Number(m[1]))) continue;
-            try {
-                unlinkSync(join(dirname(file), name));
-                removed++;
-            } catch {
-                /* gone already */
-            }
-        }
-    } catch {
-        /* directory unreadable: nothing to sweep */
-    }
-    return removed;
-}
-
-/** @param {number} pid */
-function alive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    } catch (e) {
-        // EPERM: it exists, owned by someone else.
-        return e.code === "EPERM";
-    }
-}
-
-/**
- * Run `fn` while holding an exclusive lock on `lockPath`.
- *
- * A held lock is waited for, up to `timeoutMs`. It is taken over when its holder is dead or when it
- * is older than `staleMs` (a read-modify-write of a small file takes milliseconds, so anything older
- * is a crashed holder, or a pid the OS reused). The lock is released when `fn` returns or throws.
- *
- * @template T
- * @param {string} lockPath
- * @param {() => T} fn
- * @param {{ timeoutMs?: number, staleMs?: number }} [options]
- * @returns {T}
- */
-export function withFileLock(lockPath, fn, { timeoutMs = 10_000, staleMs = 30_000 } = {}) {
-    mkdirSync(dirname(lockPath), { recursive: true });
-    const started = Date.now();
-    const mine = JSON.stringify({ pid: process.pid, at: Date.now() });
-
-    for (;;) {
-        try {
-            const fd = openSync(lockPath, "wx", 0o600);
-            try {
-                writeSync(fd, mine);
-            } finally {
-                closeSync(fd);
-            }
-            break;
-        } catch (e) {
-            if (e.code !== "EEXIST" && !(process.platform === "win32" && TRANSIENT.has(e.code))) throw e;
-        }
-
-        // Held. Is the holder gone?
-        let seen = null;
-        let holder = null;
-        try {
-            seen = readFileSync(lockPath, "utf8");
-            holder = JSON.parse(seen)?.pid ?? null;
-        } catch {
-            /* released meanwhile, or torn: judged by age below */
-        }
-        let age = 0;
-        try {
-            age = Date.now() - statSync(lockPath).mtimeMs;
-        } catch {
-            continue; // released between the two looks: try to take it
-        }
-        if ((holder !== null && !alive(holder)) || age > staleMs) {
-            try {
-                // Only remove what was judged stale: a lock freed and retaken meanwhile is a live one.
-                if (readFileSync(lockPath, "utf8") === seen) unlinkSync(lockPath);
-            } catch {
-                /* someone else got there first */
-            }
-            continue;
-        }
-
-        if (Date.now() - started > timeoutMs) {
-            throw new Error(
-                `could not lock ${lockPath} within ${Math.round(timeoutMs / 1000)}s: held by pid ${holder ?? "unknown"}. ` +
-                    "If that process is gone, delete the lock file.",
-            );
-        }
-        // Short polls: a critical section is a few milliseconds, so a long wait leaves the lock idle.
-        sleepSync(2 + Math.floor(Math.random() * 8));
-    }
-
-    try {
-        return fn();
-    } finally {
-        try {
-            // Never remove a lock another process took over while this one was stuck.
-            if (readFileSync(lockPath, "utf8") === mine) unlinkSync(lockPath);
-        } catch {
-            /* already gone */
-        }
-    }
-}

package/src/utils/bank-helpers.test.js

@@ -1,66 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { resolveBankBin, BIN_TO_DISPLAY, BANK_NAME_TO_BIN } from "./bank-helpers.js";
-
-describe("resolveBankBin", () => {
-    it("resolves OCB by name", () => {
-        assert.equal(resolveBankBin("ocb"), 970448);
-    });
-
-    it("resolves VCB alias", () => {
-        assert.equal(resolveBankBin("vcb"), 970436);
-    });
-
-    it("resolves Vietcombank full name", () => {
-        assert.equal(resolveBankBin("vietcombank"), 970436);
-    });
-
-    it("resolves BIDV by BIN string", () => {
-        assert.equal(resolveBankBin("970418"), 970418);
-    });
-
-    it("returns null for unknown name", () => {
-        assert.equal(resolveBankBin("unknown"), null);
-    });
-
-    it("returns null for unknown BIN", () => {
-        assert.equal(resolveBankBin("999999"), null);
-    });
-
-    it("is case insensitive", () => {
-        assert.equal(resolveBankBin("OCB"), 970448);
-        assert.equal(resolveBankBin("Vietcombank"), 970436);
-        assert.equal(resolveBankBin("BIDV"), 970418);
-    });
-
-    it("handles spaces and underscores", () => {
-        assert.equal(resolveBankBin("mb bank"), 970422);
-        assert.equal(resolveBankBin("mb_bank"), 970422);
-    });
-
-    it("resolves MB shorthand", () => {
-        assert.equal(resolveBankBin("mb"), 970422);
-    });
-
-    it("resolves CTG alias for VietinBank", () => {
-        assert.equal(resolveBankBin("ctg"), 970415);
-    });
-});
-
-describe("BIN_TO_DISPLAY", () => {
-    it("has at least 50 banks", () => {
-        assert.ok(Object.keys(BIN_TO_DISPLAY).length >= 50);
-    });
-
-    it("maps known BINs correctly", () => {
-        assert.equal(BIN_TO_DISPLAY[970448], "OCB");
-        assert.equal(BIN_TO_DISPLAY[970436], "Vietcombank");
-        assert.equal(BIN_TO_DISPLAY[970418], "BIDV");
-    });
-});
-
-describe("BANK_NAME_TO_BIN", () => {
-    it("has at least 50 aliases", () => {
-        assert.ok(Object.keys(BANK_NAME_TO_BIN).length >= 50);
-    });
-});

package/src/utils/device-fingerprint.js

@@ -1,72 +0,0 @@
-/**
- * Generates a randomized-but-internally-consistent browser fingerprint
- * (User-Agent + matching Client Hints) for the one-time QR login handshake.
- *
- * Why this exists: zca-js's default QR-login fingerprint is broken and
- * identical across every install on earth — it sends a literal
- * "...Firefox/133.0" User-Agent header while our zca-js patch's
- * secChUaHeaders() fallback (and, before this patch, every hardcoded call
- * site in loginQR.js) separately claims Chromium/Chrome v130 Client Hints
- * on every QR-flow request to id.zalo.me. Real browsers never produce that
- * combination — Firefox doesn't send sec-ch-ua headers at all — and Zalo's
- * server appears to read the Client Hints for the "Thiết bị" device label
- * shown on the phone's QR-confirm screen, which is why every zca-js login
- * shows "Chrome - Windows 10" regardless of what's actually running the
- * CLI. Beyond being cosmetically wrong, a fingerprint that's byte-identical
- * across every zca-js user is itself a correlatable signal.
- *
- * Scope: this only matters for the INITIAL QR-login handshake. Once logged
- * in, the chosen userAgent is persisted in that account's credentials file
- * (see extractCredentials()/loginWithCredentials() in zalo-client.js) and
- * reused consistently for every subsequent API call — so a fresh, plausible,
- * internally-consistent choice made once here, at first login, is enough;
- * it doesn't need to be regenerated per-command. Re-scanning to log into the
- * same account again later (after a full logout, not just a session resume)
- * gets a freshly randomized fingerprint, same as a real user occasionally
- * updating their browser — that's expected, not a bug.
- */
-
-const CHROME_VERSIONS = ["131.0.0.0", "130.0.0.0", "129.0.0.0", "128.0.0.0"];
-
-/**
- * Windows-first, Chrome-only presets. Deliberately not branching into
- * Firefox/Safari: those browsers don't send sec-ch-ua headers at all, and
- * Zalo's own device-label rendering already appears tuned for Chrome/Chromium
- * (see the hardcoded literals this patch replaces) — straying from Chrome
- * would trade one kind of oddity for another. Varying version + OS build is
- * enough to avoid every install presenting an identical fingerprint.
- */
-const PRESETS = [
-    ...CHROME_VERSIONS.map((v) => ({
-        userAgent: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${v} Safari/537.36`,
-        secChUaPlatform: '"Windows"',
-    })),
-    ...CHROME_VERSIONS.map((v) => ({
-        userAgent: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${v} Safari/537.36`,
-        secChUaPlatform: '"macOS"',
-    })),
-];
-
-function buildSecChUa(chromeVersion) {
-    const major = chromeVersion.split(".")[0];
-    // Matches the brand-list shape real Chrome sends (order, quoting, the
-    // "Not?A_Brand" filler entry — all part of Chrome's actual GREASE
-    // pattern for this header, not something we're inventing).
-    return `"Chromium";v="${major}", "Google Chrome";v="${major}", "Not?A_Brand";v="99"`;
-}
-
-/**
- * Pick a random, internally-consistent fingerprint for a fresh QR login.
- * @returns {{userAgent: string, secChUa: string, secChUaPlatform: string, secChUaMobile: string}}
- */
-export function generateDeviceFingerprint() {
-    const preset = PRESETS[Math.floor(Math.random() * PRESETS.length)];
-    const versionMatch = preset.userAgent.match(/Chrome\/([\d.]+)/);
-    const chromeVersion = versionMatch ? versionMatch[1] : CHROME_VERSIONS[0];
-    return {
-        userAgent: preset.userAgent,
-        secChUa: buildSecChUa(chromeVersion),
-        secChUaPlatform: preset.secChUaPlatform,
-        secChUaMobile: "?0",
-    };
-}

package/src/utils/mentions.js

@@ -1,140 +0,0 @@
-/**
- * Zalo @-mention offsets.
- *
- * A mention is `{ pos, uid, len }`, where `pos` and `len` are **UTF-16
- * code-unit offsets into the message string** — not byte offsets, and not
- * grapheme counts. Zalo renders the tag over exactly `text.slice(pos, pos +
- * len)`, so an offset that is off by one paints the highlight over the wrong
- * span and the tagged person may not be notified at all.
- *
- * Measured against real mentions in a local cache (name changed):
- *
- *     text  "Em ko biết mở ch ạ @Trần Bích Ngọc"   { pos: 19, len: 15 }
- *     text.slice(19, 34)              === "@Trần Bích Ngọc"       correct
- *     Buffer.from(text).slice(19, 34) -> "h ạ @Trần Bí…"          wrong
- *
- * Accented Vietnamese is exactly where hand-counted offsets break, and it is
- * most of what this CLI sends. So `--mention <pos:uid:len>` stays for
- * back-compat, but the `@[uid]` token form below computes the offsets from
- * the string it just built and is the one to reach for.
- */
-
-/** The uid Zalo reserves for @All. zca-js turns it into `type: 1`. */
-export const ALL_MENTION_UID = "-1";
-
-/**
- * Label used for `@[-1]` when no name is supplied.
- *
- * Zalo's own clients write the literal "@All" (confirmed on real @All rows
- * in the cache: `{ uid: "-1", pos: 0, len: 4, type: 1 }`), including in
- * Vietnamese groups. Do not localize this.
- */
-export const ALL_MENTION_LABEL = "All";
-
-/**
- * `@[uid]` — the token expanded by {@link expandMentions}.
- *
- * Deliberately restricted to decimal ids (plus `-1` for @All), which is every
- * uid Zalo accepts in a mention. Anything else in brackets — `@[see below]`,
- * `@[TODO]` — is left in the text verbatim rather than turned into a mention
- * of a uid that does not exist.
- */
-const MENTION_TOKEN = /@\[(-?\d+)\]/g;
-
-/**
- * Parse the legacy `--mention pos:uid:len` specs.
- *
- * Kept because scripts pass it; `@[uid]` tokens are the safe way in. Specs
- * that are not three colon-separated parts, or whose pos/len are not numbers,
- * are dropped rather than sent as NaN — zca-js's own filter would discard
- * them anyway, silently and later.
- *
- * @param {string[]} [specs] - raw `pos:uid:len` strings
- * @returns {{pos: number, uid: string, len: number}[]}
- */
-export function parseMentionSpecs(specs) {
-    return (specs || [])
-        .map((spec) => {
-            const [pos, uid, len] = String(spec).split(":");
-            if (!uid) return null;
-            const parsed = { pos: Number(pos), uid, len: Number(len) };
-            if (!Number.isFinite(parsed.pos) || !Number.isFinite(parsed.len)) return null;
-            return parsed;
-        })
-        .filter(Boolean);
-}
-
-/**
- * Expand `@[uid]` tokens into `@Display Name`, recording each mention's
- * offsets in the string that comes out.
- *
- * Because the offsets are measured on the built string rather than counted by
- * hand, they are correct whatever the surrounding text contains — accents,
- * emoji, earlier mentions of different lengths.
- *
- * `edits` reports each substitution in *input* coordinates so that text
- * styles counted against the pre-expansion message can be moved with
- * {@link shiftStyles}.
- *
- * @param {string} text - message body, possibly containing `@[uid]` tokens
- * @param {(uid: string) => (string|null|undefined)} [resolveName] - uid → display
- *   name; anything falsy falls back to "All" for `@[-1]` and to the uid itself
- *   otherwise, so an unknown user still gets a syntactically valid mention
- * @returns {{text: string, mentions: {pos: number, uid: string, len: number}[],
- *            edits: {start: number, oldLen: number, newLen: number}[]}}
- */
-export function expandMentions(text, resolveName) {
-    const src = String(text ?? "");
-    const mentions = [];
-    const edits = [];
-    let out = "";
-    let cursor = 0;
-
-    // lastIndex is shared state on a module-level regex, so iterate a fresh copy.
-    const token = new RegExp(MENTION_TOKEN.source, "g");
-    let match;
-    while ((match = token.exec(src)) !== null) {
-        const uid = match[1];
-        const resolved = typeof resolveName === "function" ? resolveName(uid) : null;
-        const name = resolved || (uid === ALL_MENTION_UID ? ALL_MENTION_LABEL : uid);
-        const label = `@${name}`;
-
-        out += src.slice(cursor, match.index);
-        mentions.push({ pos: out.length, uid, len: label.length });
-        edits.push({ start: match.index, oldLen: match[0].length, newLen: label.length });
-        out += label;
-        cursor = match.index + match[0].length;
-    }
-    out += src.slice(cursor);
-
-    return { text: out, mentions, edits };
-}
-
-/**
- * Move text styles across the edits {@link expandMentions} made.
- *
- * `--style start:len:style` and `--md` both produce offsets against the
- * message *before* mentions expand, and a `@[uid]` token is almost always
- * shorter than the name it becomes. Without this, `--md` plus a mention
- * silently paints bold over the wrong words.
- *
- * A style that starts after an edit moves by the edit's delta; a style that
- * spans one grows by it (`**hi @[123]**` keeps the whole run bold).
- *
- * @param {{start: number, len: number, st: string}[]} styles
- * @param {{start: number, oldLen: number, newLen: number}[]} edits
- * @returns {{start: number, len: number, st: string}[]}
- */
-export function shiftStyles(styles, edits) {
-    if (!edits || edits.length === 0) return styles;
-    return styles.map((style) => {
-        let start = style.start;
-        let len = style.len;
-        for (const edit of edits) {
-            const delta = edit.newLen - edit.oldLen;
-            if (edit.start < style.start) start += delta;
-            else if (edit.start < style.start + style.len) len += delta;
-        }
-        return { ...style, start, len };
-    });
-}

package/src/utils/proxy-helpers.test.js

@@ -1,36 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { maskProxy } from "./proxy-helpers.js";
-
-describe("maskProxy", () => {
-    it("masks password in http URL", () => {
-        assert.equal(maskProxy("http://user:secret@host:8080"), "http://user:***@host:8080");
-    });
-
-    it("masks password in socks5 URL", () => {
-        assert.equal(maskProxy("socks5://admin:p4ss@1.2.3.4:1080"), "socks5://admin:***@1.2.3.4:1080");
-    });
-
-    it("masks long password", () => {
-        assert.equal(
-            maskProxy("http://3AccFfq:pkLbHLRjhqids_session-Ntekoom2@geo.iproyal.com:12321"),
-            "http://3AccFfq:***@geo.iproyal.com:12321",
-        );
-    });
-
-    it("returns URL unchanged when no password", () => {
-        assert.equal(maskProxy("http://host:8080"), "http://host:8080");
-    });
-
-    it('returns "none" for null', () => {
-        assert.equal(maskProxy(null), "none");
-    });
-
-    it('returns "none" for empty string', () => {
-        assert.equal(maskProxy(""), "none");
-    });
-
-    it('returns "none" for undefined', () => {
-        assert.equal(maskProxy(undefined), "none");
-    });
-});

package/src/utils/split-message.js

@@ -1,166 +0,0 @@
-/**
- * Splitting a long text message the way Zalo Web does.
- *
- * Zalo refuses one oversized message instead of cutting it: `114 "Tham số không hợp lệ"` for plain text past 3000
- * UTF-16 units, and `112 "Lỗi không xác định"` for a styled message (what Markdown becomes) whose text plus style
- * list passes roughly 3.1 to 3.5 KB. Chinese and long bulleted answers hit the second one early, because a Chinese
- * character is three bytes and each bullet carries a style entry. Measured live, 2026-10-29.
- *
- * The Web client never sends such a message. It budgets every message at `limitMsgByte` (3000) UTF-8 bytes of the
- * text plus, for a styled message, the JSON of its styles; cuts at a newline when it can, else at a sentence end or
- * a space; trims the pieces; and sends them one after another, 300 ms apart. This does the same.
- *
- * Pure: no I/O, no Zalo. Styles are `{ start, len, st }` and mentions `{ pos, len, uid }`, both in UTF-16 units of
- * the text they belong to; each part gets its own text and the ranges re-based to it.
- */
-
-/** Zalo Web's `limitMsgByte`: the most UTF-8 bytes of text (plus style JSON) in one message. */
-export const MESSAGE_BYTE_LIMIT = 3000;
-
-/** The pause between parts of one split message, as Web's `setTimeout(…, 300)`. */
-export const PART_GAP_MS = 300;
-
-const byteLength = (s) => Buffer.byteLength(s, "utf8");
-
-/** Style ranges clipped to `[from, to)` and re-based to `from`. */
-function clipStyles(styles, from, to) {
-    const out = [];
-    for (const s of styles) {
-        const a = Math.max(s.start, from);
-        const b = Math.min(s.start + s.len, to);
-        if (b > a) out.push({ ...s, start: a - from, len: b - a });
-    }
-    return out;
-}
-
-/** What one message costs against the limit: its text bytes plus its style list, as Web counts it. */
-function cost(text, styles) {
-    return byteLength(text) + (styles.length > 0 ? byteLength(JSON.stringify(styles)) : 0);
-}
-
-/**
- * How good a place `text[i]` is to end a part after: higher is better, null when it is no break at all.
- * Web's own order (`" ,;)!?."`, a full stop strongest), a newline above all, and the CJK marks that do the same job
- * (Web's list is ASCII only, so a long Chinese text with no space would otherwise be cut blind).
- */
-function breakRank(text, i) {
-    const c = text[i];
-    if (c === "\n") return 7;
-    const cjk = { "。": 6, "？": 5, "！": 4, "；": 2, "，": 1, "、": 1 }[c];
-    if (cjk !== undefined) return cjk;
-    const ascii = " ,;)!?.".indexOf(c);
-    if (ascii === -1) return null;
-    const next = text[i + 1];
-    return c === " " || next === undefined || next === " " || next === "\n" ? ascii : null;
-}
-
-/**
- * Where to cut `text` between `pos` and `end` (the farthest the budget allows): the nearest newline in the last two
- * thirds of the window, else the strongest sentence or clause end there, else `end` itself.
- *
- * @returns {number} the cut: the part is `text.slice(pos, cut)`
- */
-function chooseCut(text, pos, end) {
-    const floor = pos + Math.floor((end - pos) / 3);
-    let best = -1;
-    let bestRank = -1;
-    for (let i = end - 1; i >= floor && i >= pos; i--) {
-        const rank = breakRank(text, i);
-        if (rank === null) continue;
-        if (rank === 7) return i; // the newline is dropped with the whitespace that follows
-        if (rank > bestRank) {
-            best = i + 1;
-            bestRank = rank;
-        }
-    }
-    return best > pos ? best : end;
-}
-
-/**
- * Split one message into parts that each fit {@link MESSAGE_BYTE_LIMIT}. A message that fits comes back untouched
- * (the same text, no trimming), so only a message that needed splitting is ever changed.
- *
- * A style range that spans a cut is clipped into both parts. A mention is never cut: the cut moves before it. A
- * surrogate pair (an emoji) is never cut. Whitespace at a cut is dropped, as Web trims its parts.
- *
- * @param {{text: string, styles?: Array<{start: number, len: number, st: string}>, mentions?: Array<{pos: number, len: number, uid: string}>}} message
- * @param {number} [limit] - bytes per part
- * @returns {Array<{text: string, styles: object[], mentions: object[]}>} at least one part
- */
-export function splitMessage({ text, styles = [], mentions = [] }, limit = MESSAGE_BYTE_LIMIT) {
-    if (cost(text, styles) <= limit) return [{ text, styles, mentions }];
-
-    const parts = [];
-    let pos = 0;
-    while (pos < text.length) {
-        // The farthest end this part can reach inside the budget (always at least one character).
-        let lo = pos + 1;
-        let hi = text.length;
-        while (lo < hi) {
-            const mid = Math.ceil((lo + hi) / 2);
-            if (cost(text.slice(pos, mid), clipStyles(styles, pos, mid)) <= limit) lo = mid;
-            else hi = mid - 1;
-        }
-        let cut = lo;
-
-        if (cut < text.length) {
-            cut = chooseCut(text, pos, cut);
-            for (const m of mentions) {
-                if (m.pos > pos && m.pos < cut && cut < m.pos + m.len) cut = m.pos;
-            }
-            const high = text.charCodeAt(cut - 1);
-            if (high >= 0xd800 && high <= 0xdbff) cut -= 1;
-            if (cut <= pos) cut = Math.min(text.length, pos + 2);
-        }
-
-        const raw = text.slice(pos, cut);
-        const body = raw.trimEnd();
-        if (body.length > 0) {
-            const end = pos + body.length;
-            parts.push({
-                text: body,
-                styles: clipStyles(styles, pos, end),
-                mentions: mentions
-                    .filter((m) => m.pos >= pos && m.pos + m.len <= end)
-                    .map((m) => ({ ...m, pos: m.pos - pos })),
-            });
-        }
-        pos = cut;
-        // Web trims each remainder: the whitespace at a cut belongs to no part.
-        while (pos < text.length && /\s/.test(text[pos])) pos++;
-    }
-    return parts.length > 0 ? parts : [{ text, styles, mentions }];
-}
-
-const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/**
- * Send the parts of one message one after another, {@link PART_GAP_MS} apart. Stops at the first part Zalo refuses
- * and says how many had already gone out, because nothing can take those back.
- *
- * @template T
- * @param {Array<object>} parts - from {@link splitMessage}
- * @param {(part: object, index: number) => Promise<T>} send - sends one part, resolves what Zalo answered
- * @param {{gapMs?: number, sleep?: (ms: number) => Promise<void>}} [opts]
- * @returns {Promise<T[]>} what Zalo answered for each part, in order
- * @throws {Error} with `.sent` (the answers of the parts that went out) set when a later part failed
- */
-export async function sendParts(parts, send, { gapMs = PART_GAP_MS, sleep = defaultSleep } = {}) {
-    const answers = [];
-    for (let i = 0; i < parts.length; i++) {
-        if (i > 0) await sleep(gapMs);
-        try {
-            answers.push(await send(parts[i], i));
-        } catch (e) {
-            if (i === 0) throw e;
-            const failure = new Error(
-                `${e?.message ?? e} (part ${i + 1} of ${parts.length} failed; the ${i} earlier part(s) were already delivered)`,
-                { cause: e },
-            );
-            failure.sent = answers;
-            if (e?.code !== undefined) failure.code = e.code;
-            throw failure;
-        }
-    }
-    return answers;
-}