@dev-pi2pie/word-counter 0.1.3 → 0.1.4

package/dist/esm/bin.mjs

@@ -4,8 +4,9 @@ import { Command, Option } from "commander";
 import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFile, readdir, stat } from "node:fs/promises";
+import os from "node:os";
 import { parseDocument } from "yaml";
+import { readFile, readdir, stat } from "node:fs/promises";
 
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -345,8 +346,14 @@ function collectPathValue(value, previous = []) {
 function collectLatinHintValue(value, previous = []) {
 	return [...previous, value];
 }
+function parseJobsOption(value) {
+	if (!/^\d+$/.test(value)) throw new Error("`--jobs` must be an integer >= 1.");
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isSafeInteger(parsed) || parsed < 1) throw new Error("`--jobs` must be an integer >= 1.");
+	return parsed;
+}
 function configureProgramOptions(program, parseMode) {
-	program.addOption(new Option("-m, --mode <mode>", "breakdown mode").choices(MODE_CHOICES).argParser(parseMode).default("chunk")).addOption(new Option("-f, --format <format>", "output format").choices(FORMAT_CHOICES).default("standard")).addOption(new Option("--section <section>", "document section mode").choices(SECTION_CHOICES).default("all")).addOption(new Option("--path-mode <mode>", "path resolution mode: auto (default) expands directories; manual treats --path values as literal files").choices(PATH_MODE_CHOICES).default("auto")).option("--latin-language <language>", "hint a language tag for Latin script text").option("--latin-tag <tag>", "hint a BCP 47 tag for Latin script text").option("--latin-locale <locale>", "legacy alias of --latin-language").option("--latin-hint <tag>=<pattern>", "add a custom Latin hint rule (repeatable)", collectLatinHintValue, []).option("--latin-hints-file <path>", "load custom Latin hint rules from a JSON file").option("--no-default-latin-hints", "disable built-in Latin hint rules").option("--han-language <language>", "hint a language tag for Han script text").option("--han-tag <tag>", "hint a BCP 47 tag for Han script text").option("--non-words", "collect emoji, symbols, and punctuation (excludes whitespace)").option("--include-whitespace", "include whitespace counts (implies with --non-words; same as --misc)").option("--misc", "collect non-words plus whitespace (alias for --include-whitespace)").option("--total-of <parts>", "override total composition (comma-separated): words,emoji,symbols,punctuation,whitespace", parseTotalOfOption).option("--pretty", "pretty print JSON output", false).option("--debug", "enable debug diagnostics on stderr").option("--verbose", "emit verbose per-file debug diagnostics (requires --debug)").option("--debug-report [path]", "write debug diagnostics to a report file").option("--debug-report-tee", "mirror debug diagnostics to both report file and stderr").option("--debug-tee", "alias of --debug-report-tee").option("--merged", "show merged aggregate output (default)").option("--per-file", "show per-file output plus merged summary").option("--no-progress", "disable batch progress indicator").option("--keep-progress", "keep final batch progress line visible in standard mode").option("--no-recursive", "disable recursive directory traversal").option("--quiet-skips", "hide skip diagnostics (applies when --debug is enabled)").option("--include-ext <exts>", "comma-separated extensions to include during directory scanning", collectExtensionOption, []).option("--exclude-ext <exts>", "comma-separated extensions to exclude during directory scanning", collectExtensionOption, []).option("--regex <pattern>", "regex filter for directory-scanned paths (applies to --path directories only)").option("-p, --path <path>", "read input from file or directory (directories expand in auto mode by default)", collectPathValue, []).argument("[text...]", "text to count").showHelpAfterError();
+	program.addOption(new Option("-m, --mode <mode>", "breakdown mode").choices(MODE_CHOICES).argParser(parseMode).default("chunk")).addOption(new Option("-f, --format <format>", "output format").choices(FORMAT_CHOICES).default("standard")).addOption(new Option("--section <section>", "document section mode").choices(SECTION_CHOICES).default("all")).addOption(new Option("--path-mode <mode>", "path resolution mode: auto (default) expands directories; manual treats --path values as literal files").choices(PATH_MODE_CHOICES).default("auto")).option("--latin-language <language>", "hint a language tag for Latin script text").option("--latin-tag <tag>", "hint a BCP 47 tag for Latin script text").option("--latin-locale <locale>", "legacy alias of --latin-language").option("--latin-hint <tag>=<pattern>", "add a custom Latin hint rule (repeatable)", collectLatinHintValue, []).option("--latin-hints-file <path>", "load custom Latin hint rules from a JSON file").option("--no-default-latin-hints", "disable built-in Latin hint rules").option("--han-language <language>", "hint a language tag for Han script text").option("--han-tag <tag>", "hint a BCP 47 tag for Han script text").option("--non-words", "collect emoji, symbols, and punctuation (excludes whitespace)").option("--include-whitespace", "include whitespace counts (implies --non-words; same as --misc)").option("--misc", "collect non-words plus whitespace (alias for --include-whitespace)").option("--total-of <parts>", "override total composition (comma-separated): words,emoji,symbols,punctuation,whitespace", parseTotalOfOption).option("--pretty", "pretty print JSON output", false).option("--debug", "enable debug diagnostics on stderr").option("--verbose", "emit verbose per-file debug diagnostics (requires --debug)").option("--debug-report [path]", "write debug diagnostics to a report file").option("--debug-report-tee", "mirror debug diagnostics to both report file and stderr").option("--debug-tee", "alias of --debug-report-tee").option("--merged", "show merged aggregate output (default)").option("--per-file", "show per-file output plus merged summary").option("--jobs <n>", "batch jobs in --path mode (1=async main-thread, >1=worker load+count)", parseJobsOption, 1).option("--print-jobs-limit", "print host jobs-limit JSON and exit (must be used alone)").option("--no-progress", "disable batch progress indicator").option("--keep-progress", "keep final batch progress line visible in standard mode").option("--no-recursive", "disable recursive directory traversal").option("--quiet-warnings", "suppress non-fatal warning diagnostics").option("--quiet-skips", "suppress debug skip output and per-file json skipped field").option("--include-ext <exts>", "comma-separated extensions to include during directory scanning", collectExtensionOption, []).option("--exclude-ext <exts>", "comma-separated extensions to exclude during directory scanning", collectExtensionOption, []).option("--regex <pattern>", "regex filter for directory-scanned paths (applies to --path directories only)").option("-p, --path <path>", "read input from file or directory (directories expand in auto mode by default)", collectPathValue, []).argument("[text...]", "text to count").showHelpAfterError();
 }
 
 //#endregion
@@ -421,7 +428,7 @@ var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region src/cli/program/version-embedded.ts
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-const EMBEDDED_PACKAGE_VERSION = "0.1.3";
+const EMBEDDED_PACKAGE_VERSION = "0.1.4";
 
 //#endregion
 //#region src/cli/program/version.ts
@@ -474,6 +481,51 @@ function getFormattedVersionLabel() {
 	return import_picocolors.default.bgBlack(import_picocolors.default.bold(import_picocolors.default.italic(` word-counter ${import_picocolors.default.cyanBright(`ver.${version}`)} `)));
 }
 
+//#endregion
+//#region src/cli/batch/jobs/limits.ts
+const DEFAULT_UV_THREADPOOL_SIZE = 4;
+function parsePositiveInteger(value) {
+	if (!value) return;
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return;
+	return parsed;
+}
+function resolveBatchJobsLimit(env = process.env) {
+	const cpuLimit = Math.max(1, os.availableParallelism());
+	const uvThreadpool = parsePositiveInteger(env.UV_THREADPOOL_SIZE) ?? DEFAULT_UV_THREADPOOL_SIZE;
+	const ioLimit = Math.max(1, uvThreadpool * 2);
+	return {
+		suggestedMaxJobs: Math.max(1, Math.min(cpuLimit, ioLimit)),
+		cpuLimit,
+		uvThreadpool,
+		ioLimit
+	};
+}
+function clampRequestedJobs(requestedJobs, limits) {
+	return Math.max(1, Math.min(requestedJobs, limits.suggestedMaxJobs));
+}
+function formatJobsAdvisoryWarning(requestedJobs, effectiveJobs, limits) {
+	return [
+		`Warning: requested --jobs=${requestedJobs} exceeds suggested host limit (${limits.suggestedMaxJobs}).`,
+		`Running with --jobs=${effectiveJobs} as a safety cap.`,
+		`Host limits: cpuLimit=${limits.cpuLimit}, uvThreadpool=${limits.uvThreadpool}, ioLimit=${limits.ioLimit}.`
+	].join(" ");
+}
+function isResourceLimitError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const code = "code" in error ? error.code : void 0;
+	return code === "EMFILE" || code === "ENFILE";
+}
+function createResourceLimitError(path, error, requestedJobs, limits) {
+	const message = error instanceof Error ? error.message : String(error);
+	const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "UNKNOWN";
+	return new Error([
+		`Resource limit reached while processing: ${path} (${code}: ${message}).`,
+		`Requested --jobs=${requestedJobs}; suggested host limit is ${limits.suggestedMaxJobs}.`,
+		"Reduce --jobs or raise OS file descriptor limits before retrying."
+	].join(" "));
+}
+
 //#endregion
 //#region src/utils/append-all.ts
 function appendAll(target, source) {
@@ -481,1811 +533,1928 @@ function appendAll(target, source) {
 }
 
 //#endregion
-//#region src/cli/path/load.ts
-function isProbablyBinary(buffer) {
-	if (buffer.length === 0) return false;
-	const sampleSize = Math.min(buffer.length, 1024);
-	let suspicious = 0;
-	for (let index = 0; index < sampleSize; index += 1) {
-		const byte = buffer[index] ?? 0;
-		if (byte === 0) return true;
-		if (byte === 9 || byte === 10 || byte === 13) continue;
-		if (byte >= 32 && byte <= 126) continue;
-		if (byte >= 128) continue;
-		suspicious += 1;
+//#region src/markdown/toml/arrays.ts
+function ensureArrayContainer(result, key) {
+	const existing = result[key];
+	if (Array.isArray(existing)) return existing;
+	const list = [];
+	result[key] = list;
+	return list;
+}
+function flattenArrayTables(result) {
+	for (const [key, value] of Object.entries(result)) {
+		if (!Array.isArray(value)) continue;
+		result[key] = value.map((entry) => Object.entries(entry).map(([entryKey, entryValue]) => `${entryKey}=${entryValue}`).join(", ")).join(" | ");
 	}
-	return suspicious / sampleSize > .3;
 }
-async function loadBatchInputs(filePaths) {
-	const files = [];
-	const skipped = [];
-	for (const filePath of filePaths) {
-		let buffer;
-		try {
-			buffer = await readFile(filePath);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			skipped.push({
-				path: filePath,
-				reason: `not readable: ${message}`
-			});
+
+//#endregion
+//#region src/markdown/toml/keys.ts
+function stripKeyQuotes(key) {
+	const trimmed = key.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function normalizeKeyPath(key) {
+	const trimmed = key.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+		const unquoted = stripKeyQuotes(trimmed);
+		return unquoted ? unquoted : null;
+	}
+	const segments = trimmed.split(".").map((segment) => segment.trim());
+	if (segments.some((segment) => !segment)) return null;
+	return segments.join(".");
+}
+
+//#endregion
+//#region src/markdown/toml/strings.ts
+function stripInlineComment(line) {
+	let inString = null;
+	let escaped = false;
+	for (let i = 0; i < line.length; i += 1) {
+		const char = line[i] ?? "";
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\" && inString === "double") {
+				escaped = true;
+				continue;
+			}
+			if (inString === "double" && char === "\"") {
+				inString = null;
+				continue;
+			}
+			if (inString === "single" && char === "'") {
+				inString = null;
+				continue;
+			}
 			continue;
 		}
-		if (isProbablyBinary(buffer)) {
-			skipped.push({
-				path: filePath,
-				reason: "binary file"
-			});
+		if (char === "\"") {
+			inString = "double";
 			continue;
 		}
-		files.push({
-			path: filePath,
-			content: buffer.toString("utf8")
-		});
+		if (char === "'") {
+			inString = "single";
+			continue;
+		}
+		if (char === "#") return line.slice(0, i).trimEnd();
 	}
-	return {
-		files,
-		skipped
-	};
+	return line;
+}
+function unescapeBasic(input) {
+	return input.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
+}
+function parseStringLiteral(value) {
+	if (value.startsWith("\"\"\"") && value.endsWith("\"\"\"")) return unescapeBasic(value.slice(3, -3));
+	if (value.startsWith("'''") && value.endsWith("'''")) return value.slice(3, -3);
+	if (value.startsWith("\"") && value.endsWith("\"")) return unescapeBasic(value.slice(1, -1));
+	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	return null;
 }
 
 //#endregion
-//#region src/cli/path/resolve.ts
-async function expandDirectory(rootPath, directoryPath, recursive, extensionFilter, regexFilter, skipped, recordRegexExcluded, debug, stats) {
-	let entries;
-	try {
-		entries = await readdir(directoryPath, {
-			withFileTypes: true,
-			encoding: "utf8"
-		});
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		skipped.push({
-			path: directoryPath,
-			reason: `directory read failed: ${message}`
-		});
-		debug.emit("path.resolve.expand.read_failed", {
-			directory: directoryPath,
-			reason: `directory read failed: ${message}`
-		});
-		return [];
-	}
-	const sortedEntries = entries.slice().sort((left, right) => left.name.localeCompare(right.name));
-	const files = [];
-	debug.emit("path.resolve.expand.start", {
-		directory: directoryPath,
-		entries: sortedEntries.length,
-		recursive
-	});
-	for (const entry of sortedEntries) {
-		const entryPath = resolve(directoryPath, entry.name);
-		if (entry.isFile()) {
-			if (!shouldIncludeFromDirectory(entryPath, extensionFilter)) {
-				skipped.push({
-					path: entryPath,
-					reason: "extension excluded"
-				});
-				debug.emit("path.resolve.filter.excluded", {
-					path: entryPath,
-					reason: "extension excluded"
-				}, { verbosity: "verbose" });
-				stats.filterExcluded += 1;
+//#region src/markdown/toml/values.ts
+function parsePrimitive(raw) {
+	const value = raw.trim();
+	if (!value) return null;
+	const stringLiteral = parseStringLiteral(value);
+	if (stringLiteral !== null) return stringLiteral;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (/^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)) return Number(value);
+	if (/^\d{4}-\d{2}-\d{2}/.test(value)) return value;
+	return value;
+}
+function parseArray(raw) {
+	const value = raw.trim();
+	if (!value.startsWith("[") || !value.endsWith("]")) return null;
+	const inner = value.slice(1, -1).trim();
+	if (!inner) return [];
+	const items = [];
+	let current = "";
+	let inString = null;
+	let escaped = false;
+	for (let i = 0; i < inner.length; i += 1) {
+		const char = inner[i] ?? "";
+		if (inString) {
+			current += char;
+			if (escaped) {
+				escaped = false;
 				continue;
 			}
-			const relativePath = toDirectoryRelativePath(rootPath, entryPath);
-			if (!shouldIncludeFromDirectoryRegex(relativePath, regexFilter)) {
-				if (recordRegexExcluded(entryPath)) {
-					debug.emit("path.resolve.regex.excluded", {
-						path: entryPath,
-						relativePath,
-						pattern: regexFilter.sourcePattern,
-						reason: "regex excluded"
-					}, { verbosity: "verbose" });
-					stats.regexExcluded += 1;
-				}
+			if (char === "\\" && inString === "double") {
+				escaped = true;
 				continue;
 			}
-			files.push(entryPath);
-			stats.directoryIncluded += 1;
-			debug.emit("path.resolve.expand.include", {
-				path: entryPath,
-				source: "directory"
-			}, { verbosity: "verbose" });
+			if (inString === "double" && char === "\"") inString = null;
+			else if (inString === "single" && char === "'") inString = null;
 			continue;
 		}
-		if (!entry.isDirectory() || !recursive) continue;
-		appendAll(files, await expandDirectory(rootPath, entryPath, recursive, extensionFilter, regexFilter, skipped, recordRegexExcluded, debug, stats));
+		if (char === "\"") {
+			inString = "double";
+			current += char;
+			continue;
+		}
+		if (char === "'") {
+			inString = "single";
+			current += char;
+			continue;
+		}
+		if (char === ",") {
+			const item = parsePrimitive(current);
+			if (item === null) return null;
+			items.push(item);
+			current = "";
+			continue;
+		}
+		current += char;
 	}
-	debug.emit("path.resolve.expand.complete", {
-		directory: directoryPath,
-		files: files.length
-	});
-	return files;
+	const finalItem = parsePrimitive(current);
+	if (finalItem === null) return null;
+	items.push(finalItem);
+	return items;
 }
-async function resolveBatchFilePaths(pathInputs, options) {
-	const skipped = [];
-	const regexExcludedPaths = /* @__PURE__ */ new Set();
-	const resolvedFiles = /* @__PURE__ */ new Set();
-	const stats = {
-		dedupeAccepted: 0,
-		dedupeDuplicates: 0,
-		filterExcluded: 0,
-		regexExcluded: 0,
-		directoryIncluded: 0
-	};
-	const extensionFilter = options.extensionFilter ?? buildDirectoryExtensionFilter(void 0, void 0);
-	let regexFilter;
-	const debug = options.debug ?? {
-		enabled: false,
-		verbosity: "compact",
-		emit() {},
-		close: async () => {}
-	};
-	debug.emit("path.resolve.inputs", {
-		inputs: pathInputs.length,
-		pathMode: options.pathMode,
-		recursive: options.recursive,
-		hasRegex: Boolean(options.directoryRegexPattern)
-	});
-	const addResolvedFile = (filePath, details) => {
-		regexExcludedPaths.delete(filePath);
-		if (resolvedFiles.has(filePath)) {
-			stats.dedupeDuplicates += 1;
-			debug.emit("path.resolve.dedupe.duplicate", {
-				path: filePath,
-				source: details.source,
-				input: details.input
-			}, { verbosity: "verbose" });
-			return;
+function parseInlineTable(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+	const inner = trimmed.slice(1, -1).trim();
+	if (!inner) return {};
+	const pairs = [];
+	let current = "";
+	let inString = null;
+	let escaped = false;
+	let bracketDepth = 0;
+	let braceDepth = 0;
+	for (let i = 0; i < inner.length; i += 1) {
+		const char = inner[i] ?? "";
+		if (inString) {
+			current += char;
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\" && inString === "double") {
+				escaped = true;
+				continue;
+			}
+			if (inString === "double" && char === "\"") inString = null;
+			else if (inString === "single" && char === "'") inString = null;
+			continue;
 		}
-		resolvedFiles.add(filePath);
-		stats.dedupeAccepted += 1;
-		debug.emit("path.resolve.dedupe.accept", {
-			path: filePath,
-			source: details.source,
-			input: details.input
-		}, { verbosity: "verbose" });
-	};
-	const getRegexFilter = () => {
-		if (!regexFilter) regexFilter = buildDirectoryRegexFilter(options.directoryRegexPattern);
-		return regexFilter;
-	};
-	const recordRegexExcluded = (filePath) => {
-		if (resolvedFiles.has(filePath)) return false;
-		regexExcludedPaths.add(filePath);
-		return true;
-	};
-	for (const rawPath of pathInputs) {
-		const targetPath = resolve(rawPath);
-		debug.emit("path.resolve.input", {
-			rawPath,
-			resolvedPath: targetPath
-		});
-		let metadata;
-		try {
-			metadata = await stat(targetPath);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			skipped.push({
-				path: targetPath,
-				reason: `not readable: ${message}`
-			});
-			debug.emit("path.resolve.skip", {
-				path: targetPath,
-				reason: `not readable: ${message}`
-			});
+		if (char === "\"") {
+			inString = "double";
+			current += char;
 			continue;
 		}
-		if (metadata.isDirectory() && options.pathMode === "auto") {
-			const effectiveRegexFilter = getRegexFilter();
-			debug.emit("path.resolve.root.expand", {
-				root: targetPath,
-				recursive: options.recursive,
-				regex: effectiveRegexFilter.sourcePattern ?? null
-			});
-			const files = await expandDirectory(targetPath, targetPath, options.recursive, extensionFilter, effectiveRegexFilter, skipped, recordRegexExcluded, debug, stats);
-			for (const file of files) addResolvedFile(file, {
-				source: "directory",
-				input: targetPath
-			});
+		if (char === "'") {
+			inString = "single";
+			current += char;
 			continue;
 		}
-		if (!metadata.isFile()) {
-			skipped.push({
-				path: targetPath,
-				reason: "not a regular file"
-			});
-			debug.emit("path.resolve.skip", {
-				path: targetPath,
-				reason: "not a regular file"
-			});
+		if (char === "[") {
+			bracketDepth += 1;
+			current += char;
 			continue;
 		}
-		addResolvedFile(targetPath, {
-			source: "direct",
-			input: targetPath
-		});
+		if (char === "]") {
+			if (bracketDepth > 0) bracketDepth -= 1;
+			current += char;
+			continue;
+		}
+		if (char === "{") {
+			braceDepth += 1;
+			current += char;
+			continue;
+		}
+		if (char === "}") {
+			if (braceDepth > 0) braceDepth -= 1;
+			current += char;
+			continue;
+		}
+		if (char === "," && bracketDepth === 0 && braceDepth === 0) {
+			pairs.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
 	}
-	for (const path of regexExcludedPaths) skipped.push({
-		path,
-		reason: "regex excluded"
-	});
-	const files = [...resolvedFiles].sort((left, right) => left.localeCompare(right));
-	debug.emit("path.resolve.filter.summary", {
-		excluded: stats.filterExcluded + stats.regexExcluded,
-		extensionExcluded: stats.filterExcluded,
-		regexExcluded: stats.regexExcluded,
-		included: stats.directoryIncluded
-	});
-	debug.emit("path.resolve.dedupe.summary", {
-		accepted: stats.dedupeAccepted,
-		duplicates: stats.dedupeDuplicates
-	});
-	debug.emit("path.resolve.complete", {
-		files: files.length,
-		skipped: skipped.length,
-		ordering: "absolute-path-ascending"
-	});
-	return {
-		files,
-		skipped
-	};
-}
-
-//#endregion
-//#region src/cli/progress/reporter.ts
-const PROGRESS_BAR_WIDTH = 20;
-const FILLED_BAR_CHAR = "█";
-const EMPTY_BAR_CHAR = "░";
-function clamp(value, min, max) {
-	return Math.max(min, Math.min(max, value));
-}
-function buildProgressBar(completed, total) {
-	const safeTotal = Math.max(total, 1);
-	const ratio = clamp(completed / safeTotal, 0, 1);
-	const filled = completed >= safeTotal ? PROGRESS_BAR_WIDTH : Math.floor(ratio * PROGRESS_BAR_WIDTH);
-	const empty = PROGRESS_BAR_WIDTH - filled;
-	return `${FILLED_BAR_CHAR.repeat(filled)}${EMPTY_BAR_CHAR.repeat(empty)}`;
-}
-function formatElapsed(startedAtMs) {
-	const elapsedMs = Date.now() - startedAtMs;
-	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
-	const minutes = Math.floor(totalSeconds / 60);
-	const seconds = totalSeconds % 60;
-	const tenths = Math.floor(Math.max(0, elapsedMs) % 1e3 / 100);
-	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${tenths}`;
+	if (current.trim()) pairs.push(current);
+	const output = {};
+	for (const pair of pairs) {
+		const separatorIndex = pair.indexOf("=");
+		if (separatorIndex === -1) return null;
+		const key = normalizeKeyPath(pair.slice(0, separatorIndex));
+		if (!key) return null;
+		const valueRaw = pair.slice(separatorIndex + 1).trim();
+		if (!valueRaw) return null;
+		if (valueRaw.startsWith("{")) return null;
+		const normalized = normalizeValue(valueRaw);
+		if (normalized === null) return null;
+		if (typeof normalized === "object" && !Array.isArray(normalized)) return null;
+		output[key] = normalized;
+	}
+	return output;
 }
-function buildProgressLine(completed, total, startedAtMs) {
-	const safeTotal = Math.max(total, 1);
-	const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
-	return `Counting files [${buildProgressBar(completed, safeTotal)}] ${`${String(percent).padStart(3, " ")}%`} ${String(completed).padStart(String(safeTotal).length, " ")}/${safeTotal} elapsed ${formatElapsed(startedAtMs)}`;
+function normalizeValue(value) {
+	if (!value) return null;
+	const trimmed = value.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return parseInlineTable(trimmed);
+	const array = parseArray(trimmed);
+	if (array) return array;
+	if (trimmed.startsWith("[") && trimmed.endsWith("]")) return null;
+	return parsePrimitive(trimmed);
 }
-function buildFinalizingLine(startedAtMs) {
-	return `Finalizing aggregate... elapsed ${formatElapsed(startedAtMs)}`;
+function toPlainText(value) {
+	if (value == null) return "";
+	if (Array.isArray(value)) return value.map((item) => String(item)).join(", ");
+	return String(value);
 }
-function createBatchProgressReporter(options) {
-	const enabled = options.enabled;
-	const isTTY = Boolean(options.stream.isTTY);
-	const clearOnFinish = options.clearOnFinish ?? true;
-	let active = false;
-	let total = 0;
-	let lastLineLength = 0;
-	let startedAtMs = 0;
-	let lastRenderedPercent = -1;
-	let finalizingStarted = false;
-	const writeTTYLine = (line) => {
-		const trailingPadding = lastLineLength > line.length ? " ".repeat(lastLineLength - line.length) : "";
-		options.stream.write(`\r${line}${trailingPadding}`);
-		lastLineLength = line.length;
-	};
-	const render = (completed) => {
-		const line = buildProgressLine(completed, total, startedAtMs);
-		const safeTotal = Math.max(total, 1);
-		const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
-		if (!isTTY && percent === lastRenderedPercent && completed < safeTotal) return;
-		lastRenderedPercent = percent;
-		if (isTTY) {
-			writeTTYLine(line);
-			return;
-		}
-		lastLineLength = line.length;
-		options.stream.write(`${line}\n`);
-	};
-	const clearLine = () => {
-		if (lastLineLength === 0) return;
-		options.stream.write(`\r${" ".repeat(lastLineLength)}\r`);
-		lastLineLength = 0;
-	};
-	return {
-		enabled,
-		start(nextTotal, nextStartedAtMs) {
-			if (!enabled || nextTotal <= 1) return;
-			total = nextTotal;
-			active = true;
-			startedAtMs = nextStartedAtMs ?? Date.now();
-			lastRenderedPercent = -1;
-			finalizingStarted = false;
-			render(0);
-		},
-		advance(snapshot) {
-			if (!active) return;
-			render(snapshot.completed);
-		},
-		startFinalizing() {
-			if (!active || finalizingStarted) return;
-			finalizingStarted = true;
-			const line = buildFinalizingLine(startedAtMs);
-			if (isTTY) {
-				if (!clearOnFinish) {
-					options.stream.write(`\n${line}`);
-					lastLineLength = line.length;
-					return;
+
+//#endregion
+//#region src/markdown/toml/parse-frontmatter.ts
+function parseTomlFrontmatter(frontmatter) {
+	const result = {};
+	const lines = frontmatter.split("\n");
+	let tablePrefix = "";
+	let tableTarget = null;
+	let tablePrefixInList = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const rawLine = lines[index] ?? "";
+		const trimmedLine = rawLine.trim();
+		if (!trimmedLine || trimmedLine.startsWith("#")) continue;
+		if (trimmedLine.startsWith("[[")) {
+			const match = trimmedLine.match(/^\[\[([^\]]+)]]$/);
+			if (!match) return null;
+			const normalizedTable = normalizeKeyPath(match[1] ?? "");
+			if (!normalizedTable) return null;
+			const list = ensureArrayContainer(result, normalizedTable);
+			const newEntry = {};
+			list.push(newEntry);
+			tableTarget = newEntry;
+			tablePrefix = normalizedTable;
+			tablePrefixInList = true;
+			continue;
+		}
+		const tableMatch = trimmedLine.match(/^\[([^\]]+)]$/);
+		if (tableMatch) {
+			const normalizedTable = normalizeKeyPath(tableMatch[1] ?? "");
+			if (!normalizedTable) return null;
+			tablePrefix = normalizedTable;
+			tablePrefixInList = false;
+			tableTarget = null;
+			continue;
+		}
+		const lineForParsing = /("""|''')/.test(rawLine) ? rawLine : stripInlineComment(rawLine);
+		const separatorIndex = lineForParsing.indexOf("=");
+		if (separatorIndex === -1) return null;
+		const key = normalizeKeyPath(lineForParsing.slice(0, separatorIndex));
+		let valueRaw = lineForParsing.slice(separatorIndex + 1).trim();
+		if (!key) return null;
+		const tripleDelimiter = valueRaw.startsWith("\"\"\"") ? "\"\"\"" : valueRaw.startsWith("'''") ? "'''" : null;
+		if (tripleDelimiter) {
+			const closingIndex = valueRaw.indexOf(tripleDelimiter, tripleDelimiter.length);
+			if (closingIndex !== -1) {
+				const strippedAfter = stripInlineComment(valueRaw.slice(closingIndex + tripleDelimiter.length));
+				valueRaw = `${valueRaw.slice(0, closingIndex + tripleDelimiter.length)}${strippedAfter}`;
+			} else {
+				const delimiter = tripleDelimiter;
+				let combined = valueRaw;
+				let closed = false;
+				while (index + 1 < lines.length) {
+					index += 1;
+					const nextLine = lines[index] ?? "";
+					combined += `\n${nextLine}`;
+					if (new RegExp(`${delimiter}\\s*$`).test(nextLine)) {
+						closed = true;
+						break;
+					}
 				}
-				writeTTYLine(line);
-				return;
+				if (!closed) return null;
+				valueRaw = combined;
 			}
-			lastLineLength = line.length;
-			options.stream.write(`${line}\n`);
-		},
-		finish() {
-			if (!active) return;
-			if (isTTY) if (clearOnFinish) clearLine();
-			else options.stream.write("\n");
-			active = false;
 		}
-	};
+		const normalized = normalizeValue(valueRaw);
+		if (normalized === null) return null;
+		const fullKey = tablePrefix ? `${tablePrefix}.${key}` : key;
+		if (typeof normalized === "object" && !Array.isArray(normalized)) {
+			for (const [inlineKey, inlineValue] of Object.entries(normalized)) {
+				const entryKey = tablePrefixInList ? `${key}.${inlineKey}` : `${fullKey}.${inlineKey}`;
+				if (tablePrefixInList && tableTarget) tableTarget[entryKey] = toPlainText(inlineValue);
+				else result[entryKey] = toPlainText(inlineValue);
+			}
+			continue;
+		}
+		if (tablePrefixInList && tableTarget) {
+			tableTarget[key] = toPlainText(normalized);
+			continue;
+		}
+		result[fullKey] = toPlainText(normalized);
+	}
+	flattenArrayTables(result);
+	return result;
 }
 
 //#endregion
-//#region src/markdown/toml/arrays.ts
-function ensureArrayContainer(result, key) {
-	const existing = result[key];
-	if (Array.isArray(existing)) return existing;
-	const list = [];
-	result[key] = list;
-	return list;
+//#region src/markdown/parse-markdown.ts
+const FENCE_TO_TYPE = {
+	"---": "yaml",
+	"+++": "toml",
+	";;;": "json"
+};
+function normalizeNewlines(input) {
+	return input.replace(/\r\n/g, "\n");
 }
-function flattenArrayTables(result) {
-	for (const [key, value] of Object.entries(result)) {
-		if (!Array.isArray(value)) continue;
-		result[key] = value.map((entry) => Object.entries(entry).map(([entryKey, entryValue]) => `${entryKey}=${entryValue}`).join(", ")).join(" | ");
-	}
+function stripBom(line) {
+	return line.startsWith("") ? line.slice(1) : line;
 }
-
-//#endregion
-//#region src/markdown/toml/keys.ts
-function stripKeyQuotes(key) {
-	const trimmed = key.trim();
-	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
-	return trimmed;
+function getFenceType(line) {
+	const match = line.match(/^[\t ]*(---|\+\+\+|;;;)[\t ]*$/);
+	if (!match) return null;
+	return FENCE_TO_TYPE[match[1] ?? ""] ?? null;
 }
-function normalizeKeyPath(key) {
-	const trimmed = key.trim();
-	if (!trimmed) return null;
-	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-		const unquoted = stripKeyQuotes(trimmed);
-		return unquoted ? unquoted : null;
+function parseFrontmatter(frontmatter, type) {
+	if (!type) return null;
+	if (type === "json") try {
+		return JSON.parse(frontmatter);
+	} catch {
+		return null;
 	}
-	const segments = trimmed.split(".").map((segment) => segment.trim());
-	if (segments.some((segment) => !segment)) return null;
-	return segments.join(".");
+	if (type === "yaml") {
+		const doc = parseDocument(frontmatter, { prettyErrors: false });
+		if (doc.errors.length > 0) return null;
+		const data = doc.toJSON();
+		if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+		return data;
+	}
+	if (type === "toml") return parseTomlFrontmatter(frontmatter);
+	return null;
 }
-
-//#endregion
-//#region src/markdown/toml/strings.ts
-function stripInlineComment(line) {
-	let inString = null;
+function extractJsonBlock(text, startIndex) {
+	let depth = 0;
+	let inString = false;
 	let escaped = false;
-	for (let i = 0; i < line.length; i += 1) {
-		const char = line[i] ?? "";
+	for (let i = startIndex; i < text.length; i += 1) {
+		const char = text[i] ?? "";
 		if (inString) {
 			if (escaped) {
 				escaped = false;
 				continue;
 			}
-			if (char === "\\" && inString === "double") {
+			if (char === "\\") {
 				escaped = true;
 				continue;
 			}
-			if (inString === "double" && char === "\"") {
-				inString = null;
-				continue;
-			}
-			if (inString === "single" && char === "'") {
-				inString = null;
-				continue;
-			}
+			if (char === "\"") inString = false;
 			continue;
 		}
 		if (char === "\"") {
-			inString = "double";
+			inString = true;
 			continue;
 		}
-		if (char === "'") {
-			inString = "single";
+		if (char === "{") {
+			depth += 1;
 			continue;
 		}
-		if (char === "#") return line.slice(0, i).trimEnd();
+		if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return {
+				jsonText: text.slice(startIndex, i + 1),
+				endIndex: i
+			};
+		}
 	}
-	return line;
-}
-function unescapeBasic(input) {
-	return input.replace(/\\\\/g, "\\").replace(/\\"/g, "\"").replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
-}
-function parseStringLiteral(value) {
-	if (value.startsWith("\"\"\"") && value.endsWith("\"\"\"")) return unescapeBasic(value.slice(3, -3));
-	if (value.startsWith("'''") && value.endsWith("'''")) return value.slice(3, -3);
-	if (value.startsWith("\"") && value.endsWith("\"")) return unescapeBasic(value.slice(1, -1));
-	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return null;
 }
-
-//#endregion
-//#region src/markdown/toml/values.ts
-function parsePrimitive(raw) {
-	const value = raw.trim();
-	if (!value) return null;
-	const stringLiteral = parseStringLiteral(value);
-	if (stringLiteral !== null) return stringLiteral;
-	if (value === "true") return true;
-	if (value === "false") return false;
-	if (/^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)) return Number(value);
-	if (/^\d{4}-\d{2}-\d{2}/.test(value)) return value;
-	return value;
-}
-function parseArray(raw) {
-	const value = raw.trim();
-	if (!value.startsWith("[") || !value.endsWith("]")) return null;
-	const inner = value.slice(1, -1).trim();
-	if (!inner) return [];
-	const items = [];
-	let current = "";
-	let inString = null;
-	let escaped = false;
-	for (let i = 0; i < inner.length; i += 1) {
-		const char = inner[i] ?? "";
-		if (inString) {
-			current += char;
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\" && inString === "double") {
-				escaped = true;
-				continue;
-			}
-			if (inString === "double" && char === "\"") inString = null;
-			else if (inString === "single" && char === "'") inString = null;
-			continue;
-		}
-		if (char === "\"") {
-			inString = "double";
-			current += char;
-			continue;
-		}
-		if (char === "'") {
-			inString = "single";
-			current += char;
-			continue;
-		}
-		if (char === ",") {
-			const item = parsePrimitive(current);
-			if (item === null) return null;
-			items.push(item);
-			current = "";
-			continue;
-		}
-		current += char;
+function parseMarkdown(input) {
+	const normalized = normalizeNewlines(input);
+	const lines = normalized.split("\n");
+	if (lines.length === 0) return {
+		frontmatter: null,
+		content: normalized,
+		data: null,
+		frontmatterType: null
+	};
+	lines[0] = stripBom(lines[0] ?? "");
+	const normalizedWithoutBom = lines.join("\n");
+	const openingType = getFenceType(lines[0] ?? "");
+	if (!openingType) {
+		const jsonStart = (normalizedWithoutBom.match(/^[\t \n]*/)?.[0] ?? "").length;
+		if (normalizedWithoutBom[jsonStart] !== "{") return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		const jsonBlock = extractJsonBlock(normalizedWithoutBom, jsonStart);
+		if (!jsonBlock) return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		const frontmatter = jsonBlock.jsonText;
+		let content = normalizedWithoutBom.slice(jsonBlock.endIndex + 1);
+		if (content.startsWith("\n")) content = content.slice(1);
+		const data = parseFrontmatter(frontmatter, "json");
+		if (!data) return {
+			frontmatter: null,
+			content: normalizedWithoutBom,
+			data: null,
+			frontmatterType: null
+		};
+		return {
+			frontmatter,
+			content,
+			data,
+			frontmatterType: "json"
+		};
 	}
-	const finalItem = parsePrimitive(current);
-	if (finalItem === null) return null;
-	items.push(finalItem);
-	return items;
+	let closingIndex = -1;
+	for (let i = 1; i < lines.length; i += 1) if (getFenceType(lines[i] ?? "") === openingType) {
+		closingIndex = i;
+		break;
+	}
+	if (closingIndex === -1) return {
+		frontmatter: null,
+		content: normalizedWithoutBom,
+		data: null,
+		frontmatterType: null
+	};
+	const frontmatter = lines.slice(1, closingIndex).join("\n");
+	return {
+		frontmatter,
+		content: lines.slice(closingIndex + 1).join("\n"),
+		data: parseFrontmatter(frontmatter, openingType),
+		frontmatterType: openingType
+	};
 }
-function parseInlineTable(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
-	const inner = trimmed.slice(1, -1).trim();
-	if (!inner) return {};
-	const pairs = [];
-	let current = "";
-	let inString = null;
-	let escaped = false;
-	let bracketDepth = 0;
-	let braceDepth = 0;
-	for (let i = 0; i < inner.length; i += 1) {
-		const char = inner[i] ?? "";
-		if (inString) {
-			current += char;
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\" && inString === "double") {
-				escaped = true;
-				continue;
-			}
-			if (inString === "double" && char === "\"") inString = null;
-			else if (inString === "single" && char === "'") inString = null;
-			continue;
-		}
-		if (char === "\"") {
-			inString = "double";
-			current += char;
-			continue;
-		}
-		if (char === "'") {
-			inString = "single";
-			current += char;
-			continue;
-		}
-		if (char === "[") {
-			bracketDepth += 1;
-			current += char;
-			continue;
+
+//#endregion
+//#region src/wc/segmenter.ts
+const segmenterCache = /* @__PURE__ */ new Map();
+const graphemeSegmenterCache = /* @__PURE__ */ new Map();
+function getSegmenter(locale) {
+	const cached = segmenterCache.get(locale);
+	if (cached) return cached;
+	const segmenter = new Intl.Segmenter(locale, { granularity: "word" });
+	segmenterCache.set(locale, segmenter);
+	return segmenter;
+}
+function getGraphemeSegmenter(locale) {
+	const cached = graphemeSegmenterCache.get(locale);
+	if (cached) return cached;
+	const segmenter = new Intl.Segmenter(locale, { granularity: "grapheme" });
+	graphemeSegmenterCache.set(locale, segmenter);
+	return segmenter;
+}
+function supportsSegmenter() {
+	return typeof Intl !== "undefined" && typeof Intl.Segmenter === "function";
+}
+function countCharsForLocale(text, locale) {
+	if (!supportsSegmenter()) return Array.from(text).length;
+	const segmenter = getGraphemeSegmenter(locale);
+	let count = 0;
+	for (const _segment of segmenter.segment(text)) count++;
+	return count;
+}
+
+//#endregion
+//#region src/wc/non-words.ts
+const emojiRegex = /(?:\p{Extended_Pictographic}|\p{Emoji_Presentation})/u;
+const emojiPresentationRegex = /\p{Emoji_Presentation}/u;
+const keycapEmojiRegex = /[0-9#*]\uFE0F?\u20E3/u;
+const symbolRegex = /\p{S}/u;
+const punctuationRegex = /\p{P}/u;
+const whitespaceRegex = /\s/u;
+const newlineChars = new Set([
+	"\n",
+	"\r",
+	"\u2028",
+	"\u2029"
+]);
+function createNonWordCollection() {
+	return {
+		emoji: [],
+		symbols: [],
+		punctuation: [],
+		counts: {
+			emoji: 0,
+			symbols: 0,
+			punctuation: 0
 		}
-		if (char === "]") {
-			if (bracketDepth > 0) bracketDepth -= 1;
-			current += char;
+	};
+}
+function addNonWord(collection, category, segment) {
+	if (category === "emoji") {
+		collection.emoji.push(segment);
+		collection.counts.emoji += 1;
+		return;
+	}
+	if (category === "symbol") {
+		collection.symbols.push(segment);
+		collection.counts.symbols += 1;
+		return;
+	}
+	collection.punctuation.push(segment);
+	collection.counts.punctuation += 1;
+}
+function addWhitespace(collection, segment) {
+	let whitespace = collection.whitespace;
+	let count = 0;
+	for (const char of segment) {
+		if (char === " ") {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.spaces += 1;
+			count += 1;
 			continue;
 		}
-		if (char === "{") {
-			braceDepth += 1;
-			current += char;
+		if (char === "	") {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.tabs += 1;
+			count += 1;
 			continue;
 		}
-		if (char === "}") {
-			if (braceDepth > 0) braceDepth -= 1;
-			current += char;
+		if (newlineChars.has(char)) {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.newlines += 1;
+			count += 1;
 			continue;
 		}
-		if (char === "," && bracketDepth === 0 && braceDepth === 0) {
-			pairs.push(current);
-			current = "";
-			continue;
+		if (whitespaceRegex.test(char)) {
+			whitespace = whitespace ?? createWhitespaceCounts();
+			whitespace.other += 1;
+			count += 1;
 		}
-		current += char;
 	}
-	if (current.trim()) pairs.push(current);
-	const output = {};
-	for (const pair of pairs) {
-		const separatorIndex = pair.indexOf("=");
-		if (separatorIndex === -1) return null;
-		const key = normalizeKeyPath(pair.slice(0, separatorIndex));
-		if (!key) return null;
-		const valueRaw = pair.slice(separatorIndex + 1).trim();
-		if (!valueRaw) return null;
-		if (valueRaw.startsWith("{")) return null;
-		const normalized = normalizeValue(valueRaw);
-		if (normalized === null) return null;
-		if (typeof normalized === "object" && !Array.isArray(normalized)) return null;
-		output[key] = normalized;
+	if (count > 0) {
+		collection.whitespace = whitespace ?? createWhitespaceCounts();
+		collection.counts.whitespace = (collection.counts.whitespace ?? 0) + count;
 	}
-	return output;
+	return count;
 }
-function normalizeValue(value) {
-	if (!value) return null;
-	const trimmed = value.trim();
-	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return parseInlineTable(trimmed);
-	const array = parseArray(trimmed);
-	if (array) return array;
-	if (trimmed.startsWith("[") && trimmed.endsWith("]")) return null;
-	return parsePrimitive(trimmed);
+function classifyNonWordSegment(segment) {
+	const hasEmojiVariationSelector = segment.includes("️");
+	if (keycapEmojiRegex.test(segment) || emojiPresentationRegex.test(segment) || hasEmojiVariationSelector && emojiRegex.test(segment)) return "emoji";
+	if (symbolRegex.test(segment)) return "symbol";
+	if (punctuationRegex.test(segment)) return "punctuation";
+	return null;
 }
-function toPlainText(value) {
-	if (value == null) return "";
-	if (Array.isArray(value)) return value.map((item) => String(item)).join(", ");
-	return String(value);
+function mergeNonWordCollections(target, source) {
+	if (source.counts.emoji > 0) {
+		appendAll(target.emoji, source.emoji);
+		target.counts.emoji += source.counts.emoji;
+	}
+	if (source.counts.symbols > 0) {
+		appendAll(target.symbols, source.symbols);
+		target.counts.symbols += source.counts.symbols;
+	}
+	if (source.counts.punctuation > 0) {
+		appendAll(target.punctuation, source.punctuation);
+		target.counts.punctuation += source.counts.punctuation;
+	}
+	if (source.counts.whitespace && source.counts.whitespace > 0 && source.whitespace) {
+		const whitespace = target.whitespace ?? createWhitespaceCounts();
+		whitespace.spaces += source.whitespace.spaces;
+		whitespace.tabs += source.whitespace.tabs;
+		whitespace.newlines += source.whitespace.newlines;
+		whitespace.other += source.whitespace.other;
+		target.whitespace = whitespace;
+		target.counts.whitespace = (target.counts.whitespace ?? 0) + source.counts.whitespace;
+	}
+	return target;
+}
+function createWhitespaceCounts() {
+	return {
+		spaces: 0,
+		tabs: 0,
+		newlines: 0,
+		other: 0
+	};
 }
 
 //#endregion
-//#region src/markdown/toml/parse-frontmatter.ts
-function parseTomlFrontmatter(frontmatter) {
-	const result = {};
-	const lines = frontmatter.split("\n");
-	let tablePrefix = "";
-	let tableTarget = null;
-	let tablePrefixInList = false;
-	for (let index = 0; index < lines.length; index += 1) {
-		const rawLine = lines[index] ?? "";
-		const trimmedLine = rawLine.trim();
-		if (!trimmedLine || trimmedLine.startsWith("#")) continue;
-		if (trimmedLine.startsWith("[[")) {
-			const match = trimmedLine.match(/^\[\[([^\]]+)]]$/);
-			if (!match) return null;
-			const normalizedTable = normalizeKeyPath(match[1] ?? "");
-			if (!normalizedTable) return null;
-			const list = ensureArrayContainer(result, normalizedTable);
-			const newEntry = {};
-			list.push(newEntry);
-			tableTarget = newEntry;
-			tablePrefix = normalizedTable;
-			tablePrefixInList = true;
-			continue;
-		}
-		const tableMatch = trimmedLine.match(/^\[([^\]]+)]$/);
-		if (tableMatch) {
-			const normalizedTable = normalizeKeyPath(tableMatch[1] ?? "");
-			if (!normalizedTable) return null;
-			tablePrefix = normalizedTable;
-			tablePrefixInList = false;
-			tableTarget = null;
+//#region src/wc/analyze.ts
+function analyzeChunk(chunk, collectNonWords, includeWhitespace) {
+	const segmenter = getSegmenter(chunk.locale);
+	const segments = [];
+	const nonWords = collectNonWords ? createNonWordCollection() : null;
+	for (const part of segmenter.segment(chunk.text)) if (part.isWordLike) segments.push(part.segment);
+	else if (collectNonWords && nonWords) {
+		if (includeWhitespace) addWhitespace(nonWords, part.segment);
+		const category = classifyNonWordSegment(part.segment);
+		if (category) addNonWord(nonWords, category, part.segment);
+	}
+	return {
+		locale: chunk.locale,
+		text: chunk.text,
+		segments,
+		words: segments.length,
+		nonWords: nonWords ?? void 0
+	};
+}
+function analyzeCharChunk(chunk, collectNonWords, includeWhitespace) {
+	const segmenter = getSegmenter(chunk.locale);
+	const nonWords = collectNonWords ? createNonWordCollection() : null;
+	let chars = 0;
+	let wordChars = 0;
+	let nonWordChars = 0;
+	for (const part of segmenter.segment(chunk.text)) {
+		if (part.isWordLike) {
+			const count = countCharsForLocale(part.segment, chunk.locale);
+			chars += count;
+			wordChars += count;
 			continue;
 		}
-		const lineForParsing = /("""|''')/.test(rawLine) ? rawLine : stripInlineComment(rawLine);
-		const separatorIndex = lineForParsing.indexOf("=");
-		if (separatorIndex === -1) return null;
-		const key = normalizeKeyPath(lineForParsing.slice(0, separatorIndex));
-		let valueRaw = lineForParsing.slice(separatorIndex + 1).trim();
-		if (!key) return null;
-		const tripleDelimiter = valueRaw.startsWith("\"\"\"") ? "\"\"\"" : valueRaw.startsWith("'''") ? "'''" : null;
-		if (tripleDelimiter) {
-			const closingIndex = valueRaw.indexOf(tripleDelimiter, tripleDelimiter.length);
-			if (closingIndex !== -1) {
-				const strippedAfter = stripInlineComment(valueRaw.slice(closingIndex + tripleDelimiter.length));
-				valueRaw = `${valueRaw.slice(0, closingIndex + tripleDelimiter.length)}${strippedAfter}`;
-			} else {
-				const delimiter = tripleDelimiter;
-				let combined = valueRaw;
-				let closed = false;
-				while (index + 1 < lines.length) {
-					index += 1;
-					const nextLine = lines[index] ?? "";
-					combined += `\n${nextLine}`;
-					if (new RegExp(`${delimiter}\\s*$`).test(nextLine)) {
-						closed = true;
-						break;
-					}
-				}
-				if (!closed) return null;
-				valueRaw = combined;
+		if (collectNonWords && nonWords) {
+			let whitespaceCount = 0;
+			if (includeWhitespace) whitespaceCount = addWhitespace(nonWords, part.segment);
+			const category = classifyNonWordSegment(part.segment);
+			if (category) addNonWord(nonWords, category, part.segment);
+			if (category || whitespaceCount > 0) {
+				const count = countCharsForLocale(part.segment, chunk.locale);
+				chars += count;
+				nonWordChars += count;
 			}
 		}
-		const normalized = normalizeValue(valueRaw);
-		if (normalized === null) return null;
-		const fullKey = tablePrefix ? `${tablePrefix}.${key}` : key;
-		if (typeof normalized === "object" && !Array.isArray(normalized)) {
-			for (const [inlineKey, inlineValue] of Object.entries(normalized)) {
-				const entryKey = tablePrefixInList ? `${key}.${inlineKey}` : `${fullKey}.${inlineKey}`;
-				if (tablePrefixInList && tableTarget) tableTarget[entryKey] = toPlainText(inlineValue);
-				else result[entryKey] = toPlainText(inlineValue);
+	}
+	return {
+		locale: chunk.locale,
+		text: chunk.text,
+		chars,
+		wordChars,
+		nonWordChars,
+		nonWords: nonWords ?? void 0
+	};
+}
+function aggregateCharsByLocale(chunks) {
+	const order = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const existing = map.get(chunk.locale);
+		if (existing) {
+			existing.chars += chunk.chars;
+			existing.wordChars += chunk.wordChars;
+			existing.nonWordChars += chunk.nonWordChars;
+			if (chunk.nonWords) {
+				if (!existing.nonWords) existing.nonWords = createNonWordCollection();
+				mergeNonWordCollections(existing.nonWords, chunk.nonWords);
 			}
 			continue;
 		}
-		if (tablePrefixInList && tableTarget) {
-			tableTarget[key] = toPlainText(normalized);
+		order.push(chunk.locale);
+		map.set(chunk.locale, {
+			locale: chunk.locale,
+			chars: chunk.chars,
+			wordChars: chunk.wordChars,
+			nonWordChars: chunk.nonWordChars,
+			nonWords: chunk.nonWords ? mergeNonWordCollections(createNonWordCollection(), chunk.nonWords) : void 0
+		});
+	}
+	return order.map((locale) => map.get(locale));
+}
+function aggregateByLocale(chunks) {
+	const order = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const existing = map.get(chunk.locale);
+		if (existing) {
+			existing.words += chunk.words;
+			appendAll(existing.segments, chunk.segments);
 			continue;
 		}
-		result[fullKey] = toPlainText(normalized);
+		order.push(chunk.locale);
+		map.set(chunk.locale, {
+			locale: chunk.locale,
+			words: chunk.words,
+			segments: [...chunk.segments]
+		});
 	}
-	flattenArrayTables(result);
-	return result;
+	return order.map((locale) => map.get(locale));
 }
 
 //#endregion
-//#region src/markdown/parse-markdown.ts
-const FENCE_TO_TYPE = {
-	"---": "yaml",
-	"+++": "toml",
-	";;;": "json"
+//#region src/wc/mode.ts
+const MODE_ALIASES = {
+	chunk: "chunk",
+	chunks: "chunk",
+	segments: "segments",
+	segment: "segments",
+	seg: "segments",
+	collector: "collector",
+	collect: "collector",
+	colle: "collector",
+	char: "char",
+	chars: "char",
+	character: "char",
+	characters: "char",
+	"char-collector": "char-collector"
 };
-function normalizeNewlines(input) {
-	return input.replace(/\r\n/g, "\n");
+const CHAR_MODE_ALIASES = new Set([
+	"char",
+	"chars",
+	"character",
+	"characters"
+]);
+const COLLECTOR_MODE_ALIASES = new Set([
+	"collector",
+	"collect",
+	"colle",
+	"col"
+]);
+function collapseSeparators(value) {
+	return value.replace(/[-_\s]+/g, "");
 }
-function stripBom(line) {
-	return line.startsWith("") ? line.slice(1) : line;
+function isComposedCharCollectorFromTokens(value) {
+	const tokens = value.split(/[-_\s]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+	if (tokens.length < 2) return false;
+	let hasCharAlias = false;
+	let hasCollectorAlias = false;
+	for (const token of tokens) {
+		if (CHAR_MODE_ALIASES.has(token)) {
+			hasCharAlias = true;
+			continue;
+		}
+		if (COLLECTOR_MODE_ALIASES.has(token)) {
+			hasCollectorAlias = true;
+			continue;
+		}
+		return false;
+	}
+	return hasCharAlias && hasCollectorAlias;
 }
-function getFenceType(line) {
-	const match = line.match(/^[\t ]*(---|\+\+\+|;;;)[\t ]*$/);
-	if (!match) return null;
-	return FENCE_TO_TYPE[match[1] ?? ""] ?? null;
+function isComposedCharCollectorCompact(value) {
+	for (const charAlias of CHAR_MODE_ALIASES) for (const collectorAlias of COLLECTOR_MODE_ALIASES) if (value === `${charAlias}${collectorAlias}` || value === `${collectorAlias}${charAlias}`) return true;
+	return false;
 }
-function parseFrontmatter(frontmatter, type) {
-	if (!type) return null;
-	if (type === "json") try {
-		return JSON.parse(frontmatter);
-	} catch {
-		return null;
-	}
-	if (type === "yaml") {
-		const doc = parseDocument(frontmatter, { prettyErrors: false });
-		if (doc.errors.length > 0) return null;
-		const data = doc.toJSON();
-		if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-		return data;
-	}
-	if (type === "toml") return parseTomlFrontmatter(frontmatter);
-	return null;
+function normalizeMode(input) {
+	if (!input) return null;
+	const normalized = input.trim().toLowerCase();
+	const direct = MODE_ALIASES[normalized];
+	if (direct) return direct;
+	if (isComposedCharCollectorFromTokens(normalized)) return "char-collector";
+	const compact = collapseSeparators(normalized);
+	if (isComposedCharCollectorCompact(compact)) return "char-collector";
+	return MODE_ALIASES[compact] ?? null;
 }
-function extractJsonBlock(text, startIndex) {
-	let depth = 0;
-	let inString = false;
-	let escaped = false;
-	for (let i = startIndex; i < text.length; i += 1) {
-		const char = text[i] ?? "";
-		if (inString) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (char === "\"") inString = false;
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			continue;
-		}
-		if (char === "{") {
-			depth += 1;
-			continue;
-		}
-		if (char === "}") {
-			depth -= 1;
-			if (depth === 0) return {
-				jsonText: text.slice(startIndex, i + 1),
-				endIndex: i
-			};
-		}
-	}
-	return null;
+function resolveMode(input, fallback = "chunk") {
+	return normalizeMode(input) ?? fallback;
 }
-function parseMarkdown(input) {
-	const normalized = normalizeNewlines(input);
-	const lines = normalized.split("\n");
-	if (lines.length === 0) return {
-		frontmatter: null,
-		content: normalized,
-		data: null,
-		frontmatterType: null
-	};
-	lines[0] = stripBom(lines[0] ?? "");
-	const normalizedWithoutBom = lines.join("\n");
-	const openingType = getFenceType(lines[0] ?? "");
-	if (!openingType) {
-		const jsonStart = (normalizedWithoutBom.match(/^[\t \n]*/)?.[0] ?? "").length;
-		if (normalizedWithoutBom[jsonStart] !== "{") return {
-			frontmatter: null,
-			content: normalizedWithoutBom,
-			data: null,
-			frontmatterType: null
-		};
-		const jsonBlock = extractJsonBlock(normalizedWithoutBom, jsonStart);
-		if (!jsonBlock) return {
-			frontmatter: null,
-			content: normalizedWithoutBom,
-			data: null,
-			frontmatterType: null
-		};
-		const frontmatter = jsonBlock.jsonText;
-		let content = normalizedWithoutBom.slice(jsonBlock.endIndex + 1);
-		if (content.startsWith("\n")) content = content.slice(1);
-		const data = parseFrontmatter(frontmatter, "json");
-		if (!data) return {
-			frontmatter: null,
-			content: normalizedWithoutBom,
-			data: null,
-			frontmatterType: null
-		};
-		return {
-			frontmatter,
-			content,
-			data,
-			frontmatterType: "json"
-		};
-	}
-	let closingIndex = -1;
-	for (let i = 1; i < lines.length; i += 1) if (getFenceType(lines[i] ?? "") === openingType) {
-		closingIndex = i;
-		break;
+
+//#endregion
+//#region src/wc/latin-hints.ts
+const DEFAULT_LATIN_HINT_RULES_SOURCE = [
+	{
+		tag: "de",
+		pattern: "[äöüÄÖÜß]"
+	},
+	{
+		tag: "es",
+		pattern: "[ñÑ¿¡]"
+	},
+	{
+		tag: "pt",
+		pattern: "[ãõÃÕ]"
+	},
+	{
+		tag: "fr",
+		pattern: "[œŒæÆ]"
+	},
+	{
+		tag: "pl",
+		pattern: "[ąćęłńśźżĄĆĘŁŃŚŹŻ]"
+	},
+	{
+		tag: "tr",
+		pattern: "[ıİğĞşŞ]"
+	},
+	{
+		tag: "ro",
+		pattern: "[ăĂâÂîÎșȘțȚ]"
+	},
+	{
+		tag: "hu",
+		pattern: "[őŐűŰ]"
+	},
+	{
+		tag: "is",
+		pattern: "[ðÐþÞ]"
 	}
-	if (closingIndex === -1) return {
-		frontmatter: null,
-		content: normalizedWithoutBom,
-		data: null,
-		frontmatterType: null
-	};
-	const frontmatter = lines.slice(1, closingIndex).join("\n");
-	return {
-		frontmatter,
-		content: lines.slice(closingIndex + 1).join("\n"),
-		data: parseFrontmatter(frontmatter, openingType),
-		frontmatterType: openingType
-	};
-}
+];
+const DEFAULT_LATIN_HINT_RULES = Object.freeze(DEFAULT_LATIN_HINT_RULES_SOURCE.map((rule) => Object.freeze({ ...rule })));
 
 //#endregion
-//#region src/wc/segmenter.ts
-const segmenterCache = /* @__PURE__ */ new Map();
-const graphemeSegmenterCache = /* @__PURE__ */ new Map();
-function getSegmenter(locale) {
-	const cached = segmenterCache.get(locale);
-	if (cached) return cached;
-	const segmenter = new Intl.Segmenter(locale, { granularity: "word" });
-	segmenterCache.set(locale, segmenter);
-	return segmenter;
+//#region src/wc/locale-detect.ts
+const DEFAULT_LOCALE = "und-Latn";
+const DEFAULT_HAN_TAG = "und-Hani";
+const MAX_LATIN_HINT_PATTERN_LENGTH = 256;
+const regex = {
+	hiragana: /\p{Script=Hiragana}/u,
+	katakana: /\p{Script=Katakana}/u,
+	hangul: /\p{Script=Hangul}/u,
+	han: /\p{Script=Han}/u,
+	latin: /\p{Script=Latin}/u,
+	arabic: /\p{Script=Arabic}/u,
+	cyrillic: /\p{Script=Cyrillic}/u,
+	devanagari: /\p{Script=Devanagari}/u,
+	thai: /\p{Script=Thai}/u
+};
+const defaultLatinLocales = new Set([DEFAULT_LOCALE, ...DEFAULT_LATIN_HINT_RULES.map((hint) => hint.tag)]);
+function isLatinLocale(locale, context) {
+	if (context) return context.latinLocales.has(locale);
+	return defaultLatinLocales.has(locale);
 }
-function getGraphemeSegmenter(locale) {
-	const cached = graphemeSegmenterCache.get(locale);
-	if (cached) return cached;
-	const segmenter = new Intl.Segmenter(locale, { granularity: "grapheme" });
-	graphemeSegmenterCache.set(locale, segmenter);
-	return segmenter;
+function resolveLatinHint(options) {
+	const latinTagHint = options.latinTagHint?.trim();
+	if (latinTagHint) return latinTagHint;
+	const latinLanguageHint = options.latinLanguageHint?.trim();
+	if (latinLanguageHint) return latinLanguageHint;
+	const latinLocaleHint = options.latinLocaleHint?.trim();
+	if (latinLocaleHint) return latinLocaleHint;
 }
-function supportsSegmenter() {
-	return typeof Intl !== "undefined" && typeof Intl.Segmenter === "function";
+function resolveHanHint(options) {
+	const hanTagHint = options.hanTagHint?.trim();
+	if (hanTagHint) return hanTagHint;
+	const hanLanguageHint = options.hanLanguageHint?.trim();
+	if (hanLanguageHint) return hanLanguageHint;
 }
-function countCharsForLocale(text, locale) {
-	if (!supportsSegmenter()) return Array.from(text).length;
-	const segmenter = getGraphemeSegmenter(locale);
-	let count = 0;
-	for (const _segment of segmenter.segment(text)) count++;
-	return count;
+function compileLatinHintPattern(pattern, label) {
+	const source = typeof pattern === "string" ? pattern : pattern.source;
+	const hasUnicodeMode = typeof pattern !== "string" && (pattern.flags.includes("u") || pattern.flags.includes("v"));
+	const flags = typeof pattern === "string" ? "u" : hasUnicodeMode ? pattern.flags : `${pattern.flags}u`;
+	if (source.length === 0) throw new Error(`${label}: pattern must not be empty.`);
+	if (source.length > MAX_LATIN_HINT_PATTERN_LENGTH) throw new Error(`${label}: pattern must be at most ${MAX_LATIN_HINT_PATTERN_LENGTH} characters.`);
+	try {
+		return new RegExp(source, flags);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`${label}: invalid Unicode regex pattern (${message}).`);
+	}
 }
-
-//#endregion
-//#region src/wc/non-words.ts
-const emojiRegex = /(?:\p{Extended_Pictographic}|\p{Emoji_Presentation})/u;
-const emojiPresentationRegex = /\p{Emoji_Presentation}/u;
-const keycapEmojiRegex = /[0-9#*]\uFE0F?\u20E3/u;
-const symbolRegex = /\p{S}/u;
-const punctuationRegex = /\p{P}/u;
-const whitespaceRegex = /\s/u;
-const newlineChars = new Set([
-	"\n",
-	"\r",
-	"\u2028",
-	"\u2029"
-]);
-function createNonWordCollection() {
+function normalizeLatinHintPriority(priority, label) {
+	if (priority === void 0) return 0;
+	if (typeof priority !== "number" || !Number.isFinite(priority)) throw new Error(`${label}: priority must be a finite number when provided.`);
+	return priority;
+}
+function compileLatinHintRule(rule, order, label) {
+	const tag = typeof rule.tag === "string" ? rule.tag.trim() : "";
+	if (!tag) throw new Error(`${label}: tag must be a non-empty string.`);
 	return {
-		emoji: [],
-		symbols: [],
-		punctuation: [],
-		counts: {
-			emoji: 0,
-			symbols: 0,
-			punctuation: 0
-		}
+		tag,
+		pattern: compileLatinHintPattern(rule.pattern, label),
+		priority: normalizeLatinHintPriority(rule.priority, label),
+		order
 	};
 }
-function addNonWord(collection, category, segment) {
-	if (category === "emoji") {
-		collection.emoji.push(segment);
-		collection.counts.emoji += 1;
-		return;
-	}
-	if (category === "symbol") {
-		collection.symbols.push(segment);
-		collection.counts.symbols += 1;
-		return;
-	}
-	collection.punctuation.push(segment);
-	collection.counts.punctuation += 1;
-}
-function addWhitespace(collection, segment) {
-	let whitespace = collection.whitespace;
-	let count = 0;
-	for (const char of segment) {
-		if (char === " ") {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.spaces += 1;
-			count += 1;
-			continue;
-		}
-		if (char === "	") {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.tabs += 1;
-			count += 1;
-			continue;
-		}
-		if (newlineChars.has(char)) {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.newlines += 1;
-			count += 1;
-			continue;
-		}
-		if (whitespaceRegex.test(char)) {
-			whitespace = whitespace ?? createWhitespaceCounts();
-			whitespace.other += 1;
-			count += 1;
-		}
+function resolveLatinHintRules$1(options) {
+	const useDefaultLatinHints = options.useDefaultLatinHints !== false;
+	const customRules = options.latinHintRules ?? [];
+	const combinedRules = [];
+	for (let index = 0; index < customRules.length; index += 1) {
+		const rule = customRules[index];
+		if (!rule) continue;
+		combinedRules.push({
+			rule,
+			label: `Invalid custom Latin hint rule at index ${index}`
+		});
 	}
-	if (count > 0) {
-		collection.whitespace = whitespace ?? createWhitespaceCounts();
-		collection.counts.whitespace = (collection.counts.whitespace ?? 0) + count;
+	if (useDefaultLatinHints) for (let index = 0; index < DEFAULT_LATIN_HINT_RULES.length; index += 1) {
+		const rule = DEFAULT_LATIN_HINT_RULES[index];
+		if (!rule) continue;
+		combinedRules.push({
+			rule,
+			label: `Invalid default Latin hint rule at index ${index}`
+		});
 	}
-	return count;
+	const resolvedRules = combinedRules.map((entry, index) => compileLatinHintRule(entry.rule, index, entry.label));
+	resolvedRules.sort((left, right) => {
+		if (left.priority !== right.priority) return right.priority - left.priority;
+		return left.order - right.order;
+	});
+	return resolvedRules;
 }
-function classifyNonWordSegment(segment) {
-	const hasEmojiVariationSelector = segment.includes("️");
-	if (keycapEmojiRegex.test(segment) || emojiPresentationRegex.test(segment) || hasEmojiVariationSelector && emojiRegex.test(segment)) return "emoji";
-	if (symbolRegex.test(segment)) return "symbol";
-	if (punctuationRegex.test(segment)) return "punctuation";
-	return null;
+function resolveLocaleDetectContext(options = {}) {
+	const latinHint = resolveLatinHint(options);
+	const latinHintRules = resolveLatinHintRules$1(options);
+	const latinLocales = new Set([DEFAULT_LOCALE]);
+	for (const rule of latinHintRules) latinLocales.add(rule.tag);
+	if (latinHint) latinLocales.add(latinHint);
+	return {
+		latinHint,
+		hanHint: resolveHanHint(options),
+		latinHintRules,
+		latinLocales
+	};
 }
-function mergeNonWordCollections(target, source) {
-	if (source.counts.emoji > 0) {
-		appendAll(target.emoji, source.emoji);
-		target.counts.emoji += source.counts.emoji;
-	}
-	if (source.counts.symbols > 0) {
-		appendAll(target.symbols, source.symbols);
-		target.counts.symbols += source.counts.symbols;
+function detectLatinLocale(char, context) {
+	for (const hint of context.latinHintRules) {
+		hint.pattern.lastIndex = 0;
+		if (hint.pattern.test(char)) return hint.tag;
 	}
-	if (source.counts.punctuation > 0) {
-		appendAll(target.punctuation, source.punctuation);
-		target.counts.punctuation += source.counts.punctuation;
+	return DEFAULT_LOCALE;
+}
+function detectLocaleForChar(char, previousLocale, options = {}, context = resolveLocaleDetectContext(options), allowLatinLocaleCarry = true, allowJapaneseHanCarry = true) {
+	if (regex.hiragana.test(char) || regex.katakana.test(char)) return "ja";
+	if (regex.hangul.test(char)) return "ko";
+	if (regex.arabic.test(char)) return "ar";
+	if (regex.cyrillic.test(char)) return "ru";
+	if (regex.devanagari.test(char)) return "hi";
+	if (regex.thai.test(char)) return "th";
+	if (regex.han.test(char)) {
+		if (allowJapaneseHanCarry && previousLocale && previousLocale.startsWith("ja")) return previousLocale;
+		return context.hanHint ?? DEFAULT_HAN_TAG;
 	}
-	if (source.counts.whitespace && source.counts.whitespace > 0 && source.whitespace) {
-		const whitespace = target.whitespace ?? createWhitespaceCounts();
-		whitespace.spaces += source.whitespace.spaces;
-		whitespace.tabs += source.whitespace.tabs;
-		whitespace.newlines += source.whitespace.newlines;
-		whitespace.other += source.whitespace.other;
-		target.whitespace = whitespace;
-		target.counts.whitespace = (target.counts.whitespace ?? 0) + source.counts.whitespace;
+	if (regex.latin.test(char)) {
+		const hintedLocale = detectLatinLocale(char, context);
+		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
+		if (allowLatinLocaleCarry && previousLocale && isLatinLocale(previousLocale, context) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
+		if (context.latinHint) return context.latinHint;
+		return DEFAULT_LOCALE;
 	}
-	return target;
-}
-function createWhitespaceCounts() {
-	return {
-		spaces: 0,
-		tabs: 0,
-		newlines: 0,
-		other: 0
-	};
+	return null;
 }
 
 //#endregion
-//#region src/wc/analyze.ts
-function analyzeChunk(chunk, collectNonWords, includeWhitespace) {
-	const segmenter = getSegmenter(chunk.locale);
-	const segments = [];
-	const nonWords = collectNonWords ? createNonWordCollection() : null;
-	for (const part of segmenter.segment(chunk.text)) if (part.isWordLike) segments.push(part.segment);
-	else if (collectNonWords && nonWords) {
-		if (includeWhitespace) addWhitespace(nonWords, part.segment);
-		const category = classifyNonWordSegment(part.segment);
-		if (category) addNonWord(nonWords, category, part.segment);
-	}
-	return {
-		locale: chunk.locale,
-		text: chunk.text,
-		segments,
-		words: segments.length,
-		nonWords: nonWords ?? void 0
+//#region src/wc/segment.ts
+const HARD_BOUNDARY_REGEX = /[\r\n,.!?;:，、。！？；：．｡､]/u;
+const LATIN_PROMOTION_BREAK_REGEX = /[\s,.!?;:，、。！？；：．｡､]/u;
+function segmentTextByLocale(text, options = {}) {
+	const context = resolveLocaleDetectContext(options);
+	const chunks = [];
+	let currentLocale = DEFAULT_LOCALE;
+	let buffer = "";
+	let bufferHasScript = false;
+	let sawCarryBoundary = false;
+	const updateCarryBoundaryState = (detected, char) => {
+		if (detected !== null) {
+			sawCarryBoundary = false;
+			return;
+		}
+		if (HARD_BOUNDARY_REGEX.test(char)) sawCarryBoundary = true;
 	};
-}
-function analyzeCharChunk(chunk, collectNonWords, includeWhitespace) {
-	const segmenter = getSegmenter(chunk.locale);
-	const nonWords = collectNonWords ? createNonWordCollection() : null;
-	let chars = 0;
-	let wordChars = 0;
-	let nonWordChars = 0;
-	for (const part of segmenter.segment(chunk.text)) {
-		if (part.isWordLike) {
-			const count = countCharsForLocale(part.segment, chunk.locale);
-			chars += count;
-			wordChars += count;
+	for (const char of text) {
+		const detected = detectLocaleForChar(char, currentLocale, options, context, !sawCarryBoundary, !sawCarryBoundary);
+		const targetLocale = detected ?? currentLocale;
+		if (buffer === "") {
+			currentLocale = targetLocale;
+			buffer = char;
+			bufferHasScript = detected !== null;
+			updateCarryBoundaryState(detected, char);
 			continue;
 		}
-		if (collectNonWords && nonWords) {
-			let whitespaceCount = 0;
-			if (includeWhitespace) whitespaceCount = addWhitespace(nonWords, part.segment);
-			const category = classifyNonWordSegment(part.segment);
-			if (category) addNonWord(nonWords, category, part.segment);
-			if (category || whitespaceCount > 0) {
-				const count = countCharsForLocale(part.segment, chunk.locale);
-				chars += count;
-				nonWordChars += count;
+		if (detected !== null && !bufferHasScript) {
+			currentLocale = targetLocale;
+			buffer += char;
+			bufferHasScript = true;
+			updateCarryBoundaryState(detected, char);
+			continue;
+		}
+		if (targetLocale !== currentLocale && detected !== null) {
+			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale, context)) {
+				const promotionBreakIndex = findLastLatinPromotionBreakIndex(buffer);
+				if (promotionBreakIndex === -1) {
+					currentLocale = targetLocale;
+					buffer += char;
+					bufferHasScript = true;
+					updateCarryBoundaryState(detected, char);
+					continue;
+				}
+				const prefix = buffer.slice(0, promotionBreakIndex + 1);
+				const suffix = buffer.slice(promotionBreakIndex + 1);
+				if (prefix.length > 0) chunks.push({
+					locale: currentLocale,
+					text: prefix
+				});
+				currentLocale = targetLocale;
+				buffer = `${suffix}${char}`;
+				bufferHasScript = true;
+				updateCarryBoundaryState(detected, char);
+				continue;
 			}
+			chunks.push({
+				locale: currentLocale,
+				text: buffer
+			});
+			currentLocale = targetLocale;
+			buffer = char;
+			bufferHasScript = true;
+			updateCarryBoundaryState(detected, char);
+			continue;
 		}
+		buffer += char;
+		if (detected !== null) bufferHasScript = true;
+		updateCarryBoundaryState(detected, char);
 	}
-	return {
-		locale: chunk.locale,
-		text: chunk.text,
-		chars,
-		wordChars,
-		nonWordChars,
-		nonWords: nonWords ?? void 0
-	};
+	if (buffer.length > 0) chunks.push({
+		locale: currentLocale,
+		text: buffer
+	});
+	return mergeAdjacentChunks(chunks);
 }
-function aggregateCharsByLocale(chunks) {
-	const order = [];
-	const map = /* @__PURE__ */ new Map();
-	for (const chunk of chunks) {
-		const existing = map.get(chunk.locale);
-		if (existing) {
-			existing.chars += chunk.chars;
-			existing.wordChars += chunk.wordChars;
-			existing.nonWordChars += chunk.nonWordChars;
-			if (chunk.nonWords) {
-				if (!existing.nonWords) existing.nonWords = createNonWordCollection();
-				mergeNonWordCollections(existing.nonWords, chunk.nonWords);
-			}
-			continue;
-		}
-		order.push(chunk.locale);
-		map.set(chunk.locale, {
-			locale: chunk.locale,
-			chars: chunk.chars,
-			wordChars: chunk.wordChars,
-			nonWordChars: chunk.nonWordChars,
-			nonWords: chunk.nonWords ? mergeNonWordCollections(createNonWordCollection(), chunk.nonWords) : void 0
-		});
+function findLastLatinPromotionBreakIndex(buffer) {
+	for (let index = buffer.length - 1; index >= 0; index -= 1) {
+		const char = buffer[index];
+		if (!char) continue;
+		if (LATIN_PROMOTION_BREAK_REGEX.test(char)) return index;
 	}
-	return order.map((locale) => map.get(locale));
+	return -1;
 }
-function aggregateByLocale(chunks) {
-	const order = [];
-	const map = /* @__PURE__ */ new Map();
-	for (const chunk of chunks) {
-		const existing = map.get(chunk.locale);
-		if (existing) {
-			existing.words += chunk.words;
-			appendAll(existing.segments, chunk.segments);
-			continue;
+function mergeAdjacentChunks(chunks) {
+	if (chunks.length === 0) return chunks;
+	const merged = [];
+	let last = chunks[0];
+	for (let i = 1; i < chunks.length; i++) {
+		const chunk = chunks[i];
+		if (chunk.locale === last.locale) last = {
+			locale: last.locale,
+			text: last.text + chunk.text
+		};
+		else {
+			merged.push(last);
+			last = chunk;
 		}
-		order.push(chunk.locale);
-		map.set(chunk.locale, {
-			locale: chunk.locale,
-			words: chunk.words,
-			segments: [...chunk.segments]
-		});
 	}
-	return order.map((locale) => map.get(locale));
+	merged.push(last);
+	return merged;
 }
 
 //#endregion
-//#region src/wc/mode.ts
-const MODE_ALIASES = {
-	chunk: "chunk",
-	chunks: "chunk",
-	segments: "segments",
-	segment: "segments",
-	seg: "segments",
-	collector: "collector",
-	collect: "collector",
-	colle: "collector",
-	char: "char",
-	chars: "char",
-	character: "char",
-	characters: "char",
-	"char-collector": "char-collector"
-};
-const CHAR_MODE_ALIASES = new Set([
-	"char",
-	"chars",
-	"character",
-	"characters"
-]);
-const COLLECTOR_MODE_ALIASES = new Set([
-	"collector",
-	"collect",
-	"colle",
-	"col"
-]);
-function collapseSeparators(value) {
-	return value.replace(/[-_\s]+/g, "");
-}
-function isComposedCharCollectorFromTokens(value) {
-	const tokens = value.split(/[-_\s]+/).map((token) => token.trim()).filter((token) => token.length > 0);
-	if (tokens.length < 2) return false;
-	let hasCharAlias = false;
-	let hasCollectorAlias = false;
-	for (const token of tokens) {
-		if (CHAR_MODE_ALIASES.has(token)) {
-			hasCharAlias = true;
-			continue;
+//#region src/wc/wc.ts
+function wordCounter(text, options = {}) {
+	const mode = resolveMode(options.mode, "chunk");
+	const collectNonWords = Boolean(options.nonWords);
+	const includeWhitespace = Boolean(options.includeWhitespace);
+	const chunks = segmentTextByLocale(text, {
+		latinLanguageHint: options.latinLanguageHint,
+		latinTagHint: options.latinTagHint,
+		latinLocaleHint: options.latinLocaleHint,
+		latinHintRules: options.latinHintRules,
+		useDefaultLatinHints: options.useDefaultLatinHints,
+		hanLanguageHint: options.hanLanguageHint,
+		hanTagHint: options.hanTagHint
+	});
+	if (mode === "char" || mode === "char-collector") {
+		const analyzed = chunks.map((chunk) => analyzeCharChunk(chunk, collectNonWords, includeWhitespace));
+		const total = analyzed.reduce((sum, chunk) => sum + chunk.chars, 0);
+		const counts = collectNonWords ? {
+			words: analyzed.reduce((sum, chunk) => sum + chunk.wordChars, 0),
+			nonWords: analyzed.reduce((sum, chunk) => sum + chunk.nonWordChars, 0),
+			total
+		} : void 0;
+		if (mode === "char") return {
+			total,
+			counts,
+			breakdown: {
+				mode,
+				items: analyzed.map((chunk) => ({
+					locale: chunk.locale,
+					text: chunk.text,
+					chars: chunk.chars,
+					nonWords: chunk.nonWords
+				}))
+			}
+		};
+		return {
+			total,
+			counts,
+			breakdown: {
+				mode,
+				items: aggregateCharsByLocale(analyzed).map((chunk) => ({
+					locale: chunk.locale,
+					chars: chunk.chars,
+					nonWords: chunk.nonWords
+				}))
+			}
+		};
+	}
+	const analyzed = chunks.map((chunk) => analyzeChunk(chunk, collectNonWords, includeWhitespace));
+	const wordsTotal = analyzed.reduce((sum, chunk) => sum + chunk.words, 0);
+	const nonWordsTotal = collectNonWords ? analyzed.reduce((sum, chunk) => {
+		if (!chunk.nonWords) return sum;
+		return sum + getNonWordTotal(chunk.nonWords);
+	}, 0) : 0;
+	const total = analyzed.reduce((sum, chunk) => {
+		let chunkTotal = chunk.words;
+		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal(chunk.nonWords);
+		return sum + chunkTotal;
+	}, 0);
+	const counts = collectNonWords ? {
+		words: wordsTotal,
+		nonWords: nonWordsTotal,
+		total
+	} : void 0;
+	if (mode === "segments") return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words,
+				segments: chunk.segments,
+				nonWords: chunk.nonWords
+			}))
 		}
-		if (COLLECTOR_MODE_ALIASES.has(token)) {
-			hasCollectorAlias = true;
-			continue;
+	};
+	if (mode === "collector") return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: aggregateByLocale(analyzed),
+			nonWords: collectNonWordsAggregate(analyzed, collectNonWords)
 		}
-		return false;
-	}
-	return hasCharAlias && hasCollectorAlias;
-}
-function isComposedCharCollectorCompact(value) {
-	for (const charAlias of CHAR_MODE_ALIASES) for (const collectorAlias of COLLECTOR_MODE_ALIASES) if (value === `${charAlias}${collectorAlias}` || value === `${collectorAlias}${charAlias}`) return true;
-	return false;
+	};
+	return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words,
+				nonWords: chunk.nonWords
+			}))
+		}
+	};
 }
-function normalizeMode(input) {
-	if (!input) return null;
-	const normalized = input.trim().toLowerCase();
-	const direct = MODE_ALIASES[normalized];
-	if (direct) return direct;
-	if (isComposedCharCollectorFromTokens(normalized)) return "char-collector";
-	const compact = collapseSeparators(normalized);
-	if (isComposedCharCollectorCompact(compact)) return "char-collector";
-	return MODE_ALIASES[compact] ?? null;
+function getNonWordTotal(nonWords) {
+	return nonWords.counts.emoji + nonWords.counts.symbols + nonWords.counts.punctuation + (nonWords.counts.whitespace ?? 0);
 }
-function resolveMode(input, fallback = "chunk") {
-	return normalizeMode(input) ?? fallback;
+function collectNonWordsAggregate(analyzed, enabled) {
+	if (!enabled) return;
+	const collection = createNonWordCollection();
+	for (const chunk of analyzed) {
+		if (!chunk.nonWords) continue;
+		mergeNonWordCollections(collection, chunk.nonWords);
+	}
+	return collection;
 }
 
 //#endregion
-//#region src/wc/latin-hints.ts
-const DEFAULT_LATIN_HINT_RULES_SOURCE = [
-	{
-		tag: "de",
-		pattern: "[äöüÄÖÜß]"
-	},
-	{
-		tag: "es",
-		pattern: "[ñÑ¿¡]"
-	},
-	{
-		tag: "pt",
-		pattern: "[ãõÃÕ]"
-	},
-	{
-		tag: "fr",
-		pattern: "[œŒæÆ]"
-	},
-	{
-		tag: "pl",
-		pattern: "[ąćęłńśźżĄĆĘŁŃŚŹŻ]"
-	},
-	{
-		tag: "tr",
-		pattern: "[ıİğĞşŞ]"
-	},
-	{
-		tag: "ro",
-		pattern: "[ăĂâÂîÎșȘțȚ]"
-	},
-	{
-		tag: "hu",
-		pattern: "[őŐűŰ]"
-	},
-	{
-		tag: "is",
-		pattern: "[ðÐþÞ]"
-	}
-];
-const DEFAULT_LATIN_HINT_RULES = Object.freeze(DEFAULT_LATIN_HINT_RULES_SOURCE.map((rule) => Object.freeze({ ...rule })));
+//#region src/wc/index.ts
+var wc_default = wordCounter;
 
 //#endregion
-//#region src/wc/locale-detect.ts
-const DEFAULT_LOCALE = "und-Latn";
-const DEFAULT_HAN_TAG = "und-Hani";
-const MAX_LATIN_HINT_PATTERN_LENGTH = 256;
-const regex = {
-	hiragana: /\p{Script=Hiragana}/u,
-	katakana: /\p{Script=Katakana}/u,
-	hangul: /\p{Script=Hangul}/u,
-	han: /\p{Script=Han}/u,
-	latin: /\p{Script=Latin}/u,
-	arabic: /\p{Script=Arabic}/u,
-	cyrillic: /\p{Script=Cyrillic}/u,
-	devanagari: /\p{Script=Devanagari}/u,
-	thai: /\p{Script=Thai}/u
-};
-const defaultLatinLocales = new Set([DEFAULT_LOCALE, ...DEFAULT_LATIN_HINT_RULES.map((hint) => hint.tag)]);
-function isLatinLocale(locale, context) {
-	if (context) return context.latinLocales.has(locale);
-	return defaultLatinLocales.has(locale);
-}
-function resolveLatinHint(options) {
-	const latinTagHint = options.latinTagHint?.trim();
-	if (latinTagHint) return latinTagHint;
-	const latinLanguageHint = options.latinLanguageHint?.trim();
-	if (latinLanguageHint) return latinLanguageHint;
-	const latinLocaleHint = options.latinLocaleHint?.trim();
-	if (latinLocaleHint) return latinLocaleHint;
-}
-function resolveHanHint(options) {
-	const hanTagHint = options.hanTagHint?.trim();
-	if (hanTagHint) return hanTagHint;
-	const hanLanguageHint = options.hanLanguageHint?.trim();
-	if (hanLanguageHint) return hanLanguageHint;
-}
-function compileLatinHintPattern(pattern, label) {
-	const source = typeof pattern === "string" ? pattern : pattern.source;
-	const hasUnicodeMode = typeof pattern !== "string" && (pattern.flags.includes("u") || pattern.flags.includes("v"));
-	const flags = typeof pattern === "string" ? "u" : hasUnicodeMode ? pattern.flags : `${pattern.flags}u`;
-	if (source.length === 0) throw new Error(`${label}: pattern must not be empty.`);
-	if (source.length > MAX_LATIN_HINT_PATTERN_LENGTH) throw new Error(`${label}: pattern must be at most ${MAX_LATIN_HINT_PATTERN_LENGTH} characters.`);
+//#region src/markdown/section-count.ts
+function normalizeText(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
 	try {
-		return new RegExp(source, flags);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`${label}: invalid Unicode regex pattern (${message}).`);
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
 	}
 }
-function normalizeLatinHintPriority(priority, label) {
-	if (priority === void 0) return 0;
-	if (typeof priority !== "number" || !Number.isFinite(priority)) throw new Error(`${label}: priority must be a finite number when provided.`);
-	return priority;
-}
-function compileLatinHintRule(rule, order, label) {
-	const tag = typeof rule.tag === "string" ? rule.tag.trim() : "";
-	if (!tag) throw new Error(`${label}: tag must be a non-empty string.`);
-	return {
-		tag,
-		pattern: compileLatinHintPattern(rule.pattern, label),
-		priority: normalizeLatinHintPriority(rule.priority, label),
-		order
-	};
-}
-function resolveLatinHintRules$1(options) {
-	const useDefaultLatinHints = options.useDefaultLatinHints !== false;
-	const customRules = options.latinHintRules ?? [];
-	const combinedRules = [];
-	for (let index = 0; index < customRules.length; index += 1) {
-		const rule = customRules[index];
-		if (!rule) continue;
-		combinedRules.push({
-			rule,
-			label: `Invalid custom Latin hint rule at index ${index}`
-		});
-	}
-	if (useDefaultLatinHints) for (let index = 0; index < DEFAULT_LATIN_HINT_RULES.length; index += 1) {
-		const rule = DEFAULT_LATIN_HINT_RULES[index];
-		if (!rule) continue;
-		combinedRules.push({
-			rule,
-			label: `Invalid default Latin hint rule at index ${index}`
-		});
-	}
-	const resolvedRules = combinedRules.map((entry, index) => compileLatinHintRule(entry.rule, index, entry.label));
-	resolvedRules.sort((left, right) => {
-		if (left.priority !== right.priority) return right.priority - left.priority;
-		return left.order - right.order;
+function buildPerKeyItems(data, mode, options) {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+	return Object.entries(data).map(([key, value]) => {
+		const valueText = normalizeText(value);
+		return {
+			name: key,
+			source: "frontmatter",
+			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
+		};
 	});
-	return resolvedRules;
 }
-function resolveLocaleDetectContext(options = {}) {
-	const latinHint = resolveLatinHint(options);
-	const latinHintRules = resolveLatinHintRules$1(options);
-	const latinLocales = new Set([DEFAULT_LOCALE]);
-	for (const rule of latinHintRules) latinLocales.add(rule.tag);
-	if (latinHint) latinLocales.add(latinHint);
-	return {
-		latinHint,
-		hanHint: resolveHanHint(options),
-		latinHintRules,
-		latinLocales
-	};
+function buildSingleItem(name, text, mode, options, source) {
+	return [{
+		name,
+		source,
+		result: wc_default(text, options)
+	}];
 }
-function detectLatinLocale(char, context) {
-	for (const hint of context.latinHintRules) {
-		hint.pattern.lastIndex = 0;
-		if (hint.pattern.test(char)) return hint.tag;
-	}
-	return DEFAULT_LOCALE;
+function sumTotals(items) {
+	return items.reduce((sum, item) => sum + item.result.total, 0);
 }
-function detectLocaleForChar(char, previousLocale, options = {}, context = resolveLocaleDetectContext(options), allowLatinLocaleCarry = true, allowJapaneseHanCarry = true) {
-	if (regex.hiragana.test(char) || regex.katakana.test(char)) return "ja";
-	if (regex.hangul.test(char)) return "ko";
-	if (regex.arabic.test(char)) return "ar";
-	if (regex.cyrillic.test(char)) return "ru";
-	if (regex.devanagari.test(char)) return "hi";
-	if (regex.thai.test(char)) return "th";
-	if (regex.han.test(char)) {
-		if (allowJapaneseHanCarry && previousLocale && previousLocale.startsWith("ja")) return previousLocale;
-		return context.hanHint ?? DEFAULT_HAN_TAG;
-	}
-	if (regex.latin.test(char)) {
-		const hintedLocale = detectLatinLocale(char, context);
-		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
-		if (allowLatinLocaleCarry && previousLocale && isLatinLocale(previousLocale, context) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
-		if (context.latinHint) return context.latinHint;
-		return DEFAULT_LOCALE;
+function countSections(input, section, options = {}) {
+	const mode = options.mode ?? "chunk";
+	if (section === "all") {
+		const result = wc_default(input, options);
+		return {
+			section,
+			total: result.total,
+			frontmatterType: null,
+			items: [{
+				name: "all",
+				source: "content",
+				result
+			}]
+		};
 	}
-	return null;
+	const parsed = parseMarkdown(input);
+	const frontmatterText = parsed.frontmatter ?? "";
+	const contentText = parsed.content ?? "";
+	let items = [];
+	if (section === "frontmatter") items = buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter");
+	else if (section === "content") items = buildSingleItem("content", contentText, mode, options, "content");
+	else if (section === "split") items = [...buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter"), ...buildSingleItem("content", contentText, mode, options, "content")];
+	else if (section === "per-key") items = buildPerKeyItems(parsed.data, mode, options);
+	else if (section === "split-per-key") items = [...buildPerKeyItems(parsed.data, mode, options), ...buildSingleItem("content", contentText, mode, options, "content")];
+	return {
+		section,
+		total: sumTotals(items),
+		frontmatterType: parsed.frontmatterType,
+		items
+	};
 }
 
 //#endregion
-//#region src/wc/segment.ts
-const HARD_BOUNDARY_REGEX = /[\r\n,.!?;:，、。！？；：．｡､]/u;
-const LATIN_PROMOTION_BREAK_REGEX = /[\s,.!?;:，、。！？；：．｡､]/u;
-function segmentTextByLocale(text, options = {}) {
-	const context = resolveLocaleDetectContext(options);
-	const chunks = [];
-	let currentLocale = DEFAULT_LOCALE;
-	let buffer = "";
-	let bufferHasScript = false;
-	let sawCarryBoundary = false;
-	const updateCarryBoundaryState = (detected, char) => {
-		if (detected !== null) {
-			sawCarryBoundary = false;
-			return;
+//#region src/cli/batch/aggregate.ts
+function mergeWordCounterResult(left, right, preserveCollectorSegments) {
+	if (left.breakdown.mode !== right.breakdown.mode) throw new Error("Cannot merge different breakdown modes.");
+	const total = left.total + right.total;
+	const counts = left.counts || right.counts ? {
+		words: (left.counts?.words ?? 0) + (right.counts?.words ?? 0),
+		nonWords: (left.counts?.nonWords ?? 0) + (right.counts?.nonWords ?? 0),
+		total: (left.counts?.total ?? 0) + (right.counts?.total ?? 0)
+	} : void 0;
+	if (left.breakdown.mode === "chunk" && right.breakdown.mode === "chunk") return {
+		total,
+		counts,
+		breakdown: {
+			mode: "chunk",
+			items: [...left.breakdown.items, ...right.breakdown.items]
 		}
-		if (HARD_BOUNDARY_REGEX.test(char)) sawCarryBoundary = true;
 	};
-	for (const char of text) {
-		const detected = detectLocaleForChar(char, currentLocale, options, context, !sawCarryBoundary, !sawCarryBoundary);
-		const targetLocale = detected ?? currentLocale;
-		if (buffer === "") {
-			currentLocale = targetLocale;
-			buffer = char;
-			bufferHasScript = detected !== null;
-			updateCarryBoundaryState(detected, char);
-			continue;
+	if (left.breakdown.mode === "segments" && right.breakdown.mode === "segments") return {
+		total,
+		counts,
+		breakdown: {
+			mode: "segments",
+			items: [...left.breakdown.items, ...right.breakdown.items]
 		}
-		if (detected !== null && !bufferHasScript) {
-			currentLocale = targetLocale;
-			buffer += char;
-			bufferHasScript = true;
-			updateCarryBoundaryState(detected, char);
-			continue;
+	};
+	if (left.breakdown.mode === "char" && right.breakdown.mode === "char") return {
+		total,
+		counts,
+		breakdown: {
+			mode: "char",
+			items: [...left.breakdown.items, ...right.breakdown.items]
 		}
-		if (targetLocale !== currentLocale && detected !== null) {
-			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale, context)) {
-				const promotionBreakIndex = findLastLatinPromotionBreakIndex(buffer);
-				if (promotionBreakIndex === -1) {
-					currentLocale = targetLocale;
-					buffer += char;
-					bufferHasScript = true;
-					updateCarryBoundaryState(detected, char);
+	};
+	if (left.breakdown.mode === "char-collector" && right.breakdown.mode === "char-collector") {
+		const localeOrder = [];
+		const mergedByLocale = /* @__PURE__ */ new Map();
+		const addItems = (items) => {
+			for (const item of items) {
+				const existing = mergedByLocale.get(item.locale);
+				if (existing) {
+					existing.chars += item.chars;
+					if (item.nonWords) {
+						if (!existing.nonWords) existing.nonWords = createNonWordCollection();
+						mergeNonWordCollections(existing.nonWords, item.nonWords);
+					}
 					continue;
 				}
-				const prefix = buffer.slice(0, promotionBreakIndex + 1);
-				const suffix = buffer.slice(promotionBreakIndex + 1);
-				if (prefix.length > 0) chunks.push({
-					locale: currentLocale,
-					text: prefix
+				localeOrder.push(item.locale);
+				mergedByLocale.set(item.locale, {
+					locale: item.locale,
+					chars: item.chars,
+					nonWords: item.nonWords ? mergeNonWordCollections(createNonWordCollection(), item.nonWords) : void 0
 				});
-				currentLocale = targetLocale;
-				buffer = `${suffix}${char}`;
-				bufferHasScript = true;
-				updateCarryBoundaryState(detected, char);
-				continue;
 			}
-			chunks.push({
-				locale: currentLocale,
-				text: buffer
-			});
-			currentLocale = targetLocale;
-			buffer = char;
-			bufferHasScript = true;
-			updateCarryBoundaryState(detected, char);
-			continue;
-		}
-		buffer += char;
-		if (detected !== null) bufferHasScript = true;
-		updateCarryBoundaryState(detected, char);
-	}
-	if (buffer.length > 0) chunks.push({
-		locale: currentLocale,
-		text: buffer
-	});
-	return mergeAdjacentChunks(chunks);
-}
-function findLastLatinPromotionBreakIndex(buffer) {
-	for (let index = buffer.length - 1; index >= 0; index -= 1) {
-		const char = buffer[index];
-		if (!char) continue;
-		if (LATIN_PROMOTION_BREAK_REGEX.test(char)) return index;
-	}
-	return -1;
-}
-function mergeAdjacentChunks(chunks) {
-	if (chunks.length === 0) return chunks;
-	const merged = [];
-	let last = chunks[0];
-	for (let i = 1; i < chunks.length; i++) {
-		const chunk = chunks[i];
-		if (chunk.locale === last.locale) last = {
-			locale: last.locale,
-			text: last.text + chunk.text
 		};
-		else {
-			merged.push(last);
-			last = chunk;
-		}
-	}
-	merged.push(last);
-	return merged;
-}
-
-//#endregion
-//#region src/wc/wc.ts
-function wordCounter(text, options = {}) {
-	const mode = resolveMode(options.mode, "chunk");
-	const collectNonWords = Boolean(options.nonWords);
-	const includeWhitespace = Boolean(options.includeWhitespace);
-	const chunks = segmentTextByLocale(text, {
-		latinLanguageHint: options.latinLanguageHint,
-		latinTagHint: options.latinTagHint,
-		latinLocaleHint: options.latinLocaleHint,
-		latinHintRules: options.latinHintRules,
-		useDefaultLatinHints: options.useDefaultLatinHints,
-		hanLanguageHint: options.hanLanguageHint,
-		hanTagHint: options.hanTagHint
-	});
-	if (mode === "char" || mode === "char-collector") {
-		const analyzed = chunks.map((chunk) => analyzeCharChunk(chunk, collectNonWords, includeWhitespace));
-		const total = analyzed.reduce((sum, chunk) => sum + chunk.chars, 0);
-		const counts = collectNonWords ? {
-			words: analyzed.reduce((sum, chunk) => sum + chunk.wordChars, 0),
-			nonWords: analyzed.reduce((sum, chunk) => sum + chunk.nonWordChars, 0),
-			total
-		} : void 0;
-		if (mode === "char") return {
+		addItems(left.breakdown.items);
+		addItems(right.breakdown.items);
+		return {
 			total,
 			counts,
 			breakdown: {
-				mode,
-				items: analyzed.map((chunk) => ({
-					locale: chunk.locale,
-					text: chunk.text,
-					chars: chunk.chars,
-					nonWords: chunk.nonWords
-				}))
+				mode: "char-collector",
+				items: localeOrder.map((locale) => {
+					const value = mergedByLocale.get(locale);
+					if (!value) throw new Error(`Missing char-collector entry for locale: ${locale}`);
+					return value;
+				})
+			}
+		};
+	}
+	if (left.breakdown.mode === "collector" && right.breakdown.mode === "collector") {
+		const localeOrder = [];
+		const mergedByLocale = /* @__PURE__ */ new Map();
+		const addItems = (items) => {
+			for (const item of items) {
+				const existing = mergedByLocale.get(item.locale);
+				if (existing) {
+					existing.words += item.words;
+					if (preserveCollectorSegments) appendAll(existing.segments, item.segments);
+					continue;
+				}
+				localeOrder.push(item.locale);
+				mergedByLocale.set(item.locale, {
+					locale: item.locale,
+					words: item.words,
+					segments: preserveCollectorSegments ? [...item.segments] : []
+				});
 			}
 		};
+		addItems(left.breakdown.items);
+		addItems(right.breakdown.items);
+		let mergedNonWords;
+		if (left.breakdown.nonWords || right.breakdown.nonWords) {
+			mergedNonWords = createNonWordCollection();
+			if (left.breakdown.nonWords) mergeNonWordCollections(mergedNonWords, left.breakdown.nonWords);
+			if (right.breakdown.nonWords) mergeNonWordCollections(mergedNonWords, right.breakdown.nonWords);
+		}
 		return {
 			total,
 			counts,
 			breakdown: {
-				mode,
-				items: aggregateCharsByLocale(analyzed).map((chunk) => ({
-					locale: chunk.locale,
-					chars: chunk.chars,
-					nonWords: chunk.nonWords
-				}))
+				mode: "collector",
+				items: localeOrder.map((locale) => {
+					const value = mergedByLocale.get(locale);
+					if (!value) throw new Error(`Missing collector entry for locale: ${locale}`);
+					return value;
+				}),
+				nonWords: mergedNonWords
 			}
 		};
 	}
-	const analyzed = chunks.map((chunk) => analyzeChunk(chunk, collectNonWords, includeWhitespace));
-	const wordsTotal = analyzed.reduce((sum, chunk) => sum + chunk.words, 0);
-	const nonWordsTotal = collectNonWords ? analyzed.reduce((sum, chunk) => {
-		if (!chunk.nonWords) return sum;
-		return sum + getNonWordTotal(chunk.nonWords);
-	}, 0) : 0;
-	const total = analyzed.reduce((sum, chunk) => {
-		let chunkTotal = chunk.words;
-		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal(chunk.nonWords);
-		return sum + chunkTotal;
-	}, 0);
-	const counts = collectNonWords ? {
-		words: wordsTotal,
-		nonWords: nonWordsTotal,
-		total
-	} : void 0;
-	if (mode === "segments") return {
-		total,
-		counts,
-		breakdown: {
-			mode,
-			items: analyzed.map((chunk) => ({
-				locale: chunk.locale,
-				text: chunk.text,
-				words: chunk.words,
-				segments: chunk.segments,
-				nonWords: chunk.nonWords
-			}))
-		}
-	};
-	if (mode === "collector") return {
-		total,
-		counts,
-		breakdown: {
-			mode,
-			items: aggregateByLocale(analyzed),
-			nonWords: collectNonWordsAggregate(analyzed, collectNonWords)
-		}
-	};
 	return {
 		total,
 		counts,
-		breakdown: {
-			mode,
-			items: analyzed.map((chunk) => ({
-				locale: chunk.locale,
-				text: chunk.text,
-				words: chunk.words,
-				nonWords: chunk.nonWords
-			}))
-		}
+		breakdown: left.breakdown
 	};
 }
-function getNonWordTotal(nonWords) {
-	return nonWords.counts.emoji + nonWords.counts.symbols + nonWords.counts.punctuation + (nonWords.counts.whitespace ?? 0);
-}
-function collectNonWordsAggregate(analyzed, enabled) {
-	if (!enabled) return;
-	const collection = createNonWordCollection();
-	for (const chunk of analyzed) {
-		if (!chunk.nonWords) continue;
-		mergeNonWordCollections(collection, chunk.nonWords);
+function aggregateWordCounterResults(results, preserveCollectorSegments) {
+	if (results.length === 0) return wc_default("", { mode: "chunk" });
+	const first = results[0];
+	if (!first) return wc_default("", { mode: "chunk" });
+	let aggregate = first;
+	for (let index = 1; index < results.length; index += 1) {
+		const current = results[index];
+		if (!current) continue;
+		aggregate = mergeWordCounterResult(aggregate, current, preserveCollectorSegments);
 	}
-	return collection;
+	return aggregate;
 }
-
-//#endregion
-//#region src/wc/index.ts
-var wc_default = wordCounter;
-
-//#endregion
-//#region src/markdown/section-count.ts
-function normalizeText(value) {
-	if (value == null) return "";
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
+function buildSectionKey(name, source) {
+	return `${source}:${name}`;
 }
-function buildPerKeyItems(data, mode, options) {
-	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
-	return Object.entries(data).map(([key, value]) => {
-		const valueText = normalizeText(value);
-		return {
-			name: key,
-			source: "frontmatter",
-			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
-		};
-	});
+function aggregateSectionedResults(results, preserveCollectorSegments) {
+	if (results.length === 0) return {
+		section: "all",
+		total: 0,
+		frontmatterType: null,
+		items: []
+	};
+	const section = results[0]?.section ?? "all";
+	const grouped = /* @__PURE__ */ new Map();
+	let total = 0;
+	let frontmatterType = results[0]?.frontmatterType ?? null;
+	for (const result of results) {
+		total += result.total;
+		if (result.section !== section) throw new Error("Cannot aggregate section results with different section modes.");
+		if (frontmatterType !== result.frontmatterType) frontmatterType = null;
+		for (const item of result.items) {
+			const key = buildSectionKey(item.name, item.source);
+			const existing = grouped.get(key);
+			if (!existing) {
+				grouped.set(key, {
+					name: item.name,
+					source: item.source,
+					items: [item.result]
+				});
+				continue;
+			}
+			existing.items.push(item.result);
+		}
+	}
+	const sourceOrder = new Map([["frontmatter", 0], ["content", 1]]);
+	const items = [...grouped.values()].sort((left, right) => {
+		const sourceDiff = (sourceOrder.get(left.source) ?? 0) - (sourceOrder.get(right.source) ?? 0);
+		if (sourceDiff !== 0) return sourceDiff;
+		return left.name.localeCompare(right.name);
+	}).map((entry) => ({
+		name: entry.name,
+		source: entry.source,
+		result: aggregateWordCounterResults(entry.items, preserveCollectorSegments)
+	}));
+	return {
+		section,
+		total,
+		frontmatterType,
+		items
+	};
 }
-function buildSingleItem(name, text, mode, options, source) {
-	return [{
-		name,
-		source,
-		result: wc_default(text, options)
-	}];
+function stripCollectorSegmentsFromWordCounterResult(result) {
+	if (result.breakdown.mode !== "collector") return;
+	for (const item of result.breakdown.items) item.segments = [];
 }
-function sumTotals(items) {
-	return items.reduce((sum, item) => sum + item.result.total, 0);
+function stripCollectorSegmentsFromSectionedResult(result) {
+	for (const item of result.items) stripCollectorSegmentsFromWordCounterResult(item.result);
 }
-function countSections(input, section, options = {}) {
-	const mode = options.mode ?? "chunk";
-	if (section === "all") {
-		const result = wc_default(input, options);
-		return {
+function compactCollectorSegmentsInCountResult(result) {
+	if ("section" in result) {
+		stripCollectorSegmentsFromSectionedResult(result);
+		return;
+	}
+	stripCollectorSegmentsFromWordCounterResult(result);
+}
+function finalizeBatchSummaryFromFileResults(files, section, wcOptions, options = {}) {
+	const preserveCollectorSegments = options.preserveCollectorSegments ?? true;
+	if (!preserveCollectorSegments) for (const file of files) compactCollectorSegmentsInCountResult(file.result);
+	options.onFinalizeStart?.();
+	if (files.length === 0) return {
+		files,
+		skipped: [],
+		aggregate: section === "all" ? wc_default("", wcOptions) : {
 			section,
-			total: result.total,
+			total: 0,
 			frontmatterType: null,
-			items: [{
-				name: "all",
-				source: "content",
-				result
-			}]
-		};
-	}
-	const parsed = parseMarkdown(input);
-	const frontmatterText = parsed.frontmatter ?? "";
-	const contentText = parsed.content ?? "";
-	let items = [];
-	if (section === "frontmatter") items = buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter");
-	else if (section === "content") items = buildSingleItem("content", contentText, mode, options, "content");
-	else if (section === "split") items = [...buildSingleItem("frontmatter", frontmatterText, mode, options, "frontmatter"), ...buildSingleItem("content", contentText, mode, options, "content")];
-	else if (section === "per-key") items = buildPerKeyItems(parsed.data, mode, options);
-	else if (section === "split-per-key") items = [...buildPerKeyItems(parsed.data, mode, options), ...buildSingleItem("content", contentText, mode, options, "content")];
+			items: []
+		}
+	};
 	return {
-		section,
-		total: sumTotals(items),
-		frontmatterType: parsed.frontmatterType,
-		items
+		files,
+		skipped: [],
+		aggregate: section === "all" ? aggregateWordCounterResults(files.map((file) => file.result), preserveCollectorSegments) : aggregateSectionedResults(files.map((file) => file.result), preserveCollectorSegments)
 	};
 }
 
 //#endregion
-//#region src/cli/batch/aggregate.ts
-function mergeWordCounterResult(left, right, preserveCollectorSegments) {
-	if (left.breakdown.mode !== right.breakdown.mode) throw new Error("Cannot merge different breakdown modes.");
-	const total = left.total + right.total;
-	const counts = left.counts || right.counts ? {
-		words: (left.counts?.words ?? 0) + (right.counts?.words ?? 0),
-		nonWords: (left.counts?.nonWords ?? 0) + (right.counts?.nonWords ?? 0),
-		total: (left.counts?.total ?? 0) + (right.counts?.total ?? 0)
-	} : void 0;
-	if (left.breakdown.mode === "chunk" && right.breakdown.mode === "chunk") return {
-		total,
-		counts,
-		breakdown: {
-			mode: "chunk",
-			items: [...left.breakdown.items, ...right.breakdown.items]
+//#region src/cli/batch/jobs/queue.ts
+async function runBoundedQueue(total, requestedJobs, worker) {
+	if (total === 0) return [];
+	const safeRequestedJobs = Number.isFinite(requestedJobs) ? Math.floor(requestedJobs) : 1;
+	const concurrency = Math.max(1, Math.min(total, safeRequestedJobs));
+	const results = new Array(total);
+	let nextIndex = 0;
+	const runWorker = async () => {
+		while (true) {
+			const current = nextIndex;
+			nextIndex += 1;
+			if (current >= total) return;
+			results[current] = await worker(current);
 		}
 	};
-	if (left.breakdown.mode === "segments" && right.breakdown.mode === "segments") return {
-		total,
-		counts,
-		breakdown: {
-			mode: "segments",
-			items: [...left.breakdown.items, ...right.breakdown.items]
-		}
+	await Promise.all(Array.from({ length: concurrency }, () => runWorker()));
+	return results;
+}
+
+//#endregion
+//#region src/cli/path/load.ts
+function isProbablyBinary(buffer) {
+	if (buffer.length === 0) return false;
+	const sampleSize = Math.min(buffer.length, 1024);
+	let suspicious = 0;
+	for (let index = 0; index < sampleSize; index += 1) {
+		const byte = buffer[index] ?? 0;
+		if (byte === 0) return true;
+		if (byte === 9 || byte === 10 || byte === 13) continue;
+		if (byte >= 32 && byte <= 126) continue;
+		if (byte >= 128) continue;
+		suspicious += 1;
+	}
+	return suspicious / sampleSize > .3;
+}
+
+//#endregion
+//#region src/cli/batch/jobs/read-input.ts
+async function readBatchInput(path, options) {
+	if (!path) return {
+		type: "skip",
+		path: "",
+		reason: "not readable: missing path"
 	};
-	if (left.breakdown.mode === "char" && right.breakdown.mode === "char") return {
-		total,
-		counts,
-		breakdown: {
-			mode: "char",
-			items: [...left.breakdown.items, ...right.breakdown.items]
-		}
+	let buffer;
+	try {
+		buffer = await readFile(path);
+	} catch (error) {
+		if (isResourceLimitError(error)) throw createResourceLimitError(path, error, options.requestedJobs, options.limits);
+		return {
+			type: "skip",
+			path,
+			reason: `not readable: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	if (isProbablyBinary(buffer)) return {
+		type: "skip",
+		path,
+		reason: "binary file"
 	};
-	if (left.breakdown.mode === "char-collector" && right.breakdown.mode === "char-collector") {
-		const localeOrder = [];
-		const mergedByLocale = /* @__PURE__ */ new Map();
-		const addItems = (items) => {
-			for (const item of items) {
-				const existing = mergedByLocale.get(item.locale);
-				if (existing) {
-					existing.chars += item.chars;
-					if (item.nonWords) {
-						if (!existing.nonWords) existing.nonWords = createNonWordCollection();
-						mergeNonWordCollections(existing.nonWords, item.nonWords);
-					}
-					continue;
+	return {
+		type: "file",
+		path,
+		content: buffer.toString("utf8")
+	};
+}
+
+//#endregion
+//#region src/cli/batch/jobs/load-count.ts
+async function countBatchInputsWithJobs(filePaths, options) {
+	const limits = resolveBatchJobsLimit();
+	const total = filePaths.length;
+	let completed = 0;
+	const entries = await runBoundedQueue(filePaths.length, options.jobs, async (index) => {
+		const loaded = await readBatchInput(filePaths[index], {
+			requestedJobs: options.jobs,
+			limits
+		});
+		if (loaded.type === "skip") {
+			completed += 1;
+			options.onFileProcessed?.({
+				completed,
+				total
+			});
+			return {
+				type: "skip",
+				skip: {
+					path: loaded.path,
+					reason: loaded.reason
 				}
-				localeOrder.push(item.locale);
-				mergedByLocale.set(item.locale, {
-					locale: item.locale,
-					chars: item.chars,
-					nonWords: item.nonWords ? mergeNonWordCollections(createNonWordCollection(), item.nonWords) : void 0
-				});
-			}
-		};
-		addItems(left.breakdown.items);
-		addItems(right.breakdown.items);
+			};
+		}
+		const result = options.section === "all" ? wc_default(loaded.content, options.wcOptions) : countSections(loaded.content, options.section, options.wcOptions);
+		if (!options.preserveCollectorSegments) compactCollectorSegmentsInCountResult(result);
+		completed += 1;
+		options.onFileProcessed?.({
+			completed,
+			total
+		});
 		return {
-			total,
-			counts,
-			breakdown: {
-				mode: "char-collector",
-				items: localeOrder.map((locale) => {
-					const value = mergedByLocale.get(locale);
-					if (!value) throw new Error(`Missing char-collector entry for locale: ${locale}`);
-					return value;
-				})
+			type: "file",
+			file: {
+				path: loaded.path,
+				result
 			}
 		};
+	});
+	const files = [];
+	const skipped = [];
+	for (const entry of entries) {
+		if (entry.type === "file") {
+			files.push(entry.file);
+			continue;
+		}
+		skipped.push(entry.skip);
 	}
-	if (left.breakdown.mode === "collector" && right.breakdown.mode === "collector") {
-		const localeOrder = [];
-		const mergedByLocale = /* @__PURE__ */ new Map();
-		const addItems = (items) => {
-			for (const item of items) {
-				const existing = mergedByLocale.get(item.locale);
-				if (existing) {
-					existing.words += item.words;
-					if (preserveCollectorSegments) appendAll(existing.segments, item.segments);
-					continue;
-				}
-				localeOrder.push(item.locale);
-				mergedByLocale.set(item.locale, {
-					locale: item.locale,
-					words: item.words,
-					segments: preserveCollectorSegments ? [...item.segments] : []
+	return {
+		files,
+		skipped
+	};
+}
+
+//#endregion
+//#region src/cli/batch/jobs/load-count-worker.ts
+var WorkerRouteUnavailableError = class extends Error {};
+function isFallbackFriendlyWorkerError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const code = "code" in error ? String(error.code) : "";
+	if (code === "ERR_WORKER_PATH" || code === "ERR_WORKER_UNSUPPORTED_EXTENSION" || code === "ERR_UNKNOWN_FILE_EXTENSION" || code === "ERR_MODULE_NOT_FOUND") return true;
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("Unknown file extension") || message.includes("Cannot find module");
+}
+async function countBatchInputsWithWorkerJobs(filePaths, options) {
+	if (process.env.WORD_COUNTER_DISABLE_WORKER_JOBS === "1" || process.env.WORD_COUNTER_DISABLE_EXPERIMENTAL_WORKERS === "1") throw new WorkerRouteUnavailableError("Worker route disabled by environment.");
+	let workerPoolModule;
+	try {
+		workerPoolModule = await import("./worker-pool.mjs");
+	} catch (error) {
+		throw new WorkerRouteUnavailableError(`Worker route unavailable: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	try {
+		return await workerPoolModule.countBatchInputsWithWorkerPool({
+			filePaths,
+			jobs: options.jobs,
+			section: options.section,
+			wcOptions: options.wcOptions,
+			preserveCollectorSegments: options.preserveCollectorSegments,
+			onFileProcessed: options.onFileProcessed
+		});
+	} catch (error) {
+		if (error instanceof workerPoolModule.WorkerPoolTaskFatalError) {
+			if (error.code === "EMFILE" || error.code === "ENFILE") throw createResourceLimitError(error.path, {
+				code: error.code,
+				message: error.message
+			}, options.jobs, resolveBatchJobsLimit());
+			throw new Error(error.message);
+		}
+		if (error instanceof workerPoolModule.WorkerPoolUnavailableError || isFallbackFriendlyWorkerError(error)) throw new WorkerRouteUnavailableError(`Worker route unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/cli/batch/jobs/render.ts
+function finalizeBatchJobsSummary(files, section, wcOptions, options = {}) {
+	return finalizeBatchSummaryFromFileResults(files, section, wcOptions, {
+		onFinalizeStart: options.onFinalizeStart,
+		preserveCollectorSegments: options.preserveCollectorSegments
+	});
+}
+
+//#endregion
+//#region src/cli/path/resolve.ts
+async function expandDirectory(rootPath, directoryPath, recursive, extensionFilter, regexFilter, skipped, recordRegexExcluded, debug, stats) {
+	let entries;
+	try {
+		entries = await readdir(directoryPath, {
+			withFileTypes: true,
+			encoding: "utf8"
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		skipped.push({
+			path: directoryPath,
+			reason: `directory read failed: ${message}`
+		});
+		debug.emit("path.resolve.expand.read_failed", {
+			directory: directoryPath,
+			reason: `directory read failed: ${message}`
+		});
+		return [];
+	}
+	const sortedEntries = entries.slice().sort((left, right) => left.name.localeCompare(right.name));
+	const files = [];
+	debug.emit("path.resolve.expand.start", {
+		directory: directoryPath,
+		entries: sortedEntries.length,
+		recursive
+	});
+	for (const entry of sortedEntries) {
+		const entryPath = resolve(directoryPath, entry.name);
+		if (entry.isFile()) {
+			if (!shouldIncludeFromDirectory(entryPath, extensionFilter)) {
+				skipped.push({
+					path: entryPath,
+					reason: "extension excluded"
 				});
+				debug.emit("path.resolve.filter.excluded", {
+					path: entryPath,
+					reason: "extension excluded"
+				}, { verbosity: "verbose" });
+				stats.filterExcluded += 1;
+				continue;
 			}
-		};
-		addItems(left.breakdown.items);
-		addItems(right.breakdown.items);
-		let mergedNonWords;
-		if (left.breakdown.nonWords || right.breakdown.nonWords) {
-			mergedNonWords = createNonWordCollection();
-			if (left.breakdown.nonWords) mergeNonWordCollections(mergedNonWords, left.breakdown.nonWords);
-			if (right.breakdown.nonWords) mergeNonWordCollections(mergedNonWords, right.breakdown.nonWords);
+			const relativePath = toDirectoryRelativePath(rootPath, entryPath);
+			if (!shouldIncludeFromDirectoryRegex(relativePath, regexFilter)) {
+				if (recordRegexExcluded(entryPath)) {
+					debug.emit("path.resolve.regex.excluded", {
+						path: entryPath,
+						relativePath,
+						pattern: regexFilter.sourcePattern,
+						reason: "regex excluded"
+					}, { verbosity: "verbose" });
+					stats.regexExcluded += 1;
+				}
+				continue;
+			}
+			files.push(entryPath);
+			stats.directoryIncluded += 1;
+			debug.emit("path.resolve.expand.include", {
+				path: entryPath,
+				source: "directory"
+			}, { verbosity: "verbose" });
+			continue;
+		}
+		if (!entry.isDirectory() || !recursive) continue;
+		appendAll(files, await expandDirectory(rootPath, entryPath, recursive, extensionFilter, regexFilter, skipped, recordRegexExcluded, debug, stats));
+	}
+	debug.emit("path.resolve.expand.complete", {
+		directory: directoryPath,
+		files: files.length
+	});
+	return files;
+}
+async function resolveBatchFilePaths(pathInputs, options) {
+	const skipped = [];
+	const regexExcludedPaths = /* @__PURE__ */ new Set();
+	const resolvedFiles = /* @__PURE__ */ new Set();
+	const stats = {
+		dedupeAccepted: 0,
+		dedupeDuplicates: 0,
+		filterExcluded: 0,
+		regexExcluded: 0,
+		directoryIncluded: 0
+	};
+	const extensionFilter = options.extensionFilter ?? buildDirectoryExtensionFilter(void 0, void 0);
+	let regexFilter;
+	const debug = options.debug ?? {
+		enabled: false,
+		verbosity: "compact",
+		emit() {},
+		close: async () => {}
+	};
+	debug.emit("path.resolve.inputs", {
+		inputs: pathInputs.length,
+		pathMode: options.pathMode,
+		recursive: options.recursive,
+		hasRegex: Boolean(options.directoryRegexPattern)
+	});
+	const addResolvedFile = (filePath, details) => {
+		regexExcludedPaths.delete(filePath);
+		if (resolvedFiles.has(filePath)) {
+			stats.dedupeDuplicates += 1;
+			debug.emit("path.resolve.dedupe.duplicate", {
+				path: filePath,
+				source: details.source,
+				input: details.input
+			}, { verbosity: "verbose" });
+			return;
+		}
+		resolvedFiles.add(filePath);
+		stats.dedupeAccepted += 1;
+		debug.emit("path.resolve.dedupe.accept", {
+			path: filePath,
+			source: details.source,
+			input: details.input
+		}, { verbosity: "verbose" });
+	};
+	const getRegexFilter = () => {
+		if (!regexFilter) regexFilter = buildDirectoryRegexFilter(options.directoryRegexPattern);
+		return regexFilter;
+	};
+	const recordRegexExcluded = (filePath) => {
+		if (resolvedFiles.has(filePath)) return false;
+		regexExcludedPaths.add(filePath);
+		return true;
+	};
+	for (const rawPath of pathInputs) {
+		const targetPath = resolve(rawPath);
+		debug.emit("path.resolve.input", {
+			rawPath,
+			resolvedPath: targetPath
+		});
+		let metadata;
+		try {
+			metadata = await stat(targetPath);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			skipped.push({
+				path: targetPath,
+				reason: `not readable: ${message}`
+			});
+			debug.emit("path.resolve.skip", {
+				path: targetPath,
+				reason: `not readable: ${message}`
+			});
+			continue;
+		}
+		if (metadata.isDirectory() && options.pathMode === "auto") {
+			const effectiveRegexFilter = getRegexFilter();
+			debug.emit("path.resolve.root.expand", {
+				root: targetPath,
+				recursive: options.recursive,
+				regex: effectiveRegexFilter.sourcePattern ?? null
+			});
+			const files = await expandDirectory(targetPath, targetPath, options.recursive, extensionFilter, effectiveRegexFilter, skipped, recordRegexExcluded, debug, stats);
+			for (const file of files) addResolvedFile(file, {
+				source: "directory",
+				input: targetPath
+			});
+			continue;
 		}
-		return {
-			total,
-			counts,
-			breakdown: {
-				mode: "collector",
-				items: localeOrder.map((locale) => {
-					const value = mergedByLocale.get(locale);
-					if (!value) throw new Error(`Missing collector entry for locale: ${locale}`);
-					return value;
-				}),
-				nonWords: mergedNonWords
-			}
-		};
+		if (!metadata.isFile()) {
+			skipped.push({
+				path: targetPath,
+				reason: "not a regular file"
+			});
+			debug.emit("path.resolve.skip", {
+				path: targetPath,
+				reason: "not a regular file"
+			});
+			continue;
+		}
+		addResolvedFile(targetPath, {
+			source: "direct",
+			input: targetPath
+		});
 	}
+	for (const path of regexExcludedPaths) skipped.push({
+		path,
+		reason: "regex excluded"
+	});
+	const files = [...resolvedFiles].sort((left, right) => left.localeCompare(right));
+	debug.emit("path.resolve.filter.summary", {
+		excluded: stats.filterExcluded + stats.regexExcluded,
+		extensionExcluded: stats.filterExcluded,
+		regexExcluded: stats.regexExcluded,
+		included: stats.directoryIncluded
+	});
+	debug.emit("path.resolve.dedupe.summary", {
+		accepted: stats.dedupeAccepted,
+		duplicates: stats.dedupeDuplicates
+	});
+	debug.emit("path.resolve.complete", {
+		files: files.length,
+		skipped: skipped.length,
+		ordering: "absolute-path-ascending"
+	});
 	return {
-		total,
-		counts,
-		breakdown: left.breakdown
+		files,
+		skipped
 	};
 }
-function aggregateWordCounterResults(results, preserveCollectorSegments) {
-	if (results.length === 0) return wc_default("", { mode: "chunk" });
-	const first = results[0];
-	if (!first) return wc_default("", { mode: "chunk" });
-	let aggregate = first;
-	for (let index = 1; index < results.length; index += 1) {
-		const current = results[index];
-		if (!current) continue;
-		aggregate = mergeWordCounterResult(aggregate, current, preserveCollectorSegments);
-	}
-	return aggregate;
+
+//#endregion
+//#region src/cli/progress/reporter.ts
+const PROGRESS_BAR_WIDTH = 20;
+const FILLED_BAR_CHAR = "█";
+const EMPTY_BAR_CHAR = "░";
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
 }
-function buildSectionKey(name, source) {
-	return `${source}:${name}`;
+function buildProgressBar(completed, total) {
+	const safeTotal = Math.max(total, 1);
+	const ratio = clamp(completed / safeTotal, 0, 1);
+	const filled = completed >= safeTotal ? PROGRESS_BAR_WIDTH : Math.floor(ratio * PROGRESS_BAR_WIDTH);
+	const empty = PROGRESS_BAR_WIDTH - filled;
+	return `${FILLED_BAR_CHAR.repeat(filled)}${EMPTY_BAR_CHAR.repeat(empty)}`;
 }
-function aggregateSectionedResults(results, preserveCollectorSegments) {
-	if (results.length === 0) return {
-		section: "all",
-		total: 0,
-		frontmatterType: null,
-		items: []
-	};
-	const section = results[0]?.section ?? "all";
-	const grouped = /* @__PURE__ */ new Map();
-	let total = 0;
-	let frontmatterType = results[0]?.frontmatterType ?? null;
-	for (const result of results) {
-		total += result.total;
-		if (result.section !== section) throw new Error("Cannot aggregate section results with different section modes.");
-		if (frontmatterType !== result.frontmatterType) frontmatterType = null;
-		for (const item of result.items) {
-			const key = buildSectionKey(item.name, item.source);
-			const existing = grouped.get(key);
-			if (!existing) {
-				grouped.set(key, {
-					name: item.name,
-					source: item.source,
-					items: [item.result]
-				});
-				continue;
-			}
-			existing.items.push(item.result);
-		}
-	}
-	const sourceOrder = new Map([["frontmatter", 0], ["content", 1]]);
-	const items = [...grouped.values()].sort((left, right) => {
-		const sourceDiff = (sourceOrder.get(left.source) ?? 0) - (sourceOrder.get(right.source) ?? 0);
-		if (sourceDiff !== 0) return sourceDiff;
-		return left.name.localeCompare(right.name);
-	}).map((entry) => ({
-		name: entry.name,
-		source: entry.source,
-		result: aggregateWordCounterResults(entry.items, preserveCollectorSegments)
-	}));
-	return {
-		section,
-		total,
-		frontmatterType,
-		items
-	};
+function formatElapsed(startedAtMs) {
+	const elapsedMs = Date.now() - startedAtMs;
+	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	const tenths = Math.floor(Math.max(0, elapsedMs) % 1e3 / 100);
+	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${tenths}`;
 }
-function stripCollectorSegmentsFromWordCounterResult(result) {
-	if (result.breakdown.mode !== "collector") return;
-	for (const item of result.breakdown.items) item.segments = [];
+function buildProgressLine(completed, total, startedAtMs) {
+	const safeTotal = Math.max(total, 1);
+	const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
+	return `Counting files [${buildProgressBar(completed, safeTotal)}] ${`${String(percent).padStart(3, " ")}%`} ${String(completed).padStart(String(safeTotal).length, " ")}/${safeTotal} elapsed ${formatElapsed(startedAtMs)}`;
 }
-function stripCollectorSegmentsFromSectionedResult(result) {
-	for (const item of result.items) stripCollectorSegmentsFromWordCounterResult(item.result);
+function buildFinalizingLine(startedAtMs) {
+	return `Finalizing aggregate... elapsed ${formatElapsed(startedAtMs)}`;
 }
-async function buildBatchSummary(inputs, section, wcOptions, options = {}) {
-	const preserveCollectorSegments = options.preserveCollectorSegments ?? true;
-	const files = [];
-	for (const input of inputs) {
-		const result = section === "all" ? wc_default(input.content, wcOptions) : countSections(input.content, section, wcOptions);
-		if (!preserveCollectorSegments) if ("section" in result) stripCollectorSegmentsFromSectionedResult(result);
-		else stripCollectorSegmentsFromWordCounterResult(result);
-		files.push({
-			path: input.path,
-			result
-		});
-		options.onFileCounted?.({
-			completed: files.length,
-			total: inputs.length
-		});
-	}
-	options.onFinalizeStart?.();
-	if (files.length === 0) return {
-		files,
-		skipped: [],
-		aggregate: section === "all" ? wc_default("", wcOptions) : {
-			section,
-			total: 0,
-			frontmatterType: null,
-			items: []
+function createBatchProgressReporter(options) {
+	const enabled = options.enabled;
+	const isTTY = Boolean(options.stream.isTTY);
+	const clearOnFinish = options.clearOnFinish ?? true;
+	let active = false;
+	let total = 0;
+	let lastLineLength = 0;
+	let startedAtMs = 0;
+	let lastRenderedPercent = -1;
+	let finalizingStarted = false;
+	const writeTTYLine = (line) => {
+		const trailingPadding = lastLineLength > line.length ? " ".repeat(lastLineLength - line.length) : "";
+		options.stream.write(`\r${line}${trailingPadding}`);
+		lastLineLength = line.length;
+	};
+	const render = (completed) => {
+		const line = buildProgressLine(completed, total, startedAtMs);
+		const safeTotal = Math.max(total, 1);
+		const percent = completed >= safeTotal ? 100 : Math.floor(completed / safeTotal * 100);
+		if (!isTTY && percent === lastRenderedPercent && completed < safeTotal) return;
+		lastRenderedPercent = percent;
+		if (isTTY) {
+			writeTTYLine(line);
+			return;
 		}
+		lastLineLength = line.length;
+		options.stream.write(`${line}\n`);
+	};
+	const clearLine = () => {
+		if (lastLineLength === 0) return;
+		options.stream.write(`\r${" ".repeat(lastLineLength)}\r`);
+		lastLineLength = 0;
 	};
 	return {
-		files,
-		skipped: [],
-		aggregate: section === "all" ? aggregateWordCounterResults(files.map((file) => file.result), preserveCollectorSegments) : aggregateSectionedResults(files.map((file) => file.result), preserveCollectorSegments)
+		enabled,
+		start(nextTotal, nextStartedAtMs) {
+			if (!enabled || nextTotal <= 1) return;
+			total = nextTotal;
+			active = true;
+			startedAtMs = nextStartedAtMs ?? Date.now();
+			lastRenderedPercent = -1;
+			finalizingStarted = false;
+			render(0);
+		},
+		advance(snapshot) {
+			if (!active) return;
+			render(snapshot.completed);
+		},
+		startFinalizing() {
+			if (!active || finalizingStarted) return;
+			finalizingStarted = true;
+			const line = buildFinalizingLine(startedAtMs);
+			if (isTTY) {
+				if (!clearOnFinish) {
+					options.stream.write(`\n${line}`);
+					lastLineLength = line.length;
+					return;
+				}
+				writeTTYLine(line);
+				return;
+			}
+			lastLineLength = line.length;
+			options.stream.write(`${line}\n`);
+		},
+		finish() {
+			if (!active) return;
+			if (isTTY) if (clearOnFinish) clearLine();
+			else options.stream.write("\n");
+			active = false;
+		}
 	};
 }
 
@@ -2316,34 +2485,90 @@ async function runBatchCount(options) {
 		stage: "resolve",
 		elapsedMs: resolveElapsedMs
 	});
-	const loadStartedAtMs = Date.now();
-	options.debug.emit("batch.load.start", { files: resolved.files.length });
-	const loaded = await loadBatchInputs(resolved.files);
-	const loadElapsedMs = Date.now() - loadStartedAtMs;
+	options.debug.emit("batch.jobs.strategy", {
+		strategy: options.jobsStrategy,
+		jobs: options.jobs
+	});
+	let summary;
+	let routeSkips = [];
+	options.debug.emit("batch.load.start", {
+		files: resolved.files.length,
+		jobs: options.jobs,
+		strategy: options.jobsStrategy
+	});
 	options.debug.emit("batch.load.complete", {
-		files: loaded.files.length,
-		skipped: loaded.skipped.length,
-		elapsedMs: loadElapsedMs
+		files: 0,
+		skipped: 0,
+		elapsedMs: 0,
+		strategy: options.jobsStrategy
 	});
 	options.debug.emit("batch.stage.timing", {
 		stage: "load",
-		elapsedMs: loadElapsedMs
+		elapsedMs: 0
 	});
-	const progressEnabled = options.progressReporter.enabled && loaded.files.length > 1;
+	const progressEnabled = options.progressReporter.enabled && resolved.files.length > 1;
 	options.debug.emit("batch.progress.start", {
 		enabled: progressEnabled,
-		total: loaded.files.length
+		total: resolved.files.length
 	});
-	if (progressEnabled) options.progressReporter.start(loaded.files.length, batchStartedAtMs);
-	let summary;
+	if (progressEnabled) options.progressReporter.start(resolved.files.length, batchStartedAtMs);
 	const countStartedAtMs = Date.now();
 	let finalizeStartedAtMs = null;
 	let emittedCountTiming = false;
 	try {
-		summary = await buildBatchSummary(loaded.files, options.section, options.wcOptions, {
-			onFileCounted: (snapshot) => {
-				if (progressEnabled) options.progressReporter.advance(snapshot);
-			},
+		let counted;
+		if (options.jobs > 1) try {
+			counted = await countBatchInputsWithWorkerJobs(resolved.files, {
+				jobs: options.jobs,
+				section: options.section,
+				wcOptions: options.wcOptions,
+				preserveCollectorSegments: options.preserveCollectorSegments,
+				onFileProcessed: (snapshot) => {
+					if (progressEnabled) options.progressReporter.advance(snapshot);
+				}
+			});
+			options.debug.emit("batch.jobs.executor", {
+				strategy: options.jobsStrategy,
+				executor: "worker-pool",
+				jobs: options.jobs
+			});
+		} catch (error) {
+			if (!(error instanceof WorkerRouteUnavailableError)) throw error;
+			options.emitWarning?.(`Worker executor unavailable; falling back to async load+count. (${error.message})`);
+			options.debug.emit("batch.jobs.executor", {
+				strategy: options.jobsStrategy,
+				executor: "async-fallback",
+				reason: error.message,
+				jobs: options.jobs
+			});
+			counted = await countBatchInputsWithJobs(resolved.files, {
+				jobs: options.jobs,
+				section: options.section,
+				wcOptions: options.wcOptions,
+				preserveCollectorSegments: options.preserveCollectorSegments,
+				onFileProcessed: (snapshot) => {
+					if (progressEnabled) options.progressReporter.advance(snapshot);
+				}
+			});
+		}
+		else {
+			counted = await countBatchInputsWithJobs(resolved.files, {
+				jobs: options.jobs,
+				section: options.section,
+				wcOptions: options.wcOptions,
+				preserveCollectorSegments: options.preserveCollectorSegments,
+				onFileProcessed: (snapshot) => {
+					if (progressEnabled) options.progressReporter.advance(snapshot);
+				}
+			});
+			options.debug.emit("batch.jobs.executor", {
+				strategy: options.jobsStrategy,
+				executor: "async-main",
+				jobs: options.jobs
+			});
+		}
+		routeSkips = counted.skipped;
+		summary = finalizeBatchJobsSummary(counted.files, options.section, options.wcOptions, {
 			onFinalizeStart: () => {
 				finalizeStartedAtMs = Date.now();
 				if (progressEnabled) options.progressReporter.startFinalizing();
@@ -2360,7 +2585,7 @@ async function runBatchCount(options) {
 		if (progressEnabled) options.progressReporter.finish();
 		options.debug.emit("batch.progress.complete", {
 			enabled: progressEnabled,
-			total: loaded.files.length
+			total: resolved.files.length
 		});
 	}
 	if (!emittedCountTiming) {
@@ -2376,7 +2601,7 @@ async function runBatchCount(options) {
 		elapsedMs: finalizeElapsedMs
 	});
 	appendAll(summary.skipped, resolved.skipped);
-	appendAll(summary.skipped, loaded.skipped);
+	appendAll(summary.skipped, routeSkips);
 	options.debug.emit("batch.aggregate.complete", {
 		files: summary.files.length,
 		skipped: summary.skipped.length,
@@ -2385,6 +2610,12 @@ async function runBatchCount(options) {
 	return summary;
 }
 
+//#endregion
+//#region src/cli/batch/jobs/strategy.ts
+function resolveBatchJobsStrategy(_jobs) {
+	return "load-count";
+}
+
 //#endregion
 //#region src/utils/show-singular-or-plural-word.ts
 function showSingularOrPluralWord(count, word) {
@@ -2601,6 +2832,10 @@ function countLongOptionOccurrences(argv, optionName) {
 function validateSingleRegexOptionUsage(argv) {
 	if (countLongOptionOccurrences(argv, "--regex") > 1) throw new Error("`--regex` can only be provided once.");
 }
+function validateStandalonePrintJobsLimitUsage(argv) {
+	const tokens = argv.slice(2).filter((token) => token.length > 0);
+	if (tokens.length !== 1 || tokens[0] !== "--print-jobs-limit") throw new Error("`--print-jobs-limit` must be used alone.");
+}
 function resolveBatchScope(argv) {
 	let scope = "merged";
 	for (const token of argv) {
@@ -2701,6 +2936,12 @@ function formatInputReadError(error) {
 //#endregion
 //#region src/cli/runtime/batch.ts
 async function executeBatchCount({ argv, options, runtime, resolved, debug, teeEnabled }) {
+	const warningsEnabled = !Boolean(options.quietWarnings);
+	const emitWarning = (message) => {
+		if (!warningsEnabled) return;
+		const warningLine = message.startsWith("Warning:") ? message : `Warning: ${message}`;
+		console.error(import_picocolors.default.yellow(warningLine));
+	};
 	const batchOptions = {
 		scope: resolveBatchScope(argv),
 		pathMode: options.pathMode,
@@ -2709,6 +2950,11 @@ async function executeBatchCount({ argv, options, runtime, resolved, debug, teeE
 		directoryRegexPattern: options.regex
 	};
 	const extensionFilter = buildDirectoryExtensionFilter(options.includeExt, options.excludeExt);
+	const requestedJobs = options.jobs;
+	const jobsLimit = resolveBatchJobsLimit();
+	const jobs = clampRequestedJobs(requestedJobs, jobsLimit);
+	if (requestedJobs > jobsLimit.suggestedMaxJobs) emitWarning(formatJobsAdvisoryWarning(requestedJobs, jobs, jobsLimit));
+	const jobsStrategy = resolveBatchJobsStrategy(jobs);
 	const debugEnabled = Boolean(options.debug);
 	const mirrorDebugToTerminal = debugEnabled && (!debug.reportPath || teeEnabled);
 	const summary = await runBatchCount({
@@ -2723,16 +2969,21 @@ async function executeBatchCount({ argv, options, runtime, resolved, debug, teeE
 			enabled: options.format === "standard" && options.progress,
 			stream: runtime.stderr ?? process.stderr,
 			clearOnFinish: !(mirrorDebugToTerminal || options.keepProgress)
-		})
+		}),
+		jobs,
+		jobsStrategy,
+		emitWarning
 	});
 	const showSkipDiagnostics = debugEnabled && !batchOptions.quietSkips;
+	const showSkipItems = showSkipDiagnostics && Boolean(options.verbose);
 	debug.emit("batch.skips.policy", {
 		enabled: showSkipDiagnostics,
+		items: showSkipItems,
 		quietSkips: batchOptions.quietSkips
 	});
 	if (showSkipDiagnostics) {
 		debug.emit("batch.skips.report", { count: summary.skipped.length });
-		if (options.verbose) for (const skip of summary.skipped) debug.emit("batch.skips.item", {
+		if (showSkipItems) for (const skip of summary.skipped) debug.emit("batch.skips.item", {
 			path: skip.path,
 			reason: skip.reason
 		}, { verbosity: "verbose" });
@@ -2891,6 +3142,17 @@ async function runCli(argv = process.argv, runtime = {}) {
 	program.name("word-counter").description("Locale-aware word counting powered by Intl.Segmenter.").version(getFormattedVersionLabel(), "-v, --version", "output the version number");
 	configureProgramOptions(program, parseMode);
 	program.action(async (textTokens, options) => {
+		if (options.printJobsLimit) {
+			try {
+				validateStandalonePrintJobsLimitUsage(argv);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				program.error(import_picocolors.default.red(message));
+				return;
+			}
+			console.log(JSON.stringify(resolveBatchJobsLimit()));
+			return;
+		}
 		const debugEnabled = Boolean(options.debug);
 		const debugReportPath = resolveDebugReportPathOption(options.debugReport);
 		const debugReportEnabled = options.debugReport !== void 0 && options.debugReport !== false;