@dev-pi2pie/word-counter 0.1.0-canary.4 → 0.1.0

package/dist/esm/bin.mjs

@@ -1,37 +1,759 @@
 #!/usr/bin/env node
 
 import { Command, Option } from "commander";
-import { readFileSync } from "node:fs";
-import { parseDocument } from "yaml";
-import { extname, relative, resolve } from "node:path";
+import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { readFile, readdir, stat } from "node:fs/promises";
+import { parseDocument } from "yaml";
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/cli/debug/channel.ts
+const NOOP_CLOSE = async () => {};
+function shouldEmitAtVerbosity(channelVerbosity, eventVerbosity) {
+	return channelVerbosity === "verbose" || eventVerbosity === "compact";
+}
+function formatTimestampPart(value) {
+	return String(value).padStart(2, "0");
+}
+function formatDebugReportTimestamp(now) {
+	return [`${now.getFullYear()}${formatTimestampPart(now.getMonth() + 1)}${formatTimestampPart(now.getDate())}`, `${formatTimestampPart(now.getHours())}${formatTimestampPart(now.getMinutes())}${formatTimestampPart(now.getSeconds())}`].join("-");
+}
+function withCollisionSuffix(pathValue, sequence) {
+	if (sequence <= 0) return pathValue;
+	const extension = extname(pathValue);
+	const baseName = basename(pathValue, extension);
+	return join(dirname(pathValue), `${baseName}-${sequence}${extension}`);
+}
+function resolveReportPath(report, now, pid) {
+	const cwd = report.cwd ?? process.cwd();
+	const defaultName = `wc-debug-${formatDebugReportTimestamp(now)}-${pid}.jsonl`;
+	const explicitPath = typeof report.path === "string";
+	const basePath = explicitPath ? resolve(cwd, report.path) : resolve(cwd, defaultName);
+	mkdirSync(dirname(basePath), { recursive: true });
+	if (explicitPath) {
+		if (existsSync(basePath) && statSync(basePath).isDirectory()) throw new Error(`debug report path must be a file: ${basePath}`);
+		return basePath;
+	}
+	let candidate = basePath;
+	let sequence = 0;
+	while (existsSync(candidate)) {
+		sequence += 1;
+		candidate = withCollisionSuffix(basePath, sequence);
+	}
+	return candidate;
+}
+function createTerminalSink() {
+	return {
+		write(line) {
+			console.error(`[debug] ${line}`);
+		},
+		close: NOOP_CLOSE
+	};
+}
+function createFileSink(pathValue) {
+	try {
+		closeSync(openSync(pathValue, "a"));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`debug report path is not writable: ${pathValue} (${message})`);
+	}
+	const stream = createWriteStream(pathValue, {
+		flags: "a",
+		encoding: "utf8"
+	});
+	let streamError;
+	stream.on("error", (error) => {
+		streamError = error;
+	});
+	return {
+		write(line) {
+			if (streamError || stream.destroyed) return;
+			stream.write(`${line}\n`);
+		},
+		close() {
+			if (streamError || stream.destroyed || stream.writableEnded) return Promise.resolve();
+			return new Promise((resolve) => {
+				stream.end(() => {
+					resolve();
+				});
+			});
+		}
+	};
+}
+function createDebugChannel(options) {
+	if (!options.enabled) return {
+		enabled: false,
+		verbosity: options.verbosity ?? "compact",
+		emit() {},
+		close: NOOP_CLOSE
+	};
+	const verbosity = options.verbosity ?? "compact";
+	const sinks = [];
+	let reportPath;
+	if (options.report) {
+		const now = options.now?.() ?? /* @__PURE__ */ new Date();
+		const pid = options.pid ?? process.pid;
+		reportPath = resolveReportPath(options.report, now, pid);
+		sinks.push(createFileSink(reportPath));
+		if (options.report.tee) sinks.push(createTerminalSink());
+	} else sinks.push(createTerminalSink());
+	return {
+		enabled: true,
+		verbosity,
+		reportPath,
+		emit(event, details = {}, eventOptions = {}) {
+			if (!shouldEmitAtVerbosity(verbosity, eventOptions.verbosity ?? "compact")) return;
+			const payload = JSON.stringify({
+				event,
+				...details
+			});
+			for (const sink of sinks) sink.write(payload);
+		},
+		async close() {
+			for (const sink of sinks) await sink.close();
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/path/filter.ts
+const DEFAULT_INCLUDE_EXTENSIONS = new Set([
+	".md",
+	".markdown",
+	".mdx",
+	".mdc",
+	".txt"
+]);
+function collectExtensionOption(value, previous = []) {
+	return [...previous, value];
+}
+function normalizeExtensionToken(value) {
+	const trimmed = value.trim().toLowerCase();
+	if (!trimmed) return null;
+	const normalized = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+	if (normalized === ".") return null;
+	return normalized;
+}
+function parseExtensionValues(values) {
+	const parsed = /* @__PURE__ */ new Set();
+	if (!values || values.length === 0) return parsed;
+	for (const value of values) for (const token of value.split(",")) {
+		const normalized = normalizeExtensionToken(token);
+		if (!normalized) continue;
+		parsed.add(normalized);
+	}
+	return parsed;
+}
+function buildDirectoryExtensionFilter(includeValues, excludeValues) {
+	const includeFromFlags = parseExtensionValues(includeValues);
+	const excludeExtensions = parseExtensionValues(excludeValues);
+	const includeExtensions = includeFromFlags.size > 0 ? includeFromFlags : new Set(DEFAULT_INCLUDE_EXTENSIONS);
+	const effectiveIncludeExtensions = /* @__PURE__ */ new Set();
+	for (const extension of includeExtensions) {
+		if (excludeExtensions.has(extension)) continue;
+		effectiveIncludeExtensions.add(extension);
+	}
+	return {
+		includeExtensions,
+		excludeExtensions,
+		effectiveIncludeExtensions
+	};
+}
+function shouldIncludeFromDirectory(filePath, filter) {
+	const extension = extname(filePath).toLowerCase();
+	return filter.effectiveIncludeExtensions.has(extension);
+}
+
+//#endregion
+//#region src/cli/total-of.ts
+const TOTAL_OF_PARTS = [
+	"words",
+	"emoji",
+	"symbols",
+	"punctuation",
+	"whitespace"
+];
+const TOTAL_OF_PART_ALIASES = {
+	word: "words",
+	words: "words",
+	emoji: "emoji",
+	emojis: "emoji",
+	symbol: "symbols",
+	symbols: "symbols",
+	punction: "punctuation",
+	punctuation: "punctuation",
+	whitespace: "whitespace"
+};
+function createTotalOfCounts() {
+	return {
+		words: 0,
+		emoji: 0,
+		symbols: 0,
+		punctuation: 0,
+		whitespace: 0
+	};
+}
+function collectNonWordCounts(target, nonWords) {
+	if (!nonWords) return;
+	target.emoji += nonWords.counts.emoji;
+	target.symbols += nonWords.counts.symbols;
+	target.punctuation += nonWords.counts.punctuation;
+	target.whitespace += nonWords.counts.whitespace ?? 0;
+}
+function collectFromWordCounterResult(result) {
+	const counts = createTotalOfCounts();
+	counts.words += result.counts?.words ?? result.total;
+	if (result.breakdown.mode === "collector") {
+		collectNonWordCounts(counts, result.breakdown.nonWords);
+		return counts;
+	}
+	for (const item of result.breakdown.items) collectNonWordCounts(counts, item.nonWords);
+	return counts;
+}
+function collectTotalOfCounts(result) {
+	if (!("section" in result)) return collectFromWordCounterResult(result);
+	const counts = createTotalOfCounts();
+	for (const item of result.items) {
+		const itemCounts = collectFromWordCounterResult(item.result);
+		for (const part of TOTAL_OF_PARTS) counts[part] += itemCounts[part];
+	}
+	return counts;
+}
+function parseTotalOfToken(token) {
+	const canonical = TOTAL_OF_PART_ALIASES[token.trim().toLowerCase()];
+	if (canonical) return canonical;
+	throw new Error(`Invalid --total-of part: ${token}. Allowed: ${TOTAL_OF_PARTS.join(", ")}.`);
+}
+function parseTotalOfOption(value) {
+	const rawTokens = value.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+	if (rawTokens.length === 0) throw new Error(`Invalid --total-of value: "${value}". Use comma-separated parts from: ${TOTAL_OF_PARTS.join(", ")}.`);
+	const parts = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const token of rawTokens) {
+		const parsed = parseTotalOfToken(token);
+		if (seen.has(parsed)) continue;
+		seen.add(parsed);
+		parts.push(parsed);
+	}
+	return parts;
+}
+function requiresNonWordCollection(parts) {
+	if (!parts || parts.length === 0) return false;
+	return parts.some((part) => part !== "words");
+}
+function requiresWhitespaceCollection(parts) {
+	if (!parts || parts.length === 0) return false;
+	return parts.includes("whitespace");
+}
+function resolveTotalOfOverride(result, parts) {
+	if (!parts || parts.length === 0) return;
+	const counts = collectTotalOfCounts(result);
+	let total = 0;
+	for (const part of parts) total += counts[part];
+	return {
+		parts: [...parts],
+		total
+	};
+}
+function formatTotalOfParts(parts) {
+	return parts.join(", ");
+}
+
+//#endregion
+//#region src/cli/program/options.ts
+const MODE_CHOICES = [
+	"chunk",
+	"segments",
+	"collector",
+	"char",
+	"char-collector"
+];
+const FORMAT_CHOICES = [
+	"standard",
+	"raw",
+	"json"
+];
+const SECTION_CHOICES = [
+	"all",
+	"split",
+	"frontmatter",
+	"content",
+	"per-key",
+	"split-per-key"
+];
+const PATH_MODE_CHOICES = ["auto", "manual"];
+function collectPathValue(value, previous = []) {
+	return [...previous, value];
+}
+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").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("--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("-p, --path <path>", "read input from file or directory", collectPathValue, []).argument("[text...]", "text to count").showHelpAfterError();
+}
+
+//#endregion
+//#region node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+
+//#endregion
+//#region src/cli/program/version.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+function* candidateSearchRoots() {
+	yield dirname(fileURLToPath(import.meta.url));
+	const argvPath = process.argv[1];
+	if (typeof argvPath === "string" && argvPath.length > 0) yield dirname(resolve(argvPath));
+	yield process.cwd();
+}
+function* walkUpDirectories(start, maxLevels) {
+	let current = start;
+	for (let depth = 0; depth < maxLevels; depth += 1) {
+		yield current;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+}
+function resolveVersionFromPath(start, maxLevels) {
+	for (const directory of walkUpDirectories(start, maxLevels)) try {
+		const raw = readFileSync(join(directory, "package.json"), "utf8");
+		const data = JSON.parse(raw);
+		if (data.version) return data.version;
+	} catch {}
+	return null;
+}
+function resolvePackageVersion() {
+	const maxLevels = 8;
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of candidateSearchRoots()) {
+		if (seen.has(root)) continue;
+		seen.add(root);
+		const version = resolveVersionFromPath(root, maxLevels);
+		if (version) return version;
+	}
+	return "0.0.0";
+}
+function getFormattedVersionLabel() {
+	const version = resolvePackageVersion();
+	return import_picocolors.default.bgBlack(import_picocolors.default.bold(import_picocolors.default.italic(` word-counter ${import_picocolors.default.cyanBright(`ver.${version}`)} `)));
+}
+
+//#endregion
+//#region src/utils/append-all.ts
+function appendAll(target, source) {
+	for (const item of source) target.push(item);
+}
+
+//#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;
+}
+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}`
+			});
+			continue;
+		}
+		if (isProbablyBinary(buffer)) {
+			skipped.push({
+				path: filePath,
+				reason: "binary file"
+			});
+			continue;
+		}
+		files.push({
+			path: filePath,
+			content: buffer.toString("utf8")
+		});
+	}
+	return {
+		files,
+		skipped
+	};
+}
 
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+//#endregion
+//#region src/cli/path/resolve.ts
+async function expandDirectory(directoryPath, recursive, filter, skipped, 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, filter)) {
+				skipped.push({
+					path: entryPath,
+					reason: "extension excluded"
 				});
+				debug.emit("path.resolve.filter.excluded", {
+					path: entryPath,
+					reason: "extension excluded"
+				}, { verbosity: "verbose" });
+				stats.filterExcluded += 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(entryPath, recursive, filter, skipped, debug, stats));
 	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+	debug.emit("path.resolve.expand.complete", {
+		directory: directoryPath,
+		files: files.length
+	});
+	return files;
+}
+async function resolveBatchFilePaths(pathInputs, options) {
+	const skipped = [];
+	const resolvedFiles = /* @__PURE__ */ new Set();
+	const stats = {
+		dedupeAccepted: 0,
+		dedupeDuplicates: 0,
+		filterExcluded: 0,
+		directoryIncluded: 0
+	};
+	const extensionFilter = options.extensionFilter ?? buildDirectoryExtensionFilter(void 0, void 0);
+	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
+	});
+	const addResolvedFile = (filePath, details) => {
+		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" });
+	};
+	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") {
+			debug.emit("path.resolve.root.expand", {
+				root: targetPath,
+				recursive: options.recursive
+			});
+			const files = await expandDirectory(targetPath, options.recursive, extensionFilter, skipped, debug, stats);
+			for (const file of files) addResolvedFile(file, {
+				source: "directory",
+				input: targetPath
+			});
+			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"
+			});
+			continue;
+		}
+		addResolvedFile(targetPath, {
+			source: "direct",
+			input: targetPath
+		});
+	}
+	const files = [...resolvedFiles].sort((left, right) => left.localeCompare(right));
+	debug.emit("path.resolve.filter.summary", {
+		excluded: stats.filterExcluded,
+		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}`;
+}
+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 buildFinalizingLine(startedAtMs) {
+	return `Finalizing aggregate... elapsed ${formatElapsed(startedAtMs)}`;
+}
+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;
+				}
+				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;
+		}
+	};
+}
 
 //#endregion
 //#region src/markdown/toml/arrays.ts
@@ -329,7 +1051,7 @@ function parseTomlFrontmatter(frontmatter) {
 					index += 1;
 					const nextLine = lines[index] ?? "";
 					combined += `\n${nextLine}`;
-					if ((/* @__PURE__ */ new RegExp(`${delimiter}\\s*$`)).test(nextLine)) {
+					if (new RegExp(`${delimiter}\\s*$`).test(nextLine)) {
 						closed = true;
 						break;
 					}
@@ -457,10 +1179,10 @@ function parseMarkdown(input) {
 			data: null,
 			frontmatterType: null
 		};
-		const frontmatter$1 = jsonBlock.jsonText;
+		const frontmatter = jsonBlock.jsonText;
 		let content = normalizedWithoutBom.slice(jsonBlock.endIndex + 1);
 		if (content.startsWith("\n")) content = content.slice(1);
-		const data = parseFrontmatter(frontmatter$1, "json");
+		const data = parseFrontmatter(frontmatter, "json");
 		if (!data) return {
 			frontmatter: null,
 			content: normalizedWithoutBom,
@@ -468,7 +1190,7 @@ function parseMarkdown(input) {
 			frontmatterType: null
 		};
 		return {
-			frontmatter: frontmatter$1,
+			frontmatter,
 			content,
 			data,
 			frontmatterType: "json"
@@ -523,12 +1245,6 @@ function countCharsForLocale(text, locale) {
 	return count;
 }
 
-//#endregion
-//#region src/utils/append-all.ts
-function appendAll(target, source) {
-	for (const item of source) target.push(item);
-}
-
 //#endregion
 //#region src/wc/non-words.ts
 const emojiRegex = /(?:\p{Extended_Pictographic}|\p{Emoji_Presentation})/u;
@@ -697,6 +1413,32 @@ function analyzeCharChunk(chunk, collectNonWords, includeWhitespace) {
 		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;
+		}
+		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();
@@ -731,11 +1473,55 @@ const MODE_ALIASES = {
 	char: "char",
 	chars: "char",
 	character: "char",
-	characters: "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;
+		}
+		if (COLLECTOR_MODE_ALIASES.has(token)) {
+			hasCollectorAlias = true;
+			continue;
+		}
+		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;
+}
 function normalizeMode(input) {
 	if (!input) return null;
-	return MODE_ALIASES[input.trim().toLowerCase()] ?? 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 resolveMode(input, fallback = "chunk") {
 	return normalizeMode(input) ?? fallback;
@@ -897,25 +1683,37 @@ function wordCounter(text, options = {}) {
 		hanLanguageHint: options.hanLanguageHint,
 		hanTagHint: options.hanTagHint
 	});
-	if (mode === "char") {
-		const analyzed$1 = chunks.map((chunk) => analyzeCharChunk(chunk, collectNonWords, includeWhitespace));
-		const total$1 = analyzed$1.reduce((sum, chunk) => sum + chunk.chars, 0);
-		const items = analyzed$1.map((chunk) => ({
-			locale: chunk.locale,
-			text: chunk.text,
-			chars: chunk.chars,
-			nonWords: chunk.nonWords
-		}));
+	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: total$1,
-			counts: collectNonWords ? {
-				words: analyzed$1.reduce((sum, chunk) => sum + chunk.wordChars, 0),
-				nonWords: analyzed$1.reduce((sum, chunk) => sum + chunk.nonWordChars, 0),
-				total: total$1
-			} : void 0,
+			total,
+			counts,
 			breakdown: {
 				mode,
-				items
+				items: aggregateCharsByLocale(analyzed).map((chunk) => ({
+					locale: chunk.locale,
+					chars: chunk.chars,
+					nonWords: chunk.nonWords
+				}))
 			}
 		};
 	}
@@ -1006,327 +1804,51 @@ function buildPerKeyItems(data, mode, options) {
 	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 buildSingleItem(name, text, mode, options, source) {
-	return [{
-		name,
-		source,
-		result: wc_default(text, options)
-	}];
-}
-function sumTotals(items) {
-	return items.reduce((sum, item) => sum + item.result.total, 0);
-}
-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
-			}]
-		};
-	}
-	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/cli/path/filter.ts
-const DEFAULT_INCLUDE_EXTENSIONS = new Set([
-	".md",
-	".markdown",
-	".mdx",
-	".mdc",
-	".txt"
-]);
-function collectExtensionOption(value, previous = []) {
-	return [...previous, value];
-}
-function normalizeExtensionToken(value) {
-	const trimmed = value.trim().toLowerCase();
-	if (!trimmed) return null;
-	const normalized = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
-	if (normalized === ".") return null;
-	return normalized;
-}
-function parseExtensionValues(values) {
-	const parsed = /* @__PURE__ */ new Set();
-	if (!values || values.length === 0) return parsed;
-	for (const value of values) for (const token of value.split(",")) {
-		const normalized = normalizeExtensionToken(token);
-		if (!normalized) continue;
-		parsed.add(normalized);
-	}
-	return parsed;
-}
-function buildDirectoryExtensionFilter(includeValues, excludeValues) {
-	const includeFromFlags = parseExtensionValues(includeValues);
-	const excludeExtensions = parseExtensionValues(excludeValues);
-	const includeExtensions = includeFromFlags.size > 0 ? includeFromFlags : new Set(DEFAULT_INCLUDE_EXTENSIONS);
-	const effectiveIncludeExtensions = /* @__PURE__ */ new Set();
-	for (const extension of includeExtensions) {
-		if (excludeExtensions.has(extension)) continue;
-		effectiveIncludeExtensions.add(extension);
-	}
-	return {
-		includeExtensions,
-		excludeExtensions,
-		effectiveIncludeExtensions
-	};
-}
-function shouldIncludeFromDirectory(filePath, filter) {
-	const extension = extname(filePath).toLowerCase();
-	return filter.effectiveIncludeExtensions.has(extension);
-}
-
-//#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;
-}
-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}`
-			});
-			continue;
-		}
-		if (isProbablyBinary(buffer)) {
-			skipped.push({
-				path: filePath,
-				reason: "binary file"
-			});
-			continue;
-		}
-		files.push({
-			path: filePath,
-			content: buffer.toString("utf8")
-		});
-	}
-	return {
-		files,
-		skipped
-	};
-}
-
-//#endregion
-//#region src/cli/path/resolve.ts
-async function expandDirectory(directoryPath, recursive, filter, skipped) {
-	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}`
-		});
-		return [];
-	}
-	const sortedEntries = entries.slice().sort((left, right) => left.name.localeCompare(right.name));
-	const files = [];
-	for (const entry of sortedEntries) {
-		const entryPath = resolve(directoryPath, entry.name);
-		if (entry.isFile()) {
-			if (!shouldIncludeFromDirectory(entryPath, filter)) {
-				skipped.push({
-					path: entryPath,
-					reason: "extension excluded"
-				});
-				continue;
-			}
-			files.push(entryPath);
-			continue;
-		}
-		if (!entry.isDirectory() || !recursive) continue;
-		appendAll(files, await expandDirectory(entryPath, recursive, filter, skipped));
-	}
-	return files;
-}
-async function resolveBatchFilePaths(pathInputs, options) {
-	const skipped = [];
-	const resolvedFiles = /* @__PURE__ */ new Set();
-	const extensionFilter = options.extensionFilter ?? buildDirectoryExtensionFilter(void 0, void 0);
-	for (const rawPath of pathInputs) {
-		const targetPath = resolve(rawPath);
-		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}`
-			});
-			continue;
-		}
-		if (metadata.isDirectory() && options.pathMode === "auto") {
-			const files = await expandDirectory(targetPath, options.recursive, extensionFilter, skipped);
-			for (const file of files) resolvedFiles.add(file);
-			continue;
-		}
-		if (!metadata.isFile()) {
-			skipped.push({
-				path: targetPath,
-				reason: "not a regular file"
-			});
-			continue;
-		}
-		resolvedFiles.add(targetPath);
-	}
-	return {
-		files: [...resolvedFiles].sort((left, right) => left.localeCompare(right)),
-		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}`;
+			name: key,
+			source: "frontmatter",
+			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
+		};
+	});
 }
-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 buildSingleItem(name, text, mode, options, source) {
+	return [{
+		name,
+		source,
+		result: wc_default(text, options)
+	}];
 }
-function buildFinalizingLine(startedAtMs) {
-	return `Finalizing aggregate... elapsed ${formatElapsed(startedAtMs)}`;
+function sumTotals(items) {
+	return items.reduce((sum, item) => sum + item.result.total, 0);
 }
-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;
-	};
+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
+			}]
+		};
+	}
+	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 {
-		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;
-		}
+		section,
+		total: sumTotals(items),
+		frontmatterType: parsed.frontmatterType,
+		items
 	};
 }
 
@@ -1364,6 +1886,43 @@ function mergeWordCounterResult(left, right, preserveCollectorSegments) {
 			items: [...left.breakdown.items, ...right.breakdown.items]
 		}
 	};
+	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;
+				}
+				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);
+		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;
+				})
+			}
+		};
+	}
 	if (left.breakdown.mode === "collector" && right.breakdown.mode === "collector") {
 		const localeOrder = [];
 		const mergedByLocale = /* @__PURE__ */ new Map();
@@ -1526,7 +2085,8 @@ async function runBatchCount(options) {
 	const resolved = await resolveBatchFilePaths(options.pathInputs, {
 		pathMode: options.batchOptions.pathMode,
 		recursive: options.batchOptions.recursive,
-		extensionFilter: options.extensionFilter
+		extensionFilter: options.extensionFilter,
+		debug: options.debug
 	});
 	const resolveElapsedMs = Date.now() - resolveStartedAtMs;
 	options.debug.emit("batch.resolve.complete", {
@@ -1608,199 +2168,18 @@ async function runBatchCount(options) {
 }
 
 //#endregion
-//#region src/cli/debug/channel.ts
-function createDebugChannel(enabled) {
-	return {
-		enabled,
-		emit(event, details = {}) {
-			if (!enabled) return;
-			const payload = {
-				event,
-				...details
-			};
-			console.error(`[debug] ${JSON.stringify(payload)}`);
-		}
-	};
-}
-
-//#endregion
-//#region src/utils/show-singular-or-plural-word.ts
-function showSingularOrPluralWord(count, word) {
-	return `${count} ${word}${count === 1 ? "" : "s"}`;
-}
-
-//#endregion
-//#region src/cli/total-of.ts
-const TOTAL_OF_PARTS = [
-	"words",
-	"emoji",
-	"symbols",
-	"punctuation",
-	"whitespace"
-];
-const TOTAL_OF_PART_ALIASES = {
-	word: "words",
-	words: "words",
-	emoji: "emoji",
-	emojis: "emoji",
-	symbol: "symbols",
-	symbols: "symbols",
-	punction: "punctuation",
-	punctuation: "punctuation",
-	whitespace: "whitespace"
-};
-function createTotalOfCounts() {
-	return {
-		words: 0,
-		emoji: 0,
-		symbols: 0,
-		punctuation: 0,
-		whitespace: 0
-	};
-}
-function collectNonWordCounts(target, nonWords) {
-	if (!nonWords) return;
-	target.emoji += nonWords.counts.emoji;
-	target.symbols += nonWords.counts.symbols;
-	target.punctuation += nonWords.counts.punctuation;
-	target.whitespace += nonWords.counts.whitespace ?? 0;
-}
-function collectFromWordCounterResult(result) {
-	const counts = createTotalOfCounts();
-	counts.words += result.counts?.words ?? result.total;
-	if (result.breakdown.mode === "collector") {
-		collectNonWordCounts(counts, result.breakdown.nonWords);
-		return counts;
-	}
-	for (const item of result.breakdown.items) collectNonWordCounts(counts, item.nonWords);
-	return counts;
-}
-function collectTotalOfCounts(result) {
-	if (!("section" in result)) return collectFromWordCounterResult(result);
-	const counts = createTotalOfCounts();
-	for (const item of result.items) {
-		const itemCounts = collectFromWordCounterResult(item.result);
-		for (const part of TOTAL_OF_PARTS) counts[part] += itemCounts[part];
-	}
-	return counts;
-}
-function parseTotalOfToken(token) {
-	const canonical = TOTAL_OF_PART_ALIASES[token.trim().toLowerCase()];
-	if (canonical) return canonical;
-	throw new Error(`Invalid --total-of part: ${token}. Allowed: ${TOTAL_OF_PARTS.join(", ")}.`);
-}
-function parseTotalOfOption(value) {
-	const rawTokens = value.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
-	if (rawTokens.length === 0) throw new Error(`Invalid --total-of value: "${value}". Use comma-separated parts from: ${TOTAL_OF_PARTS.join(", ")}.`);
-	const parts = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const token of rawTokens) {
-		const parsed = parseTotalOfToken(token);
-		if (seen.has(parsed)) continue;
-		seen.add(parsed);
-		parts.push(parsed);
-	}
-	return parts;
-}
-function requiresNonWordCollection(parts) {
-	if (!parts || parts.length === 0) return false;
-	return parts.some((part) => part !== "words");
-}
-function requiresWhitespaceCollection(parts) {
-	if (!parts || parts.length === 0) return false;
-	return parts.includes("whitespace");
-}
-function resolveTotalOfOverride(result, parts) {
-	if (!parts || parts.length === 0) return;
-	const counts = collectTotalOfCounts(result);
-	let total = 0;
-	for (const part of parts) total += counts[part];
-	return {
-		parts: [...parts],
-		total
-	};
-}
-function formatTotalOfParts(parts) {
-	return parts.join(", ");
-}
-
-//#endregion
-//#region node_modules/picocolors/picocolors.js
-var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	let p = process || {}, argv = p.argv || [], env = p.env || {};
-	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-	let formatter = (open, close, replace = open) => (input) => {
-		let string = "" + input, index = string.indexOf(close, open.length);
-		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-	};
-	let replaceClose = (string, close, replace, index) => {
-		let result = "", cursor = 0;
-		do {
-			result += string.substring(cursor, index) + replace;
-			cursor = index + close.length;
-			index = string.indexOf(close, cursor);
-		} while (~index);
-		return result + string.substring(cursor);
-	};
-	let createColors = (enabled = isColorSupported) => {
-		let f = enabled ? formatter : () => String;
-		return {
-			isColorSupported: enabled,
-			reset: f("\x1B[0m", "\x1B[0m"),
-			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-			italic: f("\x1B[3m", "\x1B[23m"),
-			underline: f("\x1B[4m", "\x1B[24m"),
-			inverse: f("\x1B[7m", "\x1B[27m"),
-			hidden: f("\x1B[8m", "\x1B[28m"),
-			strikethrough: f("\x1B[9m", "\x1B[29m"),
-			black: f("\x1B[30m", "\x1B[39m"),
-			red: f("\x1B[31m", "\x1B[39m"),
-			green: f("\x1B[32m", "\x1B[39m"),
-			yellow: f("\x1B[33m", "\x1B[39m"),
-			blue: f("\x1B[34m", "\x1B[39m"),
-			magenta: f("\x1B[35m", "\x1B[39m"),
-			cyan: f("\x1B[36m", "\x1B[39m"),
-			white: f("\x1B[37m", "\x1B[39m"),
-			gray: f("\x1B[90m", "\x1B[39m"),
-			bgBlack: f("\x1B[40m", "\x1B[49m"),
-			bgRed: f("\x1B[41m", "\x1B[49m"),
-			bgGreen: f("\x1B[42m", "\x1B[49m"),
-			bgYellow: f("\x1B[43m", "\x1B[49m"),
-			bgBlue: f("\x1B[44m", "\x1B[49m"),
-			bgMagenta: f("\x1B[45m", "\x1B[49m"),
-			bgCyan: f("\x1B[46m", "\x1B[49m"),
-			bgWhite: f("\x1B[47m", "\x1B[49m"),
-			blackBright: f("\x1B[90m", "\x1B[39m"),
-			redBright: f("\x1B[91m", "\x1B[39m"),
-			greenBright: f("\x1B[92m", "\x1B[39m"),
-			yellowBright: f("\x1B[93m", "\x1B[39m"),
-			blueBright: f("\x1B[94m", "\x1B[39m"),
-			magentaBright: f("\x1B[95m", "\x1B[39m"),
-			cyanBright: f("\x1B[96m", "\x1B[39m"),
-			whiteBright: f("\x1B[97m", "\x1B[39m"),
-			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-			bgRedBright: f("\x1B[101m", "\x1B[49m"),
-			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-		};
-	};
-	module.exports = createColors();
-	module.exports.createColors = createColors;
-}));
+//#region src/utils/show-singular-or-plural-word.ts
+function showSingularOrPluralWord(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
 
 //#endregion
 //#region src/cli/output/render.ts
-var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 function getCountUnit(mode) {
-	return mode === "char" ? "character" : "word";
+	return mode === "char" || mode === "char-collector" ? "character" : "word";
 }
 function getTotalLabels(mode, includeNonWords) {
-	const unit = mode === "char" ? "characters" : "words";
+	const unit = mode === "char" || mode === "char-collector" ? "characters" : "words";
 	if (includeNonWords) return {
 		overall: "Total count",
 		section: "total count"
@@ -1856,7 +2235,7 @@ function renderStandardResult(result, totalLabel, totalOfOverride) {
 		renderNonWords(result.breakdown.nonWords, false);
 		return;
 	}
-	if (result.breakdown.mode === "char") {
+	if (result.breakdown.mode === "char" || result.breakdown.mode === "char-collector") {
 		renderCountBreakdown(result.breakdown.items.map((item) => ({
 			locale: item.locale,
 			count: item.chars,
@@ -1894,7 +2273,7 @@ function renderStandardSectionedResult(result, labels, totalOfOverride) {
 			renderNonWords(item.result.breakdown.nonWords, false);
 			continue;
 		}
-		if (item.result.breakdown.mode === "char") {
+		if (item.result.breakdown.mode === "char" || item.result.breakdown.mode === "char-collector") {
 			renderCountBreakdown(item.result.breakdown.items.map((chunk) => ({
 				locale: chunk.locale,
 				count: chunk.chars,
@@ -1922,92 +2301,25 @@ function reportSkipped(skipped) {
 	console.error(import_picocolors.default.yellow(`Skipped ${skipped.length} path(s):`));
 	for (const item of skipped) console.error(import_picocolors.default.yellow(`- ${toDisplayPath(item.path)} (${item.reason})`));
 }
-function renderPerFileStandard(summary, labels, resolveTotalOfOverride$1) {
+function renderPerFileStandard(summary, labels, resolveTotalOfOverride) {
 	for (const file of summary.files) {
 		console.log(import_picocolors.default.bold(`[File] ${toDisplayPath(file.path)}`));
 		if (isSectionedResult(file.result)) {
-			renderStandardSectionedResult(file.result, labels, resolveTotalOfOverride$1?.(file.result));
+			renderStandardSectionedResult(file.result, labels, resolveTotalOfOverride?.(file.result));
 			continue;
 		}
-		renderStandardResult(file.result, labels.overall, resolveTotalOfOverride$1?.(file.result));
+		renderStandardResult(file.result, labels.overall, resolveTotalOfOverride?.(file.result));
 	}
 	console.log(import_picocolors.default.bold(`[Merged] ${summary.files.length} file(s)`));
 	if (isSectionedResult(summary.aggregate)) {
-		renderStandardSectionedResult(summary.aggregate, labels, resolveTotalOfOverride$1?.(summary.aggregate));
+		renderStandardSectionedResult(summary.aggregate, labels, resolveTotalOfOverride?.(summary.aggregate));
 		return;
 	}
-	renderStandardResult(summary.aggregate, labels.overall, resolveTotalOfOverride$1?.(summary.aggregate));
+	renderStandardResult(summary.aggregate, labels.overall, resolveTotalOfOverride?.(summary.aggregate));
 }
 
 //#endregion
-//#region src/command.ts
-const MODE_CHOICES = [
-	"chunk",
-	"segments",
-	"collector",
-	"char"
-];
-const FORMAT_CHOICES = [
-	"standard",
-	"raw",
-	"json"
-];
-const SECTION_CHOICES = [
-	"all",
-	"split",
-	"frontmatter",
-	"content",
-	"per-key",
-	"split-per-key"
-];
-const PATH_MODE_CHOICES = ["auto", "manual"];
-function getPackageVersion() {
-	const packageCandidates = [new URL("../package.json", import.meta.url), new URL("../../package.json", import.meta.url)];
-	let version = "0.0.0";
-	for (const packageUrl of packageCandidates) try {
-		const raw = readFileSync(packageUrl, "utf8");
-		const data = JSON.parse(raw);
-		if (data.version) {
-			version = data.version;
-			break;
-		}
-	} catch {
-		continue;
-	}
-	return import_picocolors.default.bgBlack(import_picocolors.default.bold(import_picocolors.default.italic(` word-counter ${import_picocolors.default.cyanBright(`ver.${version}`)} `)));
-}
-async function readStdin() {
-	if (process.stdin.isTTY) return "";
-	return new Promise((resolve$1, reject) => {
-		const chunks = [];
-		process.stdin.setEncoding("utf8");
-		process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
-		process.stdin.on("end", () => resolve$1(chunks.join("")));
-		process.stdin.on("error", (error) => reject(error));
-		process.stdin.resume();
-	});
-}
-async function resolveInput(textTokens) {
-	if (textTokens.length > 0) return textTokens.join(" ");
-	return readStdin();
-}
-function collectPathValue(value, previous = []) {
-	return [...previous, value];
-}
-function resolveBatchScope(argv) {
-	let scope = "merged";
-	for (const token of argv) {
-		if (token === "--merged") {
-			scope = "merged";
-			continue;
-		}
-		if (token === "--per-file") scope = "per-file";
-	}
-	return scope;
-}
-function hasPathInput(pathValues) {
-	return Array.isArray(pathValues) && pathValues.length > 0;
-}
+//#region src/cli/output/normalize-base.ts
 function normalizeWordCounterResultBase(result) {
 	result.total = result.counts?.words ?? result.total;
 	delete result.counts;
@@ -2015,7 +2327,7 @@ function normalizeWordCounterResultBase(result) {
 		delete result.breakdown.nonWords;
 		return result;
 	}
-	if (result.breakdown.mode === "char") {
+	if (result.breakdown.mode === "char" || result.breakdown.mode === "char-collector") {
 		for (const item of result.breakdown.items) {
 			const nonWordCount = (item.nonWords?.counts.emoji ?? 0) + (item.nonWords?.counts.symbols ?? 0) + (item.nonWords?.counts.punctuation ?? 0) + (item.nonWords?.counts.whitespace ?? 0);
 			item.chars = Math.max(0, item.chars - nonWordCount);
@@ -2044,24 +2356,41 @@ function normalizeBatchSummaryBase(summary) {
 	normalizeResultBase(summary.aggregate);
 	return summary;
 }
-async function runCli(argv = process.argv, runtime = {}) {
-	const program = new Command();
-	const parseMode = (value) => {
-		const normalized = normalizeMode(value);
-		if (!normalized) throw new Error(`Invalid mode: ${value}`);
-		return normalized;
-	};
-	program.name("word-counter").description("Locale-aware word counting powered by Intl.Segmenter.").version(getPackageVersion(), "-v, --version", "output the version number").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").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("--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("--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("-p, --path <path>", "read input from file or directory", collectPathValue, []).argument("[text...]", "text to count").showHelpAfterError();
-	program.action(async (textTokens, options) => {
-		const useSection = options.section !== "all";
-		const totalOfParts = options.totalOf;
-		const requestedNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc);
-		const collectNonWordsForOverride = requiresNonWordCollection(totalOfParts);
-		const collectWhitespaceForOverride = requiresWhitespaceCollection(totalOfParts);
-		const enableNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc || collectNonWordsForOverride);
-		const enableWhitespace = Boolean(options.includeWhitespace || options.misc || collectWhitespaceForOverride);
-		const shouldNormalizeBaseOutput = !requestedNonWords && enableNonWords;
-		const wcOptions = {
+
+//#endregion
+//#region src/cli/runtime/options.ts
+function hasPathInput(pathValues) {
+	return Array.isArray(pathValues) && pathValues.length > 0;
+}
+function resolveBatchScope(argv) {
+	let scope = "merged";
+	for (const token of argv) {
+		if (token === "--merged") {
+			scope = "merged";
+			continue;
+		}
+		if (token === "--per-file") scope = "per-file";
+	}
+	return scope;
+}
+function resolveDebugReportPathOption(rawValue) {
+	if (rawValue === void 0 || rawValue === false) return;
+	if (typeof rawValue === "string") return rawValue;
+}
+function resolveCountRunOptions(options) {
+	const useSection = options.section !== "all";
+	const totalOfParts = options.totalOf;
+	const requestedNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc);
+	const collectNonWordsForOverride = requiresNonWordCollection(totalOfParts);
+	const collectWhitespaceForOverride = requiresWhitespaceCollection(totalOfParts);
+	const enableNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc || collectNonWordsForOverride);
+	const enableWhitespace = Boolean(options.includeWhitespace || options.misc || collectWhitespaceForOverride);
+	return {
+		useSection,
+		totalOfParts,
+		requestedNonWords,
+		shouldNormalizeBaseOutput: !requestedNonWords && enableNonWords,
+		wcOptions: {
 			mode: options.mode,
 			latinLanguageHint: options.latinLanguage,
 			latinTagHint: options.latinTag,
@@ -2070,152 +2399,255 @@ async function runCli(argv = process.argv, runtime = {}) {
 			hanTagHint: options.hanTag,
 			nonWords: enableNonWords,
 			includeWhitespace: enableWhitespace
-		};
-		if (!hasPathInput(options.path)) {
-			let input;
-			try {
-				input = await resolveInput(textTokens);
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				program.error(`Failed to read input: ${message}`);
-				return;
-			}
-			const trimmed = input.trim();
-			if (!trimmed) {
-				program.error(import_picocolors.default.red("No input provided. Pass text, pipe stdin, or use --path."));
-				return;
-			}
-			const result = useSection ? countSections(trimmed, options.section, wcOptions) : wc_default(trimmed, wcOptions);
-			const totalOfOverride = resolveTotalOfOverride(result, totalOfParts);
-			const displayResult = shouldNormalizeBaseOutput ? normalizeResultBase(result) : result;
-			if (options.format === "raw") {
-				console.log(totalOfOverride?.total ?? displayResult.total);
-				return;
-			}
-			if (options.format === "json") {
-				const spacing = options.pretty ? 2 : 0;
-				if (!totalOfOverride) {
-					console.log(JSON.stringify(displayResult, null, spacing));
-					return;
-				}
-				console.log(JSON.stringify({
-					...displayResult,
-					meta: {
-						totalOf: totalOfOverride.parts,
-						totalOfOverride: totalOfOverride.total
-					}
-				}, null, spacing));
-				return;
-			}
-			const labels$1 = getTotalLabels(options.mode, requestedNonWords);
-			if (isSectionedResult(displayResult)) {
-				renderStandardSectionedResult(displayResult, labels$1, totalOfOverride);
-				return;
-			}
-			renderStandardResult(displayResult, labels$1.overall, totalOfOverride);
-			return;
 		}
-		const batchOptions = {
-			scope: resolveBatchScope(argv),
-			pathMode: options.pathMode,
-			recursive: options.recursive,
-			quietSkips: Boolean(options.quietSkips)
-		};
-		const debug = createDebugChannel(Boolean(options.debug));
-		const extensionFilter = buildDirectoryExtensionFilter(options.includeExt, options.excludeExt);
-		const summary = await runBatchCount({
-			pathInputs: options.path,
-			batchOptions,
-			extensionFilter,
-			section: options.section,
-			wcOptions,
-			preserveCollectorSegments: options.format === "json",
-			debug,
-			progressReporter: createBatchProgressReporter({
-				enabled: options.format === "standard" && options.progress,
-				stream: runtime.stderr ?? process.stderr,
-				clearOnFinish: !Boolean(options.debug || options.keepProgress)
-			})
-		});
-		const showSkipDiagnostics = Boolean(options.debug) && !batchOptions.quietSkips;
-		debug.emit("batch.skips.policy", {
-			enabled: showSkipDiagnostics,
-			quietSkips: batchOptions.quietSkips
-		});
-		if (showSkipDiagnostics) {
-			debug.emit("batch.skips.report", { count: summary.skipped.length });
-			reportSkipped(summary.skipped);
+	};
+}
+function formatInputReadError(error) {
+	return `Failed to read input: ${error instanceof Error ? error.message : String(error)}`;
+}
+
+//#endregion
+//#region src/cli/runtime/batch.ts
+async function executeBatchCount({ argv, options, runtime, resolved, debug, teeEnabled }) {
+	const batchOptions = {
+		scope: resolveBatchScope(argv),
+		pathMode: options.pathMode,
+		recursive: options.recursive,
+		quietSkips: Boolean(options.quietSkips)
+	};
+	const extensionFilter = buildDirectoryExtensionFilter(options.includeExt, options.excludeExt);
+	const debugEnabled = Boolean(options.debug);
+	const mirrorDebugToTerminal = debugEnabled && (!debug.reportPath || teeEnabled);
+	const summary = await runBatchCount({
+		pathInputs: options.path ?? [],
+		batchOptions,
+		extensionFilter,
+		section: options.section,
+		wcOptions: resolved.wcOptions,
+		preserveCollectorSegments: options.format === "json",
+		debug,
+		progressReporter: createBatchProgressReporter({
+			enabled: options.format === "standard" && options.progress,
+			stream: runtime.stderr ?? process.stderr,
+			clearOnFinish: !(mirrorDebugToTerminal || options.keepProgress)
+		})
+	});
+	const showSkipDiagnostics = debugEnabled && !batchOptions.quietSkips;
+	debug.emit("batch.skips.policy", {
+		enabled: showSkipDiagnostics,
+		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", {
+			path: skip.path,
+			reason: skip.reason
+		}, { verbosity: "verbose" });
+		if (mirrorDebugToTerminal) reportSkipped(summary.skipped);
+	}
+	if (summary.files.length === 0) throw new Error("No readable text-like inputs were found from --path.");
+	let aggregateTotalOfOverride;
+	let totalOfOverridesByResult;
+	if (resolved.totalOfParts && resolved.totalOfParts.length > 0) {
+		totalOfOverridesByResult = /* @__PURE__ */ new WeakMap();
+		const aggregateOverride = resolveTotalOfOverride(summary.aggregate, resolved.totalOfParts);
+		if (aggregateOverride) {
+			totalOfOverridesByResult.set(summary.aggregate, aggregateOverride);
+			aggregateTotalOfOverride = aggregateOverride;
+		}
+		for (const file of summary.files) {
+			const fileOverride = resolveTotalOfOverride(file.result, resolved.totalOfParts);
+			if (!fileOverride) continue;
+			totalOfOverridesByResult.set(file.result, fileOverride);
+		}
+	} else aggregateTotalOfOverride = resolveTotalOfOverride(summary.aggregate, resolved.totalOfParts);
+	if (resolved.shouldNormalizeBaseOutput) normalizeBatchSummaryBase(summary);
+	if (!aggregateTotalOfOverride && totalOfOverridesByResult) aggregateTotalOfOverride = totalOfOverridesByResult.get(summary.aggregate);
+	if (options.format === "raw") {
+		console.log(aggregateTotalOfOverride?.total ?? summary.aggregate.total);
+		return;
+	}
+	if (options.format === "json") {
+		const spacing = options.pretty ? 2 : 0;
+		if (batchOptions.scope === "per-file") {
+			const skipped = showSkipDiagnostics ? summary.skipped : void 0;
+			const meta = resolved.totalOfParts && resolved.totalOfParts.length > 0 ? {
+				totalOf: resolved.totalOfParts,
+				aggregateTotalOfOverride: aggregateTotalOfOverride?.total ?? summary.aggregate.total
+			} : void 0;
+			const payload = {
+				scope: "per-file",
+				files: summary.files.map((file) => ({
+					path: file.path,
+					result: file.result
+				})),
+				...skipped ? { skipped } : {},
+				aggregate: summary.aggregate,
+				...meta ? { meta } : {}
+			};
+			console.log(JSON.stringify(payload, null, spacing));
+			return;
 		}
-		if (summary.files.length === 0) {
-			program.error(import_picocolors.default.red("No readable text-like inputs were found from --path."));
+		if (!aggregateTotalOfOverride) {
+			console.log(JSON.stringify(summary.aggregate, null, spacing));
 			return;
 		}
-		let aggregateTotalOfOverride;
-		let totalOfOverridesByResult;
-		if (totalOfParts && totalOfParts.length > 0) {
-			totalOfOverridesByResult = /* @__PURE__ */ new WeakMap();
-			const aggregateOverride = resolveTotalOfOverride(summary.aggregate, totalOfParts);
-			if (aggregateOverride) {
-				totalOfOverridesByResult.set(summary.aggregate, aggregateOverride);
-				aggregateTotalOfOverride = aggregateOverride;
+		console.log(JSON.stringify({
+			...summary.aggregate,
+			meta: {
+				totalOf: aggregateTotalOfOverride.parts,
+				totalOfOverride: aggregateTotalOfOverride.total
 			}
-			for (const file of summary.files) {
-				const fileOverride = resolveTotalOfOverride(file.result, totalOfParts);
-				if (!fileOverride) continue;
-				totalOfOverridesByResult.set(file.result, fileOverride);
-			}
-		} else aggregateTotalOfOverride = resolveTotalOfOverride(summary.aggregate, totalOfParts);
-		if (shouldNormalizeBaseOutput) normalizeBatchSummaryBase(summary);
-		if (!aggregateTotalOfOverride && totalOfOverridesByResult) aggregateTotalOfOverride = totalOfOverridesByResult.get(summary.aggregate);
-		if (options.format === "raw") {
-			console.log(aggregateTotalOfOverride?.total ?? summary.aggregate.total);
+		}, null, spacing));
+		return;
+	}
+	const labels = getTotalLabels(options.mode, resolved.requestedNonWords);
+	const totalOfResolver = resolved.totalOfParts && resolved.totalOfParts.length > 0 ? (result) => totalOfOverridesByResult?.get(result) ?? resolveTotalOfOverride(result, resolved.totalOfParts) : void 0;
+	if (batchOptions.scope === "per-file") {
+		renderPerFileStandard(summary, labels, totalOfResolver);
+		return;
+	}
+	if (isSectionedResult(summary.aggregate)) {
+		renderStandardSectionedResult(summary.aggregate, labels, aggregateTotalOfOverride);
+		return;
+	}
+	renderStandardResult(summary.aggregate, labels.overall, aggregateTotalOfOverride);
+}
+
+//#endregion
+//#region src/cli/runtime/input.ts
+async function readStdin() {
+	if (process.stdin.isTTY) return "";
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.setEncoding("utf8");
+		process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
+		process.stdin.on("end", () => resolve(chunks.join("")));
+		process.stdin.on("error", (error) => reject(error));
+		process.stdin.resume();
+	});
+}
+async function resolveInput(textTokens) {
+	if (textTokens.length > 0) return textTokens.join(" ");
+	return readStdin();
+}
+
+//#endregion
+//#region src/cli/runtime/single.ts
+async function executeSingleCount({ textTokens, options, resolved }) {
+	let input;
+	try {
+		input = await resolveInput(textTokens);
+	} catch (error) {
+		throw new Error(formatInputReadError(error));
+	}
+	const trimmed = input.trim();
+	if (!trimmed) throw new Error("No input provided. Pass text, pipe stdin, or use --path.");
+	const result = resolved.useSection ? countSections(trimmed, options.section, resolved.wcOptions) : wc_default(trimmed, resolved.wcOptions);
+	const totalOfOverride = resolveTotalOfOverride(result, resolved.totalOfParts);
+	const displayResult = resolved.shouldNormalizeBaseOutput ? normalizeResultBase(result) : result;
+	if (options.format === "raw") {
+		console.log(totalOfOverride?.total ?? displayResult.total);
+		return;
+	}
+	if (options.format === "json") {
+		const spacing = options.pretty ? 2 : 0;
+		if (!totalOfOverride) {
+			console.log(JSON.stringify(displayResult, null, spacing));
 			return;
 		}
-		if (options.format === "json") {
-			const spacing = options.pretty ? 2 : 0;
-			if (batchOptions.scope === "per-file") {
-				const skipped = showSkipDiagnostics ? summary.skipped : void 0;
-				const meta = totalOfParts && totalOfParts.length > 0 ? {
-					totalOf: totalOfParts,
-					aggregateTotalOfOverride: aggregateTotalOfOverride?.total ?? summary.aggregate.total
-				} : void 0;
-				const payload = {
-					scope: "per-file",
-					files: summary.files.map((file) => ({
-						path: file.path,
-						result: file.result
-					})),
-					...skipped ? { skipped } : {},
-					aggregate: summary.aggregate,
-					...meta ? { meta } : {}
-				};
-				console.log(JSON.stringify(payload, null, spacing));
-				return;
-			}
-			if (!aggregateTotalOfOverride) {
-				console.log(JSON.stringify(summary.aggregate, null, spacing));
-				return;
+		console.log(JSON.stringify({
+			...displayResult,
+			meta: {
+				totalOf: totalOfOverride.parts,
+				totalOfOverride: totalOfOverride.total
 			}
-			console.log(JSON.stringify({
-				...summary.aggregate,
-				meta: {
-					totalOf: aggregateTotalOfOverride.parts,
-					totalOfOverride: aggregateTotalOfOverride.total
-				}
-			}, null, spacing));
+		}, null, spacing));
+		return;
+	}
+	const labels = getTotalLabels(options.mode, resolved.requestedNonWords);
+	if (isSectionedResult(displayResult)) {
+		renderStandardSectionedResult(displayResult, labels, totalOfOverride);
+		return;
+	}
+	renderStandardResult(displayResult, labels.overall, totalOfOverride);
+}
+
+//#endregion
+//#region src/command.ts
+async function runCli(argv = process.argv, runtime = {}) {
+	const program = new Command();
+	const parseMode = (value) => {
+		const normalized = normalizeMode(value);
+		if (!normalized) throw new Error(`Invalid mode: ${value}`);
+		return normalized;
+	};
+	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) => {
+		const debugEnabled = Boolean(options.debug);
+		const debugReportPath = resolveDebugReportPathOption(options.debugReport);
+		const debugReportEnabled = options.debugReport !== void 0 && options.debugReport !== false;
+		if (options.verbose && !debugEnabled) {
+			program.error(import_picocolors.default.red("`--verbose` requires `--debug`."));
 			return;
 		}
-		const labels = getTotalLabels(options.mode, requestedNonWords);
-		const totalOfResolver = totalOfParts && totalOfParts.length > 0 ? (result) => totalOfOverridesByResult?.get(result) ?? resolveTotalOfOverride(result, totalOfParts) : void 0;
-		if (batchOptions.scope === "per-file") {
-			renderPerFileStandard(summary, labels, totalOfResolver);
+		if (debugReportEnabled && !debugEnabled) {
+			program.error(import_picocolors.default.red("`--debug-report` requires `--debug`."));
+			return;
+		}
+		const teeEnabled = Boolean(options.debugReportTee || options.debugTee);
+		if (teeEnabled && !debugReportEnabled) {
+			program.error(import_picocolors.default.red("`--debug-report-tee` (alias: `--debug-tee`) requires `--debug-report`."));
 			return;
 		}
-		if (isSectionedResult(summary.aggregate)) {
-			renderStandardSectionedResult(summary.aggregate, labels, aggregateTotalOfOverride);
+		let debug;
+		try {
+			debug = createDebugChannel({
+				enabled: debugEnabled,
+				verbosity: options.verbose ? "verbose" : "compact",
+				report: debugReportEnabled ? {
+					path: debugReportPath,
+					tee: teeEnabled
+				} : void 0
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			program.error(import_picocolors.default.red(`Failed to initialize debug diagnostics: ${message}`));
 			return;
 		}
-		renderStandardResult(summary.aggregate, labels.overall, aggregateTotalOfOverride);
+		try {
+			const resolved = resolveCountRunOptions(options);
+			if (hasPathInput(options.path)) {
+				await executeBatchCount({
+					argv,
+					options,
+					runtime,
+					resolved,
+					debug,
+					teeEnabled
+				});
+				return;
+			}
+			await executeSingleCount({
+				textTokens,
+				options,
+				resolved
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message === "No input provided. Pass text, pipe stdin, or use --path.") {
+				program.error(import_picocolors.default.red(message));
+				return;
+			}
+			if (message === "No readable text-like inputs were found from --path.") {
+				program.error(import_picocolors.default.red(message));
+				return;
+			}
+			program.error(message);
+		} finally {
+			await debug.close();
+		}
 	});
 	await program.parseAsync(argv);
 }