@openclaw/whatsapp 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{setup-core-BbIgEl2M.js → shared-UcAwtJaq.js}

@@ -1,8 +1,8 @@
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-ejK8sXPU.js";
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CSqLvCY5.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-DSZnHkKF.js";
-import { t as WhatsAppChannelConfigSchema } from "./config-schema-BZ8h1hWA.js";
-import { n as whatsappDoctor } from "./doctor-By3SB4lm.js";
+import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-CugRyONv.js";
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-DARep0Nn.js";
+import { n as whatsappDoctor } from "./doctor-CwzVXKoE.js";
 import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.js";
 import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.js";
 import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-nAzD945y.js";
@@ -11,12 +11,24 @@ import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-
 import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
 import { createChannelPluginBase } from "openclaw/plugin-sdk/core";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { buildChannelGroupsScopeTree, collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
+import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
 import { createDelegatedSetupWizardProxy } from "openclaw/plugin-sdk/setup-runtime";
 import { readChannelAllowFromStore } from "openclaw/plugin-sdk/channel-pairing";
-import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
+//#region extensions/whatsapp/src/channel-runtime-loader.ts
+const loadWhatsAppAuthStore = createLazyRuntimeModule(() => import("./auth-store-DcEpIOmE.js").then((n) => n.i));
+async function isWhatsAppAuthConfigured(authDir) {
+	return await (await loadWhatsAppAuthStore()).readWebAuthState(authDir) === "linked";
+}
+const loadWhatsAppChannelRuntime = createLazyRuntimeModule(async () => {
+	await loadWhatsAppAuthStore();
+	return await import("./channel.runtime-Q5fJ2I2b.js");
+});
+//#endregion
 //#region extensions/whatsapp/src/config-accessors.ts
 function formatWhatsAppConfigAllowFromEntries(allowFrom) {
 	return normalizeWhatsAppAllowFromEntries(allowFrom);
@@ -41,6 +53,62 @@ function resolveWhatsAppGroupToolPolicy(params) {
 	});
 }
 //#endregion
+//#region extensions/whatsapp/src/setup-core.ts
+const channel = "whatsapp";
+const whatsappSetupAdapter = {
+	singleAccountKeysToMove: ["authDir"],
+	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: channel,
+		accountId,
+		name,
+		alwaysUseAccounts: true
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const setupInput = input;
+		const next = migrateBaseNameToDefaultAccount({
+			cfg: applyAccountNameToChannelSection({
+				cfg,
+				channelKey: channel,
+				accountId,
+				name: setupInput.name,
+				alwaysUseAccounts: true
+			}),
+			channelKey: channel,
+			alwaysUseAccounts: true
+		});
+		const entry = {
+			...next.channels?.whatsapp?.accounts?.[accountId],
+			...setupInput.authDir ? { authDir: setupInput.authDir } : {},
+			enabled: true
+		};
+		return {
+			...next,
+			channels: {
+				...next.channels,
+				whatsapp: {
+					...next.channels?.whatsapp,
+					accounts: {
+						...next.channels?.whatsapp?.accounts,
+						[accountId]: entry
+					}
+				}
+			}
+		};
+	}
+};
+const whatsappSetupContract = defineChannelSetupContract({
+	fields: { authDir: {
+		kind: "string",
+		cli: {
+			flags: "--auth-dir <path>",
+			description: "WhatsApp auth directory override"
+		}
+	} },
+	legacyAdapter: whatsappSetupAdapter
+});
+//#endregion
 //#region extensions/whatsapp/src/security-fix.ts
 function applyGroupAllowFromFromStore(params) {
 	const next = structuredClone(params.cfg ?? {});
@@ -83,11 +151,8 @@ async function applyWhatsAppSecurityConfigFixes(params) {
 //#endregion
 //#region extensions/whatsapp/src/shared.ts
 const WHATSAPP_CHANNEL = "whatsapp";
-async function loadWhatsAppChannelRuntime() {
-	return await import("./channel.runtime-CjkhQzk8.js");
-}
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-DhnXEZir.js");
+	return await import("./setup-surface-BjvUbR6M.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({
@@ -191,7 +256,7 @@ function createWhatsAppPluginBase(params) {
 			docsLabel: "whatsapp",
 			blurb: "works with your own number; recommend a separate phone + eSIM.",
 			systemImage: "message",
-			showConfigured: false,
+			exposure: { configured: false },
 			quickstartAllowFrom: true,
 			forceAccountBinding: true,
 			preferSessionLookupForAnnounceTarget: true
@@ -213,7 +278,7 @@ function createWhatsAppPluginBase(params) {
 		},
 		reload: {
 			configPrefixes: [
-				"web",
+				"channels.whatsapp.enabled",
 				"channels.whatsapp.accounts",
 				"channels.whatsapp.selfChatMode"
 			],
@@ -223,7 +288,7 @@ function createWhatsAppPluginBase(params) {
 		configSchema: WhatsAppChannelConfigSchema,
 		config: {
 			...whatsappConfigAdapter,
-			isEnabled: (account, cfg) => account.enabled && cfg.web?.enabled !== false,
+			isEnabled: (account) => account.enabled,
 			disabledReason: () => "disabled",
 			isConfigured: params.isConfigured,
 			hasPersistedAuthState: ({ cfg }) => hasAnyWhatsAppAuth(cfg),
@@ -245,6 +310,7 @@ function createWhatsAppPluginBase(params) {
 		},
 		doctor: whatsappDoctor,
 		setup: params.setup,
+		...params.setupContract ? { setupContract: params.setupContract } : {},
 		groups: params.groups
 	});
 	return {
@@ -274,48 +340,4 @@ function createWhatsAppPluginBase(params) {
 	};
 }
 //#endregion
-//#region extensions/whatsapp/src/setup-core.ts
-const channel = "whatsapp";
-const whatsappSetupAdapter = {
-	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
-	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
-		cfg,
-		channelKey: channel,
-		accountId,
-		name,
-		alwaysUseAccounts: true
-	}),
-	applyAccountConfig: ({ cfg, accountId, input }) => {
-		const next = migrateBaseNameToDefaultAccount({
-			cfg: applyAccountNameToChannelSection({
-				cfg,
-				channelKey: channel,
-				accountId,
-				name: input.name,
-				alwaysUseAccounts: true
-			}),
-			channelKey: channel,
-			alwaysUseAccounts: true
-		});
-		const entry = {
-			...next.channels?.whatsapp?.accounts?.[accountId],
-			...input.authDir ? { authDir: input.authDir } : {},
-			enabled: true
-		};
-		return {
-			...next,
-			channels: {
-				...next.channels,
-				whatsapp: {
-					...next.channels?.whatsapp,
-					accounts: {
-						...next.channels?.whatsapp?.accounts,
-						[accountId]: entry
-					}
-				}
-			}
-		};
-	}
-};
-//#endregion
-export { resolveWhatsAppGroupRequireMention as a, whatsappSetupWizardProxy as i, createWhatsAppPluginBase as n, resolveWhatsAppGroupToolPolicy as o, loadWhatsAppChannelRuntime as r, formatWhatsAppConfigAllowFromEntries as s, whatsappSetupAdapter as t };
+export { resolveWhatsAppGroupRequireMention as a, isWhatsAppAuthConfigured as c, whatsappSetupContract as i, loadWhatsAppChannelRuntime as l, whatsappSetupWizardProxy as n, resolveWhatsAppGroupToolPolicy as o, whatsappSetupAdapter as r, formatWhatsAppConfigAllowFromEntries as s, createWhatsAppPluginBase as t };

package/dist/{socket-close-jNGyZY4T.js → socket-close-DridEuzz.js}

@@ -1,5 +1,5 @@
 import { o as resolveWebCredsBackupPath, s as resolveWebCredsPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-B1kSWtBg.js";
-import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-BQi9pZqQ.js";
+import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-DcEpIOmE.js";
 import { n as getStatusCode } from "./session-errors-JuazczrA.js";
 import { a as makeWASocket, i as makeCacheableSignalKeyStore, n as createBaileysSignalRepository, r as fetchLatestBaileysVersion, s as useMultiFileAuthState } from "./session.runtime-Nsqaehbd.js";
 import { VERSION, formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
@@ -177,12 +177,11 @@ var WhatsAppSocketOperationTimeoutError = class extends Error {
 		this.name = "WhatsAppSocketOperationTimeoutError";
 	}
 };
-function resolveWhatsAppSocketTiming(cfg, overrides) {
-	const configured = cfg.web?.whatsapp;
+function resolveWhatsAppSocketTiming(overrides) {
 	return {
-		keepAliveIntervalMs: parseStrictPositiveInteger(overrides?.keepAliveIntervalMs) ?? parseStrictPositiveInteger(configured?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
-		connectTimeoutMs: parseStrictPositiveInteger(overrides?.connectTimeoutMs) ?? parseStrictPositiveInteger(configured?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
-		defaultQueryTimeoutMs: parseStrictPositiveInteger(overrides?.defaultQueryTimeoutMs) ?? parseStrictPositiveInteger(configured?.defaultQueryTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
+		keepAliveIntervalMs: parseStrictPositiveInteger(overrides?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
+		connectTimeoutMs: parseStrictPositiveInteger(overrides?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
+		defaultQueryTimeoutMs: parseStrictPositiveInteger(overrides?.defaultQueryTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
 	};
 }
 function isWhatsAppSocketOperationTimeoutError(error) {

package/dist/{targets-runtime-Bsh0HR9y.js → targets-runtime-TMk0lGuy.js}

@@ -1,12 +1,57 @@
 import fs from "node:fs";
 import path from "node:path";
 import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { CONFIG_DIR, escapeRegExp, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { FormatCapabilityProfile, markdownToIRWithMeta, renderMarkdownIRChunksWithinLimit, renderMarkdownWithMarkers, sliceMarkdownIR } from "openclaw/plugin-sdk/text-chunking";
+import { CONFIG_DIR, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/whatsapp/src/targets-runtime.ts
-const WHATSAPP_FENCE_PLACEHOLDER = "\0FENCE";
-const WHATSAPP_INLINE_CODE_PLACEHOLDER = "\0CODE";
-const WHATSAPP_PLACEHOLDER_TERMINATOR = "\0";
+const WHATSAPP_FORMAT_CAPABILITIES = FormatCapabilityProfile.define({
+	mechanism: "markdown",
+	constructs: {
+		underline: "strip",
+		spoiler: "fallback",
+		codeLanguage: "fallback",
+		linkLabel: "fallback",
+		heading: "fallback",
+		taskList: "fallback",
+		table: "fallback",
+		image: "fallback"
+	},
+	chunk: {
+		limit: 4096,
+		unit: "chars"
+	}
+});
+const WHATSAPP_STYLE_MARKERS = {
+	bold: {
+		open: "*",
+		close: "*"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~",
+		close: "~"
+	},
+	code: {
+		open: "```",
+		close: "```"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+const WHATSAPP_INDENT_GUARD = "⁠";
+const WHATSAPP_MARKERS = [
+	"*",
+	"_",
+	"~",
+	"`"
+];
 function assertWebChannel(input) {
 	if (input !== "web") throw new Error("Web channel must be 'web'");
 }
@@ -165,31 +210,90 @@ async function resolveJidToE164(jid, opts) {
 		return null;
 	}
 }
-function markdownToWhatsApp(text) {
-	if (!text) return text;
-	const fences = [];
-	let result = text.replace(/```[\s\S]*?```/g, (match) => {
-		fences.push(match);
-		return `${WHATSAPP_FENCE_PLACEHOLDER}${fences.length - 1}${WHATSAPP_PLACEHOLDER_TERMINATOR}`;
-	});
-	const inlineCodes = [];
-	result = result.replace(/`[^`\n]+`/g, (match) => {
-		inlineCodes.push(match);
-		return `${WHATSAPP_INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}${WHATSAPP_PLACEHOLDER_TERMINATOR}`;
+function protectWhatsAppEscapedMarkers(text) {
+	const placeholders = [];
+	for (const [start, end] of [[57344, 63743], [983040, 1048573]]) for (let codePoint = start; codePoint <= end && placeholders.length < WHATSAPP_MARKERS.length; codePoint += 1) {
+		const candidate = String.fromCodePoint(codePoint);
+		if (!text.includes(candidate)) placeholders.push(candidate);
+	}
+	if (placeholders.length < WHATSAPP_MARKERS.length) throw new Error("Unable to reserve WhatsApp formatting placeholders");
+	const markers = WHATSAPP_MARKERS.map((marker, index) => ({
+		source: `\\${marker}`,
+		placeholder: placeholders[index] ?? ""
+	}));
+	let protectedText = text;
+	for (const { source, placeholder } of markers) protectedText = protectedText.replaceAll(source, placeholder);
+	return {
+		text: protectedText,
+		markers
+	};
+}
+function restoreWhatsAppEscapedMarkers(text, markers) {
+	let restored = text;
+	for (const { source, placeholder } of markers) restored = restored.replaceAll(placeholder, source);
+	return restored;
+}
+function renderWhatsAppMarkdownIR(ir, escapedMarkers) {
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: WHATSAPP_STYLE_MARKERS,
+		escapeText: (value) => restoreWhatsAppEscapedMarkers(value, escapedMarkers)
+	}, WHATSAPP_FORMAT_CAPABILITIES);
+}
+function prepareWhatsAppMarkdown(text, tableMode) {
+	const guardedIndent = /^[\t ]/u.test(text);
+	const escaped = protectWhatsAppEscapedMarkers(text);
+	const markdown = guardedIndent ? `${WHATSAPP_INDENT_GUARD}${escaped.text}` : escaped.text;
+	const trailingWhitespace = text.match(/\s+$/u)?.[0] ?? "";
+	const { ir: parsedIr, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		enableSpoilers: true,
+		enableHtmlUnderline: true,
+		enableTaskLists: true,
+		headingStyle: "rich",
+		blockquotePrefix: "> ",
+		tableMode: tableMode === "block" ? "code" : tableMode,
+		preserveSourceBlockSpacing: true
 	});
-	result = result.replace(/\*\*\*(.+?)\*\*\*/g, "*_$1_*");
-	result = result.replace(/___(.+?)___/g, "*_$1_*");
-	result = result.replace(/\*\*_(.+?)_\*\*/g, "*_$1_*");
-	result = result.replace(/__\*(.+?)\*__/g, "*_$1_*");
-	result = result.replace(/_\*\*(.+?)\*\*_/g, "*_$1_*");
-	result = result.replace(/\*__(.+?)__\*/g, "*_$1_*");
-	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
-	result = result.replace(/__(.+?)__/g, "*$1*");
-	result = result.replace(/~~(.+?)~~/g, "~$1~");
-	const terminator = escapeRegExp(WHATSAPP_PLACEHOLDER_TERMINATOR);
-	result = result.replace(new RegExp(`${escapeRegExp(WHATSAPP_INLINE_CODE_PLACEHOLDER)}(\\d+)${terminator}`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
-	result = result.replace(new RegExp(`${escapeRegExp(WHATSAPP_FENCE_PLACEHOLDER)}(\\d+)${terminator}`, "g"), (_, idx) => fences[Number(idx)] ?? "");
-	return result;
+	let ir = parsedIr;
+	if (guardedIndent && ir.text.startsWith(WHATSAPP_INDENT_GUARD)) ir = sliceMarkdownIR(ir, 1, ir.text.length);
+	if (!hasTables && trailingWhitespace) ir.text = `${ir.text.trimEnd()}${trailingWhitespace}`;
+	return {
+		ir,
+		escapedMarkers: escaped.markers
+	};
+}
+function splitWhatsAppIRForChunkMode(ir, limit, chunkMode) {
+	if (chunkMode !== "newline") return [ir];
+	const chunkTexts = chunkMarkdownTextWithMode(ir.text, limit, chunkMode);
+	const chunks = [];
+	let cursor = 0;
+	for (const text of chunkTexts) {
+		const start = ir.text.indexOf(text, cursor);
+		if (start < 0) return [ir];
+		const end = start + text.length;
+		chunks.push(sliceMarkdownIR(ir, start, end));
+		cursor = end;
+	}
+	return chunks;
+}
+function markdownToWhatsAppChunks(text, limit, tableMode = "bullets", chunkMode = "length") {
+	if (!text) return [];
+	if (!text.trim()) return chunkMarkdownTextWithMode(text, limit, chunkMode);
+	const { ir, escapedMarkers } = prepareWhatsAppMarkdown(text, tableMode);
+	const render = (chunk) => renderWhatsAppMarkdownIR(chunk, escapedMarkers);
+	const rendered = render(ir);
+	let chunks = ir.styles.length === 0 && ir.links.length === 0 ? chunkMarkdownTextWithMode(rendered, limit, chunkMode) : splitWhatsAppIRForChunkMode(ir, limit, chunkMode).flatMap((source) => renderMarkdownIRChunksWithinLimit({
+		ir: source,
+		limit,
+		renderChunk: render,
+		measureRendered: (value) => value.length
+	}).map((chunk) => chunk.rendered));
+	if (chunkMode === "newline") chunks = chunks.map((chunk) => chunk.trimEnd()).filter(Boolean);
+	return chunks;
+}
+function markdownToWhatsApp(text, tableMode = "bullets") {
+	return markdownToWhatsAppChunks(text, Number.POSITIVE_INFINITY, tableMode).join("");
 }
 //#endregion
-export { resolveEquivalentWhatsAppDirectChatJids as a, toWhatsappJidWithLid as c, markdownToWhatsApp as i, isSelfChatMode as n, resolveJidToE164 as o, jidToE164 as r, toWhatsappJid as s, assertWebChannel as t };
+export { markdownToWhatsAppChunks as a, toWhatsappJid as c, markdownToWhatsApp as i, toWhatsappJidWithLid as l, isSelfChatMode as n, resolveEquivalentWhatsAppDirectChatJids as o, jidToE164 as r, resolveJidToE164 as s, assertWebChannel as t };

package/dist/text-runtime-CaKLhowd.js

@@ -0,0 +1,4 @@
+import "./targets-runtime-TMk0lGuy.js";
+import { sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile, stripToolCallXmlTags } from "openclaw/plugin-sdk/text-chunking";
+import { normalizeE164, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
+export { stripToolCallXmlTags as a, sanitizeAssistantVisibleTextWithProfile as i, resolveUserPath$1 as n, sanitizeAssistantVisibleText as r, normalizeE164 as t };

package/node_modules/@protobufjs/utf8/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [1.1.2](https://github.com/protobufjs/protobuf.js/compare/utf8-v1.1.1...utf8-v1.1.2) (2026-07-05)
+
+
+### Performance Improvements
+
+* Batch String.fromCharCode in @protobufjs/utf8 read ([#2355](https://github.com/protobufjs/protobuf.js/issues/2355)) ([d1ae3ce](https://github.com/protobufjs/protobuf.js/commit/d1ae3ce46370254ada0f3db689506a9139c8d1ee))

package/node_modules/@protobufjs/utf8/index.js

@@ -6,7 +6,7 @@
  * @namespace
  */
 var utf8 = exports,
-    replacementChar = "\ufffd";
+    replacementCharCode = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER
 
 /**
  * Calculates the UTF8 byte length of a string.
@@ -39,34 +39,45 @@ utf8.length = function utf8_length(string) {
  * @returns {string} String read
  */
 utf8.read = function utf8_read(buffer, start, end) {
-    if (end - start < 1) {
+    if (end - start < 1)
         return "";
-    }
-
-    var str = "";
-    for (var i = start; i < end;) {
-        var t = buffer[i++];
+    // Batch code units and flush via String.fromCharCode.apply in 8192-unit
+    // chunks to avoid the per-character ConsString buildup of `str += ...`.
+    var parts = null,
+        chunk = [],
+        i = 0, // chunk write index
+        t, t2, c2, c3;
+    while (start < end) {
+        t = buffer[start++];
         if (t <= 0x7F) {
-            str += String.fromCharCode(t);
+            chunk[i++] = t;
         } else if (t >= 0xC0 && t < 0xE0) {
-            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;
-            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;
+            c2 = (t & 0x1F) << 6 | buffer[start++] & 0x3F;
+            chunk[i++] = c2 >= 0x80 ? c2 : replacementCharCode;
         } else if (t >= 0xE0 && t < 0xF0) {
-            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
-            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;
+            c3 = (t & 0xF) << 12 | (buffer[start++] & 0x3F) << 6 | buffer[start++] & 0x3F;
+            chunk[i++] = c3 >= 0x800 ? c3 : replacementCharCode;
         } else if (t >= 0xF0) {
-            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
+            t2 = (t & 7) << 18 | (buffer[start++] & 0x3F) << 12 | (buffer[start++] & 0x3F) << 6 | buffer[start++] & 0x3F;
             if (t2 < 0x10000 || t2 > 0x10FFFF)
-                str += replacementChar;
+                chunk[i++] = replacementCharCode;
             else {
                 t2 -= 0x10000;
-                str += String.fromCharCode(0xD800 + (t2 >> 10));
-                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));
+                chunk[i++] = 0xD800 + (t2 >> 10);
+                chunk[i++] = 0xDC00 + (t2 & 0x3FF);
             }
         }
+        if (i > 8191) {
+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+            i = 0;
+        }
     }
-
-    return str;
+    if (parts) {
+        if (i)
+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+    }
+    return String.fromCharCode.apply(String, chunk.slice(0, i));
 };
 
 /**

package/node_modules/@protobufjs/utf8/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@protobufjs/utf8",
   "description": "A minimal UTF8 implementation for number arrays.",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dcodeIO/protobuf.js.git"
+    "url": "https://github.com/protobufjs/protobuf.js.git"
   },
   "license": "BSD-3-Clause",
   "main": "index.js",

package/node_modules/@protobufjs/utf8/tests/index.js

@@ -47,6 +47,11 @@ tape.test("utf8", function(test) {
             test.equal(comp, "\ufffd", "should decode overlong UTF-8 sequences as replacement characters");
         });
 
+        var longMultibyteStr = "\u20ac\u00df\u7a7a\u03bb\ud835\udd4f".repeat(20000); // 3-byte, 2-byte and surrogate-pair code points
+        var longMultibyte = Buffer.from(longMultibyteStr, "utf8");
+        comp = utf8.read(longMultibyte, 0, longMultibyte.length);
+        test.equal(comp, longMultibyteStr, "should decode a large multibyte string spanning many flush boundaries");
+
         test.end();
     });
 

package/node_modules/@thi.ng/bitstream/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/bitstream",
-	"version": "2.4.53",
+	"version": "2.4.54",
 	"description": "ES6 iterator based read/write bit streams with support for variable word widths",
 	"type": "module",
 	"module": "./index.js",
@@ -40,10 +40,10 @@
 		"tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
 	},
 	"dependencies": {
-		"@thi.ng/errors": "^2.6.15"
+		"@thi.ng/errors": "^2.6.16"
 	},
 	"devDependencies": {
-		"esbuild": "^0.28.0",
+		"esbuild": "^0.28.1",
 		"typedoc": "^0.28.19",
 		"typescript": "^6.0.3"
 	},
@@ -84,5 +84,5 @@
 			"rle-pack"
 		]
 	},
-	"gitHead": "c47c56420bcae2e0477d252a497be44f08ca185a"
+	"gitHead": "febee81fd8b59e5e330a6e6521a2667ed5401a3d"
 }

package/node_modules/@thi.ng/errors/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/errors",
-	"version": "2.6.15",
+	"version": "2.6.16",
 	"description": "Custom error types and error factory functions",
 	"type": "module",
 	"module": "./index.js",
@@ -40,8 +40,8 @@
 		"tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
 	},
 	"devDependencies": {
-		"@types/node": "^25.6.2",
-		"esbuild": "^0.28.0",
+		"@types/node": "^25.9.4",
+		"esbuild": "^0.28.1",
 		"typedoc": "^0.28.19",
 		"typescript": "^6.0.3"
 	},
@@ -100,5 +100,5 @@
 		"alias": "err",
 		"year": 2018
 	},
-	"gitHead": "c47c56420bcae2e0477d252a497be44f08ca185a"
+	"gitHead": "febee81fd8b59e5e330a6e6521a2667ed5401a3d"
 }

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Wed, 01 Jul 2026 11:03:38 GMT
+ * Last updated: Wed, 08 Jul 2026 06:47:45 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/fs/promises.d.ts

@@ -153,7 +153,11 @@ declare module "node:fs/promises" {
          * @return Fulfills with `undefined` upon success.
          */
         appendFile(
-            data: string | Uint8Array,
+            data:
+                | string
+                | NodeJS.ArrayBufferView
+                | Iterable<string | NodeJS.ArrayBufferView>
+                | AsyncIterable<string | NodeJS.ArrayBufferView>,
             options?:
                 | (ObjectEncodingOptions & Abortable)
                 | BufferEncoding
@@ -470,7 +474,11 @@ declare module "node:fs/promises" {
          * @since v10.0.0
          */
         writeFile(
-            data: string | Uint8Array,
+            data:
+                | string
+                | NodeJS.ArrayBufferView
+                | Iterable<string | NodeJS.ArrayBufferView>
+                | AsyncIterable<string | NodeJS.ArrayBufferView>,
             options?:
                 | (ObjectEncodingOptions & Abortable)
                 | BufferEncoding
@@ -1208,8 +1216,7 @@ declare module "node:fs/promises" {
             | string
             | NodeJS.ArrayBufferView
             | Iterable<string | NodeJS.ArrayBufferView>
-            | AsyncIterable<string | NodeJS.ArrayBufferView>
-            | Stream,
+            | AsyncIterable<string | NodeJS.ArrayBufferView>,
         options?:
             | (ObjectEncodingOptions & {
                 mode?: Mode | undefined;
@@ -1240,7 +1247,11 @@ declare module "node:fs/promises" {
      */
     function appendFile(
         path: PathLike | FileHandle,
-        data: string | Uint8Array,
+        data:
+            | string
+            | NodeJS.ArrayBufferView
+            | Iterable<string | NodeJS.ArrayBufferView>
+            | AsyncIterable<string | NodeJS.ArrayBufferView>,
         options?: (ObjectEncodingOptions & FlagAndOpenMode & { flush?: boolean | undefined }) | BufferEncoding | null,
     ): Promise<void>;
     /**
@@ -1432,7 +1443,6 @@ declare module "node:fs/promises" {
      * When copying a directory to another directory, globs are not supported and
      * behavior is similar to `cp dir1/ dir2/`.
      * @since v16.7.0
-     * @experimental
      * @param src source path to copy.
      * @param dest destination path to copy to.
      * @return Fulfills with `undefined` upon success.

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "26.1.0",
+    "version": "26.1.1",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~8.3.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "bac6fe2369bbd2e0f2cf6643373e8c398ed66b886a72749c8d1fb0b9b60031ab",
+    "typesPublisherContentHash": "a59119b073061829bc67a5bf6bc2b8ecb0a5a6196058e3c73172a00440f4e16d",
     "typeScriptVersion": "5.6"
 }