@dev-pi2pie/word-counter 0.1.4 → 0.1.5-canary.2

package/dist/esm/bin.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
+import { createRequire } from "node:module";
 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 os from "node:os";
+import { fileURLToPath } from "node:url";
 import { parseDocument } from "yaml";
 import { readFile, readdir, stat } from "node:fs/promises";
-
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -17,16 +17,12 @@ 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
-				});
-			}
-		}
+	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;
 };
@@ -34,7 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-
 //#endregion
 //#region src/cli/debug/channel.ts
 const NOOP_CLOSE = async () => {};
@@ -144,7 +139,470 @@ function createDebugChannel(options) {
 		}
 	};
 }
-
+//#endregion
+//#region src/cli/program/version-embedded.ts
+var import_picocolors = /* @__PURE__ */ __toESM((/* @__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;
+})))(), 1);
+//#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/cli/batch/jobs/load-count-worker.ts
+var WorkerRouteUnavailableError = class extends Error {};
+async function resolveWorkerThreadsAvailability() {
+	try {
+		return typeof (await import("node:worker_threads")).Worker === "function";
+	} catch {
+		return false;
+	}
+}
+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 resolveWorkerRoutePreflight(env = process.env) {
+	const disableWorkerJobsEnv = env.WORD_COUNTER_DISABLE_WORKER_JOBS ?? null;
+	const workerRouteDisabledByEnv = disableWorkerJobsEnv === "1";
+	const workerThreadsAvailable = await resolveWorkerThreadsAvailability();
+	try {
+		return {
+			workerThreadsAvailable,
+			workerRouteDisabledByEnv,
+			disableWorkerJobsEnv,
+			workerPoolModuleLoadable: true,
+			workerEntryFound: (await import("./worker-pool.mjs")).resolveWorkerEntryUrl() !== null
+		};
+	} catch {
+		return {
+			workerThreadsAvailable,
+			workerRouteDisabledByEnv,
+			disableWorkerJobsEnv,
+			workerPoolModuleLoadable: false,
+			workerEntryFound: false
+		};
+	}
+}
+async function countBatchInputsWithWorkerJobs(filePaths, options) {
+	if (process.env.WORD_COUNTER_DISABLE_WORKER_JOBS === "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,
+			detectorMode: options.detectorMode ?? "regex",
+			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/doctor/checks.ts
+const REQUIRED_NODE_RANGE = ">=20";
+const REQUIRED_NODE_MAJOR = 20;
+const SAMPLE_TEXT = "Hello 世界";
+function normalizePackageVersion(value) {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : "0.0.0";
+}
+function deriveBuildChannel(packageVersion) {
+	const prereleaseMatch = /(?:^|[.-])(alpha|beta|rc|canary)(?:[.-]|$)/i.exec(packageVersion);
+	if (!prereleaseMatch) return "stable";
+	const channel = prereleaseMatch[1]?.toLowerCase();
+	if (channel === "alpha" || channel === "beta" || channel === "rc" || channel === "canary") return channel;
+	return "stable";
+}
+function parseNodeMajor(version) {
+	const match = /^v?(\d+)(?:\.\d+){0,2}(?:[-+].*)?$/.exec(version.trim());
+	if (!match) return null;
+	const major = Number.parseInt(match[1] ?? "", 10);
+	return Number.isFinite(major) ? major : null;
+}
+function resolveRuntimeSummary(overrides = {}) {
+	const packageVersion = normalizePackageVersion(overrides.packageVersion ?? "0.1.5-canary.2");
+	const nodeVersion = overrides.nodeVersion ?? process.version;
+	const major = parseNodeMajor(nodeVersion);
+	return {
+		packageVersion,
+		buildChannel: deriveBuildChannel(packageVersion),
+		requiredNodeRange: REQUIRED_NODE_RANGE,
+		nodeVersion,
+		meetsProjectRequirement: major !== null && major >= REQUIRED_NODE_MAJOR,
+		platform: overrides.platform ?? process.platform,
+		arch: overrides.arch ?? process.arch
+	};
+}
+function resolveSegmenterHealth(overrides = {}) {
+	const Segmenter = (overrides.intl ?? Intl).Segmenter;
+	const available = typeof Segmenter === "function";
+	let wordGranularity = false;
+	let graphemeGranularity = false;
+	let sampleWordSegmentation = false;
+	if (!available) return {
+		available,
+		wordGranularity,
+		graphemeGranularity,
+		sampleWordSegmentation
+	};
+	try {
+		const wordSegmenter = new Segmenter("en", { granularity: "word" });
+		wordGranularity = true;
+		for (const _segment of wordSegmenter.segment(SAMPLE_TEXT)) {
+			sampleWordSegmentation = true;
+			break;
+		}
+	} catch {
+		wordGranularity = false;
+		sampleWordSegmentation = false;
+	}
+	try {
+		new Segmenter("en", { granularity: "grapheme" });
+		graphemeGranularity = true;
+	} catch {
+		graphemeGranularity = false;
+	}
+	return {
+		available,
+		wordGranularity,
+		graphemeGranularity,
+		sampleWordSegmentation
+	};
+}
+function collectWarnings(runtime, segmenter, workerRoute) {
+	const warnings = [];
+	if (!runtime.meetsProjectRequirement) warnings.push(`Node.js ${runtime.nodeVersion} is outside the supported range ${runtime.requiredNodeRange}.`);
+	if (!segmenter.available) warnings.push("Intl.Segmenter is unavailable.");
+	else {
+		if (!segmenter.wordGranularity) warnings.push("Intl.Segmenter word granularity is unusable.");
+		if (!segmenter.graphemeGranularity) warnings.push("Intl.Segmenter grapheme granularity is unusable.");
+		if (!segmenter.sampleWordSegmentation) warnings.push("Intl.Segmenter sample segmentation failed.");
+	}
+	if (!workerRoute.workerThreadsAvailable) warnings.push("Worker threads are unavailable on this runtime.");
+	if (workerRoute.workerRouteDisabledByEnv) warnings.push("Worker route is disabled by environment.");
+	if (!workerRoute.workerPoolModuleLoadable) warnings.push("Worker route preflight failed: worker-pool module could not be loaded.");
+	else if (!workerRoute.workerEntryFound) warnings.push("Worker route preflight failed: count-worker entry file was not found.");
+	return warnings;
+}
+function resolveStatus(segmenter, warnings) {
+	if (!segmenter.available || !segmenter.wordGranularity || !segmenter.graphemeGranularity || !segmenter.sampleWordSegmentation) return "fail";
+	if (warnings.length > 0) return "warn";
+	return "ok";
+}
+async function createDoctorReport(overrides = {}) {
+	const runtime = resolveRuntimeSummary(overrides);
+	const segmenter = resolveSegmenterHealth(overrides);
+	const env = overrides.env ?? process.env;
+	const jobs = resolveBatchJobsLimit(env);
+	const workerRoute = await resolveWorkerRoutePreflight(env);
+	const warnings = collectWarnings(runtime, segmenter, workerRoute);
+	return {
+		status: resolveStatus(segmenter, warnings),
+		runtime,
+		segmenter,
+		jobs,
+		workerRoute,
+		warnings
+	};
+}
+//#endregion
+//#region src/cli/doctor/render.ts
+function colorStatus(status) {
+	if (status === "ok") return import_picocolors.default.green(import_picocolors.default.bold(status));
+	if (status === "warn") return import_picocolors.default.yellow(import_picocolors.default.bold(status));
+	return import_picocolors.default.red(import_picocolors.default.bold(status));
+}
+function renderSection(title, lines) {
+	console.log(import_picocolors.default.bold(title));
+	for (const line of lines) console.log(`- ${line}`);
+	console.log("");
+}
+function colorBoolean(value, yes = "yes", no = "no") {
+	return value ? import_picocolors.default.green(yes) : import_picocolors.default.red(no);
+}
+function colorNumber(value) {
+	return import_picocolors.default.yellow(String(value));
+}
+function colorStatusWord(value) {
+	return value ? import_picocolors.default.green("ok") : import_picocolors.default.red("fail");
+}
+function renderStandardDoctorReport(report) {
+	console.log(`Doctor: ${colorStatus(report.status)}`);
+	console.log("");
+	renderSection("Runtime", [
+		`package: ${report.runtime.packageVersion} (${report.runtime.buildChannel})`,
+		`node: ${report.runtime.nodeVersion} (supported: ${colorBoolean(report.runtime.meetsProjectRequirement)}; required ${report.runtime.requiredNodeRange})`,
+		`platform: ${report.runtime.platform} ${report.runtime.arch}`
+	]);
+	renderSection("Segmenter", [
+		`Intl.Segmenter: ${colorBoolean(report.segmenter.available, "available", "missing")}`,
+		`word granularity: ${colorStatusWord(report.segmenter.wordGranularity)}`,
+		`grapheme granularity: ${colorStatusWord(report.segmenter.graphemeGranularity)}`,
+		`sample segmentation: ${colorStatusWord(report.segmenter.sampleWordSegmentation)}`
+	]);
+	renderSection("Batch jobs", [
+		`cpuLimit: ${colorNumber(report.jobs.cpuLimit)}`,
+		`uvThreadpool: ${colorNumber(report.jobs.uvThreadpool)}`,
+		`ioLimit: ${colorNumber(report.jobs.ioLimit)}`,
+		`suggestedMaxJobs: ${colorNumber(report.jobs.suggestedMaxJobs)}`
+	]);
+	renderSection("Worker route", [
+		`worker threads: ${colorBoolean(report.workerRoute.workerThreadsAvailable, "available", "missing")}`,
+		`disabled by env: ${colorBoolean(report.workerRoute.workerRouteDisabledByEnv)}`,
+		`disableWorkerJobsEnv: ${report.workerRoute.disableWorkerJobsEnv ?? "null"}`,
+		`worker pool module: ${colorBoolean(report.workerRoute.workerPoolModuleLoadable, "loadable", "missing")}`,
+		`worker entry: ${colorBoolean(report.workerRoute.workerEntryFound, "found", "missing")}`
+	]);
+	if (report.warnings.length > 0) {
+		console.log(import_picocolors.default.bold("Warnings"));
+		for (const warning of report.warnings) console.log(import_picocolors.default.yellow(`- ${warning}`));
+	}
+}
+function renderDoctorReport(report, options) {
+	if (options.format === "json") {
+		console.log(JSON.stringify(report, null, options.pretty ? 2 : 0));
+		return;
+	}
+	renderStandardDoctorReport(report);
+}
+//#endregion
+//#region src/cli/doctor/run.ts
+const DOCTOR_HELP_LINES = [
+	"Usage: word-counter doctor [options]",
+	"",
+	"report runtime diagnostics for this host",
+	"",
+	"Options:",
+	"  --format <format>  doctor output format (json)",
+	"  --pretty           pretty print doctor JSON output (default: false)",
+	"  -h, --help         display help for command"
+];
+function parseDoctorFormat(rawValue) {
+	if (rawValue === void 0) return "standard";
+	if (rawValue === "json") return "json";
+	return null;
+}
+function validateDoctorInvocation(argv) {
+	const doctorIndex = argv.findIndex((token, index) => index >= 2 && token === "doctor");
+	const tokens = doctorIndex >= 0 ? argv.slice(doctorIndex + 1) : [];
+	let expectsFormatValue = false;
+	let format = "standard";
+	let pretty = false;
+	for (const token of tokens) {
+		if (token === "-h" || token === "--help") return {
+			ok: true,
+			help: true
+		};
+		if (expectsFormatValue) {
+			const parsedFormat = parseDoctorFormat(token);
+			if (parsedFormat === null) return {
+				ok: false,
+				message: "`doctor` only supports default text output or `--format json`."
+			};
+			format = parsedFormat;
+			expectsFormatValue = false;
+			continue;
+		}
+		if (token === "--") return {
+			ok: false,
+			message: "`doctor` does not accept positional inputs."
+		};
+		if (token === "--format") {
+			expectsFormatValue = true;
+			continue;
+		}
+		if (token.startsWith("--format=")) {
+			const rawValue = token.slice(9);
+			if (rawValue.length === 0) return {
+				ok: false,
+				message: "`--format` requires a value."
+			};
+			const parsedFormat = parseDoctorFormat(rawValue);
+			if (parsedFormat === null) return {
+				ok: false,
+				message: "`doctor` only supports default text output or `--format json`."
+			};
+			format = parsedFormat;
+			continue;
+		}
+		if (token === "--pretty") {
+			pretty = true;
+			continue;
+		}
+		if (token.startsWith("-")) return {
+			ok: false,
+			message: `\`${token}\` is not supported by \`doctor\`.`
+		};
+		return {
+			ok: false,
+			message: "`doctor` does not accept positional inputs."
+		};
+	}
+	if (expectsFormatValue) return {
+		ok: false,
+		message: "`--format` requires a value."
+	};
+	if (pretty && format !== "json") return {
+		ok: false,
+		message: "`--pretty` requires `--format json`."
+	};
+	return {
+		ok: true,
+		format,
+		pretty
+	};
+}
+function isExplicitDoctorInvocation(argv) {
+	if (argv[2] !== "doctor") return false;
+	const trailingTokens = argv.slice(3);
+	if (trailingTokens.length === 0) return true;
+	return trailingTokens.some((token) => token === "--" || token.startsWith("-"));
+}
+function printDoctorHelp() {
+	for (const line of DOCTOR_HELP_LINES) console.log(line);
+}
+async function executeDoctorCommand({ argv, runtime }) {
+	const validated = validateDoctorInvocation(argv);
+	if (!validated.ok) {
+		console.error(import_picocolors.default.red(`error: ${validated.message}`));
+		process.exitCode = 1;
+		return;
+	}
+	if ("help" in validated) {
+		printDoctorHelp();
+		process.exitCode = 0;
+		return;
+	}
+	const report = await createDoctorReport(runtime);
+	renderDoctorReport(report, {
+		format: validated.format,
+		pretty: validated.pretty
+	});
+	process.exitCode = report.status === "fail" ? 2 : 0;
+}
 //#endregion
 //#region src/cli/path/filter.ts
 const DEFAULT_INCLUDE_EXTENSIONS = Object.freeze([
@@ -221,7 +679,6 @@ function shouldIncludeFromDirectoryRegex(relativePath, filter) {
 	if (!filter.regex) return true;
 	return filter.regex.test(relativePath);
 }
-
 //#endregion
 //#region src/cli/total-of.ts
 const TOTAL_OF_PARTS = Object.freeze([
@@ -316,7 +773,6 @@ function resolveTotalOfOverride(result, parts) {
 function formatTotalOfParts(parts) {
 	return parts.join(", ");
 }
-
 //#endregion
 //#region src/cli/program/options.ts
 const MODE_CHOICES = [
@@ -326,6 +782,7 @@ const MODE_CHOICES = [
 	"char",
 	"char-collector"
 ];
+const DETECTOR_CHOICES = ["regex", "wasm"];
 const FORMAT_CHOICES = [
 	"standard",
 	"raw",
@@ -353,83 +810,8 @@ function parseJobsOption(value) {
 	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 --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();
+	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("--detector <mode>", "locale detector mode").choices(DETECTOR_CHOICES).default("regex")).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
-//#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-embedded.ts
-var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-const EMBEDDED_PACKAGE_VERSION = "0.1.4";
-
 //#endregion
 //#region src/cli/program/version.ts
 function* candidateSearchRoots() {
@@ -462,7 +844,7 @@ function normalizeVersion(value) {
 	return trimmed;
 }
 function resolvePackageVersion(options = {}) {
-	const embeddedVersion = normalizeVersion(options.embeddedVersion ?? EMBEDDED_PACKAGE_VERSION);
+	const embeddedVersion = normalizeVersion(options.embeddedVersion ?? "0.1.5-canary.2");
 	if (embeddedVersion) return embeddedVersion;
 	const maxLevels = options.maxLevels ?? 8;
 	const resolveFromPath = options.resolveFromPath ?? resolveVersionFromPath;
@@ -480,58 +862,11 @@ 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/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) {
 	for (const item of source) target.push(item);
 }
-
 //#endregion
 //#region src/markdown/toml/arrays.ts
 function ensureArrayContainer(result, key) {
@@ -547,7 +882,6 @@ function flattenArrayTables(result) {
 		result[key] = value.map((entry) => Object.entries(entry).map(([entryKey, entryValue]) => `${entryKey}=${entryValue}`).join(", ")).join(" | ");
 	}
 }
-
 //#endregion
 //#region src/markdown/toml/keys.ts
 function stripKeyQuotes(key) {
@@ -566,7 +900,6 @@ function normalizeKeyPath(key) {
 	if (segments.some((segment) => !segment)) return null;
 	return segments.join(".");
 }
-
 //#endregion
 //#region src/markdown/toml/strings.ts
 function stripInlineComment(line) {
@@ -615,7 +948,6 @@ function parseStringLiteral(value) {
 	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return null;
 }
-
 //#endregion
 //#region src/markdown/toml/values.ts
 function parsePrimitive(raw) {
@@ -773,7 +1105,6 @@ function toPlainText(value) {
 	if (Array.isArray(value)) return value.map((item) => String(item)).join(", ");
 	return String(value);
 }
-
 //#endregion
 //#region src/markdown/toml/parse-frontmatter.ts
 function parseTomlFrontmatter(frontmatter) {
@@ -857,7 +1188,6 @@ function parseTomlFrontmatter(frontmatter) {
 	flattenArrayTables(result);
 	return result;
 }
-
 //#endregion
 //#region src/markdown/parse-markdown.ts
 const FENCE_TO_TYPE = {
@@ -992,7 +1322,6 @@ function parseMarkdown(input) {
 		frontmatterType: openingType
 	};
 }
-
 //#endregion
 //#region src/wc/segmenter.ts
 const segmenterCache = /* @__PURE__ */ new Map();
@@ -1021,7 +1350,6 @@ function countCharsForLocale(text, locale) {
 	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;
@@ -1135,7 +1463,6 @@ function createWhitespaceCounts() {
 		other: 0
 	};
 }
-
 //#endregion
 //#region src/wc/analyze.ts
 function analyzeChunk(chunk, collectNonWords, includeWhitespace) {
@@ -1235,7 +1562,6 @@ function aggregateByLocale(chunks) {
 	}
 	return order.map((locale) => map.get(locale));
 }
-
 //#endregion
 //#region src/wc/mode.ts
 const MODE_ALIASES = {
@@ -1303,10 +1629,7 @@ function normalizeMode(input) {
 function resolveMode(input, fallback = "chunk") {
 	return normalizeMode(input) ?? fallback;
 }
-
-//#endregion
-//#region src/wc/latin-hints.ts
-const DEFAULT_LATIN_HINT_RULES_SOURCE = [
+const DEFAULT_LATIN_HINT_RULES = Object.freeze([
 	{
 		tag: "de",
 		pattern: "[äöüÄÖÜß]"
@@ -1343,9 +1666,7 @@ const DEFAULT_LATIN_HINT_RULES_SOURCE = [
 		tag: "is",
 		pattern: "[ðÐþÞ]"
 	}
-];
-const DEFAULT_LATIN_HINT_RULES = Object.freeze(DEFAULT_LATIN_HINT_RULES_SOURCE.map((rule) => Object.freeze({ ...rule })));
-
+].map((rule) => Object.freeze({ ...rule })));
 //#endregion
 //#region src/wc/locale-detect.ts
 const DEFAULT_LOCALE = "und-Latn";
@@ -1465,18 +1786,17 @@ function detectLocaleForChar(char, previousLocale, options = {}, context = resol
 	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;
+		return context.hanHint ?? "und-Hani";
 	}
 	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 (hintedLocale !== "und-Latn") return hintedLocale;
+		if (allowLatinLocaleCarry && previousLocale && isLatinLocale(previousLocale, context) && previousLocale !== "und-Latn") return previousLocale;
 		if (context.latinHint) return context.latinHint;
 		return DEFAULT_LOCALE;
 	}
 	return null;
 }
-
 //#endregion
 //#region src/wc/segment.ts
 const HARD_BOUNDARY_REGEX = /[\r\n,.!?;:，、。！？；：．｡､]/u;
@@ -1513,7 +1833,7 @@ function segmentTextByLocale(text, options = {}) {
 			continue;
 		}
 		if (targetLocale !== currentLocale && detected !== null) {
-			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale, context)) {
+			if (currentLocale === "und-Latn" && isLatinLocale(targetLocale, context)) {
 				const promotionBreakIndex = findLastLatinPromotionBreakIndex(buffer);
 				if (promotionBreakIndex === -1) {
 					currentLocale = targetLocale;
@@ -1544,58 +1864,249 @@ function segmentTextByLocale(text, options = {}) {
 			updateCarryBoundaryState(detected, char);
 			continue;
 		}
-		buffer += char;
-		if (detected !== null) bufferHasScript = true;
-		updateCarryBoundaryState(detected, char);
+		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 {
+			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$1(chunk.nonWords);
+	}, 0) : 0;
+	const total = analyzed.reduce((sum, chunk) => {
+		let chunkTotal = chunk.words;
+		if (collectNonWords && chunk.nonWords) chunkTotal += getNonWordTotal$1(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$1(analyzed, collectNonWords)
+		}
+	};
+	return {
+		total,
+		counts,
+		breakdown: {
+			mode,
+			items: analyzed.map((chunk) => ({
+				locale: chunk.locale,
+				text: chunk.text,
+				words: chunk.words,
+				nonWords: chunk.nonWords
+			}))
+		}
+	};
+}
+function getNonWordTotal$1(nonWords) {
+	return nonWords.counts.emoji + nonWords.counts.symbols + nonWords.counts.punctuation + (nonWords.counts.whitespace ?? 0);
+}
+function collectNonWordsAggregate$1(analyzed, enabled) {
+	if (!enabled) return;
+	const collection = createNonWordCollection();
+	for (const chunk of analyzed) {
+		if (!chunk.nonWords) continue;
+		mergeNonWordCollections(collection, chunk.nonWords);
 	}
-	if (buffer.length > 0) chunks.push({
-		locale: currentLocale,
-		text: buffer
-	});
-	return mergeAdjacentChunks(chunks);
+	return collection;
 }
-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;
+//#endregion
+//#region src/wc/index.ts
+var wc_default = wordCounter;
+//#endregion
+//#region src/markdown/section-count.ts
+function normalizeText$1(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);
 	}
-	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
+function buildPerKeyItems$1(data, mode, options) {
+	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+	return Object.entries(data).map(([key, value]) => {
+		const valueText = normalizeText$1(value);
+		return {
+			name: key,
+			source: "frontmatter",
+			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
+		};
+	});
+}
+function buildSingleItem$1(name, text, mode, options, source) {
+	return [{
+		name,
+		source,
+		result: wc_default(text, options)
+	}];
+}
+function sumTotals$1(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
+			}]
 		};
-		else {
-			merged.push(last);
-			last = chunk;
-		}
 	}
-	merged.push(last);
-	return merged;
+	const parsed = parseMarkdown(input);
+	const frontmatterText = parsed.frontmatter ?? "";
+	const contentText = parsed.content ?? "";
+	let items = [];
+	if (section === "frontmatter") items = buildSingleItem$1("frontmatter", frontmatterText, mode, options, "frontmatter");
+	else if (section === "content") items = buildSingleItem$1("content", contentText, mode, options, "content");
+	else if (section === "split") items = [...buildSingleItem$1("frontmatter", frontmatterText, mode, options, "frontmatter"), ...buildSingleItem$1("content", contentText, mode, options, "content")];
+	else if (section === "per-key") items = buildPerKeyItems$1(parsed.data, mode, options);
+	else if (section === "split-per-key") items = [...buildPerKeyItems$1(parsed.data, mode, options), ...buildSingleItem$1("content", contentText, mode, options, "content")];
+	return {
+		section,
+		total: sumTotals$1(items),
+		frontmatterType: parsed.frontmatterType,
+		items
+	};
 }
-
 //#endregion
-//#region src/wc/wc.ts
-function wordCounter(text, options = {}) {
+//#region src/detector/none.ts
+async function wordCounterWithRegexDetector(text, options = {}) {
+	return wc_default(text, options);
+}
+async function countSectionsWithRegexDetector(input, section, options = {}) {
+	return countSections(input, section, options);
+}
+//#endregion
+//#region src/detector/result-builder.ts
+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);
+	}
+	return collection;
+}
+function buildWordCounterResultFromChunks(chunks, 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);
@@ -1683,25 +2194,8 @@ function wordCounter(text, options = {}) {
 		}
 	};
 }
-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);
-	}
-	return collection;
-}
-
-//#endregion
-//#region src/wc/index.ts
-var wc_default = wordCounter;
-
 //#endregion
-//#region src/markdown/section-count.ts
+//#region src/detector/sections.ts
 function normalizeText(value) {
 	if (value == null) return "";
 	if (typeof value === "string") return value;
@@ -1712,31 +2206,31 @@ function normalizeText(value) {
 		return String(value);
 	}
 }
-function buildPerKeyItems(data, mode, options) {
+async function buildPerKeyItems(data, options) {
 	if (!data || typeof data !== "object" || Array.isArray(data)) return [];
-	return Object.entries(data).map(([key, value]) => {
+	return Promise.all(Object.entries(data).map(async ([key, value]) => {
 		const valueText = normalizeText(value);
 		return {
 			name: key,
 			source: "frontmatter",
-			result: wc_default(valueText ? `${key}: ${valueText}` : key, options)
+			result: await wordCounterWithDetector(valueText ? `${key}: ${valueText}` : key, options)
 		};
-	});
+	}));
 }
-function buildSingleItem(name, text, mode, options, source) {
+async function buildSingleItem(name, text, options, source) {
 	return [{
 		name,
 		source,
-		result: wc_default(text, options)
+		result: await wordCounterWithDetector(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";
+async function countSectionsWithResolvedDetector(input, section, options = {}) {
+	options.mode;
 	if (section === "all") {
-		const result = wc_default(input, options);
+		const result = await wordCounterWithDetector(input, options);
 		return {
 			section,
 			total: result.total,
@@ -1752,11 +2246,11 @@ function countSections(input, section, options = {}) {
 	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")];
+	if (section === "frontmatter") items = await buildSingleItem("frontmatter", frontmatterText, options, "frontmatter");
+	else if (section === "content") items = await buildSingleItem("content", contentText, options, "content");
+	else if (section === "split") items = [...await buildSingleItem("frontmatter", frontmatterText, options, "frontmatter"), ...await buildSingleItem("content", contentText, options, "content")];
+	else if (section === "per-key") items = await buildPerKeyItems(parsed.data, options);
+	else if (section === "split-per-key") items = [...await buildPerKeyItems(parsed.data, options), ...await buildSingleItem("content", contentText, options, "content")];
 	return {
 		section,
 		total: sumTotals(items),
@@ -1764,7 +2258,207 @@ function countSections(input, section, options = {}) {
 		items
 	};
 }
-
+const LATIN_WASM_MIN_CONFIDENCE = .75;
+const HANI_WASM_MIN_CONFIDENCE = .9;
+const LATIN_SCRIPT_REGEX = /\p{Script=Latin}/u;
+const HAN_SCRIPT_REGEX = /\p{Script=Han}/u;
+const DETECTOR_ROUTE_POLICIES = {
+	[DEFAULT_LOCALE]: {
+		routeTag: DEFAULT_LOCALE,
+		minScriptChars: 24,
+		minConfidence: LATIN_WASM_MIN_CONFIDENCE,
+		requireReliable: true
+	},
+	[DEFAULT_HAN_TAG]: {
+		routeTag: DEFAULT_HAN_TAG,
+		minScriptChars: 12,
+		minConfidence: HANI_WASM_MIN_CONFIDENCE,
+		requireReliable: true
+	}
+};
+function isAmbiguousDetectorRoute(locale) {
+	return locale === "und-Latn" || locale === "und-Hani";
+}
+function countScriptBearingCharsForRoute(text, routeTag) {
+	const matcher = routeTag === "und-Hani" ? HAN_SCRIPT_REGEX : LATIN_SCRIPT_REGEX;
+	let count = 0;
+	for (const char of text) if (matcher.test(char)) count += 1;
+	return count;
+}
+function shouldRunWasmDetector(text, routeTag) {
+	const policy = DETECTOR_ROUTE_POLICIES[routeTag];
+	return countScriptBearingCharsForRoute(text, routeTag) >= policy.minScriptChars;
+}
+function normalizeDetectorSampleForRoute(text, routeTag) {
+	const matcher = routeTag === "und-Hani" ? HAN_SCRIPT_REGEX : LATIN_SCRIPT_REGEX;
+	return [...text].map((char) => {
+		if (matcher.test(char)) return char;
+		if (/\s/u.test(char)) return " ";
+		return " ";
+	}).join("").replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/detector/whatlang-wasm.ts
+const GENERATED_FOLDER_NAME = "wasm-language-detector";
+const GENERATED_MODULE_FILE = "language_detector.js";
+const MAX_SEARCH_DEPTH = 8;
+const requireFromHere = createRequire(import.meta.url);
+const WASM_DETECTOR_RUNTIME_UNAVAILABLE_MESSAGE = "WASM detector runtime is unavailable. Run `bun run build:wasm` to generate it.";
+let modulePromise = null;
+function resolveCandidateModulePaths() {
+	const moduleDir = dirname(fileURLToPath(import.meta.url));
+	const candidates = /* @__PURE__ */ new Set();
+	let currentDir = moduleDir;
+	for (let depth = 0; depth < MAX_SEARCH_DEPTH; depth += 1) {
+		candidates.add(join(currentDir, GENERATED_FOLDER_NAME, GENERATED_MODULE_FILE));
+		candidates.add(join(currentDir, "generated", GENERATED_FOLDER_NAME, GENERATED_MODULE_FILE));
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return [...candidates];
+}
+function resolveWhatlangWasmModulePath() {
+	for (const candidate of resolveCandidateModulePaths()) if (existsSync(candidate)) return candidate;
+	throw new Error(WASM_DETECTOR_RUNTIME_UNAVAILABLE_MESSAGE);
+}
+async function loadWhatlangWasmModule() {
+	if (!modulePromise) modulePromise = (async () => {
+		return requireFromHere(resolveWhatlangWasmModulePath());
+	})();
+	return modulePromise;
+}
+async function detectWithWhatlangWasm(text, routeTag) {
+	return (await loadWhatlangWasmModule()).detect_language(text, routeTag);
+}
+//#endregion
+//#region src/detector/whatlang-map.ts
+const LATIN_LANGUAGE_TAGS = {
+	cat: "ca",
+	ces: "cs",
+	dan: "da",
+	deu: "de",
+	eng: "en",
+	fin: "fi",
+	fra: "fr",
+	hun: "hu",
+	ita: "it",
+	lat: "la",
+	nld: "nl",
+	pol: "pl",
+	por: "pt",
+	ron: "ro",
+	spa: "es",
+	swe: "sv",
+	tur: "tr"
+};
+const HANI_LANGUAGE_TAGS = {
+	cmn: "zh",
+	jpn: "ja"
+};
+function hasSupportedScript(result, routeTag) {
+	if (routeTag === "und-Latn") return result.script === "Latin";
+	return result.script === "Mandarin";
+}
+function remapLanguageTag(lang, routeTag) {
+	if (routeTag === "und-Latn") return LATIN_LANGUAGE_TAGS[lang];
+	return HANI_LANGUAGE_TAGS[lang];
+}
+function remapWhatlangResult(result, routeTag) {
+	if (!hasSupportedScript(result, routeTag)) return null;
+	const tag = remapLanguageTag(result.lang, routeTag);
+	if (!tag) return null;
+	return {
+		tag,
+		confidence: result.confidence,
+		reliable: result.reliable,
+		source: "wasm"
+	};
+}
+function getDetectorFallbackTag(routeTag) {
+	return routeTag === "und-Hani" ? DEFAULT_HAN_TAG : DEFAULT_LOCALE;
+}
+//#endregion
+//#region src/detector/wasm.ts
+function shouldAcceptDetectorTag(routeTag, confidence, reliable) {
+	const policy = DETECTOR_ROUTE_POLICIES[routeTag];
+	if (policy.requireReliable && reliable !== true) return false;
+	if (confidence === void 0) return false;
+	return confidence >= policy.minConfidence;
+}
+function buildDetectorWindows(chunks) {
+	const windows = [];
+	for (let index = 0; index < chunks.length; index += 1) {
+		const chunk = chunks[index];
+		if (!chunk || !isAmbiguousDetectorRoute(chunk.locale)) continue;
+		const previousWindow = windows[windows.length - 1];
+		if (previousWindow && previousWindow.routeTag === chunk.locale && previousWindow.endIndex === index - 1) {
+			previousWindow.endIndex = index;
+			previousWindow.text += chunk.text;
+			continue;
+		}
+		windows.push({
+			routeTag: chunk.locale,
+			startIndex: index,
+			endIndex: index,
+			text: chunk.text
+		});
+	}
+	return windows;
+}
+async function resolveWindowLocale(window) {
+	if (!shouldRunWasmDetector(window.text, window.routeTag)) return window.routeTag;
+	const rawResult = await detectWithWhatlangWasm(window.text, window.routeTag);
+	const rawRemapped = rawResult ? remapWhatlangResult(rawResult, window.routeTag) : null;
+	const normalizedSample = normalizeDetectorSampleForRoute(window.text, window.routeTag);
+	const normalizedResult = normalizedSample.length > 0 && normalizedSample !== window.text ? await detectWithWhatlangWasm(normalizedSample, window.routeTag) : null;
+	const normalizedRemapped = normalizedResult ? remapWhatlangResult(normalizedResult, window.routeTag) : null;
+	const candidates = [rawRemapped, normalizedRemapped].filter((value) => value !== null);
+	if (candidates.length === 0) return getDetectorFallbackTag(window.routeTag);
+	const strongestCandidate = candidates.reduce((best, current) => {
+		if (!best) return current;
+		return (current.confidence ?? 0) > (best.confidence ?? 0) ? current : best;
+	}, candidates[0]);
+	if (strongestCandidate && shouldAcceptDetectorTag(window.routeTag, strongestCandidate.confidence, strongestCandidate.reliable)) return strongestCandidate.tag;
+	if (window.routeTag === "und-Latn" && rawRemapped && normalizedRemapped && rawRemapped.tag === normalizedRemapped.tag) {
+		if (Math.max(rawRemapped.confidence ?? 0, normalizedRemapped.confidence ?? 0) >= .7) return rawRemapped.tag;
+	}
+	return getDetectorFallbackTag(window.routeTag);
+}
+async function segmentTextByLocaleWithWasmDetector(text, options = {}) {
+	const chunks = segmentTextByLocale(text, options);
+	const resolved = [...chunks];
+	const windows = buildDetectorWindows(chunks);
+	for (const window of windows) {
+		const resolvedLocale = await resolveWindowLocale(window);
+		for (let index = window.startIndex; index <= window.endIndex; index += 1) {
+			const chunk = resolved[index];
+			if (!chunk) continue;
+			resolved[index] = {
+				...chunk,
+				locale: resolvedLocale
+			};
+		}
+	}
+	return resolved;
+}
+async function wordCounterWithWasmDetector(text, options = {}) {
+	return buildWordCounterResultFromChunks(await segmentTextByLocaleWithWasmDetector(text, options), options);
+}
+async function countSectionsWithWasmDetector(input, section, options = {}) {
+	return countSectionsWithResolvedDetector(input, section, options);
+}
+function resolveDetectorMode(mode) {
+	return mode ?? "regex";
+}
+async function wordCounterWithDetector(text, options = {}) {
+	if (resolveDetectorMode(options.detector) === "wasm") return wordCounterWithWasmDetector(text, options);
+	return wordCounterWithRegexDetector(text, options);
+}
+async function countSectionsWithDetector(input, section, options = {}) {
+	if (resolveDetectorMode(options.detector) === "wasm") return countSectionsWithWasmDetector(input, section, options);
+	return countSectionsWithRegexDetector(input, section, options);
+}
 //#endregion
 //#region src/cli/batch/aggregate.ts
 function mergeWordCounterResult(left, right, preserveCollectorSegments) {
@@ -1978,7 +2672,6 @@ function finalizeBatchSummaryFromFileResults(files, section, wcOptions, options
 		aggregate: section === "all" ? aggregateWordCounterResults(files.map((file) => file.result), preserveCollectorSegments) : aggregateSectionedResults(files.map((file) => file.result), preserveCollectorSegments)
 	};
 }
-
 //#endregion
 //#region src/cli/batch/jobs/queue.ts
 async function runBoundedQueue(total, requestedJobs, worker) {
@@ -1998,7 +2691,6 @@ async function runBoundedQueue(total, requestedJobs, worker) {
 	await Promise.all(Array.from({ length: concurrency }, () => runWorker()));
 	return results;
 }
-
 //#endregion
 //#region src/cli/path/load.ts
 function isProbablyBinary(buffer) {
@@ -2015,7 +2707,6 @@ function isProbablyBinary(buffer) {
 	}
 	return suspicious / sampleSize > .3;
 }
-
 //#endregion
 //#region src/cli/batch/jobs/read-input.ts
 async function readBatchInput(path, options) {
@@ -2046,10 +2737,10 @@ async function readBatchInput(path, options) {
 		content: buffer.toString("utf8")
 	};
 }
-
 //#endregion
 //#region src/cli/batch/jobs/load-count.ts
 async function countBatchInputsWithJobs(filePaths, options) {
+	const detectorMode = options.detectorMode ?? "regex";
 	const limits = resolveBatchJobsLimit();
 	const total = filePaths.length;
 	let completed = 0;
@@ -2072,7 +2763,13 @@ async function countBatchInputsWithJobs(filePaths, options) {
 				}
 			};
 		}
-		const result = options.section === "all" ? wc_default(loaded.content, options.wcOptions) : countSections(loaded.content, options.section, options.wcOptions);
+		const result = detectorMode === "regex" ? options.section === "all" ? wc_default(loaded.content, options.wcOptions) : countSections(loaded.content, options.section, options.wcOptions) : options.section === "all" ? await wordCounterWithDetector(loaded.content, {
+			...options.wcOptions,
+			detector: detectorMode
+		}) : await countSectionsWithDetector(loaded.content, options.section, {
+			...options.wcOptions,
+			detector: detectorMode
+		});
 		if (!options.preserveCollectorSegments) compactCollectorSegmentsInCountResult(result);
 		completed += 1;
 		options.onFileProcessed?.({
@@ -2101,47 +2798,6 @@ async function countBatchInputsWithJobs(filePaths, options) {
 		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 = {}) {
@@ -2150,7 +2806,6 @@ function finalizeBatchJobsSummary(files, section, wcOptions, options = {}) {
 		preserveCollectorSegments: options.preserveCollectorSegments
 	});
 }
-
 //#endregion
 //#region src/cli/path/resolve.ts
 async function expandDirectory(rootPath, directoryPath, recursive, extensionFilter, regexFilter, skipped, recordRegexExcluded, debug, stats) {
@@ -2353,7 +3008,6 @@ async function resolveBatchFilePaths(pathInputs, options) {
 		skipped
 	};
 }
-
 //#endregion
 //#region src/cli/progress/reporter.ts
 const PROGRESS_BAR_WIDTH = 20;
@@ -2457,7 +3111,6 @@ function createBatchProgressReporter(options) {
 		}
 	};
 }
-
 //#endregion
 //#region src/cli/batch/run.ts
 async function runBatchCount(options) {
@@ -2521,6 +3174,7 @@ async function runBatchCount(options) {
 			counted = await countBatchInputsWithWorkerJobs(resolved.files, {
 				jobs: options.jobs,
 				section: options.section,
+				detectorMode: options.wcOptions.detector ?? "regex",
 				wcOptions: options.wcOptions,
 				preserveCollectorSegments: options.preserveCollectorSegments,
 				onFileProcessed: (snapshot) => {
@@ -2544,6 +3198,7 @@ async function runBatchCount(options) {
 			counted = await countBatchInputsWithJobs(resolved.files, {
 				jobs: options.jobs,
 				section: options.section,
+				detectorMode: options.wcOptions.detector ?? "regex",
 				wcOptions: options.wcOptions,
 				preserveCollectorSegments: options.preserveCollectorSegments,
 				onFileProcessed: (snapshot) => {
@@ -2555,6 +3210,7 @@ async function runBatchCount(options) {
 			counted = await countBatchInputsWithJobs(resolved.files, {
 				jobs: options.jobs,
 				section: options.section,
+				detectorMode: options.wcOptions.detector ?? "regex",
 				wcOptions: options.wcOptions,
 				preserveCollectorSegments: options.preserveCollectorSegments,
 				onFileProcessed: (snapshot) => {
@@ -2609,19 +3265,16 @@ 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) {
 	return `${count} ${word}${count === 1 ? "" : "s"}`;
 }
-
 //#endregion
 //#region src/cli/output/render.ts
 function getCountUnit(mode) {
@@ -2766,7 +3419,6 @@ function renderPerFileStandard(summary, labels, resolveTotalOfOverride) {
 	}
 	renderStandardResult(summary.aggregate, labels.overall, resolveTotalOfOverride?.(summary.aggregate));
 }
-
 //#endregion
 //#region src/cli/output/normalize-base.ts
 function normalizeWordCounterResultBase(result) {
@@ -2805,7 +3457,6 @@ function normalizeBatchSummaryBase(summary) {
 	normalizeResultBase(summary.aggregate);
 	return summary;
 }
-
 //#endregion
 //#region src/cli/runtime/options.ts
 function hasPathInput(pathValues) {
@@ -2904,6 +3555,7 @@ function resolveLatinHintRules(options) {
 }
 function resolveCountRunOptions(options) {
 	const useSection = options.section !== "all";
+	const detectorMode = options.detector ?? "regex";
 	const totalOfParts = options.totalOf;
 	const requestedNonWords = Boolean(options.nonWords || options.includeWhitespace || options.misc);
 	const collectNonWordsForOverride = requiresNonWordCollection(totalOfParts);
@@ -2912,10 +3564,12 @@ function resolveCountRunOptions(options) {
 	const enableWhitespace = Boolean(options.includeWhitespace || options.misc || collectWhitespaceForOverride);
 	return {
 		useSection,
+		detectorMode,
 		totalOfParts,
 		requestedNonWords,
 		shouldNormalizeBaseOutput: !requestedNonWords && enableNonWords,
 		wcOptions: {
+			detector: detectorMode,
 			mode: options.mode,
 			latinLanguageHint: options.latinLanguage,
 			latinTagHint: options.latinTag,
@@ -2932,7 +3586,6 @@ function resolveCountRunOptions(options) {
 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 }) {
@@ -3070,7 +3723,6 @@ async function executeBatchCount({ argv, options, runtime, resolved, debug, teeE
 	}
 	renderStandardResult(summary.aggregate, labels.overall, aggregateTotalOfOverride);
 }
-
 //#endregion
 //#region src/cli/runtime/input.ts
 async function readStdin() {
@@ -3088,7 +3740,6 @@ 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 }) {
@@ -3100,7 +3751,13 @@ async function executeSingleCount({ textTokens, options, resolved }) {
 	}
 	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 result = resolved.useSection ? resolved.detectorMode === "regex" ? countSections(trimmed, options.section, resolved.wcOptions) : await countSectionsWithDetector(trimmed, options.section, {
+		...resolved.wcOptions,
+		detector: resolved.detectorMode
+	}) : resolved.detectorMode === "regex" ? wc_default(trimmed, resolved.wcOptions) : await wordCounterWithDetector(trimmed, {
+		...resolved.wcOptions,
+		detector: resolved.detectorMode
+	});
 	const totalOfOverride = resolveTotalOfOverride(result, resolved.totalOfParts);
 	const displayResult = resolved.shouldNormalizeBaseOutput ? normalizeResultBase(result) : result;
 	if (options.format === "raw") {
@@ -3129,17 +3786,23 @@ async function executeSingleCount({ textTokens, options, resolved }) {
 	}
 	renderStandardResult(displayResult, labels.overall, totalOfOverride);
 }
-
 //#endregion
 //#region src/command.ts
 async function runCli(argv = process.argv, runtime = {}) {
+	if (isExplicitDoctorInvocation(argv)) {
+		await executeDoctorCommand({
+			argv,
+			runtime: runtime.doctor
+		});
+		return;
+	}
 	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");
+	program.name("word-counter").description("Locale-aware word counting powered by Intl.Segmenter.").version(getFormattedVersionLabel(), "-v, --version", "output the version number").addHelpText("after", "\nCommands:\n  doctor [options]      report runtime diagnostics for this host");
 	configureProgramOptions(program, parseMode);
 	program.action(async (textTokens, options) => {
 		if (options.printJobsLimit) {
@@ -3219,14 +3882,19 @@ async function runCli(argv = process.argv, runtime = {}) {
 				program.error(import_picocolors.default.red(message));
 				return;
 			}
+			if (message === "WASM detector runtime is unavailable. Run `bun run build:wasm` to generate it.") {
+				console.error(import_picocolors.default.red(message));
+				process.exitCode = 1;
+				return;
+			}
 			program.error(message);
 		} finally {
 			await debug.close();
 		}
 	});
 	await program.parseAsync(argv);
+	if (process.exitCode === void 0) process.exitCode = 0;
 }
-
 //#endregion
 //#region src/bin.ts
 runCli().catch((error) => {
@@ -3234,7 +3902,7 @@ runCli().catch((error) => {
 	console.error("Failed to run CLI:", message);
 	process.exitCode = 1;
 });
-
 //#endregion
-export {  };
+export {};
+
 //# sourceMappingURL=bin.mjs.map