nanos-lint 2.7.0 → 2.8.1

package/dist/{cli-sEO_MZ-K.js → cli-BAy_Ztvh.js}

@@ -1,11 +1,18 @@
 import { fileURLToPath } from "node:url";
+import * as xi from "node:fs";
 import fs from "node:fs";
-import path from "node:path";
+import path, { posix, win32 } from "node:path";
 import os from "node:os";
 import process$1 from "node:process";
 import childProcess, { execFile, execFileSync } from "node:child_process";
+import crypto from "node:crypto";
 import { promisify, stripVTControlCharacters } from "node:util";
+import Pe, { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { lstatSync, readdir, readdirSync, readlinkSync, realpathSync } from "fs";
+import { lstat, readdir as readdir$1, readlink, realpath } from "node:fs/promises";
 import { EventEmitter } from "node:events";
+import { StringDecoder } from "node:string_decoder";
 //#region src/logger.ts
 const LOG_LEVELS = [
 	"silent",
@@ -929,6 +936,77 @@ function cleanCache(targetDir = systemPaths.cache) {
 	}
 	return null;
 }
+/**
+* Recursively calculates total disk usage of a file or directory in bytes.
+* Handles missing paths and inaccessible files gracefully.
+*/
+function getDirectorySize(targetPath) {
+	if (!fs.existsSync(targetPath)) return 0;
+	let total = 0;
+	try {
+		const stat = fs.statSync(targetPath);
+		if (!stat.isDirectory()) return stat.size;
+		const entries = fs.readdirSync(targetPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = `${targetPath}/${entry.name}`;
+			try {
+				if (entry.isDirectory()) total += getDirectorySize(fullPath);
+				else if (entry.isFile()) total += fs.statSync(fullPath).size;
+			} catch (err) {
+				logger.debug(`[paths] Failed to stat entry ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+	} catch (err) {
+		logger.debug(`[paths] Failed to calculate directory size for ${targetPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return 0;
+	}
+	return total;
+}
+/**
+* Formats byte values into human-readable strings (e.g. "86.4 MB", "1.42 MB", "42.5 MB").
+*/
+function formatBytes(bytes) {
+	if (bytes <= 0 || !Number.isFinite(bytes)) return "0 B";
+	if (bytes < 1) return `${Math.round(bytes)} B`;
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	let i = Math.max(0, Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1));
+	let val = bytes / Math.pow(1024, i);
+	if (Math.round(val) >= 1024 && i < units.length - 1) {
+		i++;
+		val /= 1024;
+	}
+	return `${i === 0 ? val.toFixed(0) : val < 10 ? val.toFixed(2) : val < 100 ? val.toFixed(1) : val.toFixed(0)} ${units[i]}`;
+}
+//#endregion
+//#region src/errors.ts
+var NanosLintError = class extends Error {
+	code;
+	remedy;
+	name = "NanosLintError";
+	constructor(message, code, remedy, options) {
+		super(message, options);
+		this.code = code;
+		this.remedy = remedy;
+	}
+};
+var ConfigError = class extends NanosLintError {
+	name = "ConfigError";
+};
+var LuaLSError = class extends NanosLintError {
+	name = "LuaLSError";
+};
+var AnnotationsError = class extends NanosLintError {
+	name = "AnnotationsError";
+};
+var CacheError = class extends NanosLintError {
+	name = "CacheError";
+};
 //#endregion
 //#region src/config.ts
 const __filename = fileURLToPath(import.meta.url);
@@ -980,8 +1058,14 @@ function parseJsonc(text) {
 	return result;
 }
 function loadConfigFile(filePath) {
-	if (!fs.existsSync(filePath)) throw new Error(`Configuration file not found: ${filePath}`);
-	return parseJsonc(fs.readFileSync(filePath, "utf-8"));
+	if (!fs.existsSync(filePath)) throw new ConfigError(`Configuration file not found: ${filePath}`, "ERR_CONFIG_NOT_FOUND", "Ensure the configuration file path is correct or run 'nanos-lint init' to generate a default config.");
+	const content = fs.readFileSync(filePath, "utf-8");
+	try {
+		return parseJsonc(content);
+	} catch (err) {
+		if (err instanceof ConfigError) throw err;
+		throw new ConfigError(`Failed to parse configuration file at ${filePath}: ${err instanceof Error ? err.message : String(err)}`, "ERR_CONFIG_PARSE", "Check your .luarc.json syntax or run 'nanos-lint init --force' to scaffold a clean template.", { cause: err });
+	}
 }
 /**
 * Removes trailing `/` characters from a path-like string.
@@ -997,6 +1081,76 @@ function stripTrailingSlashes(value) {
 	return end === value.length ? value : value.slice(0, end);
 }
 /**
+* Set of recognized diagnostic codes supported by Lua Language Server (LuaLS).
+* LuaLS discards the entire `diagnostics.severity` object if it contains a single
+* unrecognized key (such as obsolete 'syntax-error'). nanos-lint filters severity
+* and neededFileStatus maps against this allow-list to ensure valid configuration.
+*/
+const VALID_LUALS_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+	"ambiguity-1",
+	"assign-type-mismatch",
+	"await-in-sync",
+	"cast-local-type",
+	"cast-type-mismatch",
+	"circle-doc-class",
+	"close-non-object",
+	"code-after-break",
+	"codestyle-check",
+	"count-down-loop",
+	"deprecated",
+	"different-requires",
+	"discard-returns",
+	"doc-field-no-class",
+	"duplicate-doc-alias",
+	"duplicate-doc-field",
+	"duplicate-doc-param",
+	"duplicate-index",
+	"duplicate-set-field",
+	"empty-block",
+	"global-element",
+	"global-in-nil-env",
+	"incomplete-signature-doc",
+	"inject-field",
+	"invisible",
+	"lowercase-global",
+	"missing-fields",
+	"missing-global-doc",
+	"missing-local-export-doc",
+	"missing-parameter",
+	"missing-return",
+	"missing-return-value",
+	"name-style-check",
+	"need-check-nil",
+	"newfield-call",
+	"newline-call",
+	"no-unknown",
+	"not-yieldable",
+	"param-type-mismatch",
+	"redefined-local",
+	"redundant-parameter",
+	"redundant-return",
+	"redundant-return-value",
+	"redundant-value",
+	"return-type-mismatch",
+	"spell-check",
+	"trailing-space",
+	"unbalanced-assignments",
+	"undefined-doc-class",
+	"undefined-doc-name",
+	"undefined-doc-param",
+	"undefined-env-child",
+	"undefined-field",
+	"undefined-global",
+	"unknown-cast-variable",
+	"unknown-diag-code",
+	"unknown-operator",
+	"unreachable-code",
+	"unused-function",
+	"unused-label",
+	"unused-local",
+	"unused-vararg"
+]);
+/**
 * Merges a base nanos configuration with a workspace override configuration.
 * Guarantees that nanos API annotations are included in workspace.library,
 * and standardizes paths for LuaLS.
@@ -1027,10 +1181,20 @@ function mergeConfigs(base, override = {}, definitionsPath = getDefaultAnnotatio
 	const baseGlobals = base.diagnostics?.globals ?? [];
 	const overrideGlobals = override.diagnostics?.globals ?? [];
 	const globalsSet = /* @__PURE__ */ new Set([...baseGlobals, ...overrideGlobals]);
-	const mergedSeverity = {
+	const rawSeverity = {
 		...base.diagnostics?.severity ?? {},
 		...override.diagnostics?.severity ?? {}
 	};
+	const mergedSeverity = {};
+	for (const [code, level] of Object.entries(rawSeverity)) if (VALID_LUALS_DIAGNOSTIC_CODES.has(code)) mergedSeverity[code] = level;
+	else logger.warn(`[config] Unrecognized diagnostic code "${code}" in diagnostics.severity was dropped to prevent LuaLS from discarding the severity configuration.`);
+	const rawNeededFileStatus = {
+		...base.diagnostics?.neededFileStatus ?? {},
+		...override.diagnostics?.neededFileStatus ?? {}
+	};
+	const mergedNeededFileStatus = {};
+	for (const [code, status] of Object.entries(rawNeededFileStatus)) if (VALID_LUALS_DIAGNOSTIC_CODES.has(code)) mergedNeededFileStatus[code] = status;
+	else logger.warn(`[config] Unrecognized diagnostic code "${code}" in diagnostics.neededFileStatus was dropped.`);
 	const hasCliIgnore = Boolean(options?.cliIgnore && options.cliIgnore.length > 0);
 	let mergedIgnoreDir;
 	let mergedFilesExclude;
@@ -1103,7 +1267,8 @@ function mergeConfigs(base, override = {}, definitionsPath = getDefaultAnnotatio
 			...base.diagnostics ?? {},
 			...override.diagnostics ?? {},
 			globals: Array.from(globalsSet),
-			severity: mergedSeverity
+			severity: mergedSeverity,
+			...Object.keys(mergedNeededFileStatus).length > 0 ? { neededFileStatus: mergedNeededFileStatus } : {}
 		}
 	};
 }
@@ -1165,10 +1330,10 @@ function resolveWorkspaceConfig(workspacePath, customConfigPath, options) {
 */
 function initWorkspace(workspacePath, options) {
 	const targetFile = path.join(workspacePath, ".luarc.json");
-	if (fs.existsSync(targetFile) && !options?.force) throw new Error(`.luarc.json already exists at ${targetFile}. Use --force to overwrite.`);
+	if (fs.existsSync(targetFile) && !options?.force) throw new ConfigError(`.luarc.json already exists at ${targetFile}. Use --force to overwrite.`, "ERR_CONFIG_EXISTS", "Pass --force to overwrite the existing .luarc.json file.");
 	const template = loadConfigFile(getDefaultTemplatePath());
 	const sourceAnnotations = options?.annotationsPath || getDefaultAnnotationsPath();
-	if (!fs.existsSync(sourceAnnotations)) throw new Error(`Definitions file not found at ${sourceAnnotations}. Make sure annotations have been downloaded or pass a valid file with --annotations.`);
+	if (!fs.existsSync(sourceAnnotations)) throw new ConfigError(`Definitions file not found at ${sourceAnnotations}. Make sure annotations have been downloaded or pass a valid file with --annotations.`, "ERR_ANNOTATIONS_NOT_FOUND", "Run 'nanos-lint warmup' to download annotations or provide --annotations <path>.");
 	const targetNanosDir = path.join(workspacePath, ".nanos-lint");
 	fs.mkdirSync(targetNanosDir, { recursive: true });
 	const targetAnnotations = path.join(targetNanosDir, "annotations.lua");
@@ -1184,8 +1349,7 @@ function initWorkspace(workspacePath, options) {
 	return targetFile;
 }
 //#endregion
-//#region src/luals.ts
-const execFileAsync = promisify(execFile);
+//#region src/luals/version.ts
 const FALLBACK_LUALS_VERSION = "3.19.1";
 const DEFAULT_LUALS_VERSION = "latest";
 /**
@@ -1222,12 +1386,6 @@ function sanitizeLuaLSVersion(raw) {
 	return first >= 48 && first <= 57 || first >= 65 && first <= 90 || first >= 97 && first <= 122 ? version : null;
 }
 /**
-* Escapes single quotes for safe PowerShell single-quoted string interpolation.
-*/
-function escapePowerShellSingleQuote(str) {
-	return str.replace(/'/g, "''");
-}
-/**
 * Fetches the latest available LuaLS release tag from the GitHub API.
 * Returns null if the request fails, times out, or receives an invalid tag.
 */
@@ -1264,9 +1422,11 @@ async function resolveLatestLuaLSVersion() {
 async function resolveLuaLSVersion(version) {
 	if (!version || version === "latest") return await resolveLatestLuaLSVersion();
 	const sanitized = sanitizeLuaLSVersion(version);
-	if (!sanitized) throw new Error(`Invalid LuaLS version: "${version}". Expected a release tag such as "3.19.1", or "latest".`);
+	if (!sanitized) throw new LuaLSError(`Invalid LuaLS version: "${version}". Expected a release tag such as "3.19.1", or "latest".`, "ERR_LUALS_INVALID_VERSION", "Provide a valid release tag like '3.19.1' or use 'latest'.");
 	return sanitized;
 }
+//#endregion
+//#region src/luals/platform.ts
 function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 	const platform = process.platform;
 	const arch = process.arch;
@@ -1277,7 +1437,7 @@ function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 			assetName: `lua-language-server-${version}-win32-x64.zip`,
 			binaryRelativePath: path.join("bin", "lua-language-server.exe")
 		};
-		throw new Error(`Unsupported Windows architecture: ${arch}. Supported: x64`);
+		throw new LuaLSError(`Unsupported Windows architecture: ${arch}. Supported: x64`, "ERR_LUALS_UNSUPPORTED_ARCH", "LuaLS provides pre-built binaries for Windows x64. Use a compatible system or set LUALS_BIN to a custom binary.");
 	}
 	if (platform === "linux") {
 		if (arch === "x64") return {
@@ -1292,7 +1452,7 @@ function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 			assetName: `lua-language-server-${version}-linux-arm64.tar.gz`,
 			binaryRelativePath: path.join("bin", "lua-language-server")
 		};
-		throw new Error(`Unsupported Linux architecture: ${arch}. Supported: x64, arm64`);
+		throw new LuaLSError(`Unsupported Linux architecture: ${arch}. Supported: x64, arm64`, "ERR_LUALS_UNSUPPORTED_ARCH", "LuaLS provides pre-built binaries for Linux x64 and arm64. Use LUALS_BIN to specify a custom build.");
 	}
 	if (platform === "darwin") return {
 		platform: "darwin",
@@ -1300,8 +1460,91 @@ function getPlatformInfo(version = FALLBACK_LUALS_VERSION) {
 		assetName: `lua-language-server-${version}-darwin-${arch === "arm64" ? "arm64" : "x64"}.tar.gz`,
 		binaryRelativePath: path.join("bin", "lua-language-server")
 	};
-	throw new Error(`Unsupported platform: ${platform}`);
+	throw new LuaLSError(`Unsupported platform: ${platform}`, "ERR_LUALS_UNSUPPORTED_PLATFORM", "LuaLS provides pre-built binaries for Windows, Linux, and macOS. Use LUALS_BIN to specify a custom build.");
+}
+//#endregion
+//#region src/luals/validation.ts
+/**
+* Minimum plausible size of a downloaded LuaLS executable. Release assets are
+* several megabytes, so anything smaller is a truncated download or a stray
+* file. This floor only applies to binaries nanos-lint fetched itself: a
+* user-supplied `LUALS_BIN` may legitimately be a small wrapper script.
+*/
+const MIN_DOWNLOADED_BINARY_SIZE_BYTES = 1e5;
+/**
+* Runs `binaryPath --version` and checks that it reports a LuaLS version.
+* Shared by every binary validation path; the size heuristic stays separate
+* because only downloaded archives have a known-plausible size.
+*/
+function reportsLuaLSVersion(binaryPath) {
+	try {
+		const output = execFileSync(binaryPath, ["--version"], {
+			timeout: 5e3,
+			stdio: "pipe",
+			encoding: "utf-8"
+		});
+		return /^\d+\.\d+\.\d+/.test(output.trim());
+	} catch (err) {
+		logger.debug(`[luals] Binary validation check failed for ${binaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+}
+/**
+* Verifies that a downloaded or cached LuaLS binary exists, has non-trivial
+* size, and is executable.
+*/
+function isBinaryValid(binaryPath) {
+	if (!fs.existsSync(binaryPath)) return false;
+	try {
+		const stats = fs.statSync(binaryPath);
+		if (!stats.isFile() || stats.size < 1e5) return false;
+		return reportsLuaLSVersion(binaryPath);
+	} catch (err) {
+		logger.debug(`[luals] Binary validation check failed for ${binaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+}
+/**
+* Verifies that an explicitly configured binary is a regular file that runs and
+* reports a LuaLS version, without the downloaded-archive size heuristic so
+* wrapper scripts (`LUALS_BIN=/usr/local/bin/lua-language-server`) keep working.
+*/
+function isBinaryRunnable(binaryPath) {
+	try {
+		if (!fs.statSync(binaryPath).isFile()) return false;
+	} catch (err) {
+		logger.debug(`[luals] Binary validation check failed for ${binaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	return reportsLuaLSVersion(binaryPath);
+}
+/**
+* Validates an explicitly configured LuaLS binary (`LUALS_BIN` environment
+* variable or `--luals-bin` CLI option) and returns its path.
+*
+* Both are documented escape hatches, so a typo, a stale path, a directory or an
+* unrelated executable must fail with an actionable error instead of a
+* confusing low-level failure deep inside the check run (#26). Executables are
+* accepted as-is when `--version` reports a version, including the thin wrapper
+* scripts that Homebrew/mason-style installations put on `PATH`: the size floor
+* used for downloaded archives would reject those.
+*
+* @param binaryPath Path exactly as the user supplied it.
+* @param source Name of the setting being validated (`LUALS_BIN` / `--luals-bin`).
+*/
+function assertValidLuaLSBinary(binaryPath, source) {
+	let stats;
+	try {
+		stats = fs.statSync(binaryPath);
+	} catch (err) {
+		throw new LuaLSError(`${source} points to '${binaryPath}', which does not exist or cannot be read: ${err instanceof Error ? err.message : String(err)}`, "ERR_LUALS_BIN_INVALID", `Set ${source} to the full path of a lua-language-server executable, or leave it unset so nanos-lint resolves LuaLS automatically.`, { cause: err });
+	}
+	if (!stats.isFile()) throw new LuaLSError(`${source} points to '${binaryPath}', which is not a regular file (a directory or special file was found).`, "ERR_LUALS_BIN_INVALID", `Point ${source} at the lua-language-server executable itself, or leave it unset so nanos-lint resolves LuaLS automatically.`);
+	if (!isBinaryRunnable(binaryPath)) throw new LuaLSError(`${source} points to '${binaryPath}', which is not a runnable LuaLS binary (running it with '--version' failed or printed no version).`, "ERR_LUALS_BIN_INVALID", `Verify ${source} points at a working lua-language-server executable or wrapper script, or leave it unset so nanos-lint resolves LuaLS automatically.`);
+	return binaryPath;
 }
+//#endregion
+//#region src/luals/cache.ts
 function getBaseLuaLSCacheDir() {
 	return path.join(systemPaths.cache, "luals");
 }
@@ -1340,9 +1583,26 @@ function readLuaLSMetadata(baseCacheDir = getBaseLuaLSCacheDir()) {
 	try {
 		const content = fs.readFileSync(metaPath, "utf-8");
 		const parsed = JSON.parse(content);
-		if (typeof parsed?.lastCheckedWeek === "string" && typeof parsed?.latestVersion === "string") return parsed;
+		const rawVersion = parsed?.latestVersion;
+		const safeVersion = typeof rawVersion === "string" ? sanitizeLuaLSVersion(rawVersion) : null;
+		if (typeof parsed?.lastCheckedWeek === "string" && safeVersion !== null) return {
+			...parsed,
+			latestVersion: safeVersion
+		};
+		try {
+			fs.unlinkSync(metaPath);
+			logger.warn(`[luals] Stale or invalid LuaLS metadata at ${metaPath} purged.`);
+		} catch (unlinkErr) {
+			logger.debug(`[luals] Failed to unlink invalid metadata: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
+		}
 	} catch (err) {
 		logger.debug(`[luals] Failed to parse LuaLS metadata: ${err instanceof Error ? err.message : String(err)}`);
+		try {
+			fs.unlinkSync(metaPath);
+			logger.warn(`[luals] Corrupted LuaLS metadata at ${metaPath} purged.`);
+		} catch (unlinkErr) {
+			logger.debug(`[luals] Failed to unlink corrupted metadata: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
+		}
 	}
 	return null;
 }
@@ -1356,6 +1616,26 @@ function writeLuaLSMetadata(metadata, baseCacheDir = getBaseLuaLSCacheDir()) {
 	}
 }
 /**
+* Lists all candidate LuaLS version directories under baseCacheDir without running
+* execution smoke tests on the binaries.
+*/
+function listCachedLuaLSVersionDirs(baseCacheDir = getBaseLuaLSCacheDir()) {
+	if (!fs.existsSync(baseCacheDir)) return [];
+	try {
+		const entries = fs.readdirSync(baseCacheDir, { withFileTypes: true });
+		const versions = [];
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+			const version = sanitizeLuaLSVersion(entry.name);
+			if (version) versions.push(version);
+		}
+		return versions;
+	} catch (err) {
+		logger.debug(`[luals] Failed to list cached LuaLS version directories: ${err instanceof Error ? err.message : String(err)}`);
+		return [];
+	}
+}
+/**
 * Lists all cached LuaLS versions in baseCacheDir that have a valid .complete marker
 * and a functional executable binary.
 */
@@ -1432,37 +1712,78 @@ function findExistingLuaLSDir(version, baseCacheDir = getBaseLuaLSCacheDir()) {
 		logger.debug(`[luals] Error checking primary LuaLS cache marker at ${primaryMarker}: ${err instanceof Error ? err.message : String(err)}`);
 	}
 	const legacyCache = getLegacyCacheDir(version);
-	const legacyBin = path.join(legacyCache, info.binaryRelativePath);
-	const legacyMarker = path.join(legacyCache, ".complete");
-	if (fs.existsSync(legacyMarker)) try {
-		if (fs.readFileSync(legacyMarker, "utf-8").trim() === version && isBinaryValid(legacyBin)) return legacyCache;
-	} catch (err) {
-		logger.debug(`[luals] Error checking legacy LuaLS cache marker at ${legacyMarker}: ${err instanceof Error ? err.message : String(err)}`);
+	if (path.resolve(legacyCache) !== path.resolve(primaryCache)) {
+		const legacyBin = path.join(legacyCache, info.binaryRelativePath);
+		const legacyMarker = path.join(legacyCache, ".complete");
+		if (fs.existsSync(legacyMarker)) try {
+			if (fs.readFileSync(legacyMarker, "utf-8").trim() === version && isBinaryValid(legacyBin)) return legacyCache;
+		} catch (err) {
+			logger.debug(`[luals] Error checking legacy LuaLS cache marker at ${legacyMarker}: ${err instanceof Error ? err.message : String(err)}`);
+		}
 	}
 	const pkgRoot = getPackageRoot();
 	const pkgBin = path.join(pkgRoot, info.binaryRelativePath);
 	if (fs.existsSync(pkgBin) && isBinaryValid(pkgBin)) return pkgRoot;
 	return null;
 }
+//#endregion
+//#region src/luals/download.ts
+const DOWNLOAD_TIMEOUT_MS = 12e4;
+const MAX_ARCHIVE_SIZE_BYTES = 157286400;
+const ALLOWED_DOWNLOAD_DOMAINS = ["github.com", "githubusercontent.com"];
 /**
-* Verifies that a LuaLS binary exists, has non-trivial size, and is executable.
+* Validates that a download URL uses HTTPS and targets an allowlisted host.
 */
-function isBinaryValid(binaryPath) {
-	if (!fs.existsSync(binaryPath)) return false;
+function isAllowedDownloadUrl(urlString) {
 	try {
-		const stats = fs.statSync(binaryPath);
-		if (!stats.isFile() || stats.size < 1e5) return false;
-		const output = execFileSync(binaryPath, ["--version"], {
-			timeout: 5e3,
-			stdio: "pipe",
-			encoding: "utf-8"
-		});
-		return /^\d+\.\d+\.\d+/.test(output.trim());
-	} catch (err) {
-		logger.debug(`[luals] Binary validation check failed for ${binaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+		const parsed = new URL(urlString);
+		if (parsed.protocol !== "https:") return false;
+		const hostname = parsed.hostname.toLowerCase();
+		return ALLOWED_DOWNLOAD_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+	} catch {
 		return false;
 	}
 }
+/** Chunk size used when hashing an archive, so a 150 MB asset is never buffered whole. */
+const HASH_CHUNK_SIZE_BYTES = 1048576;
+/**
+* Calculates the SHA-256 hash of a file on disk in bounded memory.
+*/
+function computeFileSha256(filePath) {
+	const hash = crypto.createHash("sha256");
+	const fd = fs.openSync(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(HASH_CHUNK_SIZE_BYTES);
+		let position = 0;
+		let bytesRead = fs.readSync(fd, buffer, 0, buffer.length, position);
+		while (bytesRead > 0) {
+			hash.update(buffer.subarray(0, bytesRead));
+			position += bytesRead;
+			bytesRead = fs.readSync(fd, buffer, 0, buffer.length, position);
+		}
+	} finally {
+		fs.closeSync(fd);
+	}
+	return hash.digest("hex");
+}
+const execFileAsync$1 = promisify(execFile);
+/**
+* Escapes single quotes for safe PowerShell single-quoted string interpolation.
+*/
+function escapePowerShellSingleQuote(str) {
+	return str.replace(/'/g, "''");
+}
+/**
+* Enforces a maximum byte count on an asynchronous download stream.
+*/
+async function* limitDownloadStream(source) {
+	let total = 0;
+	for await (const chunk of source) {
+		total += chunk.length;
+		if (total > 157286400) throw new LuaLSError(`Download exceeded maximum allowed size of ${MAX_ARCHIVE_SIZE_BYTES} bytes`, "ERR_LUALS_DOWNLOAD", "Verify the LuaLS release asset size or specify a local binary with LUALS_BIN.");
+		yield chunk;
+	}
+}
 async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDir, options) {
 	const resolvedVersion = await resolveLuaLSVersion(version);
 	const info = getPlatformInfo(resolvedVersion);
@@ -1470,7 +1791,7 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 	const binaryPath = path.join(destDir, info.binaryRelativePath);
 	const completeMarker = path.join(destDir, ".complete");
 	if (fs.existsSync(destDir)) {
-		if (fs.existsSync(binaryPath) && fs.existsSync(completeMarker)) try {
+		if (options?.reuseExisting !== false && fs.existsSync(binaryPath) && fs.existsSync(completeMarker)) try {
 			if (fs.readFileSync(completeMarker, "utf-8").trim() === resolvedVersion && isBinaryValid(binaryPath)) return binaryPath;
 		} catch (err) {
 			logger.debug(`[luals] Failed to read complete marker at ${completeMarker}: ${err instanceof Error ? err.message : String(err)}`);
@@ -1497,12 +1818,17 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 			if (!options?.quiet) logger.info(`[luals] Reusing existing LuaLS ${resolvedVersion} installation from ${existingSourceDir}...`);
 			fs.cpSync(existingSourceDir, tempDir, { recursive: true });
 		} else {
+			if (!isAllowedDownloadUrl(url)) throw new LuaLSError(`Refusing to download LuaLS from untrusted URL: ${url}`, "ERR_LUALS_DOWNLOAD", "Download URLs must use HTTPS and target an allowlisted GitHub host.");
 			if (!options?.quiet) logger.info(`[luals] Downloading LuaLS ${resolvedVersion} from ${url}...`);
 			let response = null;
 			let lastErr = null;
 			for (let attempt = 1; attempt <= 3; attempt++) {
 				try {
-					const res = await fetch(url);
+					const res = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+					if (res.url && !isAllowedDownloadUrl(res.url)) {
+						await res.body?.cancel();
+						throw new LuaLSError(`Redirect to untrusted URL blocked: ${res.url}`, "ERR_LUALS_DOWNLOAD", "Download redirects must stay on allowlisted HTTPS GitHub hosts.");
+					}
 					if (res.ok && res.body) {
 						response = res;
 						break;
@@ -1514,19 +1840,49 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 				}
 				if (attempt < 3) await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
 			}
-			if (!response || !response.body) throw lastErr || /* @__PURE__ */ new Error(`Failed to download ${url}`);
-			const arrayBuffer = await response.arrayBuffer();
-			fs.writeFileSync(archivePath, Buffer.from(arrayBuffer));
+			if (!response || !response.body) {
+				if (lastErr instanceof LuaLSError) throw lastErr;
+				throw new LuaLSError(`Failed to download LuaLS from ${url}${lastErr ? `: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}` : ""}`, "ERR_LUALS_DOWNLOAD", "Check your network connection or specify a custom binary with LUALS_BIN.", { cause: lastErr });
+			}
+			const contentLengthHeader = response.headers?.get?.("content-length");
+			if (contentLengthHeader) {
+				const contentLength = parseInt(contentLengthHeader, 10);
+				if (!isNaN(contentLength) && contentLength > 157286400) {
+					await response.body.cancel();
+					throw new LuaLSError(`Archive size (${contentLength} bytes) exceeds maximum limit (${MAX_ARCHIVE_SIZE_BYTES} bytes)`, "ERR_LUALS_DOWNLOAD", "Verify the LuaLS release asset size or specify a local binary with LUALS_BIN.");
+				}
+			}
+			const fileStream = fs.createWriteStream(archivePath);
+			try {
+				const streamSource = typeof Readable.fromWeb === "function" && !("pipe" in response.body) ? Readable.fromWeb(response.body) : response.body;
+				await pipeline(streamSource, limitDownloadStream, fileStream);
+			} catch (streamErr) {
+				try {
+					if (fs.existsSync(archivePath)) fs.unlinkSync(archivePath);
+				} catch (unlinkErr) {}
+				if (streamErr instanceof LuaLSError) throw streamErr;
+				throw new LuaLSError(`Failed to download LuaLS from ${url}: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`, "ERR_LUALS_DOWNLOAD", "Check your network connection or specify a custom binary with LUALS_BIN.", { cause: streamErr });
+			}
+			const archiveSha256 = computeFileSha256(archivePath);
+			logger.info(`[luals] Downloaded ${info.assetName} (SHA-256 ${archiveSha256})`);
 			if (!options?.quiet) logger.info(`[luals] Extracting to ${destDir}...`);
 			try {
-				await execFileAsync("tar", [
+				const tarArgs = process.platform === "win32" ? [
 					"-xf",
 					archivePath,
 					"-C",
 					tempDir
-				]);
+				] : [
+					"-xf",
+					archivePath,
+					"--no-same-owner",
+					"--no-same-permissions",
+					"-C",
+					tempDir
+				];
+				await execFileAsync$1("tar", tarArgs);
 			} catch (tarErr) {
-				if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync("powershell.exe", [
+				if (process.platform === "win32" && info.assetName.endsWith(".zip")) await execFileAsync$1("powershell.exe", [
 					"-NoProfile",
 					"-Command",
 					`Expand-Archive -Path '${escapePowerShellSingleQuote(archivePath)}' -DestinationPath '${escapePowerShellSingleQuote(tempDir)}' -Force`
@@ -1540,13 +1896,20 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 			}
 		}
 		const tempBinaryPath = path.join(tempDir, info.binaryRelativePath);
+		if (!fs.existsSync(tempBinaryPath)) throw new LuaLSError(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
+		const lstat = fs.lstatSync(tempBinaryPath);
+		if (lstat.isSymbolicLink()) throw new LuaLSError(`Extracted binary at '${tempBinaryPath}' is a symbolic link. Refusing to chmod or execute archive-planted symlinks.`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		if (!lstat.isFile()) throw new LuaLSError(`Extracted binary at '${tempBinaryPath}' is not a regular file.`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
+		const realBinaryPath = fs.realpathSync(tempBinaryPath);
+		const resolvedTemp = fs.realpathSync(tempDir);
+		if (!realBinaryPath.startsWith(resolvedTemp + path.sep) && realBinaryPath !== resolvedTemp) throw new LuaLSError(`Extracted binary path escapes extraction directory: ${realBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and verify the LuaLS release integrity.");
 		if (process.platform !== "win32") try {
 			fs.chmodSync(tempBinaryPath, 493);
 		} catch (err) {
 			logger.warn(`[luals] Failed to chmod binary at ${tempBinaryPath}: ${err instanceof Error ? err.message : String(err)}`);
 		}
-		if (!fs.existsSync(tempBinaryPath) || fs.statSync(tempBinaryPath).size < 1e5) throw new Error(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`);
-		if (!isBinaryValid(tempBinaryPath)) throw new Error(`Extracted LuaLS binary at ${tempBinaryPath} is invalid or non-functional.`);
+		if (lstat.size < 1e5) throw new LuaLSError(`Failed to extract valid LuaLS binary to expected path: ${tempBinaryPath}`, "ERR_LUALS_EXTRACT", "Run 'nanos-lint clean-cache' and ensure there is sufficient disk space.");
+		if (!isBinaryValid(tempBinaryPath)) throw new LuaLSError(`Extracted LuaLS binary at ${tempBinaryPath} is invalid or non-functional.`, "ERR_LUALS_INVALID_BINARY", "Run 'nanos-lint clean-cache' to remove corrupted downloads or set LUALS_BIN to a custom binary.");
 		fs.writeFileSync(path.join(tempDir, ".complete"), resolvedVersion, "utf-8");
 		for (let attempt = 0; attempt < 5; attempt++) try {
 			fs.renameSync(tempDir, destDir);
@@ -1574,25 +1937,3487 @@ async function downloadAndExtractLuaLS(version = DEFAULT_LUALS_VERSION, targetDi
 				} catch (err) {
 					logger.warn(`[luals] Failed to clean up broken destination directory ${destDir}: ${err instanceof Error ? err.message : String(err)}`);
 				}
-				throw renameErr;
+				throw renameErr;
+			}
+		}
+		if (!options?.quiet) logger.info(`[luals] Ready: ${binaryPath}`);
+		return binaryPath;
+	} finally {
+		if (fs.existsSync(tempDir)) try {
+			fs.rmSync(tempDir, {
+				recursive: true,
+				force: true
+			});
+		} catch (err) {
+			logger.debug(`[luals] Failed to clean up temporary directory ${tempDir}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+}
+//#endregion
+//#region node_modules/glob/dist/esm/index.min.js
+var Gt = (n, t, e) => {
+	let s = n instanceof RegExp ? ce(n, e) : n, i = t instanceof RegExp ? ce(t, e) : t, r = s !== null && i != null && ss(s, i, e);
+	return r && {
+		start: r[0],
+		end: r[1],
+		pre: e.slice(0, r[0]),
+		body: e.slice(r[0] + s.length, r[1]),
+		post: e.slice(r[1] + i.length)
+	};
+};
+var ce = (n, t) => {
+	let e = t.match(n);
+	return e ? e[0] : null;
+};
+var ss = (n, t, e) => {
+	let s, i, r, o, h, a = e.indexOf(n), l = e.indexOf(t, a + 1), u = a;
+	if (a >= 0 && l > 0) {
+		if (n === t) return [a, l];
+		for (s = [], r = e.length; u >= 0 && !h;) {
+			if (u === a) s.push(u), a = e.indexOf(n, u + 1);
+			else if (s.length === 1) {
+				let c = s.pop();
+				c !== void 0 && (h = [c, l]);
+			} else i = s.pop(), i !== void 0 && i < r && (r = i, o = l), l = e.indexOf(t, u + 1);
+			u = a < l && a >= 0 ? a : l;
+		}
+		s.length && o !== void 0 && (h = [r, o]);
+	}
+	return h;
+};
+var fe = "\0SLASH" + Math.random() + "\0";
+var ue = "\0OPEN" + Math.random() + "\0";
+var qt = "\0CLOSE" + Math.random() + "\0";
+var de = "\0COMMA" + Math.random() + "\0";
+var pe = "\0PERIOD" + Math.random() + "\0";
+var is = new RegExp(fe, "g");
+var rs = new RegExp(ue, "g");
+var ns = new RegExp(qt, "g");
+var os$1 = new RegExp(de, "g");
+var hs = new RegExp(pe, "g");
+var as = /\\\\/g;
+var ls = /\\{/g;
+var cs = /\\}/g;
+var fs$1 = /\\,/g;
+var us = /\\./g;
+var ds = 1e5;
+function Ht(n) {
+	return isNaN(n) ? n.charCodeAt(0) : parseInt(n, 10);
+}
+function ps(n) {
+	return n.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs$1, de).replace(us, pe);
+}
+function ms(n) {
+	return n.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os$1, ",").replace(hs, ".");
+}
+function me(n) {
+	if (!n) return [""];
+	let t = [], e = Gt("{", "}", n);
+	if (!e) return n.split(",");
+	let { pre: s, body: i, post: r } = e, o = s.split(",");
+	o[o.length - 1] += "{" + i + "}";
+	let h = me(r);
+	return r.length && (o[o.length - 1] += h.shift(), o.push.apply(o, h)), t.push.apply(t, o), t;
+}
+function ge(n, t = {}) {
+	if (!n) return [];
+	let { max: e = ds } = t;
+	return n.slice(0, 2) === "{}" && (n = "\\{\\}" + n.slice(2)), ht(ps(n), e, !0).map(ms);
+}
+function gs(n) {
+	return "{" + n + "}";
+}
+function ws(n) {
+	return /^-?0\d/.test(n);
+}
+function ys(n, t) {
+	return n <= t;
+}
+function bs(n, t) {
+	return n >= t;
+}
+function ht(n, t, e) {
+	let s = [], i = Gt("{", "}", n);
+	if (!i) return [n];
+	let r = i.pre, o = i.post.length ? ht(i.post, t, !1) : [""];
+	if (/\$$/.test(i.pre)) for (let h = 0; h < o.length && h < t; h++) {
+		let a = r + "{" + i.body + "}" + o[h];
+		s.push(a);
+	}
+	else {
+		let h = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body), a = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body), l = h || a, u = i.body.indexOf(",") >= 0;
+		if (!l && !u) return i.post.match(/,(?!,).*\}/) ? (n = i.pre + "{" + i.body + qt + i.post, ht(n, t, !0)) : [n];
+		let c;
+		if (l) c = i.body.split(/\.\./);
+		else if (c = me(i.body), c.length === 1 && c[0] !== void 0 && (c = ht(c[0], t, !1).map(gs), c.length === 1)) return o.map((f) => i.pre + c[0] + f);
+		let d;
+		if (l && c[0] !== void 0 && c[1] !== void 0) {
+			let f = Ht(c[0]), m = Ht(c[1]), p = Math.max(c[0].length, c[1].length), w = c.length === 3 && c[2] !== void 0 ? Math.abs(Ht(c[2])) : 1, g = ys;
+			m < f && (w *= -1, g = bs);
+			let E = c.some(ws);
+			d = [];
+			for (let y = f; g(y, m); y += w) {
+				let b;
+				if (a) b = String.fromCharCode(y), b === "\\" && (b = "");
+				else if (b = String(y), E) {
+					let z = p - b.length;
+					if (z > 0) {
+						let $ = new Array(z + 1).join("0");
+						y < 0 ? b = "-" + $ + b.slice(1) : b = $ + b;
+					}
+				}
+				d.push(b);
+			}
+		} else {
+			d = [];
+			for (let f = 0; f < c.length; f++) d.push.apply(d, ht(c[f], t, !1));
+		}
+		for (let f = 0; f < d.length; f++) for (let m = 0; m < o.length && s.length < t; m++) {
+			let p = r + d[f] + o[m];
+			(!e || l || p) && s.push(p);
+		}
+	}
+	return s;
+}
+var at = (n) => {
+	if (typeof n != "string") throw new TypeError("invalid pattern");
+	if (n.length > 65536) throw new TypeError("pattern is too long");
+};
+var Ss = {
+	"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", !0],
+	"[:alpha:]": ["\\p{L}\\p{Nl}", !0],
+	"[:ascii:]": ["\\x00-\\x7f", !1],
+	"[:blank:]": ["\\p{Zs}\\t", !0],
+	"[:cntrl:]": ["\\p{Cc}", !0],
+	"[:digit:]": ["\\p{Nd}", !0],
+	"[:graph:]": [
+		"\\p{Z}\\p{C}",
+		!0,
+		!0
+	],
+	"[:lower:]": ["\\p{Ll}", !0],
+	"[:print:]": ["\\p{C}", !0],
+	"[:punct:]": ["\\p{P}", !0],
+	"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", !0],
+	"[:upper:]": ["\\p{Lu}", !0],
+	"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", !0],
+	"[:xdigit:]": ["A-Fa-f0-9", !1]
+};
+var lt = (n) => n.replace(/[[\]\\-]/g, "\\$&");
+var Es = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var we = (n) => n.join("");
+var ye = (n, t) => {
+	let e = t;
+	if (n.charAt(e) !== "[") throw new Error("not in a brace expression");
+	let s = [], i = [], r = e + 1, o = !1, h = !1, a = !1, l = !1, u = e, c = "";
+	t: for (; r < n.length;) {
+		let p = n.charAt(r);
+		if ((p === "!" || p === "^") && r === e + 1) {
+			l = !0, r++;
+			continue;
+		}
+		if (p === "]" && o && !a) {
+			u = r + 1;
+			break;
+		}
+		if (o = !0, p === "\\" && !a) {
+			a = !0, r++;
+			continue;
+		}
+		if (p === "[" && !a) {
+			for (let [w, [g, S, E]] of Object.entries(Ss)) if (n.startsWith(w, r)) {
+				if (c) return [
+					"$.",
+					!1,
+					n.length - e,
+					!0
+				];
+				r += w.length, E ? i.push(g) : s.push(g), h = h || S;
+				continue t;
+			}
+		}
+		if (a = !1, c) {
+			p > c ? s.push(lt(c) + "-" + lt(p)) : p === c && s.push(lt(p)), c = "", r++;
+			continue;
+		}
+		if (n.startsWith("-]", r + 1)) {
+			s.push(lt(p + "-")), r += 2;
+			continue;
+		}
+		if (n.startsWith("-", r + 1)) {
+			c = p, r += 2;
+			continue;
+		}
+		s.push(lt(p)), r++;
+	}
+	if (u < r) return [
+		"",
+		!1,
+		0,
+		!1
+	];
+	if (!s.length && !i.length) return [
+		"$.",
+		!1,
+		n.length - e,
+		!0
+	];
+	if (i.length === 0 && s.length === 1 && /^\\?.$/.test(s[0]) && !l) return [
+		Es(s[0].length === 2 ? s[0].slice(-1) : s[0]),
+		!1,
+		u - e,
+		!1
+	];
+	let d = "[" + (l ? "^" : "") + we(s) + "]", f = "[" + (l ? "" : "^") + we(i) + "]";
+	return [
+		s.length && i.length ? "(" + d + "|" + f + ")" : s.length ? d : f,
+		h,
+		u - e,
+		!0
+	];
+};
+var W = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !0 } = {}) => e ? t ? n.replace(/\[([^\/\\])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1") : t ? n.replace(/\[([^\/\\{}])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+var xs = /* @__PURE__ */ new Set([
+	"!",
+	"?",
+	"+",
+	"*",
+	"@"
+]);
+var be = (n) => xs.has(n);
+var vs = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var Ct = "(?!\\.)";
+var Cs = /* @__PURE__ */ new Set(["[", "."]);
+var Ts = /* @__PURE__ */ new Set(["..", "."]);
+var As = /* @__PURE__ */ new Set("().*{}+?[]^$\\!");
+var ks = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Kt = "[^/]";
+var Se = Kt + "*?";
+var Ee = Kt + "+?";
+var Q = class n {
+	type;
+	#t;
+	#s;
+	#n = !1;
+	#r = [];
+	#o;
+	#S;
+	#w;
+	#c = !1;
+	#h;
+	#u;
+	#f = !1;
+	constructor(t, e, s = {}) {
+		this.type = t, t && (this.#s = !0), this.#o = e, this.#t = this.#o ? this.#o.#t : this, this.#h = this.#t === this ? s : this.#t.#h, this.#w = this.#t === this ? [] : this.#t.#w, t === "!" && !this.#t.#c && this.#w.push(this), this.#S = this.#o ? this.#o.#r.length : 0;
+	}
+	get hasMagic() {
+		if (this.#s !== void 0) return this.#s;
+		for (let t of this.#r) if (typeof t != "string" && (t.type || t.hasMagic)) return this.#s = !0;
+		return this.#s;
+	}
+	toString() {
+		return this.#u !== void 0 ? this.#u : this.type ? this.#u = this.type + "(" + this.#r.map((t) => String(t)).join("|") + ")" : this.#u = this.#r.map((t) => String(t)).join("");
+	}
+	#a() {
+		if (this !== this.#t) throw new Error("should only call on root");
+		if (this.#c) return this;
+		this.toString(), this.#c = !0;
+		let t;
+		for (; t = this.#w.pop();) {
+			if (t.type !== "!") continue;
+			let e = t, s = e.#o;
+			for (; s;) {
+				for (let i = e.#S + 1; !s.type && i < s.#r.length; i++) for (let r of t.#r) {
+					if (typeof r == "string") throw new Error("string part in extglob AST??");
+					r.copyIn(s.#r[i]);
+				}
+				e = s, s = e.#o;
+			}
+		}
+		return this;
+	}
+	push(...t) {
+		for (let e of t) if (e !== "") {
+			if (typeof e != "string" && !(e instanceof n && e.#o === this)) throw new Error("invalid part: " + e);
+			this.#r.push(e);
+		}
+	}
+	toJSON() {
+		let t = this.type === null ? this.#r.slice().map((e) => typeof e == "string" ? e : e.toJSON()) : [this.type, ...this.#r.map((e) => e.toJSON())];
+		return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === this.#t || this.#t.#c && this.#o?.type === "!") && t.push({}), t;
+	}
+	isStart() {
+		if (this.#t === this) return !0;
+		if (!this.#o?.isStart()) return !1;
+		if (this.#S === 0) return !0;
+		let t = this.#o;
+		for (let e = 0; e < this.#S; e++) {
+			let s = t.#r[e];
+			if (!(s instanceof n && s.type === "!")) return !1;
+		}
+		return !0;
+	}
+	isEnd() {
+		if (this.#t === this || this.#o?.type === "!") return !0;
+		if (!this.#o?.isEnd()) return !1;
+		if (!this.type) return this.#o?.isEnd();
+		let t = this.#o ? this.#o.#r.length : 0;
+		return this.#S === t - 1;
+	}
+	copyIn(t) {
+		typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+	}
+	clone(t) {
+		let e = new n(this.type, t);
+		for (let s of this.#r) e.copyIn(s);
+		return e;
+	}
+	static #i(t, e, s, i) {
+		let r = !1, o = !1, h = -1, a = !1;
+		if (e.type === null) {
+			let f = s, m = "";
+			for (; f < t.length;) {
+				let p = t.charAt(f++);
+				if (r || p === "\\") {
+					r = !r, m += p;
+					continue;
+				}
+				if (o) {
+					f === h + 1 ? (p === "^" || p === "!") && (a = !0) : p === "]" && !(f === h + 2 && a) && (o = !1), m += p;
+					continue;
+				} else if (p === "[") {
+					o = !0, h = f, a = !1, m += p;
+					continue;
+				}
+				if (!i.noext && be(p) && t.charAt(f) === "(") {
+					e.push(m), m = "";
+					let w = new n(p, e);
+					f = n.#i(t, w, f, i), e.push(w);
+					continue;
+				}
+				m += p;
+			}
+			return e.push(m), f;
+		}
+		let l = s + 1, u = new n(null, e), c = [], d = "";
+		for (; l < t.length;) {
+			let f = t.charAt(l++);
+			if (r || f === "\\") {
+				r = !r, d += f;
+				continue;
+			}
+			if (o) {
+				l === h + 1 ? (f === "^" || f === "!") && (a = !0) : f === "]" && !(l === h + 2 && a) && (o = !1), d += f;
+				continue;
+			} else if (f === "[") {
+				o = !0, h = l, a = !1, d += f;
+				continue;
+			}
+			if (be(f) && t.charAt(l) === "(") {
+				u.push(d), d = "";
+				let m = new n(f, u);
+				u.push(m), l = n.#i(t, m, l, i);
+				continue;
+			}
+			if (f === "|") {
+				u.push(d), d = "", c.push(u), u = new n(null, e);
+				continue;
+			}
+			if (f === ")") return d === "" && e.#r.length === 0 && (e.#f = !0), u.push(d), d = "", e.push(...c, u), l;
+			d += f;
+		}
+		return e.type = null, e.#s = void 0, e.#r = [t.substring(s - 1)], l;
+	}
+	static fromGlob(t, e = {}) {
+		let s = new n(null, void 0, e);
+		return n.#i(t, s, 0, e), s;
+	}
+	toMMPattern() {
+		if (this !== this.#t) return this.#t.toMMPattern();
+		let t = this.toString(), [e, s, i, r] = this.toRegExpSource();
+		if (!(i || this.#s || this.#h.nocase && !this.#h.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase())) return s;
+		let h = (this.#h.nocase ? "i" : "") + (r ? "u" : "");
+		return Object.assign(new RegExp(`^${e}$`, h), {
+			_src: e,
+			_glob: t
+		});
+	}
+	get options() {
+		return this.#h;
+	}
+	toRegExpSource(t) {
+		let e = t ?? !!this.#h.dot;
+		if (this.#t === this && this.#a(), !this.type) {
+			let a = this.isStart() && this.isEnd() && !this.#r.some((f) => typeof f != "string"), l = this.#r.map((f) => {
+				let [m, p, w, g] = typeof f == "string" ? n.#E(f, this.#s, a) : f.toRegExpSource(t);
+				return this.#s = this.#s || w, this.#n = this.#n || g, m;
+			}).join(""), u = "";
+			if (this.isStart() && typeof this.#r[0] == "string" && !(this.#r.length === 1 && Ts.has(this.#r[0]))) {
+				let m = Cs, p = e && m.has(l.charAt(0)) || l.startsWith("\\.") && m.has(l.charAt(2)) || l.startsWith("\\.\\.") && m.has(l.charAt(4)), w = !e && !t && m.has(l.charAt(0));
+				u = p ? vs : w ? Ct : "";
+			}
+			let c = "";
+			return this.isEnd() && this.#t.#c && this.#o?.type === "!" && (c = "(?:$|\\/)"), [
+				u + l + c,
+				W(l),
+				this.#s = !!this.#s,
+				this.#n
+			];
+		}
+		let s = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:", r = this.#d(e);
+		if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+			let a = this.toString();
+			return this.#r = [a], this.type = null, this.#s = void 0, [
+				a,
+				W(this.toString()),
+				!1,
+				!1
+			];
+		}
+		let o = !s || t || e || !Ct ? "" : this.#d(!0);
+		o === r && (o = ""), o && (r = `(?:${r})(?:${o})*?`);
+		let h = "";
+		if (this.type === "!" && this.#f) h = (this.isStart() && !e ? Ct : "") + Ee;
+		else {
+			let a = this.type === "!" ? "))" + (this.isStart() && !e && !t ? Ct : "") + Se + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : `)${this.type}`;
+			h = i + r + a;
+		}
+		return [
+			h,
+			W(r),
+			this.#s = !!this.#s,
+			this.#n
+		];
+	}
+	#d(t) {
+		return this.#r.map((e) => {
+			if (typeof e == "string") throw new Error("string type in extglob ast??");
+			let [s, i, r, o] = e.toRegExpSource(t);
+			return this.#n = this.#n || o, s;
+		}).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+	}
+	static #E(t, e, s = !1) {
+		let i = !1, r = "", o = !1, h = !1;
+		for (let a = 0; a < t.length; a++) {
+			let l = t.charAt(a);
+			if (i) {
+				i = !1, r += (As.has(l) ? "\\" : "") + l;
+				continue;
+			}
+			if (l === "*") {
+				if (h) continue;
+				h = !0, r += s && /^[*]+$/.test(t) ? Ee : Se, e = !0;
+				continue;
+			} else h = !1;
+			if (l === "\\") {
+				a === t.length - 1 ? r += "\\\\" : i = !0;
+				continue;
+			}
+			if (l === "[") {
+				let [u, c, d, f] = ye(t, a);
+				if (d) {
+					r += u, o = o || c, a += d - 1, e = e || f;
+					continue;
+				}
+			}
+			if (l === "?") {
+				r += Kt, e = !0;
+				continue;
+			}
+			r += ks(l);
+		}
+		return [
+			r,
+			W(t),
+			!!e,
+			o
+		];
+	}
+};
+var tt = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !1 } = {}) => e ? t ? n.replace(/[?*()[\]{}]/g, "[$&]") : n.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? n.replace(/[?*()[\]]/g, "[$&]") : n.replace(/[?*()[\]\\]/g, "\\$&");
+var O = (n, t, e = {}) => (at(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new D(t, e).match(n));
+var Rs = /^\*+([^+@!?\*\[\(]*)$/;
+var Os = (n) => (t) => !t.startsWith(".") && t.endsWith(n);
+var Fs = (n) => (t) => t.endsWith(n);
+var Ds = (n) => (n = n.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(n));
+var Ms = (n) => (n = n.toLowerCase(), (t) => t.toLowerCase().endsWith(n));
+var Ns = /^\*+\.\*+$/;
+var _s = (n) => !n.startsWith(".") && n.includes(".");
+var Ls = (n) => n !== "." && n !== ".." && n.includes(".");
+var Ws = /^\.\*+$/;
+var Ps = (n) => n !== "." && n !== ".." && n.startsWith(".");
+var js = /^\*+$/;
+var Is = (n) => n.length !== 0 && !n.startsWith(".");
+var zs = (n) => n.length !== 0 && n !== "." && n !== "..";
+var Bs = /^\?+([^+@!?\*\[\(]*)?$/;
+var Us = ([n, t = ""]) => {
+	let e = Ce([n]);
+	return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+};
+var $s = ([n, t = ""]) => {
+	let e = Te([n]);
+	return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+};
+var Gs = ([n, t = ""]) => {
+	let e = Te([n]);
+	return t ? (s) => e(s) && s.endsWith(t) : e;
+};
+var Hs = ([n, t = ""]) => {
+	let e = Ce([n]);
+	return t ? (s) => e(s) && s.endsWith(t) : e;
+};
+var Ce = ([n]) => {
+	let t = n.length;
+	return (e) => e.length === t && !e.startsWith(".");
+};
+var Te = ([n]) => {
+	let t = n.length;
+	return (e) => e.length === t && e !== "." && e !== "..";
+};
+var Ae = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var xe = {
+	win32: { sep: "\\" },
+	posix: { sep: "/" }
+};
+O.sep = Ae === "win32" ? xe.win32.sep : xe.posix.sep;
+var A = Symbol("globstar **");
+O.GLOBSTAR = A;
+var Vs = "[^/]*?";
+var Ys = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var Xs = "(?:(?!(?:\\/|^)\\.).)*?";
+var Js = (n, t = {}) => (e) => O(e, n, t);
+O.filter = Js;
+var N = (n, t = {}) => Object.assign({}, n, t);
+var Zs = (n) => {
+	if (!n || typeof n != "object" || !Object.keys(n).length) return O;
+	let t = O;
+	return Object.assign((s, i, r = {}) => t(s, i, N(n, r)), {
+		Minimatch: class extends t.Minimatch {
+			constructor(i, r = {}) {
+				super(i, N(n, r));
+			}
+			static defaults(i) {
+				return t.defaults(N(n, i)).Minimatch;
+			}
+		},
+		AST: class extends t.AST {
+			constructor(i, r, o = {}) {
+				super(i, r, N(n, o));
+			}
+			static fromGlob(i, r = {}) {
+				return t.AST.fromGlob(i, N(n, r));
+			}
+		},
+		unescape: (s, i = {}) => t.unescape(s, N(n, i)),
+		escape: (s, i = {}) => t.escape(s, N(n, i)),
+		filter: (s, i = {}) => t.filter(s, N(n, i)),
+		defaults: (s) => t.defaults(N(n, s)),
+		makeRe: (s, i = {}) => t.makeRe(s, N(n, i)),
+		braceExpand: (s, i = {}) => t.braceExpand(s, N(n, i)),
+		match: (s, i, r = {}) => t.match(s, i, N(n, r)),
+		sep: t.sep,
+		GLOBSTAR: A
+	});
+};
+O.defaults = Zs;
+var ke = (n, t = {}) => (at(n), t.nobrace || !/\{(?:(?!\{).)*\}/.test(n) ? [n] : ge(n, { max: t.braceExpandMax }));
+O.braceExpand = ke;
+var Qs = (n, t = {}) => new D(n, t).makeRe();
+O.makeRe = Qs;
+var ti = (n, t, e = {}) => {
+	let s = new D(t, e);
+	return n = n.filter((i) => s.match(i)), s.options.nonull && !n.length && n.push(t), n;
+};
+O.match = ti;
+var ve = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var ei = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var D = class {
+	options;
+	set;
+	pattern;
+	windowsPathsNoEscape;
+	nonegate;
+	negate;
+	comment;
+	empty;
+	preserveMultipleSlashes;
+	partial;
+	globSet;
+	globParts;
+	nocase;
+	isWindows;
+	platform;
+	windowsNoMagicRoot;
+	regexp;
+	constructor(t, e = {}) {
+		at(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || Ae, this.isWindows = this.platform === "win32";
+		let s = "allowWindowsEscape";
+		this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e[s] === !1, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!e.nonegate, this.comment = !1, this.empty = !1, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+	}
+	hasMagic() {
+		if (this.options.magicalBraces && this.set.length > 1) return !0;
+		for (let t of this.set) for (let e of t) if (typeof e != "string") return !0;
+		return !1;
+	}
+	debug(...t) {}
+	make() {
+		let t = this.pattern, e = this.options;
+		if (!e.nocomment && t.charAt(0) === "#") {
+			this.comment = !0;
+			return;
+		}
+		if (!t) {
+			this.empty = !0;
+			return;
+		}
+		this.parseNegate(), this.globSet = [...new Set(this.braceExpand())], e.debug && (this.debug = (...r) => console.error(...r)), this.debug(this.pattern, this.globSet);
+		let s = this.globSet.map((r) => this.slashSplit(r));
+		this.globParts = this.preprocess(s), this.debug(this.pattern, this.globParts);
+		let i = this.globParts.map((r, o, h) => {
+			if (this.isWindows && this.windowsNoMagicRoot) {
+				let a = r[0] === "" && r[1] === "" && (r[2] === "?" || !ve.test(r[2])) && !ve.test(r[3]), l = /^[a-z]:/i.test(r[0]);
+				if (a) return [...r.slice(0, 4), ...r.slice(4).map((u) => this.parse(u))];
+				if (l) return [r[0], ...r.slice(1).map((u) => this.parse(u))];
+			}
+			return r.map((a) => this.parse(a));
+		});
+		if (this.debug(this.pattern, i), this.set = i.filter((r) => r.indexOf(!1) === -1), this.isWindows) for (let r = 0; r < this.set.length; r++) {
+			let o = this.set[r];
+			o[0] === "" && o[1] === "" && this.globParts[r][2] === "?" && typeof o[3] == "string" && /^[a-z]:$/i.test(o[3]) && (o[2] = "?");
+		}
+		this.debug(this.pattern, this.set);
+	}
+	preprocess(t) {
+		if (this.options.noglobstar) for (let s = 0; s < t.length; s++) for (let i = 0; i < t[s].length; i++) t[s][i] === "**" && (t[s][i] = "*");
+		let { optimizationLevel: e = 1 } = this.options;
+		return e >= 2 ? (t = this.firstPhasePreProcess(t), t = this.secondPhasePreProcess(t)) : e >= 1 ? t = this.levelOneOptimize(t) : t = this.adjascentGlobstarOptimize(t), t;
+	}
+	adjascentGlobstarOptimize(t) {
+		return t.map((e) => {
+			let s = -1;
+			for (; (s = e.indexOf("**", s + 1)) !== -1;) {
+				let i = s;
+				for (; e[i + 1] === "**";) i++;
+				i !== s && e.splice(s, i - s);
+			}
+			return e;
+		});
+	}
+	levelOneOptimize(t) {
+		return t.map((e) => (e = e.reduce((s, i) => {
+			let r = s[s.length - 1];
+			return i === "**" && r === "**" ? s : i === ".." && r && r !== ".." && r !== "." && r !== "**" ? (s.pop(), s) : (s.push(i), s);
+		}, []), e.length === 0 ? [""] : e));
+	}
+	levelTwoFileOptimize(t) {
+		Array.isArray(t) || (t = this.slashSplit(t));
+		let e = !1;
+		do {
+			if (e = !1, !this.preserveMultipleSlashes) {
+				for (let i = 1; i < t.length - 1; i++) {
+					let r = t[i];
+					i === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = !0, t.splice(i, 1), i--);
+				}
+				t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+			}
+			let s = 0;
+			for (; (s = t.indexOf("..", s + 1)) !== -1;) {
+				let i = t[s - 1];
+				i && i !== "." && i !== ".." && i !== "**" && (e = !0, t.splice(s - 1, 2), s -= 2);
+			}
+		} while (e);
+		return t.length === 0 ? [""] : t;
+	}
+	firstPhasePreProcess(t) {
+		let e = !1;
+		do {
+			e = !1;
+			for (let s of t) {
+				let i = -1;
+				for (; (i = s.indexOf("**", i + 1)) !== -1;) {
+					let o = i;
+					for (; s[o + 1] === "**";) o++;
+					o > i && s.splice(i + 1, o - i);
+					let h = s[i + 1], a = s[i + 2], l = s[i + 3];
+					if (h !== ".." || !a || a === "." || a === ".." || !l || l === "." || l === "..") continue;
+					e = !0, s.splice(i, 1);
+					let u = s.slice(0);
+					u[i] = "**", t.push(u), i--;
+				}
+				if (!this.preserveMultipleSlashes) {
+					for (let o = 1; o < s.length - 1; o++) {
+						let h = s[o];
+						o === 1 && h === "" && s[0] === "" || (h === "." || h === "") && (e = !0, s.splice(o, 1), o--);
+					}
+					s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = !0, s.pop());
+				}
+				let r = 0;
+				for (; (r = s.indexOf("..", r + 1)) !== -1;) {
+					let o = s[r - 1];
+					if (o && o !== "." && o !== ".." && o !== "**") {
+						e = !0;
+						let a = r === 1 && s[r + 1] === "**" ? ["."] : [];
+						s.splice(r - 1, 2, ...a), s.length === 0 && s.push(""), r -= 2;
+					}
+				}
+			}
+		} while (e);
+		return t;
+	}
+	secondPhasePreProcess(t) {
+		for (let e = 0; e < t.length - 1; e++) for (let s = e + 1; s < t.length; s++) {
+			let i = this.partsMatch(t[e], t[s], !this.preserveMultipleSlashes);
+			if (i) {
+				t[e] = [], t[s] = i;
+				break;
+			}
+		}
+		return t.filter((e) => e.length);
+	}
+	partsMatch(t, e, s = !1) {
+		let i = 0, r = 0, o = [], h = "";
+		for (; i < t.length && r < e.length;) if (t[i] === e[r]) o.push(h === "b" ? e[r] : t[i]), i++, r++;
+		else if (s && t[i] === "**" && e[r] === t[i + 1]) o.push(t[i]), i++;
+		else if (s && e[r] === "**" && t[i] === e[r + 1]) o.push(e[r]), r++;
+		else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+			if (h === "b") return !1;
+			h = "a", o.push(t[i]), i++, r++;
+		} else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+			if (h === "a") return !1;
+			h = "b", o.push(e[r]), i++, r++;
+		} else return !1;
+		return t.length === e.length && o;
+	}
+	parseNegate() {
+		if (this.nonegate) return;
+		let t = this.pattern, e = !1, s = 0;
+		for (let i = 0; i < t.length && t.charAt(i) === "!"; i++) e = !e, s++;
+		s && (this.pattern = t.slice(s)), this.negate = e;
+	}
+	matchOne(t, e, s = !1) {
+		let i = this.options;
+		if (this.isWindows) {
+			let p = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), w = !p && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), g = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), S = !g && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), E = w ? 3 : p ? 0 : void 0, y = S ? 3 : g ? 0 : void 0;
+			if (typeof E == "number" && typeof y == "number") {
+				let [b, z] = [t[E], e[y]];
+				b.toLowerCase() === z.toLowerCase() && (e[y] = b, y > E ? e = e.slice(y) : E > y && (t = t.slice(E)));
+			}
+		}
+		let { optimizationLevel: r = 1 } = this.options;
+		r >= 2 && (t = this.levelTwoFileOptimize(t)), this.debug("matchOne", this, {
+			file: t,
+			pattern: e
+		}), this.debug("matchOne", t.length, e.length);
+		for (var o = 0, h = 0, a = t.length, l = e.length; o < a && h < l; o++, h++) {
+			this.debug("matchOne loop");
+			var u = e[h], c = t[o];
+			if (this.debug(e, u, c), u === !1) return !1;
+			if (u === A) {
+				this.debug("GLOBSTAR", [
+					e,
+					u,
+					c
+				]);
+				var d = o, f = h + 1;
+				if (f === l) {
+					for (this.debug("** at the end"); o < a; o++) if (t[o] === "." || t[o] === ".." || !i.dot && t[o].charAt(0) === ".") return !1;
+					return !0;
+				}
+				for (; d < a;) {
+					var m = t[d];
+					if (this.debug(`
+globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) return this.debug("globstar found match!", d, a, m), !0;
+					if (m === "." || m === ".." || !i.dot && m.charAt(0) === ".") {
+						this.debug("dot detected!", t, d, e, f);
+						break;
+					}
+					this.debug("globstar swallow a segment, and continue"), d++;
+				}
+				return !!(s && (this.debug(`
+>>> no match, partial?`, t, d, e, f), d === a));
+			}
+			let p;
+			if (typeof u == "string" ? (p = c === u, this.debug("string match", u, c, p)) : (p = u.test(c), this.debug("pattern match", u, c, p)), !p) return !1;
+		}
+		if (o === a && h === l) return !0;
+		if (o === a) return s;
+		if (h === l) return o === a - 1 && t[o] === "";
+		throw new Error("wtf?");
+	}
+	braceExpand() {
+		return ke(this.pattern, this.options);
+	}
+	parse(t) {
+		at(t);
+		let e = this.options;
+		if (t === "**") return A;
+		if (t === "") return "";
+		let s, i = null;
+		(s = t.match(js)) ? i = e.dot ? zs : Is : (s = t.match(Rs)) ? i = (e.nocase ? e.dot ? Ms : Ds : e.dot ? Fs : Os)(s[1]) : (s = t.match(Bs)) ? i = (e.nocase ? e.dot ? $s : Us : e.dot ? Gs : Hs)(s) : (s = t.match(Ns)) ? i = e.dot ? Ls : _s : (s = t.match(Ws)) && (i = Ps);
+		let r = Q.fromGlob(t, this.options).toMMPattern();
+		return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), r;
+	}
+	makeRe() {
+		if (this.regexp || this.regexp === !1) return this.regexp;
+		let t = this.set;
+		if (!t.length) return this.regexp = !1, this.regexp;
+		let e = this.options, s = e.noglobstar ? Vs : e.dot ? Ys : Xs, i = new Set(e.nocase ? ["i"] : []), r = t.map((a) => {
+			let l = a.map((c) => {
+				if (c instanceof RegExp) for (let d of c.flags.split("")) i.add(d);
+				return typeof c == "string" ? ei(c) : c === A ? A : c._src;
+			});
+			l.forEach((c, d) => {
+				let f = l[d + 1], m = l[d - 1];
+				c !== A || m === A || (m === void 0 ? f !== void 0 && f !== A ? l[d + 1] = "(?:\\/|" + s + "\\/)?" + f : l[d] = s : f === void 0 ? l[d - 1] = m + "(?:\\/|\\/" + s + ")?" : f !== A && (l[d - 1] = m + "(?:\\/|\\/" + s + "\\/)" + f, l[d + 1] = A));
+			});
+			let u = l.filter((c) => c !== A);
+			if (this.partial && u.length >= 1) {
+				let c = [];
+				for (let d = 1; d <= u.length; d++) c.push(u.slice(0, d).join("/"));
+				return "(?:" + c.join("|") + ")";
+			}
+			return u.join("/");
+		}).join("|"), [o, h] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+		r = "^" + o + r + h + "$", this.partial && (r = "^(?:\\/|" + o + r.slice(1, -1) + h + ")$"), this.negate && (r = "^(?!" + r + ").+$");
+		try {
+			this.regexp = new RegExp(r, [...i].join(""));
+		} catch {
+			this.regexp = !1;
+		}
+		return this.regexp;
+	}
+	slashSplit(t) {
+		return this.preserveMultipleSlashes ? t.split("/") : this.isWindows && /^\/\/[^\/]+/.test(t) ? ["", ...t.split(/\/+/)] : t.split(/\/+/);
+	}
+	match(t, e = this.partial) {
+		if (this.debug("match", t, this.pattern), this.comment) return !1;
+		if (this.empty) return t === "";
+		if (t === "/" && e) return !0;
+		let s = this.options;
+		this.isWindows && (t = t.split("\\").join("/"));
+		let i = this.slashSplit(t);
+		this.debug(this.pattern, "split", i);
+		let r = this.set;
+		this.debug(this.pattern, "set", r);
+		let o = i[i.length - 1];
+		if (!o) for (let h = i.length - 2; !o && h >= 0; h--) o = i[h];
+		for (let h = 0; h < r.length; h++) {
+			let a = r[h], l = i;
+			if (s.matchBase && a.length === 1 && (l = [o]), this.matchOne(l, a, e)) return s.flipNegate ? !0 : !this.negate;
+		}
+		return s.flipNegate ? !1 : this.negate;
+	}
+	static defaults(t) {
+		return O.defaults(t).Minimatch;
+	}
+};
+O.AST = Q;
+O.Minimatch = D;
+O.escape = tt;
+O.unescape = W;
+var si = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var Oe = /* @__PURE__ */ new Set();
+var Vt = typeof process == "object" && process ? process : {};
+var Fe = (n, t, e, s) => {
+	typeof Vt.emitWarning == "function" ? Vt.emitWarning(n, t, e, s) : console.error(`[${e}] ${t}: ${n}`);
+};
+var At = globalThis.AbortController;
+var Re = globalThis.AbortSignal;
+if (typeof At > "u") {
+	Re = class {
+		onabort;
+		_onabort = [];
+		reason;
+		aborted = !1;
+		addEventListener(e, s) {
+			this._onabort.push(s);
+		}
+	}, At = class {
+		constructor() {
+			t();
+		}
+		signal = new Re();
+		abort(e) {
+			if (!this.signal.aborted) {
+				this.signal.reason = e, this.signal.aborted = !0;
+				for (let s of this.signal._onabort) s(e);
+				this.signal.onabort?.(e);
+			}
+		}
+	};
+	let n = Vt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+		n && (n = !1, Fe("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+	};
+}
+var ii = (n) => !Oe.has(n);
+var q = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+var De = (n) => q(n) ? n <= Math.pow(2, 8) ? Uint8Array : n <= Math.pow(2, 16) ? Uint16Array : n <= Math.pow(2, 32) ? Uint32Array : n <= Number.MAX_SAFE_INTEGER ? Tt : null : null;
+var Tt = class extends Array {
+	constructor(n) {
+		super(n), this.fill(0);
+	}
+};
+var ri = class ct {
+	heap;
+	length;
+	static #t = !1;
+	static create(t) {
+		let e = De(t);
+		if (!e) return [];
+		ct.#t = !0;
+		let s = new ct(t, e);
+		return ct.#t = !1, s;
+	}
+	constructor(t, e) {
+		if (!ct.#t) throw new TypeError("instantiate Stack using Stack.create(n)");
+		this.heap = new e(t), this.length = 0;
+	}
+	push(t) {
+		this.heap[this.length++] = t;
+	}
+	pop() {
+		return this.heap[--this.length];
+	}
+};
+var ft = class Me {
+	#t;
+	#s;
+	#n;
+	#r;
+	#o;
+	#S;
+	#w;
+	#c;
+	get perf() {
+		return this.#c;
+	}
+	ttl;
+	ttlResolution;
+	ttlAutopurge;
+	updateAgeOnGet;
+	updateAgeOnHas;
+	allowStale;
+	noDisposeOnSet;
+	noUpdateTTL;
+	maxEntrySize;
+	sizeCalculation;
+	noDeleteOnFetchRejection;
+	noDeleteOnStaleGet;
+	allowStaleOnFetchAbort;
+	allowStaleOnFetchRejection;
+	ignoreFetchAbort;
+	#h;
+	#u;
+	#f;
+	#a;
+	#i;
+	#d;
+	#E;
+	#b;
+	#p;
+	#R;
+	#m;
+	#C;
+	#T;
+	#g;
+	#y;
+	#x;
+	#A;
+	#e;
+	#_;
+	static unsafeExposeInternals(t) {
+		return {
+			starts: t.#T,
+			ttls: t.#g,
+			autopurgeTimers: t.#y,
+			sizes: t.#C,
+			keyMap: t.#f,
+			keyList: t.#a,
+			valList: t.#i,
+			next: t.#d,
+			prev: t.#E,
+			get head() {
+				return t.#b;
+			},
+			get tail() {
+				return t.#p;
+			},
+			free: t.#R,
+			isBackgroundFetch: (e) => t.#l(e),
+			backgroundFetch: (e, s, i, r) => t.#U(e, s, i, r),
+			moveToTail: (e) => t.#W(e),
+			indexes: (e) => t.#F(e),
+			rindexes: (e) => t.#D(e),
+			isStale: (e) => t.#v(e)
+		};
+	}
+	get max() {
+		return this.#t;
+	}
+	get maxSize() {
+		return this.#s;
+	}
+	get calculatedSize() {
+		return this.#u;
+	}
+	get size() {
+		return this.#h;
+	}
+	get fetchMethod() {
+		return this.#S;
+	}
+	get memoMethod() {
+		return this.#w;
+	}
+	get dispose() {
+		return this.#n;
+	}
+	get onInsert() {
+		return this.#r;
+	}
+	get disposeAfter() {
+		return this.#o;
+	}
+	constructor(t) {
+		let { max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: r, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: a, dispose: l, onInsert: u, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: f, maxSize: m = 0, maxEntrySize: p = 0, sizeCalculation: w, fetchMethod: g, memoMethod: S, noDeleteOnFetchRejection: E, noDeleteOnStaleGet: y, allowStaleOnFetchRejection: b, allowStaleOnFetchAbort: z, ignoreFetchAbort: $, perf: J } = t;
+		if (J !== void 0 && typeof J?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+		if (this.#c = J ?? si, e !== 0 && !q(e)) throw new TypeError("max option must be a nonnegative integer");
+		let Z = e ? De(e) : Array;
+		if (!Z) throw new Error("invalid max value: " + e);
+		if (this.#t = e, this.#s = m, this.maxEntrySize = p || this.#s, this.sizeCalculation = w, this.sizeCalculation) {
+			if (!this.#s && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+			if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+		}
+		if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+		if (this.#w = S, g !== void 0 && typeof g != "function") throw new TypeError("fetchMethod must be a function if specified");
+		if (this.#S = g, this.#A = !!g, this.#f = /* @__PURE__ */ new Map(), this.#a = new Array(e).fill(void 0), this.#i = new Array(e).fill(void 0), this.#d = new Z(e), this.#E = new Z(e), this.#b = 0, this.#p = 0, this.#R = ri.create(e), this.#h = 0, this.#u = 0, typeof l == "function" && (this.#n = l), typeof u == "function" && (this.#r = u), typeof c == "function" ? (this.#o = c, this.#m = []) : (this.#o = void 0, this.#m = void 0), this.#x = !!this.#n, this.#_ = !!this.#r, this.#e = !!this.#o, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!f, this.noDeleteOnFetchRejection = !!E, this.allowStaleOnFetchRejection = !!b, this.allowStaleOnFetchAbort = !!z, this.ignoreFetchAbort = !!$, this.maxEntrySize !== 0) {
+			if (this.#s !== 0 && !q(this.#s)) throw new TypeError("maxSize must be a positive integer if specified");
+			if (!q(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+			this.#G();
+		}
+		if (this.allowStale = !!a, this.noDeleteOnStaleGet = !!y, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = q(i) || i === 0 ? i : 1, this.ttlAutopurge = !!r, this.ttl = s || 0, this.ttl) {
+			if (!q(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+			this.#M();
+		}
+		if (this.#t === 0 && this.ttl === 0 && this.#s === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+		if (!this.ttlAutopurge && !this.#t && !this.#s) {
+			let $t = "LRU_CACHE_UNBOUNDED";
+			ii($t) && (Oe.add($t), Fe("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", $t, Me));
+		}
+	}
+	getRemainingTTL(t) {
+		return this.#f.has(t) ? 1 / 0 : 0;
+	}
+	#M() {
+		let t = new Tt(this.#t), e = new Tt(this.#t);
+		this.#g = t, this.#T = e;
+		let s = this.ttlAutopurge ? new Array(this.#t) : void 0;
+		this.#y = s, this.#j = (o, h, a = this.#c.now()) => {
+			if (e[o] = h !== 0 ? a : 0, t[o] = h, s?.[o] && (clearTimeout(s[o]), s[o] = void 0), h !== 0 && s) {
+				let l = setTimeout(() => {
+					this.#v(o) && this.#O(this.#a[o], "expire");
+				}, h + 1);
+				l.unref && l.unref(), s[o] = l;
+			}
+		}, this.#k = (o) => {
+			e[o] = t[o] !== 0 ? this.#c.now() : 0;
+		}, this.#N = (o, h) => {
+			if (t[h]) {
+				let a = t[h], l = e[h];
+				if (!a || !l) return;
+				o.ttl = a, o.start = l, o.now = i || r();
+				o.remainingTTL = a - (o.now - l);
+			}
+		};
+		let i = 0, r = () => {
+			let o = this.#c.now();
+			if (this.ttlResolution > 0) {
+				i = o;
+				let h = setTimeout(() => i = 0, this.ttlResolution);
+				h.unref && h.unref();
+			}
+			return o;
+		};
+		this.getRemainingTTL = (o) => {
+			let h = this.#f.get(o);
+			if (h === void 0) return 0;
+			let a = t[h], l = e[h];
+			if (!a || !l) return 1 / 0;
+			return a - ((i || r()) - l);
+		}, this.#v = (o) => {
+			let h = e[o], a = t[o];
+			return !!a && !!h && (i || r()) - h > a;
+		};
+	}
+	#k = () => {};
+	#N = () => {};
+	#j = () => {};
+	#v = () => !1;
+	#G() {
+		let t = new Tt(this.#t);
+		this.#u = 0, this.#C = t, this.#P = (e) => {
+			this.#u -= t[e], t[e] = 0;
+		}, this.#I = (e, s, i, r) => {
+			if (this.#l(s)) return 0;
+			if (!q(i)) if (r) {
+				if (typeof r != "function") throw new TypeError("sizeCalculation must be a function");
+				if (i = r(s, e), !q(i)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+			} else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+			return i;
+		}, this.#L = (e, s, i) => {
+			if (t[e] = s, this.#s) {
+				let r = this.#s - t[e];
+				for (; this.#u > r;) this.#B(!0);
+			}
+			this.#u += t[e], i && (i.entrySize = s, i.totalCalculatedSize = this.#u);
+		};
+	}
+	#P = (t) => {};
+	#L = (t, e, s) => {};
+	#I = (t, e, s, i) => {
+		if (s || i) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+		return 0;
+	};
+	*#F({ allowStale: t = this.allowStale } = {}) {
+		if (this.#h) for (let e = this.#p; !(!this.#z(e) || ((t || !this.#v(e)) && (yield e), e === this.#b));) e = this.#E[e];
+	}
+	*#D({ allowStale: t = this.allowStale } = {}) {
+		if (this.#h) for (let e = this.#b; !(!this.#z(e) || ((t || !this.#v(e)) && (yield e), e === this.#p));) e = this.#d[e];
+	}
+	#z(t) {
+		return t !== void 0 && this.#f.get(this.#a[t]) === t;
+	}
+	*entries() {
+		for (let t of this.#F()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+	}
+	*rentries() {
+		for (let t of this.#D()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+	}
+	*keys() {
+		for (let t of this.#F()) {
+			let e = this.#a[t];
+			e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+		}
+	}
+	*rkeys() {
+		for (let t of this.#D()) {
+			let e = this.#a[t];
+			e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+		}
+	}
+	*values() {
+		for (let t of this.#F()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
+	}
+	*rvalues() {
+		for (let t of this.#D()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	[Symbol.toStringTag] = "LRUCache";
+	find(t, e = {}) {
+		for (let s of this.#F()) {
+			let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+			if (r !== void 0 && t(r, this.#a[s], this)) return this.get(this.#a[s], e);
+		}
+	}
+	forEach(t, e = this) {
+		for (let s of this.#F()) {
+			let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+			r !== void 0 && t.call(e, r, this.#a[s], this);
+		}
+	}
+	rforEach(t, e = this) {
+		for (let s of this.#D()) {
+			let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+			r !== void 0 && t.call(e, r, this.#a[s], this);
+		}
+	}
+	purgeStale() {
+		let t = !1;
+		for (let e of this.#D({ allowStale: !0 })) this.#v(e) && (this.#O(this.#a[e], "expire"), t = !0);
+		return t;
+	}
+	info(t) {
+		let e = this.#f.get(t);
+		if (e === void 0) return;
+		let s = this.#i[e], i = this.#l(s) ? s.__staleWhileFetching : s;
+		if (i === void 0) return;
+		let r = { value: i };
+		if (this.#g && this.#T) {
+			let o = this.#g[e], h = this.#T[e];
+			if (o && h) r.ttl = o - (this.#c.now() - h), r.start = Date.now();
+		}
+		return this.#C && (r.size = this.#C[e]), r;
+	}
+	dump() {
+		let t = [];
+		for (let e of this.#F({ allowStale: !0 })) {
+			let s = this.#a[e], i = this.#i[e], r = this.#l(i) ? i.__staleWhileFetching : i;
+			if (r === void 0 || s === void 0) continue;
+			let o = { value: r };
+			if (this.#g && this.#T) {
+				o.ttl = this.#g[e];
+				let h = this.#c.now() - this.#T[e];
+				o.start = Math.floor(Date.now() - h);
+			}
+			this.#C && (o.size = this.#C[e]), t.unshift([s, o]);
+		}
+		return t;
+	}
+	load(t) {
+		this.clear();
+		for (let [e, s] of t) {
+			if (s.start) {
+				let i = Date.now() - s.start;
+				s.start = this.#c.now() - i;
+			}
+			this.set(e, s.value, s);
+		}
+	}
+	set(t, e, s = {}) {
+		if (e === void 0) return this.delete(t), this;
+		let { ttl: i = this.ttl, start: r, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: a } = s, { noUpdateTTL: l = this.noUpdateTTL } = s, u = this.#I(t, e, s.size || 0, h);
+		if (this.maxEntrySize && u > this.maxEntrySize) return a && (a.set = "miss", a.maxEntrySizeExceeded = !0), this.#O(t, "set"), this;
+		let c = this.#h === 0 ? void 0 : this.#f.get(t);
+		if (c === void 0) c = this.#h === 0 ? this.#p : this.#R.length !== 0 ? this.#R.pop() : this.#h === this.#t ? this.#B(!1) : this.#h, this.#a[c] = t, this.#i[c] = e, this.#f.set(t, c), this.#d[this.#p] = c, this.#E[c] = this.#p, this.#p = c, this.#h++, this.#L(c, u, a), a && (a.set = "add"), l = !1, this.#_ && this.#r?.(e, t, "add");
+		else {
+			this.#W(c);
+			let d = this.#i[c];
+			if (e !== d) {
+				if (this.#A && this.#l(d)) {
+					d.__abortController.abort(/* @__PURE__ */ new Error("replaced"));
+					let { __staleWhileFetching: f } = d;
+					f !== void 0 && !o && (this.#x && this.#n?.(f, t, "set"), this.#e && this.#m?.push([
+						f,
+						t,
+						"set"
+					]));
+				} else o || (this.#x && this.#n?.(d, t, "set"), this.#e && this.#m?.push([
+					d,
+					t,
+					"set"
+				]));
+				if (this.#P(c), this.#L(c, u, a), this.#i[c] = e, a) {
+					a.set = "replace";
+					let f = d && this.#l(d) ? d.__staleWhileFetching : d;
+					f !== void 0 && (a.oldValue = f);
+				}
+			} else a && (a.set = "update");
+			this.#_ && this.onInsert?.(e, t, e === d ? "update" : "replace");
+		}
+		if (i !== 0 && !this.#g && this.#M(), this.#g && (l || this.#j(c, i, r), a && this.#N(a, c)), !o && this.#e && this.#m) {
+			let d = this.#m, f;
+			for (; f = d?.shift();) this.#o?.(...f);
+		}
+		return this;
+	}
+	pop() {
+		try {
+			for (; this.#h;) {
+				let t = this.#i[this.#b];
+				if (this.#B(!0), this.#l(t)) {
+					if (t.__staleWhileFetching) return t.__staleWhileFetching;
+				} else if (t !== void 0) return t;
+			}
+		} finally {
+			if (this.#e && this.#m) {
+				let t = this.#m, e;
+				for (; e = t?.shift();) this.#o?.(...e);
+			}
+		}
+	}
+	#B(t) {
+		let e = this.#b, s = this.#a[e], i = this.#i[e];
+		return this.#A && this.#l(i) ? i.__abortController.abort(/* @__PURE__ */ new Error("evicted")) : (this.#x || this.#e) && (this.#x && this.#n?.(i, s, "evict"), this.#e && this.#m?.push([
+			i,
+			s,
+			"evict"
+		])), this.#P(e), this.#y?.[e] && (clearTimeout(this.#y[e]), this.#y[e] = void 0), t && (this.#a[e] = void 0, this.#i[e] = void 0, this.#R.push(e)), this.#h === 1 ? (this.#b = this.#p = 0, this.#R.length = 0) : this.#b = this.#d[e], this.#f.delete(s), this.#h--, e;
+	}
+	has(t, e = {}) {
+		let { updateAgeOnHas: s = this.updateAgeOnHas, status: i } = e, r = this.#f.get(t);
+		if (r !== void 0) {
+			let o = this.#i[r];
+			if (this.#l(o) && o.__staleWhileFetching === void 0) return !1;
+			if (this.#v(r)) i && (i.has = "stale", this.#N(i, r));
+			else return s && this.#k(r), i && (i.has = "hit", this.#N(i, r)), !0;
+		} else i && (i.has = "miss");
+		return !1;
+	}
+	peek(t, e = {}) {
+		let { allowStale: s = this.allowStale } = e, i = this.#f.get(t);
+		if (i === void 0 || !s && this.#v(i)) return;
+		let r = this.#i[i];
+		return this.#l(r) ? r.__staleWhileFetching : r;
+	}
+	#U(t, e, s, i) {
+		let r = e === void 0 ? void 0 : this.#i[e];
+		if (this.#l(r)) return r;
+		let o = new At(), { signal: h } = s;
+		h?.addEventListener("abort", () => o.abort(h.reason), { signal: o.signal });
+		let a = {
+			signal: o.signal,
+			options: s,
+			context: i
+		}, l = (p, w = !1) => {
+			let { aborted: g } = o.signal, S = s.ignoreFetchAbort && p !== void 0, E = s.ignoreFetchAbort || !!(s.allowStaleOnFetchAbort && p !== void 0);
+			if (s.status && (g && !w ? (s.status.fetchAborted = !0, s.status.fetchError = o.signal.reason, S && (s.status.fetchAbortIgnored = !0)) : s.status.fetchResolved = !0), g && !S && !w) return c(o.signal.reason, E);
+			let y = f, b = this.#i[e];
+			return (b === f || S && w && b === void 0) && (p === void 0 ? y.__staleWhileFetching !== void 0 ? this.#i[e] = y.__staleWhileFetching : this.#O(t, "fetch") : (s.status && (s.status.fetchUpdated = !0), this.set(t, p, a.options))), p;
+		}, u = (p) => (s.status && (s.status.fetchRejected = !0, s.status.fetchError = p), c(p, !1)), c = (p, w) => {
+			let { aborted: g } = o.signal, S = g && s.allowStaleOnFetchAbort, E = S || s.allowStaleOnFetchRejection, y = E || s.noDeleteOnFetchRejection, b = f;
+			if (this.#i[e] === f && (!y || !w && b.__staleWhileFetching === void 0 ? this.#O(t, "fetch") : S || (this.#i[e] = b.__staleWhileFetching)), E) return s.status && b.__staleWhileFetching !== void 0 && (s.status.returnedStale = !0), b.__staleWhileFetching;
+			if (b.__returned === b) throw p;
+		}, d = (p, w) => {
+			let g = this.#S?.(t, r, a);
+			g && g instanceof Promise && g.then((S) => p(S === void 0 ? void 0 : S), w), o.signal.addEventListener("abort", () => {
+				(!s.ignoreFetchAbort || s.allowStaleOnFetchAbort) && (p(void 0), s.allowStaleOnFetchAbort && (p = (S) => l(S, !0)));
+			});
+		};
+		s.status && (s.status.fetchDispatched = !0);
+		let f = new Promise(d).then(l, u), m = Object.assign(f, {
+			__abortController: o,
+			__staleWhileFetching: r,
+			__returned: void 0
+		});
+		return e === void 0 ? (this.set(t, m, {
+			...a.options,
+			status: void 0
+		}), e = this.#f.get(t)) : this.#i[e] = m, m;
+	}
+	#l(t) {
+		if (!this.#A) return !1;
+		let e = t;
+		return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof At;
+	}
+	async fetch(t, e = {}) {
+		let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: a = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: u = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: f = this.ignoreFetchAbort, allowStaleOnFetchAbort: m = this.allowStaleOnFetchAbort, context: p, forceRefresh: w = !1, status: g, signal: S } = e;
+		if (!this.#A) return g && (g.fetch = "get"), this.get(t, {
+			allowStale: s,
+			updateAgeOnGet: i,
+			noDeleteOnStaleGet: r,
+			status: g
+		});
+		let E = {
+			allowStale: s,
+			updateAgeOnGet: i,
+			noDeleteOnStaleGet: r,
+			ttl: o,
+			noDisposeOnSet: h,
+			size: a,
+			sizeCalculation: l,
+			noUpdateTTL: u,
+			noDeleteOnFetchRejection: c,
+			allowStaleOnFetchRejection: d,
+			allowStaleOnFetchAbort: m,
+			ignoreFetchAbort: f,
+			status: g,
+			signal: S
+		}, y = this.#f.get(t);
+		if (y === void 0) {
+			g && (g.fetch = "miss");
+			let b = this.#U(t, y, E, p);
+			return b.__returned = b;
+		} else {
+			let b = this.#i[y];
+			if (this.#l(b)) {
+				let Z = s && b.__staleWhileFetching !== void 0;
+				return g && (g.fetch = "inflight", Z && (g.returnedStale = !0)), Z ? b.__staleWhileFetching : b.__returned = b;
+			}
+			let z = this.#v(y);
+			if (!w && !z) return g && (g.fetch = "hit"), this.#W(y), i && this.#k(y), g && this.#N(g, y), b;
+			let $ = this.#U(t, y, E, p), J = $.__staleWhileFetching !== void 0 && s;
+			return g && (g.fetch = z ? "stale" : "refresh", J && z && (g.returnedStale = !0)), J ? $.__staleWhileFetching : $.__returned = $;
+		}
+	}
+	async forceFetch(t, e = {}) {
+		let s = await this.fetch(t, e);
+		if (s === void 0) throw new Error("fetch() returned undefined");
+		return s;
+	}
+	memo(t, e = {}) {
+		let s = this.#w;
+		if (!s) throw new Error("no memoMethod provided to constructor");
+		let { context: i, forceRefresh: r, ...o } = e, h = this.get(t, o);
+		if (!r && h !== void 0) return h;
+		let a = s(t, h, {
+			options: o,
+			context: i
+		});
+		return this.set(t, a, o), a;
+	}
+	get(t, e = {}) {
+		let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, status: o } = e, h = this.#f.get(t);
+		if (h !== void 0) {
+			let a = this.#i[h], l = this.#l(a);
+			return o && this.#N(o, h), this.#v(h) ? (o && (o.get = "stale"), l ? (o && s && a.__staleWhileFetching !== void 0 && (o.returnedStale = !0), s ? a.__staleWhileFetching : void 0) : (r || this.#O(t, "expire"), o && s && (o.returnedStale = !0), s ? a : void 0)) : (o && (o.get = "hit"), l ? a.__staleWhileFetching : (this.#W(h), i && this.#k(h), a));
+		} else o && (o.get = "miss");
+	}
+	#$(t, e) {
+		this.#E[e] = t, this.#d[t] = e;
+	}
+	#W(t) {
+		t !== this.#p && (t === this.#b ? this.#b = this.#d[t] : this.#$(this.#E[t], this.#d[t]), this.#$(this.#p, t), this.#p = t);
+	}
+	delete(t) {
+		return this.#O(t, "delete");
+	}
+	#O(t, e) {
+		let s = !1;
+		if (this.#h !== 0) {
+			let i = this.#f.get(t);
+			if (i !== void 0) if (this.#y?.[i] && (clearTimeout(this.#y?.[i]), this.#y[i] = void 0), s = !0, this.#h === 1) this.#H(e);
+			else {
+				this.#P(i);
+				let r = this.#i[i];
+				if (this.#l(r) ? r.__abortController.abort(/* @__PURE__ */ new Error("deleted")) : (this.#x || this.#e) && (this.#x && this.#n?.(r, t, e), this.#e && this.#m?.push([
+					r,
+					t,
+					e
+				])), this.#f.delete(t), this.#a[i] = void 0, this.#i[i] = void 0, i === this.#p) this.#p = this.#E[i];
+				else if (i === this.#b) this.#b = this.#d[i];
+				else {
+					let o = this.#E[i];
+					this.#d[o] = this.#d[i];
+					let h = this.#d[i];
+					this.#E[h] = this.#E[i];
+				}
+				this.#h--, this.#R.push(i);
+			}
+		}
+		if (this.#e && this.#m?.length) {
+			let i = this.#m, r;
+			for (; r = i?.shift();) this.#o?.(...r);
+		}
+		return s;
+	}
+	clear() {
+		return this.#H("delete");
+	}
+	#H(t) {
+		for (let e of this.#D({ allowStale: !0 })) {
+			let s = this.#i[e];
+			if (this.#l(s)) s.__abortController.abort(/* @__PURE__ */ new Error("deleted"));
+			else {
+				let i = this.#a[e];
+				this.#x && this.#n?.(s, i, t), this.#e && this.#m?.push([
+					s,
+					i,
+					t
+				]);
+			}
+		}
+		if (this.#f.clear(), this.#i.fill(void 0), this.#a.fill(void 0), this.#g && this.#T) {
+			this.#g.fill(0), this.#T.fill(0);
+			for (let e of this.#y ?? []) e !== void 0 && clearTimeout(e);
+			this.#y?.fill(void 0);
+		}
+		if (this.#C && this.#C.fill(0), this.#b = 0, this.#p = 0, this.#R.length = 0, this.#u = 0, this.#h = 0, this.#e && this.#m) {
+			let e = this.#m, s;
+			for (; s = e?.shift();) this.#o?.(...s);
+		}
+	}
+};
+var Ne = typeof process == "object" && process ? process : {
+	stdout: null,
+	stderr: null
+};
+var oi = (n) => !!n && typeof n == "object" && (n instanceof V || n instanceof Pe || hi(n) || ai(n));
+var hi = (n) => !!n && typeof n == "object" && n instanceof EventEmitter && typeof n.pipe == "function" && n.pipe !== Pe.Writable.prototype.pipe;
+var ai = (n) => !!n && typeof n == "object" && n instanceof EventEmitter && typeof n.write == "function" && typeof n.end == "function";
+var G = Symbol("EOF");
+var H = Symbol("maybeEmitEnd");
+var K = Symbol("emittedEnd");
+var kt = Symbol("emittingEnd");
+var ut = Symbol("emittedError");
+var Rt = Symbol("closed");
+var _e = Symbol("read");
+var Ot = Symbol("flush");
+var Le = Symbol("flushChunk");
+var P = Symbol("encoding");
+var et = Symbol("decoder");
+var v = Symbol("flowing");
+var dt = Symbol("paused");
+var st = Symbol("resume");
+var C = Symbol("buffer");
+var F = Symbol("pipes");
+var T = Symbol("bufferLength");
+var Yt = Symbol("bufferPush");
+var Ft = Symbol("bufferShift");
+var k = Symbol("objectMode");
+var x = Symbol("destroyed");
+var Xt = Symbol("error");
+var Jt = Symbol("emitData");
+var We = Symbol("emitEnd");
+var Zt = Symbol("emitEnd2");
+var B = Symbol("async");
+var Qt = Symbol("abort");
+var Dt = Symbol("aborted");
+var pt = Symbol("signal");
+var Y = Symbol("dataListeners");
+var M = Symbol("discarded");
+var mt = (n) => Promise.resolve().then(n);
+var li = (n) => n();
+var ci = (n) => n === "end" || n === "finish" || n === "prefinish";
+var fi = (n) => n instanceof ArrayBuffer || !!n && typeof n == "object" && n.constructor && n.constructor.name === "ArrayBuffer" && n.byteLength >= 0;
+var ui = (n) => !Buffer.isBuffer(n) && ArrayBuffer.isView(n);
+var Mt = class {
+	src;
+	dest;
+	opts;
+	ondrain;
+	constructor(t, e, s) {
+		this.src = t, this.dest = e, this.opts = s, this.ondrain = () => t[st](), this.dest.on("drain", this.ondrain);
+	}
+	unpipe() {
+		this.dest.removeListener("drain", this.ondrain);
+	}
+	proxyErrors(t) {}
+	end() {
+		this.unpipe(), this.opts.end && this.dest.end();
+	}
+};
+var te = class extends Mt {
+	unpipe() {
+		this.src.removeListener("error", this.proxyErrors), super.unpipe();
+	}
+	constructor(t, e, s) {
+		super(t, e, s), this.proxyErrors = (i) => this.dest.emit("error", i), t.on("error", this.proxyErrors);
+	}
+};
+var di = (n) => !!n.objectMode;
+var pi = (n) => !n.objectMode && !!n.encoding && n.encoding !== "buffer";
+var V = class extends EventEmitter {
+	[v] = !1;
+	[dt] = !1;
+	[F] = [];
+	[C] = [];
+	[k];
+	[P];
+	[B];
+	[et];
+	[G] = !1;
+	[K] = !1;
+	[kt] = !1;
+	[Rt] = !1;
+	[ut] = null;
+	[T] = 0;
+	[x] = !1;
+	[pt];
+	[Dt] = !1;
+	[Y] = 0;
+	[M] = !1;
+	writable = !0;
+	readable = !0;
+	constructor(...t) {
+		let e = t[0] || {};
+		if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
+		di(e) ? (this[k] = !0, this[P] = null) : pi(e) ? (this[P] = e.encoding, this[k] = !1) : (this[k] = !1, this[P] = null), this[B] = !!e.async, this[et] = this[P] ? new StringDecoder(this[P]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[C] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[F] });
+		let { signal: s } = e;
+		s && (this[pt] = s, s.aborted ? this[Qt]() : s.addEventListener("abort", () => this[Qt]()));
+	}
+	get bufferLength() {
+		return this[T];
+	}
+	get encoding() {
+		return this[P];
+	}
+	set encoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	setEncoding(t) {
+		throw new Error("Encoding must be set at instantiation time");
+	}
+	get objectMode() {
+		return this[k];
+	}
+	set objectMode(t) {
+		throw new Error("objectMode must be set at instantiation time");
+	}
+	get async() {
+		return this[B];
+	}
+	set async(t) {
+		this[B] = this[B] || !!t;
+	}
+	[Qt]() {
+		this[Dt] = !0, this.emit("abort", this[pt]?.reason), this.destroy(this[pt]?.reason);
+	}
+	get aborted() {
+		return this[Dt];
+	}
+	set aborted(t) {}
+	write(t, e, s) {
+		if (this[Dt]) return !1;
+		if (this[G]) throw new Error("write after end");
+		if (this[x]) return this.emit("error", Object.assign(/* @__PURE__ */ new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+		typeof e == "function" && (s = e, e = "utf8"), e || (e = "utf8");
+		let i = this[B] ? mt : li;
+		if (!this[k] && !Buffer.isBuffer(t)) {
+			if (ui(t)) t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+			else if (fi(t)) t = Buffer.from(t);
+			else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+		}
+		return this[k] ? (this[v] && this[T] !== 0 && this[Ot](!0), this[v] ? this.emit("data", t) : this[Yt](t), this[T] !== 0 && this.emit("readable"), s && i(s), this[v]) : t.length ? (typeof t == "string" && (e !== this[P] || this[et]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[P] && (t = this[et].write(t)), this[v] && this[T] !== 0 && this[Ot](!0), this[v] ? this.emit("data", t) : this[Yt](t), this[T] !== 0 && this.emit("readable"), s && i(s), this[v]) : (this[T] !== 0 && this.emit("readable"), s && i(s), this[v]);
+	}
+	read(t) {
+		if (this[x]) return null;
+		if (this[M] = !1, this[T] === 0 || t === 0 || t && t > this[T]) return this[H](), null;
+		this[k] && (t = null), this[C].length > 1 && !this[k] && (this[C] = [this[P] ? this[C].join("") : Buffer.concat(this[C], this[T])]);
+		let e = this[_e](t || null, this[C][0]);
+		return this[H](), e;
+	}
+	[_e](t, e) {
+		if (this[k]) this[Ft]();
+		else {
+			let s = e;
+			t === s.length || t === null ? this[Ft]() : typeof s == "string" ? (this[C][0] = s.slice(t), e = s.slice(0, t), this[T] -= t) : (this[C][0] = s.subarray(t), e = s.subarray(0, t), this[T] -= t);
+		}
+		return this.emit("data", e), !this[C].length && !this[G] && this.emit("drain"), e;
+	}
+	end(t, e, s) {
+		return typeof t == "function" && (s = t, t = void 0), typeof e == "function" && (s = e, e = "utf8"), t !== void 0 && this.write(t, e), s && this.once("end", s), this[G] = !0, this.writable = !1, (this[v] || !this[dt]) && this[H](), this;
+	}
+	[st]() {
+		this[x] || (!this[Y] && !this[F].length && (this[M] = !0), this[dt] = !1, this[v] = !0, this.emit("resume"), this[C].length ? this[Ot]() : this[G] ? this[H]() : this.emit("drain"));
+	}
+	resume() {
+		return this[st]();
+	}
+	pause() {
+		this[v] = !1, this[dt] = !0, this[M] = !1;
+	}
+	get destroyed() {
+		return this[x];
+	}
+	get flowing() {
+		return this[v];
+	}
+	get paused() {
+		return this[dt];
+	}
+	[Yt](t) {
+		this[k] ? this[T] += 1 : this[T] += t.length, this[C].push(t);
+	}
+	[Ft]() {
+		return this[k] ? this[T] -= 1 : this[T] -= this[C][0].length, this[C].shift();
+	}
+	[Ot](t = !1) {
+		do		;
+while (this[Le](this[Ft]()) && this[C].length);
+		!t && !this[C].length && !this[G] && this.emit("drain");
+	}
+	[Le](t) {
+		return this.emit("data", t), this[v];
+	}
+	pipe(t, e) {
+		if (this[x]) return t;
+		this[M] = !1;
+		let s = this[K];
+		return e = e || {}, t === Ne.stdout || t === Ne.stderr ? e.end = !1 : e.end = e.end !== !1, e.proxyErrors = !!e.proxyErrors, s ? e.end && t.end() : (this[F].push(e.proxyErrors ? new te(this, t, e) : new Mt(this, t, e)), this[B] ? mt(() => this[st]()) : this[st]()), t;
+	}
+	unpipe(t) {
+		let e = this[F].find((s) => s.dest === t);
+		e && (this[F].length === 1 ? (this[v] && this[Y] === 0 && (this[v] = !1), this[F] = []) : this[F].splice(this[F].indexOf(e), 1), e.unpipe());
+	}
+	addListener(t, e) {
+		return this.on(t, e);
+	}
+	on(t, e) {
+		let s = super.on(t, e);
+		if (t === "data") this[M] = !1, this[Y]++, !this[F].length && !this[v] && this[st]();
+		else if (t === "readable" && this[T] !== 0) super.emit("readable");
+		else if (ci(t) && this[K]) super.emit(t), this.removeAllListeners(t);
+		else if (t === "error" && this[ut]) {
+			let i = e;
+			this[B] ? mt(() => i.call(this, this[ut])) : i.call(this, this[ut]);
+		}
+		return s;
+	}
+	removeListener(t, e) {
+		return this.off(t, e);
+	}
+	off(t, e) {
+		let s = super.off(t, e);
+		return t === "data" && (this[Y] = this.listeners("data").length, this[Y] === 0 && !this[M] && !this[F].length && (this[v] = !1)), s;
+	}
+	removeAllListeners(t) {
+		let e = super.removeAllListeners(t);
+		return (t === "data" || t === void 0) && (this[Y] = 0, !this[M] && !this[F].length && (this[v] = !1)), e;
+	}
+	get emittedEnd() {
+		return this[K];
+	}
+	[H]() {
+		!this[kt] && !this[K] && !this[x] && this[C].length === 0 && this[G] && (this[kt] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[Rt] && this.emit("close"), this[kt] = !1);
+	}
+	emit(t, ...e) {
+		let s = e[0];
+		if (t !== "error" && t !== "close" && t !== x && this[x]) return !1;
+		if (t === "data") return !this[k] && !s ? !1 : this[B] ? (mt(() => this[Jt](s)), !0) : this[Jt](s);
+		if (t === "end") return this[We]();
+		if (t === "close") {
+			if (this[Rt] = !0, !this[K] && !this[x]) return !1;
+			let r = super.emit("close");
+			return this.removeAllListeners("close"), r;
+		} else if (t === "error") {
+			this[ut] = s, super.emit(Xt, s);
+			let r = !this[pt] || this.listeners("error").length ? super.emit("error", s) : !1;
+			return this[H](), r;
+		} else if (t === "resume") {
+			let r = super.emit("resume");
+			return this[H](), r;
+		} else if (t === "finish" || t === "prefinish") {
+			let r = super.emit(t);
+			return this.removeAllListeners(t), r;
+		}
+		let i = super.emit(t, ...e);
+		return this[H](), i;
+	}
+	[Jt](t) {
+		for (let s of this[F]) s.dest.write(t) === !1 && this.pause();
+		let e = this[M] ? !1 : super.emit("data", t);
+		return this[H](), e;
+	}
+	[We]() {
+		return this[K] ? !1 : (this[K] = !0, this.readable = !1, this[B] ? (mt(() => this[Zt]()), !0) : this[Zt]());
+	}
+	[Zt]() {
+		if (this[et]) {
+			let e = this[et].end();
+			if (e) {
+				for (let s of this[F]) s.dest.write(e);
+				this[M] || super.emit("data", e);
+			}
+		}
+		for (let e of this[F]) e.end();
+		let t = super.emit("end");
+		return this.removeAllListeners("end"), t;
+	}
+	async collect() {
+		let t = Object.assign([], { dataLength: 0 });
+		this[k] || (t.dataLength = 0);
+		let e = this.promise();
+		return this.on("data", (s) => {
+			t.push(s), this[k] || (t.dataLength += s.length);
+		}), await e, t;
+	}
+	async concat() {
+		if (this[k]) throw new Error("cannot concat in objectMode");
+		let t = await this.collect();
+		return this[P] ? t.join("") : Buffer.concat(t, t.dataLength);
+	}
+	async promise() {
+		return new Promise((t, e) => {
+			this.on(x, () => e(/* @__PURE__ */ new Error("stream destroyed"))), this.on("error", (s) => e(s)), this.on("end", () => t());
+		});
+	}
+	[Symbol.asyncIterator]() {
+		this[M] = !1;
+		let t = !1, e = async () => (this.pause(), t = !0, {
+			value: void 0,
+			done: !0
+		});
+		return {
+			next: () => {
+				if (t) return e();
+				let i = this.read();
+				if (i !== null) return Promise.resolve({
+					done: !1,
+					value: i
+				});
+				if (this[G]) return e();
+				let r, o, h = (c) => {
+					this.off("data", a), this.off("end", l), this.off(x, u), e(), o(c);
+				}, a = (c) => {
+					this.off("error", h), this.off("end", l), this.off(x, u), this.pause(), r({
+						value: c,
+						done: !!this[G]
+					});
+				}, l = () => {
+					this.off("error", h), this.off("data", a), this.off(x, u), e(), r({
+						done: !0,
+						value: void 0
+					});
+				}, u = () => h(/* @__PURE__ */ new Error("stream destroyed"));
+				return new Promise((c, d) => {
+					o = d, r = c, this.once(x, u), this.once("error", h), this.once("end", l), this.once("data", a);
+				});
+			},
+			throw: e,
+			return: e,
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			[Symbol.asyncDispose]: async () => {}
+		};
+	}
+	[Symbol.iterator]() {
+		this[M] = !1;
+		let t = !1, e = () => (this.pause(), this.off(Xt, e), this.off(x, e), this.off("end", e), t = !0, {
+			done: !0,
+			value: void 0
+		}), s = () => {
+			if (t) return e();
+			let i = this.read();
+			return i === null ? e() : {
+				done: !1,
+				value: i
+			};
+		};
+		return this.once("end", e), this.once(Xt, e), this.once(x, e), {
+			next: s,
+			throw: e,
+			return: e,
+			[Symbol.iterator]() {
+				return this;
+			},
+			[Symbol.dispose]: () => {}
+		};
+	}
+	destroy(t) {
+		if (this[x]) return t ? this.emit("error", t) : this.emit(x), this;
+		this[x] = !0, this[M] = !0, this[C].length = 0, this[T] = 0;
+		let e = this;
+		return typeof e.close == "function" && !this[Rt] && e.close(), t ? this.emit("error", t) : this.emit(x), this;
+	}
+	static get isStream() {
+		return oi;
+	}
+};
+var vi = realpathSync.native;
+var wt = {
+	lstatSync,
+	readdir,
+	readdirSync,
+	readlinkSync,
+	realpathSync: vi,
+	promises: {
+		lstat,
+		readdir: readdir$1,
+		readlink,
+		realpath
+	}
+};
+var Ue = (n) => !n || n === wt || n === xi ? wt : {
+	...wt,
+	...n,
+	promises: {
+		...wt.promises,
+		...n.promises || {}
+	}
+};
+var $e = /^\\\\\?\\([a-z]:)\\?$/i;
+var Ri = (n) => n.replace(/\//g, "\\").replace($e, "$1\\");
+var Oi = /[\\\/]/;
+var L = 0;
+var Ge = 1;
+var He = 2;
+var U = 4;
+var qe = 6;
+var Ke = 8;
+var X = 10;
+var Ve = 12;
+var _ = 15;
+var gt = ~_;
+var se = 16;
+var je = 32;
+var yt = 64;
+var j = 128;
+var Nt = 256;
+var Lt = 512;
+var Ie = yt | j | Lt;
+var Fi = 1023;
+var ie = (n) => n.isFile() ? Ke : n.isDirectory() ? U : n.isSymbolicLink() ? X : n.isCharacterDevice() ? He : n.isBlockDevice() ? qe : n.isSocket() ? Ve : n.isFIFO() ? Ge : L;
+var ze = new ft({ max: 4096 });
+var bt = (n) => {
+	let t = ze.get(n);
+	if (t) return t;
+	let e = n.normalize("NFKD");
+	return ze.set(n, e), e;
+};
+var Be = new ft({ max: 4096 });
+var _t = (n) => {
+	let t = Be.get(n);
+	if (t) return t;
+	let e = bt(n.toLowerCase());
+	return Be.set(n, e), e;
+};
+var Wt = class extends ft {
+	constructor() {
+		super({ max: 256 });
+	}
+};
+var ne = class extends ft {
+	constructor(t = 16384) {
+		super({
+			maxSize: t,
+			sizeCalculation: (e) => e.length + 1
+		});
+	}
+};
+var Ye = Symbol("PathScurry setAsCwd");
+var R = class {
+	name;
+	root;
+	roots;
+	parent;
+	nocase;
+	isCWD = !1;
+	#t;
+	#s;
+	get dev() {
+		return this.#s;
+	}
+	#n;
+	get mode() {
+		return this.#n;
+	}
+	#r;
+	get nlink() {
+		return this.#r;
+	}
+	#o;
+	get uid() {
+		return this.#o;
+	}
+	#S;
+	get gid() {
+		return this.#S;
+	}
+	#w;
+	get rdev() {
+		return this.#w;
+	}
+	#c;
+	get blksize() {
+		return this.#c;
+	}
+	#h;
+	get ino() {
+		return this.#h;
+	}
+	#u;
+	get size() {
+		return this.#u;
+	}
+	#f;
+	get blocks() {
+		return this.#f;
+	}
+	#a;
+	get atimeMs() {
+		return this.#a;
+	}
+	#i;
+	get mtimeMs() {
+		return this.#i;
+	}
+	#d;
+	get ctimeMs() {
+		return this.#d;
+	}
+	#E;
+	get birthtimeMs() {
+		return this.#E;
+	}
+	#b;
+	get atime() {
+		return this.#b;
+	}
+	#p;
+	get mtime() {
+		return this.#p;
+	}
+	#R;
+	get ctime() {
+		return this.#R;
+	}
+	#m;
+	get birthtime() {
+		return this.#m;
+	}
+	#C;
+	#T;
+	#g;
+	#y;
+	#x;
+	#A;
+	#e;
+	#_;
+	#M;
+	#k;
+	get parentPath() {
+		return (this.parent || this).fullpath();
+	}
+	get path() {
+		return this.parentPath;
+	}
+	constructor(t, e = L, s, i, r, o, h) {
+		this.name = t, this.#C = r ? _t(t) : bt(t), this.#e = e & Fi, this.nocase = r, this.roots = i, this.root = s || this, this.#_ = o, this.#g = h.fullpath, this.#x = h.relative, this.#A = h.relativePosix, this.parent = h.parent, this.parent ? this.#t = this.parent.#t : this.#t = Ue(h.fs);
+	}
+	depth() {
+		return this.#T !== void 0 ? this.#T : this.parent ? this.#T = this.parent.depth() + 1 : this.#T = 0;
+	}
+	childrenCache() {
+		return this.#_;
+	}
+	resolve(t) {
+		if (!t) return this;
+		let e = this.getRootString(t), i = t.substring(e.length).split(this.splitSep);
+		return e ? this.getRoot(e).#N(i) : this.#N(i);
+	}
+	#N(t) {
+		let e = this;
+		for (let s of t) e = e.child(s);
+		return e;
+	}
+	children() {
+		let t = this.#_.get(this);
+		if (t) return t;
+		let e = Object.assign([], { provisional: 0 });
+		return this.#_.set(this, e), this.#e &= ~se, e;
+	}
+	child(t, e) {
+		if (t === "" || t === ".") return this;
+		if (t === "..") return this.parent || this;
+		let s = this.children(), i = this.nocase ? _t(t) : bt(t);
+		for (let a of s) if (a.#C === i) return a;
+		let r = this.parent ? this.sep : "", o = this.#g ? this.#g + r + t : void 0, h = this.newChild(t, L, {
+			...e,
+			parent: this,
+			fullpath: o
+		});
+		return this.canReaddir() || (h.#e |= j), s.push(h), h;
+	}
+	relative() {
+		if (this.isCWD) return "";
+		if (this.#x !== void 0) return this.#x;
+		let t = this.name, e = this.parent;
+		if (!e) return this.#x = this.name;
+		let s = e.relative();
+		return s + (!s || !e.parent ? "" : this.sep) + t;
+	}
+	relativePosix() {
+		if (this.sep === "/") return this.relative();
+		if (this.isCWD) return "";
+		if (this.#A !== void 0) return this.#A;
+		let t = this.name, e = this.parent;
+		if (!e) return this.#A = this.fullpathPosix();
+		let s = e.relativePosix();
+		return s + (!s || !e.parent ? "" : "/") + t;
+	}
+	fullpath() {
+		if (this.#g !== void 0) return this.#g;
+		let t = this.name, e = this.parent;
+		if (!e) return this.#g = this.name;
+		let i = e.fullpath() + (e.parent ? this.sep : "") + t;
+		return this.#g = i;
+	}
+	fullpathPosix() {
+		if (this.#y !== void 0) return this.#y;
+		if (this.sep === "/") return this.#y = this.fullpath();
+		if (!this.parent) {
+			let i = this.fullpath().replace(/\\/g, "/");
+			return /^[a-z]:\//i.test(i) ? this.#y = `//?/${i}` : this.#y = i;
+		}
+		let t = this.parent, e = t.fullpathPosix(), s = e + (!e || !t.parent ? "" : "/") + this.name;
+		return this.#y = s;
+	}
+	isUnknown() {
+		return (this.#e & _) === L;
+	}
+	isType(t) {
+		return this[`is${t}`]();
+	}
+	getType() {
+		return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+	}
+	isFile() {
+		return (this.#e & _) === Ke;
+	}
+	isDirectory() {
+		return (this.#e & _) === U;
+	}
+	isCharacterDevice() {
+		return (this.#e & _) === He;
+	}
+	isBlockDevice() {
+		return (this.#e & _) === qe;
+	}
+	isFIFO() {
+		return (this.#e & _) === Ge;
+	}
+	isSocket() {
+		return (this.#e & _) === Ve;
+	}
+	isSymbolicLink() {
+		return (this.#e & X) === X;
+	}
+	lstatCached() {
+		return this.#e & je ? this : void 0;
+	}
+	readlinkCached() {
+		return this.#M;
+	}
+	realpathCached() {
+		return this.#k;
+	}
+	readdirCached() {
+		let t = this.children();
+		return t.slice(0, t.provisional);
+	}
+	canReadlink() {
+		if (this.#M) return !0;
+		if (!this.parent) return !1;
+		let t = this.#e & _;
+		return !(t !== L && t !== X || this.#e & Nt || this.#e & j);
+	}
+	calledReaddir() {
+		return !!(this.#e & se);
+	}
+	isENOENT() {
+		return !!(this.#e & j);
+	}
+	isNamed(t) {
+		return this.nocase ? this.#C === _t(t) : this.#C === bt(t);
+	}
+	async readlink() {
+		let t = this.#M;
+		if (t) return t;
+		if (this.canReadlink() && this.parent) try {
+			let e = await this.#t.promises.readlink(this.fullpath()), s = (await this.parent.realpath())?.resolve(e);
+			if (s) return this.#M = s;
+		} catch (e) {
+			this.#D(e.code);
+			return;
+		}
+	}
+	readlinkSync() {
+		let t = this.#M;
+		if (t) return t;
+		if (this.canReadlink() && this.parent) try {
+			let e = this.#t.readlinkSync(this.fullpath()), s = this.parent.realpathSync()?.resolve(e);
+			if (s) return this.#M = s;
+		} catch (e) {
+			this.#D(e.code);
+			return;
+		}
+	}
+	#j(t) {
+		this.#e |= se;
+		for (let e = t.provisional; e < t.length; e++) {
+			let s = t[e];
+			s && s.#v();
+		}
+	}
+	#v() {
+		this.#e & j || (this.#e = (this.#e | j) & gt, this.#G());
+	}
+	#G() {
+		let t = this.children();
+		t.provisional = 0;
+		for (let e of t) e.#v();
+	}
+	#P() {
+		this.#e |= Lt, this.#L();
+	}
+	#L() {
+		if (this.#e & yt) return;
+		let t = this.#e;
+		(t & _) === U && (t &= gt), this.#e = t | yt, this.#G();
+	}
+	#I(t = "") {
+		t === "ENOTDIR" || t === "EPERM" ? this.#L() : t === "ENOENT" ? this.#v() : this.children().provisional = 0;
+	}
+	#F(t = "") {
+		t === "ENOTDIR" ? this.parent.#L() : t === "ENOENT" && this.#v();
+	}
+	#D(t = "") {
+		let e = this.#e;
+		e |= Nt, t === "ENOENT" && (e |= j), (t === "EINVAL" || t === "UNKNOWN") && (e &= gt), this.#e = e, t === "ENOTDIR" && this.parent && this.parent.#L();
+	}
+	#z(t, e) {
+		return this.#U(t, e) || this.#B(t, e);
+	}
+	#B(t, e) {
+		let s = ie(t), i = this.newChild(t.name, s, { parent: this }), r = i.#e & _;
+		return r !== U && r !== X && r !== L && (i.#e |= yt), e.unshift(i), e.provisional++, i;
+	}
+	#U(t, e) {
+		for (let s = e.provisional; s < e.length; s++) {
+			let i = e[s];
+			if ((this.nocase ? _t(t.name) : bt(t.name)) === i.#C) return this.#l(t, i, s, e);
+		}
+	}
+	#l(t, e, s, i) {
+		let r = e.name;
+		return e.#e = e.#e & gt | ie(t), r !== t.name && (e.name = t.name), s !== i.provisional && (s === i.length - 1 ? i.pop() : i.splice(s, 1), i.unshift(e)), i.provisional++, e;
+	}
+	async lstat() {
+		if ((this.#e & j) === 0) try {
+			return this.#$(await this.#t.promises.lstat(this.fullpath())), this;
+		} catch (t) {
+			this.#F(t.code);
+		}
+	}
+	lstatSync() {
+		if ((this.#e & j) === 0) try {
+			return this.#$(this.#t.lstatSync(this.fullpath())), this;
+		} catch (t) {
+			this.#F(t.code);
+		}
+	}
+	#$(t) {
+		let { atime: e, atimeMs: s, birthtime: i, birthtimeMs: r, blksize: o, blocks: h, ctime: a, ctimeMs: l, dev: u, gid: c, ino: d, mode: f, mtime: m, mtimeMs: p, nlink: w, rdev: g, size: S, uid: E } = t;
+		this.#b = e, this.#a = s, this.#m = i, this.#E = r, this.#c = o, this.#f = h, this.#R = a, this.#d = l, this.#s = u, this.#S = c, this.#h = d, this.#n = f, this.#p = m, this.#i = p, this.#r = w, this.#w = g, this.#u = S, this.#o = E;
+		let y = ie(t);
+		this.#e = this.#e & gt | y | je, y !== L && y !== U && y !== X && (this.#e |= yt);
+	}
+	#W = [];
+	#O = !1;
+	#H(t) {
+		this.#O = !1;
+		let e = this.#W.slice();
+		this.#W.length = 0, e.forEach((s) => s(null, t));
+	}
+	readdirCB(t, e = !1) {
+		if (!this.canReaddir()) {
+			e ? t(null, []) : queueMicrotask(() => t(null, []));
+			return;
+		}
+		let s = this.children();
+		if (this.calledReaddir()) {
+			let r = s.slice(0, s.provisional);
+			e ? t(null, r) : queueMicrotask(() => t(null, r));
+			return;
+		}
+		if (this.#W.push(t), this.#O) return;
+		this.#O = !0;
+		let i = this.fullpath();
+		this.#t.readdir(i, { withFileTypes: !0 }, (r, o) => {
+			if (r) this.#I(r.code), s.provisional = 0;
+			else {
+				for (let h of o) this.#z(h, s);
+				this.#j(s);
+			}
+			this.#H(s.slice(0, s.provisional));
+		});
+	}
+	#q;
+	async readdir() {
+		if (!this.canReaddir()) return [];
+		let t = this.children();
+		if (this.calledReaddir()) return t.slice(0, t.provisional);
+		let e = this.fullpath();
+		if (this.#q) await this.#q;
+		else {
+			let s = () => {};
+			this.#q = new Promise((i) => s = i);
+			try {
+				for (let i of await this.#t.promises.readdir(e, { withFileTypes: !0 })) this.#z(i, t);
+				this.#j(t);
+			} catch (i) {
+				this.#I(i.code), t.provisional = 0;
+			}
+			this.#q = void 0, s();
+		}
+		return t.slice(0, t.provisional);
+	}
+	readdirSync() {
+		if (!this.canReaddir()) return [];
+		let t = this.children();
+		if (this.calledReaddir()) return t.slice(0, t.provisional);
+		let e = this.fullpath();
+		try {
+			for (let s of this.#t.readdirSync(e, { withFileTypes: !0 })) this.#z(s, t);
+			this.#j(t);
+		} catch (s) {
+			this.#I(s.code), t.provisional = 0;
+		}
+		return t.slice(0, t.provisional);
+	}
+	canReaddir() {
+		if (this.#e & Ie) return !1;
+		let t = _ & this.#e;
+		return t === L || t === U || t === X;
+	}
+	shouldWalk(t, e) {
+		return (this.#e & U) === U && !(this.#e & Ie) && !t.has(this) && (!e || e(this));
+	}
+	async realpath() {
+		if (this.#k) return this.#k;
+		if (!((Lt | Nt | j) & this.#e)) try {
+			let t = await this.#t.promises.realpath(this.fullpath());
+			return this.#k = this.resolve(t);
+		} catch {
+			this.#P();
+		}
+	}
+	realpathSync() {
+		if (this.#k) return this.#k;
+		if (!((Lt | Nt | j) & this.#e)) try {
+			let t = this.#t.realpathSync(this.fullpath());
+			return this.#k = this.resolve(t);
+		} catch {
+			this.#P();
+		}
+	}
+	[Ye](t) {
+		if (t === this) return;
+		t.isCWD = !1, this.isCWD = !0;
+		let e = /* @__PURE__ */ new Set([]), s = [], i = this;
+		for (; i && i.parent;) e.add(i), i.#x = s.join(this.sep), i.#A = s.join("/"), i = i.parent, s.push("..");
+		for (i = t; i && i.parent && !e.has(i);) i.#x = void 0, i.#A = void 0, i = i.parent;
+	}
+};
+var Pt = class n extends R {
+	sep = "\\";
+	splitSep = Oi;
+	constructor(t, e = L, s, i, r, o, h) {
+		super(t, e, s, i, r, o, h);
+	}
+	newChild(t, e = L, s = {}) {
+		return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+	}
+	getRootString(t) {
+		return win32.parse(t).root;
+	}
+	getRoot(t) {
+		if (t = Ri(t.toUpperCase()), t === this.root.name) return this.root;
+		for (let [e, s] of Object.entries(this.roots)) if (this.sameRoot(t, e)) return this.roots[t] = s;
+		return this.roots[t] = new it(t, this).root;
+	}
+	sameRoot(t, e = this.root.name) {
+		return t = t.toUpperCase().replace(/\//g, "\\").replace($e, "$1\\"), t === e;
+	}
+};
+var jt = class n extends R {
+	splitSep = "/";
+	sep = "/";
+	constructor(t, e = L, s, i, r, o, h) {
+		super(t, e, s, i, r, o, h);
+	}
+	getRootString(t) {
+		return t.startsWith("/") ? "/" : "";
+	}
+	getRoot(t) {
+		return this.root;
+	}
+	newChild(t, e = L, s = {}) {
+		return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+	}
+};
+var It = class {
+	root;
+	rootPath;
+	roots;
+	cwd;
+	#t;
+	#s;
+	#n;
+	nocase;
+	#r;
+	constructor(t = process.cwd(), e, s, { nocase: i, childrenCacheSize: r = 16384, fs: o = wt } = {}) {
+		this.#r = Ue(o), (t instanceof URL || t.startsWith("file://")) && (t = fileURLToPath(t));
+		let h = e.resolve(t);
+		this.roots = Object.create(null), this.rootPath = this.parseRootPath(h), this.#t = new Wt(), this.#s = new Wt(), this.#n = new ne(r);
+		let a = h.substring(this.rootPath.length).split(s);
+		if (a.length === 1 && !a[0] && a.pop(), i === void 0) throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+		this.nocase = i, this.root = this.newRoot(this.#r), this.roots[this.rootPath] = this.root;
+		let l = this.root, u = a.length - 1, c = e.sep, d = this.rootPath, f = !1;
+		for (let m of a) {
+			let p = u--;
+			l = l.child(m, {
+				relative: new Array(p).fill("..").join(c),
+				relativePosix: new Array(p).fill("..").join("/"),
+				fullpath: d += (f ? "" : c) + m
+			}), f = !0;
+		}
+		this.cwd = l;
+	}
+	depth(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.depth();
+	}
+	childrenCache() {
+		return this.#n;
+	}
+	resolve(...t) {
+		let e = "";
+		for (let r = t.length - 1; r >= 0; r--) {
+			let o = t[r];
+			if (!(!o || o === ".") && (e = e ? `${o}/${e}` : o, this.isAbsolute(o))) break;
+		}
+		let s = this.#t.get(e);
+		if (s !== void 0) return s;
+		let i = this.cwd.resolve(e).fullpath();
+		return this.#t.set(e, i), i;
+	}
+	resolvePosix(...t) {
+		let e = "";
+		for (let r = t.length - 1; r >= 0; r--) {
+			let o = t[r];
+			if (!(!o || o === ".") && (e = e ? `${o}/${e}` : o, this.isAbsolute(o))) break;
+		}
+		let s = this.#s.get(e);
+		if (s !== void 0) return s;
+		let i = this.cwd.resolve(e).fullpathPosix();
+		return this.#s.set(e, i), i;
+	}
+	relative(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.relative();
+	}
+	relativePosix(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.relativePosix();
+	}
+	basename(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.name;
+	}
+	dirname(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), (t.parent || t).fullpath();
+	}
+	async readdir(t = this.cwd, e = { withFileTypes: !0 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s } = e;
+		if (t.canReaddir()) {
+			let i = await t.readdir();
+			return s ? i : i.map((r) => r.name);
+		} else return [];
+	}
+	readdirSync(t = this.cwd, e = { withFileTypes: !0 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0 } = e;
+		return t.canReaddir() ? s ? t.readdirSync() : t.readdirSync().map((i) => i.name) : [];
+	}
+	async lstat(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstat();
+	}
+	lstatSync(t = this.cwd) {
+		return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstatSync();
+	}
+	async readlink(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = await t.readlink();
+		return e ? s : s?.fullpath();
+	}
+	readlinkSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = t.readlinkSync();
+		return e ? s : s?.fullpath();
+	}
+	async realpath(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = await t.realpath();
+		return e ? s : s?.fullpath();
+	}
+	realpathSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+		let s = t.realpathSync();
+		return e ? s : s?.fullpath();
+	}
+	async walk(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = [];
+		(!r || r(t)) && h.push(s ? t : t.fullpath());
+		let a = /* @__PURE__ */ new Set(), l = (c, d) => {
+			a.add(c), c.readdirCB((f, m) => {
+				if (f) return d(f);
+				let p = m.length;
+				if (!p) return d();
+				let w = () => {
+					--p === 0 && d();
+				};
+				for (let g of m) (!r || r(g)) && h.push(s ? g : g.fullpath()), i && g.isSymbolicLink() ? g.realpath().then((S) => S?.isUnknown() ? S.lstat() : S).then((S) => S?.shouldWalk(a, o) ? l(S, w) : w()) : g.shouldWalk(a, o) ? l(g, w) : w();
+			}, !0);
+		}, u = t;
+		return new Promise((c, d) => {
+			l(u, (f) => {
+				if (f) return d(f);
+				c(h);
+			});
+		});
+	}
+	walkSync(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = [];
+		(!r || r(t)) && h.push(s ? t : t.fullpath());
+		let a = /* @__PURE__ */ new Set([t]);
+		for (let l of a) {
+			let u = l.readdirSync();
+			for (let c of u) {
+				(!r || r(c)) && h.push(s ? c : c.fullpath());
+				let d = c;
+				if (c.isSymbolicLink()) {
+					if (!(i && (d = c.realpathSync()))) continue;
+					d.isUnknown() && d.lstatSync();
+				}
+				d.shouldWalk(a, o) && a.add(d);
+			}
+		}
+		return h;
+	}
+	[Symbol.asyncIterator]() {
+		return this.iterate();
+	}
+	iterate(t = this.cwd, e = {}) {
+		return typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd), this.stream(t, e)[Symbol.asyncIterator]();
+	}
+	[Symbol.iterator]() {
+		return this.iterateSync();
+	}
+	*iterateSync(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e;
+		(!r || r(t)) && (yield s ? t : t.fullpath());
+		let h = /* @__PURE__ */ new Set([t]);
+		for (let a of h) {
+			let l = a.readdirSync();
+			for (let u of l) {
+				(!r || r(u)) && (yield s ? u : u.fullpath());
+				let c = u;
+				if (u.isSymbolicLink()) {
+					if (!(i && (c = u.realpathSync()))) continue;
+					c.isUnknown() && c.lstatSync();
+				}
+				c.shouldWalk(h, o) && h.add(c);
+			}
+		}
+	}
+	stream(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = new V({ objectMode: !0 });
+		(!r || r(t)) && h.write(s ? t : t.fullpath());
+		let a = /* @__PURE__ */ new Set(), l = [t], u = 0, c = () => {
+			let d = !1;
+			for (; !d;) {
+				let f = l.shift();
+				if (!f) {
+					u === 0 && h.end();
+					return;
+				}
+				u++, a.add(f);
+				let m = (w, g, S = !1) => {
+					if (w) return h.emit("error", w);
+					if (i && !S) {
+						let E = [];
+						for (let y of g) y.isSymbolicLink() && E.push(y.realpath().then((b) => b?.isUnknown() ? b.lstat() : b));
+						if (E.length) {
+							Promise.all(E).then(() => m(null, g, !0));
+							return;
+						}
+					}
+					for (let E of g) E && (!r || r(E)) && (h.write(s ? E : E.fullpath()) || (d = !0));
+					u--;
+					for (let E of g) {
+						let y = E.realpathCached() || E;
+						y.shouldWalk(a, o) && l.push(y);
+					}
+					d && !h.flowing ? h.once("drain", c) : p || c();
+				}, p = !0;
+				f.readdirCB(m, !0), p = !1;
+			}
+		};
+		return c(), h;
+	}
+	streamSync(t = this.cwd, e = {}) {
+		typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+		let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = new V({ objectMode: !0 }), a = /* @__PURE__ */ new Set();
+		(!r || r(t)) && h.write(s ? t : t.fullpath());
+		let l = [t], u = 0, c = () => {
+			let d = !1;
+			for (; !d;) {
+				let f = l.shift();
+				if (!f) {
+					u === 0 && h.end();
+					return;
+				}
+				u++, a.add(f);
+				let m = f.readdirSync();
+				for (let p of m) (!r || r(p)) && (h.write(s ? p : p.fullpath()) || (d = !0));
+				u--;
+				for (let p of m) {
+					let w = p;
+					if (p.isSymbolicLink()) {
+						if (!(i && (w = p.realpathSync()))) continue;
+						w.isUnknown() && w.lstatSync();
+					}
+					w.shouldWalk(a, o) && l.push(w);
+				}
+			}
+			d && !h.flowing && h.once("drain", c);
+		};
+		return c(), h;
+	}
+	chdir(t = this.cwd) {
+		let e = this.cwd;
+		this.cwd = typeof t == "string" ? this.cwd.resolve(t) : t, this.cwd[Ye](e);
+	}
+};
+var it = class extends It {
+	sep = "\\";
+	constructor(t = process.cwd(), e = {}) {
+		let { nocase: s = !0 } = e;
+		super(t, win32, "\\", {
+			...e,
+			nocase: s
+		}), this.nocase = s;
+		for (let i = this.cwd; i; i = i.parent) i.nocase = this.nocase;
+	}
+	parseRootPath(t) {
+		return win32.parse(t).root.toUpperCase();
+	}
+	newRoot(t) {
+		return new Pt(this.rootPath, U, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+	}
+	isAbsolute(t) {
+		return t.startsWith("/") || t.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(t);
+	}
+};
+var rt = class extends It {
+	sep = "/";
+	constructor(t = process.cwd(), e = {}) {
+		let { nocase: s = !1 } = e;
+		super(t, posix, "/", {
+			...e,
+			nocase: s
+		}), this.nocase = s;
+	}
+	parseRootPath(t) {
+		return "/";
+	}
+	newRoot(t) {
+		return new jt(this.rootPath, U, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+	}
+	isAbsolute(t) {
+		return t.startsWith("/");
+	}
+};
+var St = class extends rt {
+	constructor(t = process.cwd(), e = {}) {
+		let { nocase: s = !0 } = e;
+		super(t, {
+			...e,
+			nocase: s
+		});
+	}
+};
+process.platform;
+var Xe = process.platform === "win32" ? it : process.platform === "darwin" ? St : rt;
+var Di = (n) => n.length >= 1;
+var Mi = (n) => n.length >= 1;
+var Ni = Symbol.for("nodejs.util.inspect.custom");
+var nt = class n {
+	#t;
+	#s;
+	#n;
+	length;
+	#r;
+	#o;
+	#S;
+	#w;
+	#c;
+	#h;
+	#u = !0;
+	constructor(t, e, s, i) {
+		if (!Di(t)) throw new TypeError("empty pattern list");
+		if (!Mi(e)) throw new TypeError("empty glob list");
+		if (e.length !== t.length) throw new TypeError("mismatched pattern list and glob list lengths");
+		if (this.length = t.length, s < 0 || s >= this.length) throw new TypeError("index out of range");
+		if (this.#t = t, this.#s = e, this.#n = s, this.#r = i, this.#n === 0) {
+			if (this.isUNC()) {
+				let [r, o, h, a, ...l] = this.#t, [u, c, d, f, ...m] = this.#s;
+				l[0] === "" && (l.shift(), m.shift());
+				let p = [
+					r,
+					o,
+					h,
+					a,
+					""
+				].join("/"), w = [
+					u,
+					c,
+					d,
+					f,
+					""
+				].join("/");
+				this.#t = [p, ...l], this.#s = [w, ...m], this.length = this.#t.length;
+			} else if (this.isDrive() || this.isAbsolute()) {
+				let [r, ...o] = this.#t, [h, ...a] = this.#s;
+				o[0] === "" && (o.shift(), a.shift());
+				let l = r + "/", u = h + "/";
+				this.#t = [l, ...o], this.#s = [u, ...a], this.length = this.#t.length;
+			}
+		}
+	}
+	[Ni]() {
+		return "Pattern <" + this.#s.slice(this.#n).join("/") + ">";
+	}
+	pattern() {
+		return this.#t[this.#n];
+	}
+	isString() {
+		return typeof this.#t[this.#n] == "string";
+	}
+	isGlobstar() {
+		return this.#t[this.#n] === A;
+	}
+	isRegExp() {
+		return this.#t[this.#n] instanceof RegExp;
+	}
+	globString() {
+		return this.#S = this.#S || (this.#n === 0 ? this.isAbsolute() ? this.#s[0] + this.#s.slice(1).join("/") : this.#s.join("/") : this.#s.slice(this.#n).join("/"));
+	}
+	hasMore() {
+		return this.length > this.#n + 1;
+	}
+	rest() {
+		return this.#o !== void 0 ? this.#o : this.hasMore() ? (this.#o = new n(this.#t, this.#s, this.#n + 1, this.#r), this.#o.#h = this.#h, this.#o.#c = this.#c, this.#o.#w = this.#w, this.#o) : this.#o = null;
+	}
+	isUNC() {
+		let t = this.#t;
+		return this.#c !== void 0 ? this.#c : this.#c = this.#r === "win32" && this.#n === 0 && t[0] === "" && t[1] === "" && typeof t[2] == "string" && !!t[2] && typeof t[3] == "string" && !!t[3];
+	}
+	isDrive() {
+		let t = this.#t;
+		return this.#w !== void 0 ? this.#w : this.#w = this.#r === "win32" && this.#n === 0 && this.length > 1 && typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]);
+	}
+	isAbsolute() {
+		let t = this.#t;
+		return this.#h !== void 0 ? this.#h : this.#h = t[0] === "" && t.length > 1 || this.isDrive() || this.isUNC();
+	}
+	root() {
+		let t = this.#t[0];
+		return typeof t == "string" && this.isAbsolute() && this.#n === 0 ? t : "";
+	}
+	checkFollowGlobstar() {
+		return !(this.#n === 0 || !this.isGlobstar() || !this.#u);
+	}
+	markFollowGlobstar() {
+		return this.#n === 0 || !this.isGlobstar() || !this.#u ? !1 : (this.#u = !1, !0);
+	}
+};
+var _i = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux";
+var ot = class {
+	relative;
+	relativeChildren;
+	absolute;
+	absoluteChildren;
+	platform;
+	mmopts;
+	constructor(t, { nobrace: e, nocase: s, noext: i, noglobstar: r, platform: o = _i }) {
+		this.relative = [], this.absolute = [], this.relativeChildren = [], this.absoluteChildren = [], this.platform = o, this.mmopts = {
+			dot: !0,
+			nobrace: e,
+			nocase: s,
+			noext: i,
+			noglobstar: r,
+			optimizationLevel: 2,
+			platform: o,
+			nocomment: !0,
+			nonegate: !0
+		};
+		for (let h of t) this.add(h);
+	}
+	add(t) {
+		let e = new D(t, this.mmopts);
+		for (let s = 0; s < e.set.length; s++) {
+			let i = e.set[s], r = e.globParts[s];
+			if (!i || !r) throw new Error("invalid pattern object");
+			for (; i[0] === "." && r[0] === ".";) i.shift(), r.shift();
+			let o = new nt(i, r, 0, this.platform), h = new D(o.globString(), this.mmopts), a = r[r.length - 1] === "**", l = o.isAbsolute();
+			l ? this.absolute.push(h) : this.relative.push(h), a && (l ? this.absoluteChildren.push(h) : this.relativeChildren.push(h));
+		}
+	}
+	ignored(t) {
+		let e = t.fullpath(), s = `${e}/`, i = t.relative() || ".", r = `${i}/`;
+		for (let o of this.relative) if (o.match(i) || o.match(r)) return !0;
+		for (let o of this.absolute) if (o.match(e) || o.match(s)) return !0;
+		return !1;
+	}
+	childrenIgnored(t) {
+		let e = t.fullpath() + "/", s = (t.relative() || ".") + "/";
+		for (let i of this.relativeChildren) if (i.match(s)) return !0;
+		for (let i of this.absoluteChildren) if (i.match(e)) return !0;
+		return !1;
+	}
+};
+var oe = class n {
+	store;
+	constructor(t = /* @__PURE__ */ new Map()) {
+		this.store = t;
+	}
+	copy() {
+		return new n(new Map(this.store));
+	}
+	hasWalked(t, e) {
+		return this.store.get(t.fullpath())?.has(e.globString());
+	}
+	storeWalked(t, e) {
+		let s = t.fullpath(), i = this.store.get(s);
+		i ? i.add(e.globString()) : this.store.set(s, /* @__PURE__ */ new Set([e.globString()]));
+	}
+};
+var he = class {
+	store = /* @__PURE__ */ new Map();
+	add(t, e, s) {
+		let i = (e ? 2 : 0) | (s ? 1 : 0), r = this.store.get(t);
+		this.store.set(t, r === void 0 ? i : i & r);
+	}
+	entries() {
+		return [...this.store.entries()].map(([t, e]) => [
+			t,
+			!!(e & 2),
+			!!(e & 1)
+		]);
+	}
+};
+var ae = class {
+	store = /* @__PURE__ */ new Map();
+	add(t, e) {
+		if (!t.canReaddir()) return;
+		let s = this.store.get(t);
+		s ? s.find((i) => i.globString() === e.globString()) || s.push(e) : this.store.set(t, [e]);
+	}
+	get(t) {
+		let e = this.store.get(t);
+		if (!e) throw new Error("attempting to walk unknown path");
+		return e;
+	}
+	entries() {
+		return this.keys().map((t) => [t, this.store.get(t)]);
+	}
+	keys() {
+		return [...this.store.keys()].filter((t) => t.canReaddir());
+	}
+};
+var Et = class n {
+	hasWalkedCache;
+	matches = new he();
+	subwalks = new ae();
+	patterns;
+	follow;
+	dot;
+	opts;
+	constructor(t, e) {
+		this.opts = t, this.follow = !!t.follow, this.dot = !!t.dot, this.hasWalkedCache = e ? e.copy() : new oe();
+	}
+	processPatterns(t, e) {
+		this.patterns = e;
+		let s = e.map((i) => [t, i]);
+		for (let [i, r] of s) {
+			this.hasWalkedCache.storeWalked(i, r);
+			let o = r.root(), h = r.isAbsolute() && this.opts.absolute !== !1;
+			if (o) {
+				i = i.resolve(o === "/" && this.opts.root !== void 0 ? this.opts.root : o);
+				let c = r.rest();
+				if (c) r = c;
+				else {
+					this.matches.add(i, !0, !1);
+					continue;
+				}
 			}
+			if (i.isENOENT()) continue;
+			let a, l, u = !1;
+			for (; typeof (a = r.pattern()) == "string" && (l = r.rest());) i = i.resolve(a), r = l, u = !0;
+			if (a = r.pattern(), l = r.rest(), u) {
+				if (this.hasWalkedCache.hasWalked(i, r)) continue;
+				this.hasWalkedCache.storeWalked(i, r);
+			}
+			if (typeof a == "string") {
+				let c = a === ".." || a === "" || a === ".";
+				this.matches.add(i.resolve(a), h, c);
+				continue;
+			} else if (a === A) {
+				(!i.isSymbolicLink() || this.follow || r.checkFollowGlobstar()) && this.subwalks.add(i, r);
+				let c = l?.pattern(), d = l?.rest();
+				if (!l || (c === "" || c === ".") && !d) this.matches.add(i, h, c === "" || c === ".");
+				else if (c === "..") {
+					let f = i.parent || i;
+					d ? this.hasWalkedCache.hasWalked(f, d) || this.subwalks.add(f, d) : this.matches.add(f, h, !0);
+				}
+			} else a instanceof RegExp && this.subwalks.add(i, r);
 		}
-		if (!options?.quiet) logger.info(`[luals] Ready: ${binaryPath}`);
-		return binaryPath;
-	} finally {
-		if (fs.existsSync(tempDir)) try {
-			fs.rmSync(tempDir, {
-				recursive: true,
-				force: true
+		return this;
+	}
+	subwalkTargets() {
+		return this.subwalks.keys();
+	}
+	child() {
+		return new n(this.opts, this.hasWalkedCache);
+	}
+	filterEntries(t, e) {
+		let s = this.subwalks.get(t), i = this.child();
+		for (let r of e) for (let o of s) {
+			let h = o.isAbsolute(), a = o.pattern(), l = o.rest();
+			a === A ? i.testGlobstar(r, o, l, h) : a instanceof RegExp ? i.testRegExp(r, a, l, h) : i.testString(r, a, l, h);
+		}
+		return i;
+	}
+	testGlobstar(t, e, s, i) {
+		if ((this.dot || !t.name.startsWith(".")) && (e.hasMore() || this.matches.add(t, i, !1), t.canReaddir() && (this.follow || !t.isSymbolicLink() ? this.subwalks.add(t, e) : t.isSymbolicLink() && (s && e.checkFollowGlobstar() ? this.subwalks.add(t, s) : e.markFollowGlobstar() && this.subwalks.add(t, e)))), s) {
+			let r = s.pattern();
+			if (typeof r == "string" && r !== ".." && r !== "" && r !== ".") this.testString(t, r, s.rest(), i);
+			else if (r === "..") {
+				let o = t.parent || t;
+				this.subwalks.add(o, s);
+			} else r instanceof RegExp && this.testRegExp(t, r, s.rest(), i);
+		}
+	}
+	testRegExp(t, e, s, i) {
+		e.test(t.name) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, !1));
+	}
+	testString(t, e, s, i) {
+		t.isNamed(e) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, !1));
+	}
+};
+var Li = (n, t) => typeof n == "string" ? new ot([n], t) : Array.isArray(n) ? new ot(n, t) : n;
+var zt = class {
+	path;
+	patterns;
+	opts;
+	seen = /* @__PURE__ */ new Set();
+	paused = !1;
+	aborted = !1;
+	#t = [];
+	#s;
+	#n;
+	signal;
+	maxDepth;
+	includeChildMatches;
+	constructor(t, e, s) {
+		if (this.patterns = t, this.path = e, this.opts = s, this.#n = !s.posix && s.platform === "win32" ? "\\" : "/", this.includeChildMatches = s.includeChildMatches !== !1, (s.ignore || !this.includeChildMatches) && (this.#s = Li(s.ignore ?? [], s), !this.includeChildMatches && typeof this.#s.add != "function")) throw new Error("cannot ignore child matches, ignore lacks add() method.");
+		this.maxDepth = s.maxDepth || 1 / 0, s.signal && (this.signal = s.signal, this.signal.addEventListener("abort", () => {
+			this.#t.length = 0;
+		}));
+	}
+	#r(t) {
+		return this.seen.has(t) || !!this.#s?.ignored?.(t);
+	}
+	#o(t) {
+		return !!this.#s?.childrenIgnored?.(t);
+	}
+	pause() {
+		this.paused = !0;
+	}
+	resume() {
+		if (this.signal?.aborted) return;
+		this.paused = !1;
+		let t;
+		for (; !this.paused && (t = this.#t.shift());) t();
+	}
+	onResume(t) {
+		this.signal?.aborted || (this.paused ? this.#t.push(t) : t());
+	}
+	async matchCheck(t, e) {
+		if (e && this.opts.nodir) return;
+		let s;
+		if (this.opts.realpath) {
+			if (s = t.realpathCached() || await t.realpath(), !s) return;
+			t = s;
+		}
+		let r = t.isUnknown() || this.opts.stat ? await t.lstat() : t;
+		if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+			let o = await r.realpath();
+			o && (o.isUnknown() || this.opts.stat) && await o.lstat();
+		}
+		return this.matchCheckTest(r, e);
+	}
+	matchCheckTest(t, e) {
+		return t && (this.maxDepth === 1 / 0 || t.depth() <= this.maxDepth) && (!e || t.canReaddir()) && (!this.opts.nodir || !t.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !t.isSymbolicLink() || !t.realpathCached()?.isDirectory()) && !this.#r(t) ? t : void 0;
+	}
+	matchCheckSync(t, e) {
+		if (e && this.opts.nodir) return;
+		let s;
+		if (this.opts.realpath) {
+			if (s = t.realpathCached() || t.realpathSync(), !s) return;
+			t = s;
+		}
+		let r = t.isUnknown() || this.opts.stat ? t.lstatSync() : t;
+		if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+			let o = r.realpathSync();
+			o && (o?.isUnknown() || this.opts.stat) && o.lstatSync();
+		}
+		return this.matchCheckTest(r, e);
+	}
+	matchFinish(t, e) {
+		if (this.#r(t)) return;
+		if (!this.includeChildMatches && this.#s?.add) {
+			let r = `${t.relativePosix()}/**`;
+			this.#s.add(r);
+		}
+		let s = this.opts.absolute === void 0 ? e : this.opts.absolute;
+		this.seen.add(t);
+		let i = this.opts.mark && t.isDirectory() ? this.#n : "";
+		if (this.opts.withFileTypes) this.matchEmit(t);
+		else if (s) {
+			let r = this.opts.posix ? t.fullpathPosix() : t.fullpath();
+			this.matchEmit(r + i);
+		} else {
+			let r = this.opts.posix ? t.relativePosix() : t.relative(), o = this.opts.dotRelative && !r.startsWith(".." + this.#n) ? "." + this.#n : "";
+			this.matchEmit(r ? o + r + i : "." + i);
+		}
+	}
+	async match(t, e, s) {
+		let i = await this.matchCheck(t, s);
+		i && this.matchFinish(i, e);
+	}
+	matchSync(t, e, s) {
+		let i = this.matchCheckSync(t, s);
+		i && this.matchFinish(i, e);
+	}
+	walkCB(t, e, s) {
+		this.signal?.aborted && s(), this.walkCB2(t, e, new Et(this.opts), s);
+	}
+	walkCB2(t, e, s, i) {
+		if (this.#o(t)) return i();
+		if (this.signal?.aborted && i(), this.paused) {
+			this.onResume(() => this.walkCB2(t, e, s, i));
+			return;
+		}
+		s.processPatterns(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || (r++, this.match(h, a, l).then(() => o()));
+		for (let h of s.subwalkTargets()) {
+			if (this.maxDepth !== 1 / 0 && h.depth() >= this.maxDepth) continue;
+			r++;
+			let a = h.readdirCached();
+			h.calledReaddir() ? this.walkCB3(h, a, s, o) : h.readdirCB((l, u) => this.walkCB3(h, u, s, o), !0);
+		}
+		o();
+	}
+	walkCB3(t, e, s, i) {
+		s = s.filterEntries(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || (r++, this.match(h, a, l).then(() => o()));
+		for (let [h, a] of s.subwalks.entries()) r++, this.walkCB2(h, a, s.child(), o);
+		o();
+	}
+	walkCBSync(t, e, s) {
+		this.signal?.aborted && s(), this.walkCB2Sync(t, e, new Et(this.opts), s);
+	}
+	walkCB2Sync(t, e, s, i) {
+		if (this.#o(t)) return i();
+		if (this.signal?.aborted && i(), this.paused) {
+			this.onResume(() => this.walkCB2Sync(t, e, s, i));
+			return;
+		}
+		s.processPatterns(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || this.matchSync(h, a, l);
+		for (let h of s.subwalkTargets()) {
+			if (this.maxDepth !== 1 / 0 && h.depth() >= this.maxDepth) continue;
+			r++;
+			let a = h.readdirSync();
+			this.walkCB3Sync(h, a, s, o);
+		}
+		o();
+	}
+	walkCB3Sync(t, e, s, i) {
+		s = s.filterEntries(t, e);
+		let r = 1, o = () => {
+			--r === 0 && i();
+		};
+		for (let [h, a, l] of s.matches.entries()) this.#r(h) || this.matchSync(h, a, l);
+		for (let [h, a] of s.subwalks.entries()) r++, this.walkCB2Sync(h, a, s.child(), o);
+		o();
+	}
+};
+var xt = class extends zt {
+	matches = /* @__PURE__ */ new Set();
+	constructor(t, e, s) {
+		super(t, e, s);
+	}
+	matchEmit(t) {
+		this.matches.add(t);
+	}
+	async walk() {
+		if (this.signal?.aborted) throw this.signal.reason;
+		return this.path.isUnknown() && await this.path.lstat(), await new Promise((t, e) => {
+			this.walkCB(this.path, this.patterns, () => {
+				this.signal?.aborted ? e(this.signal.reason) : t(this.matches);
 			});
-		} catch (err) {
-			logger.debug(`[luals] Failed to clean up temporary directory ${tempDir}: ${err instanceof Error ? err.message : String(err)}`);
+		}), this.matches;
+	}
+	walkSync() {
+		if (this.signal?.aborted) throw this.signal.reason;
+		return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => {
+			if (this.signal?.aborted) throw this.signal.reason;
+		}), this.matches;
+	}
+};
+var vt = class extends zt {
+	results;
+	constructor(t, e, s) {
+		super(t, e, s), this.results = new V({
+			signal: this.signal,
+			objectMode: !0
+		}), this.results.on("drain", () => this.resume()), this.results.on("resume", () => this.resume());
+	}
+	matchEmit(t) {
+		this.results.write(t), this.results.flowing || this.pause();
+	}
+	stream() {
+		let t = this.path;
+		return t.isUnknown() ? t.lstat().then(() => {
+			this.walkCB(t, this.patterns, () => this.results.end());
+		}) : this.walkCB(t, this.patterns, () => this.results.end()), this.results;
+	}
+	streamSync() {
+		return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => this.results.end()), this.results;
+	}
+};
+var Pi = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux";
+var I = class {
+	absolute;
+	cwd;
+	root;
+	dot;
+	dotRelative;
+	follow;
+	ignore;
+	magicalBraces;
+	mark;
+	matchBase;
+	maxDepth;
+	nobrace;
+	nocase;
+	nodir;
+	noext;
+	noglobstar;
+	pattern;
+	platform;
+	realpath;
+	scurry;
+	stat;
+	signal;
+	windowsPathsNoEscape;
+	withFileTypes;
+	includeChildMatches;
+	opts;
+	patterns;
+	constructor(t, e) {
+		if (!e) throw new TypeError("glob options required");
+		if (this.withFileTypes = !!e.withFileTypes, this.signal = e.signal, this.follow = !!e.follow, this.dot = !!e.dot, this.dotRelative = !!e.dotRelative, this.nodir = !!e.nodir, this.mark = !!e.mark, e.cwd ? (e.cwd instanceof URL || e.cwd.startsWith("file://")) && (e.cwd = fileURLToPath(e.cwd)) : this.cwd = "", this.cwd = e.cwd || "", this.root = e.root, this.magicalBraces = !!e.magicalBraces, this.nobrace = !!e.nobrace, this.noext = !!e.noext, this.realpath = !!e.realpath, this.absolute = e.absolute, this.includeChildMatches = e.includeChildMatches !== !1, this.noglobstar = !!e.noglobstar, this.matchBase = !!e.matchBase, this.maxDepth = typeof e.maxDepth == "number" ? e.maxDepth : 1 / 0, this.stat = !!e.stat, this.ignore = e.ignore, this.withFileTypes && this.absolute !== void 0) throw new Error("cannot set absolute and withFileTypes:true");
+		if (typeof t == "string" && (t = [t]), this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === !1, this.windowsPathsNoEscape && (t = t.map((a) => a.replace(/\\/g, "/"))), this.matchBase) {
+			if (e.noglobstar) throw new TypeError("base matching requires globstar");
+			t = t.map((a) => a.includes("/") ? a : `./**/${a}`);
+		}
+		if (this.pattern = t, this.platform = e.platform || Pi, this.opts = {
+			...e,
+			platform: this.platform
+		}, e.scurry) {
+			if (this.scurry = e.scurry, e.nocase !== void 0 && e.nocase !== e.scurry.nocase) throw new Error("nocase option contradicts provided scurry option");
+		} else {
+			let a = e.platform === "win32" ? it : e.platform === "darwin" ? St : e.platform ? rt : Xe;
+			this.scurry = new a(this.cwd, {
+				nocase: e.nocase,
+				fs: e.fs
+			});
+		}
+		this.nocase = this.scurry.nocase;
+		let s = this.platform === "darwin" || this.platform === "win32", i = {
+			braceExpandMax: 1e4,
+			...e,
+			dot: this.dot,
+			matchBase: this.matchBase,
+			nobrace: this.nobrace,
+			nocase: this.nocase,
+			nocaseMagicOnly: s,
+			nocomment: !0,
+			noext: this.noext,
+			nonegate: !0,
+			optimizationLevel: 2,
+			platform: this.platform,
+			windowsPathsNoEscape: this.windowsPathsNoEscape,
+			debug: !!this.opts.debug
+		}, [o, h] = this.pattern.map((a) => new D(a, i)).reduce((a, l) => (a[0].push(...l.set), a[1].push(...l.globParts), a), [[], []]);
+		this.patterns = o.map((a, l) => {
+			let u = h[l];
+			if (!u) throw new Error("invalid pattern object");
+			return new nt(a, u, 0, this.platform);
+		});
+	}
+	async walk() {
+		return [...await new xt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).walk()];
+	}
+	walkSync() {
+		return [...new xt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).walkSync()];
+	}
+	stream() {
+		return new vt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).stream();
+	}
+	streamSync() {
+		return new vt(this.patterns, this.scurry.cwd, {
+			...this.opts,
+			maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+			platform: this.platform,
+			nocase: this.nocase,
+			includeChildMatches: this.includeChildMatches
+		}).streamSync();
+	}
+	iterateSync() {
+		return this.streamSync()[Symbol.iterator]();
+	}
+	[Symbol.iterator]() {
+		return this.iterateSync();
+	}
+	iterate() {
+		return this.stream()[Symbol.asyncIterator]();
+	}
+	[Symbol.asyncIterator]() {
+		return this.iterate();
+	}
+};
+var le = (n, t = {}) => {
+	Array.isArray(n) || (n = [n]);
+	for (let e of n) if (new D(e, t).hasMagic()) return !0;
+	return !1;
+};
+function Bt(n, t = {}) {
+	return new I(n, t).streamSync();
+}
+function Qe(n, t = {}) {
+	return new I(n, t).stream();
+}
+function ts(n, t = {}) {
+	return new I(n, t).walkSync();
+}
+async function Je(n, t = {}) {
+	return new I(n, t).walk();
+}
+function Ut(n, t = {}) {
+	return new I(n, t).iterateSync();
+}
+function es(n, t = {}) {
+	return new I(n, t).iterate();
+}
+var ji = Bt;
+var Ii = Object.assign(Qe, { sync: Bt });
+var zi = Ut;
+var Bi = Object.assign(es, { sync: Ut });
+var Ui = Object.assign(ts, {
+	stream: Bt,
+	iterate: Ut
+});
+var Ze = Object.assign(Je, {
+	glob: Je,
+	globSync: ts,
+	sync: Ui,
+	globStream: Qe,
+	stream: Ii,
+	globStreamSync: Bt,
+	streamSync: ji,
+	globIterate: es,
+	iterate: Bi,
+	globIterateSync: Ut,
+	iterateSync: zi,
+	Glob: I,
+	hasMagic: le,
+	escape: tt,
+	unescape: W
+});
+Ze.glob = Ze;
+//#endregion
+//#region src/luals/files.ts
+/** Directories skipped unless the workspace config overrides `workspace.ignoreDir`. */
+const DEFAULT_IGNORE_DIRS = [
+	".git",
+	".vscode",
+	".nanos-lint",
+	"node_modules"
+];
+/** Candidate Lua files: LuaLS checks every `*.lua` file in the tree. */
+const LUA_FILE_PATTERN = "**/*.lua";
+/** `glob` rejects patterns longer than this, so they are dropped before matching. */
+const MAX_PATTERN_LENGTH = 65536;
+/**
+* Complexity budget per pattern. `minimatch` evaluates patterns through an AST
+* but still compiles them to regular expressions, so ambiguous wildcards inside
+* one path segment can backtrack, and brace groups expand combinatorially
+* (`{a,b}` repeated 16 times is 65 536 alternatives). A hostile or accidental
+* `.luarc.json` could otherwise stall the file walk, so patterns beyond the
+* budget are skipped with a warning instead of being matched.
+*
+* The ambiguity of one segment grows like `C(segment length, wildcards)`, so the
+* per-segment cap is what keeps matching cheap. `**\/*a*a*a*a\/*a*a*a*a\/*a*a*a*a\/*a*a*a*z.lua`
+* (4 wildcards per segment) stays within a 4-wildcard cap yet costs ~5 ms per
+* candidate file — ~100 s on a 20 000-file tree — while two wildcards per
+* segment cost `C(60, 2) = 1 770` splits, hundreds of times less. The budget is
+* deliberately far below what minimatch can parse: every realistic pattern
+* (`**\/*.{bak,tmp}`, `**\/node_modules\/**`, `**\/item-[0-9].lua`,
+* `**\/*.min.*`) needs at most two wildcards in any one segment.
+*/
+const MAX_WILDCARDS_PER_SEGMENT = 2;
+const MAX_TOTAL_WILDCARDS = 12;
+const MAX_BRACE_ALTERNATIVES = 256;
+/** Counts wildcard tokens (`*`, `?`, character classes and brace groups). */
+function countWildcards(value) {
+	let count = 0;
+	for (const char of value) if (char === "*" || char === "?" || char === "[" || char === "{") count += 1;
+	return count;
+}
+/**
+* Upper bound of the alternatives brace expansion would produce; `1` when the
+* pattern has no brace groups. Nested groups count towards their parent, which
+* over-estimates on purpose so the bound stays safe.
+*/
+function estimateBraceAlternatives(pattern) {
+	const pending = [];
+	let estimate = 1;
+	for (const char of pattern) if (char === "{") pending.push(0);
+	else if (char === "}" && pending.length > 0) {
+		const alternatives = (pending.pop() ?? 0) + 1;
+		estimate *= alternatives;
+		if (pending.length > 0) pending[pending.length - 1] = (pending[pending.length - 1] ?? 0) + alternatives - 1;
+	} else if (char === "," && pending.length > 0) pending[pending.length - 1] = (pending[pending.length - 1] ?? 0) + 1;
+	return estimate;
+}
+/** Returns `false` when matching the pattern could become pathologically slow. */
+function isPatternWithinBudget(pattern) {
+	if (estimateBraceAlternatives(pattern) > MAX_BRACE_ALTERNATIVES) return false;
+	if (countWildcards(pattern) > MAX_TOTAL_WILDCARDS) return false;
+	return pattern.split("/").every((segment) => countWildcards(segment) <= MAX_WILDCARDS_PER_SEGMENT);
+}
+/**
+* Normalizes one user-supplied pattern (`workspace.ignoreDir`, `files.exclude`
+* or a built-in default) into the slash-separated form `glob` expects.
+* Backslashes are accepted as separators so Windows-authored `.luarc.json`
+* files keep working, and trailing slashes are dropped so `vendor/` behaves
+* exactly like `vendor`. Patterns that cannot be matched (`""`, `"."`, NUL
+* bytes, oversized input, absolute paths, or non-string JSON values) are
+* rejected instead of being handed to `glob`.
+*/
+function normalizePattern(pattern) {
+	if (typeof pattern !== "string") return null;
+	const normalized = pattern.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+	if (!normalized || normalized === "." || normalized.length > MAX_PATTERN_LENGTH || normalized.includes("\0") || isAbsolutePattern(normalized)) return null;
+	return normalized;
+}
+/** Drive-letter prefixes, recognized on every platform (not just Windows). */
+const WINDOWS_ABSOLUTE_PATTERN = /^[A-Za-z]:\//;
+/**
+* `workspace.ignoreDir` / `files.exclude` entries are workspace-relative in
+* LuaLS, and `glob` matches ignore patterns against walk-relative paths. An
+* absolute entry is therefore unusable, and `glob` anchors it on some platforms
+* but not others (a macOS `/var` -> `/private/var` walk root or a Windows drive
+* letter behave differently again), so it is skipped to keep one `.luarc.json`
+* behaving identically on Linux, macOS and Windows.
+*/
+function isAbsolutePattern(normalized) {
+	return path.posix.isAbsolute(normalized) || WINDOWS_ABSOLUTE_PATTERN.test(normalized);
+}
+/**
+* Expands one LuaLS pattern into the equivalent `glob` ignore patterns:
+*
+* - basename-only patterns (`*.lua`, `vendor`) match at any depth, so the
+*   `**\/`-prefixed variants are added (mirrors LuaLS `matchBase` semantics);
+* - a pattern also excludes everything below a matching directory, which is
+*   what the trailing `/**` variant expresses;
+* - the pattern itself is always kept so an exact file or directory match
+*   works as written.
+*/
+function expandIgnorePattern(pattern) {
+	return pattern.includes("/") ? [pattern, `${pattern}/**`] : [`**/${pattern}`, `**/${pattern}/**`];
+}
+/** Normalizes and expands a list of LuaLS patterns into `glob` ignore patterns. */
+function toIgnorePatterns(patterns) {
+	const ignore = [];
+	for (const raw of patterns) {
+		const normalized = normalizePattern(raw);
+		if (!normalized) {
+			logger.debug(`[luals] Skipping unusable glob pattern "${String(raw)}" while counting checked files.`);
+			continue;
+		}
+		if (!isPatternWithinBudget(normalized)) {
+			logger.warn(`[luals] Skipping glob pattern "${raw}": it is too complex to match safely and would slow down file counting.`);
+			continue;
 		}
+		ignore.push(...expandIgnorePattern(normalized));
+	}
+	return ignore;
+}
+/**
+* Counts candidate Lua files within targetPath, taking `workspace.ignoreDir`
+* and `files.exclude` into account.
+*
+* Traversal and matching are delegated to the bundled `glob` package, whose
+* `minimatch` matcher understands the full glob syntax LuaLS accepts (brace
+* expansion, character classes, `**`, `?`) instead of the hand-rolled
+* glob-to-regex translation used before. Combined with the pattern budgets
+* above, this keeps the count predictable for adversarial configurations
+* while remaining consistent with LuaLS exclude semantics (#27).
+*/
+function countCheckedFiles(targetPath, configPath) {
+	let absPath = path.resolve(targetPath);
+	if (!fs.existsSync(absPath)) return 0;
+	try {
+		absPath = fs.realpathSync.native(absPath);
+	} catch {
+		try {
+			absPath = fs.realpathSync(absPath);
+		} catch (err) {}
+	}
+	if (fs.statSync(absPath).isFile()) return absPath.toLowerCase().endsWith(".lua") ? 1 : 0;
+	let ignoreDirs = DEFAULT_IGNORE_DIRS;
+	let excludePatterns = [];
+	if (configPath && fs.existsSync(configPath)) try {
+		const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+		if (Array.isArray(cfg.workspace?.ignoreDir)) ignoreDirs = cfg.workspace.ignoreDir;
+		if (Array.isArray(cfg.files?.exclude)) excludePatterns = cfg.files.exclude;
+	} catch (err) {
+		logger.warn(`[luals] Failed to parse config file for file counting at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const ignore = [...toIgnorePatterns(ignoreDirs), ...toIgnorePatterns(excludePatterns)];
+	try {
+		return ts(LUA_FILE_PATTERN, {
+			cwd: absPath,
+			ignore,
+			dot: true,
+			nocase: true,
+			follow: false,
+			withFileTypes: true
+		}).filter((entry) => entry.isFile()).length;
+	} catch (err) {
+		logger.warn(`[luals] Failed to walk ${absPath} while counting checked files: ${err instanceof Error ? err.message : String(err)}`);
+		return 0;
 	}
 }
+//#endregion
+//#region src/luals/runner.ts
+const execFileAsync = promisify(execFile);
+function isOfflineError(err) {
+	if (!err) return false;
+	const msg = err instanceof Error ? err.message : String(err);
+	return /offline|enotfound|eai_again|econnrefused|etimedout|fetch failed/i.test(msg);
+}
 async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
-	if (process.env.LUALS_BIN && fs.existsSync(process.env.LUALS_BIN)) return process.env.LUALS_BIN;
-	if (!version || version === "latest") {
+	if (process.env.LUALS_BIN) return assertValidLuaLSBinary(process.env.LUALS_BIN, "LUALS_BIN");
+	if (options?.reuseExisting !== false && (!version || version === "latest")) {
 		const defaultInfo = getPlatformInfo(FALLBACK_LUALS_VERSION);
 		const defaultBundledPath = path.join(getPackageRoot(), defaultInfo.binaryRelativePath);
 		if (fs.existsSync(defaultBundledPath) && isBinaryValid(defaultBundledPath)) return defaultBundledPath;
@@ -1602,18 +5427,28 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	if (!isDefaultOrLatest) {
 		const resolvedVersion = await resolveLuaLSVersion(version);
 		const info = getPlatformInfo(resolvedVersion);
-		const bundledPath = path.join(getPackageRoot(), info.binaryRelativePath);
-		if (fs.existsSync(bundledPath) && isBinaryValid(bundledPath)) return bundledPath;
+		if (options?.reuseExisting !== false) {
+			const bundledPath = path.join(getPackageRoot(), info.binaryRelativePath);
+			if (fs.existsSync(bundledPath) && isBinaryValid(bundledPath)) return bundledPath;
+		}
 		const cachedDir = getCacheDir(resolvedVersion, baseCacheDir);
 		const cachedPath = path.join(cachedDir, info.binaryRelativePath);
 		const completeMarker = path.join(cachedDir, ".complete");
+		let wasCorrupted = false;
 		if (fs.existsSync(cachedPath)) {
+			let isValid = false;
 			if (fs.existsSync(completeMarker)) try {
-				if (fs.readFileSync(completeMarker, "utf-8").trim() === resolvedVersion && isBinaryValid(cachedPath)) return cachedPath;
+				if (fs.readFileSync(completeMarker, "utf-8").trim() === resolvedVersion && isBinaryValid(cachedPath)) {
+					isValid = true;
+					if (options?.reuseExisting !== false) return cachedPath;
+				}
 			} catch (err) {
 				logger.debug(`[luals] Failed to read complete marker at ${completeMarker}: ${err instanceof Error ? err.message : String(err)}`);
 			}
-			if (!options?.quiet) logger.warn(`[luals] Cached LuaLS binary at ${cachedPath} is corrupted or incomplete. Repairing...`);
+			if (!isValid) {
+				wasCorrupted = true;
+				if (!options?.quiet) logger.warn(`[luals] Cached LuaLS binary at ${cachedPath} is corrupted or incomplete. Repairing...`);
+			}
 			try {
 				fs.rmSync(cachedDir, {
 					recursive: true,
@@ -1623,29 +5458,33 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 				logger.warn(`[luals] Failed to remove corrupted cache directory ${cachedDir}: ${err instanceof Error ? err.message : String(err)}`);
 			}
 		}
-		const legacyDir = getLegacyCacheDir(resolvedVersion);
-		const legacyPath = path.join(legacyDir, info.binaryRelativePath);
-		const legacyMarker = path.join(legacyDir, ".complete");
-		if (fs.existsSync(legacyPath)) {
-			let validLegacy = false;
-			if (fs.existsSync(legacyMarker)) try {
-				if (fs.readFileSync(legacyMarker, "utf-8").trim() === resolvedVersion && isBinaryValid(legacyPath)) validLegacy = true;
-			} catch (err) {
-				logger.debug(`[luals] Failed to read legacy complete marker at ${legacyMarker}: ${err instanceof Error ? err.message : String(err)}`);
-			}
-			else if (isBinaryValid(legacyPath)) validLegacy = true;
-			if (validLegacy) {
-				if (path.resolve(legacyDir) !== path.resolve(cachedDir)) try {
-					fs.mkdirSync(path.dirname(cachedDir), { recursive: true });
-					fs.cpSync(legacyDir, cachedDir, { recursive: true });
-					if (fs.existsSync(cachedPath) && isBinaryValid(cachedPath)) return cachedPath;
-				} catch (err) {
-					logger.warn(`[luals] Failed to migrate legacy cache from ${legacyDir} to ${cachedDir}: ${err instanceof Error ? err.message : String(err)}`);
+		if (options?.reuseExisting !== false) {
+			const legacyDir = getLegacyCacheDir(resolvedVersion);
+			if (path.resolve(legacyDir) !== path.resolve(cachedDir)) {
+				const legacyPath = path.join(legacyDir, info.binaryRelativePath);
+				const legacyMarker = path.join(legacyDir, ".complete");
+				if (fs.existsSync(legacyPath)) {
+					let validLegacy = false;
+					if (fs.existsSync(legacyMarker)) try {
+						if (fs.readFileSync(legacyMarker, "utf-8").trim() === resolvedVersion && isBinaryValid(legacyPath)) validLegacy = true;
+					} catch (err) {
+						logger.debug(`[luals] Failed to read legacy complete marker at ${legacyMarker}: ${err instanceof Error ? err.message : String(err)}`);
+					}
+					else if (isBinaryValid(legacyPath)) validLegacy = true;
+					if (validLegacy) {
+						try {
+							fs.mkdirSync(path.dirname(cachedDir), { recursive: true });
+							fs.cpSync(legacyDir, cachedDir, { recursive: true });
+							if (fs.existsSync(cachedPath) && isBinaryValid(cachedPath)) return cachedPath;
+						} catch (err) {
+							logger.warn(`[luals] Failed to migrate legacy cache from ${legacyDir} to ${cachedDir}: ${err instanceof Error ? err.message : String(err)}`);
+						}
+						return legacyPath;
+					}
 				}
-				return legacyPath;
 			}
 		}
-		try {
+		if (options?.reuseExisting !== false) try {
 			const cmd = process.platform === "win32" ? "where.exe" : "which";
 			const { stdout } = await execFileAsync(cmd, ["lua-language-server"]);
 			const found = stdout.trim().split(/\r?\n/)[0];
@@ -1653,20 +5492,34 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 		} catch (err) {
 			logger.debug(`[luals] LuaLS binary not found in PATH: ${err instanceof Error ? err.message : String(err)}`);
 		}
-		return await downloadAndExtractLuaLS(resolvedVersion, getCacheDir(resolvedVersion, baseCacheDir), options);
+		try {
+			return await downloadAndExtractLuaLS(resolvedVersion, getCacheDir(resolvedVersion, baseCacheDir), options);
+		} catch (err) {
+			if (wasCorrupted) {
+				const isOffline = isOfflineError(err);
+				const reason = isOffline ? "while offline" : err instanceof Error ? err.message : String(err);
+				throw new LuaLSError(`Cached LuaLS binary at '${cachedPath}' is corrupted (failed execution/size check) and cannot be re-downloaded ${isOffline ? reason : `: ${reason}`}. Please ${isOffline ? "connect to the internet" : "verify your network connection"} to repair or run 'nanos-lint clean-cache'.`, "ERR_LUALS_CORRUPTED_CACHE", "Connect to the internet to repair the corrupted binary or run 'nanos-lint clean-cache'.", { cause: err });
+			}
+			throw err;
+		}
 	}
 	const currentWeek = getIsoWeek();
 	const metadata = readLuaLSMetadata(baseCacheDir);
-	if (metadata && metadata.lastCheckedWeek === currentWeek && metadata.latestVersion) {
-		const info = getPlatformInfo(metadata.latestVersion);
-		const cachedPath = path.join(getCacheDir(metadata.latestVersion, baseCacheDir), info.binaryRelativePath);
-		if (isBinaryValid(cachedPath)) return cachedPath;
+	const safeLatest = metadata?.latestVersion ? sanitizeLuaLSVersion(metadata.latestVersion) : null;
+	if (options?.reuseExisting !== false && metadata && metadata.lastCheckedWeek === currentWeek && safeLatest) {
+		const info = getPlatformInfo(safeLatest);
+		const targetDir = path.resolve(getCacheDir(safeLatest, baseCacheDir));
+		const resolvedBase = path.resolve(baseCacheDir);
+		if (targetDir.startsWith(resolvedBase + path.sep) || targetDir === resolvedBase) {
+			const cachedPath = path.join(targetDir, info.binaryRelativePath);
+			if (isBinaryValid(cachedPath)) return cachedPath;
+		}
 	}
-	const cachedVersions = listCachedLuaLSVersions(baseCacheDir);
-	if (metadata && metadata.lastCheckedWeek === currentWeek && cachedVersions.length > 0) {
-		const fallbackVersion = cachedVersions[0];
-		const info = getPlatformInfo(fallbackVersion);
-		return path.join(getCacheDir(fallbackVersion, baseCacheDir), info.binaryRelativePath);
+	const cachedVersions = options?.reuseExisting !== false ? listCachedLuaLSVersions(baseCacheDir) : [];
+	const firstCachedVersion = cachedVersions[0];
+	if (options?.reuseExisting !== false && metadata && metadata.lastCheckedWeek === currentWeek && firstCachedVersion) {
+		const info = getPlatformInfo(firstCachedVersion);
+		return path.join(getCacheDir(firstCachedVersion, baseCacheDir), info.binaryRelativePath);
 	}
 	const onlineTag = await fetchLatestLuaLSVersionFromGitHub();
 	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -1675,9 +5528,9 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	else if (metadata?.latestVersion && cachedVersions.includes(metadata.latestVersion)) {
 		logger.info(`[luals] Network unreachable or rate limited; using cached LuaLS ${metadata.latestVersion}.`);
 		targetVersion = metadata.latestVersion;
-	} else if (cachedVersions.length > 0) {
-		logger.info(`[luals] Network unreachable or rate limited; using cached LuaLS ${cachedVersions[0]}.`);
-		targetVersion = cachedVersions[0];
+	} else if (firstCachedVersion) {
+		logger.info(`[luals] Network unreachable or rate limited; using cached LuaLS ${firstCachedVersion}.`);
+		targetVersion = firstCachedVersion;
 	} else targetVersion = FALLBACK_LUALS_VERSION;
 	writeLuaLSMetadata({
 		lastCheckedWeek: currentWeek,
@@ -1688,11 +5541,16 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	const targetCacheDir = getCacheDir(targetVersion, baseCacheDir);
 	const targetBinaryPath = path.join(targetCacheDir, info.binaryRelativePath);
 	const completeMarker = path.join(targetCacheDir, ".complete");
-	if (fs.existsSync(completeMarker) && isBinaryValid(targetBinaryPath)) {
-		cleanupOldCachedLuaLSVersions(targetVersion, baseCacheDir);
-		return targetBinaryPath;
+	let wasCorrupted = false;
+	if (fs.existsSync(targetBinaryPath)) {
+		if (fs.existsSync(completeMarker) && isBinaryValid(targetBinaryPath)) {
+			if (options?.reuseExisting !== false) {
+				cleanupOldCachedLuaLSVersions(targetVersion, baseCacheDir);
+				return targetBinaryPath;
+			}
+		} else wasCorrupted = true;
 	}
-	if (!onlineTag) try {
+	if (options?.reuseExisting !== false && !onlineTag) try {
 		const cmd = process.platform === "win32" ? "where.exe" : "which";
 		const { stdout } = await execFileAsync(cmd, ["lua-language-server"]);
 		const found = stdout.trim().split(/\r?\n/)[0];
@@ -1700,14 +5558,29 @@ async function resolveLuaLSBinary(version = DEFAULT_LUALS_VERSION, options) {
 	} catch (err) {
 		logger.debug(`[luals] LuaLS binary not found in PATH: ${err instanceof Error ? err.message : String(err)}`);
 	}
-	const downloadedBinary = await downloadAndExtractLuaLS(targetVersion, targetCacheDir, options);
+	let downloadedBinary;
+	try {
+		downloadedBinary = await downloadAndExtractLuaLS(targetVersion, targetCacheDir, options);
+	} catch (err) {
+		if (wasCorrupted) {
+			const isOffline = isOfflineError(err);
+			const reason = isOffline ? "while offline" : err instanceof Error ? err.message : String(err);
+			throw new LuaLSError(`Cached LuaLS binary at '${targetBinaryPath}' is corrupted (failed execution/size check) and cannot be re-downloaded ${isOffline ? reason : `: ${reason}`}. Please ${isOffline ? "connect to the internet" : "verify your network connection"} to repair or run 'nanos-lint clean-cache'.`, "ERR_LUALS_CORRUPTED_CACHE", "Connect to the internet to repair the corrupted binary or run 'nanos-lint clean-cache'.", { cause: err });
+		}
+		throw err;
+	}
 	cleanupOldCachedLuaLSVersions(targetVersion, baseCacheDir);
 	return downloadedBinary;
 }
 async function runLuaLSCheck(targetPath, configPath, options) {
-	const absoluteTarget = path.resolve(targetPath);
-	if (!fs.existsSync(absoluteTarget)) throw new Error(`Target path does not exist: ${targetPath}`);
-	const binary = options.lualsBin || await resolveLuaLSBinary(options.lualsVersion, { quiet: options.quiet });
+	let absoluteTarget = path.resolve(targetPath);
+	try {
+		if (fs.existsSync(absoluteTarget)) absoluteTarget = fs.realpathSync.native(absoluteTarget);
+	} catch (err) {
+		logger.debug(`[luals] Failed to resolve native realpath for target: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!fs.existsSync(absoluteTarget)) throw new LuaLSError(`Target path does not exist: ${targetPath}`, "ERR_TARGET_NOT_FOUND", "Verify that the target path exists and is accessible.");
+	const binary = options.lualsBin ? assertValidLuaLSBinary(options.lualsBin, "--luals-bin") : await resolveLuaLSBinary(options.lualsVersion, { quiet: options.quiet });
 	let checkDir = absoluteTarget;
 	let targetFileOnly = null;
 	if (fs.statSync(absoluteTarget).isFile()) {
@@ -1751,16 +5624,21 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 	}
 	if (!parseSucceeded) {
 		const cacheHint = `(Cache location: ${getCacheDir()})`;
-		if (execError) throw new Error(`LuaLS check failed to execute or produce diagnostic output: ${execError instanceof Error ? execError.message : String(execError)}. ${cacheHint}`);
-		throw new Error(`LuaLS check failed to produce diagnostic output at: ${checkOutPath}. ${cacheHint}`);
+		if (execError) throw new LuaLSError(`LuaLS check failed to execute or produce diagnostic output: ${execError instanceof Error ? execError.message : String(execError)}. ${cacheHint}`, "ERR_LUALS_EXECUTION", "Inspect the debug log with --log-level=debug or run 'nanos-lint clean-cache' to re-fetch LuaLS.", { cause: execError });
+		throw new LuaLSError(`LuaLS check failed to produce diagnostic output at: ${checkOutPath}. ${cacheHint}`, "ERR_LUALS_NO_OUTPUT", "Ensure the temporary directory is writable and sufficient disk space is available.");
 	}
 	if (targetFileOnly) {
 		const filtered = {};
-		const normTarget = path.resolve(targetFileOnly).toLowerCase();
-		for (const [rawUri, diags] of Object.entries(diagnostics)) {
-			const filePath = fileUriToPath(rawUri);
-			if (path.resolve(filePath).toLowerCase() === normTarget) filtered[rawUri] = diags;
-		}
+		const normalizeComparable = (p) => {
+			try {
+				if (fs.existsSync(p)) return fs.realpathSync.native(p).replace(/\\/g, "/").toLowerCase();
+			} catch (err) {
+				logger.debug(`[luals] Failed to resolve native realpath for comparison: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			return path.resolve(p).replace(/\\/g, "/").toLowerCase();
+		};
+		const normTarget = normalizeComparable(targetFileOnly);
+		for (const [rawUri, diags] of Object.entries(diagnostics)) if (normalizeComparable(fileUriToPath(rawUri)) === normTarget) filtered[rawUri] = diags;
 		diagnostics = filtered;
 	}
 	let totalProblems = 0;
@@ -1785,98 +5663,6 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 		diagnostics
 	};
 }
-/**
-* Counts candidate Lua files within targetPath, taking ignoreDir and files.exclude into account.
-*/
-function countCheckedFiles(targetPath, configPath) {
-	const absPath = path.resolve(targetPath);
-	if (!fs.existsSync(absPath)) return 0;
-	if (fs.statSync(absPath).isFile()) return absPath.toLowerCase().endsWith(".lua") ? 1 : 0;
-	let ignoreDirs = [
-		".git",
-		".vscode",
-		".nanos-lint",
-		"node_modules"
-	];
-	let excludePatterns = [];
-	if (configPath && fs.existsSync(configPath)) try {
-		const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-		if (cfg.workspace?.ignoreDir) ignoreDirs = cfg.workspace.ignoreDir;
-		if (cfg.files?.exclude) excludePatterns = cfg.files.exclude;
-	} catch (err) {
-		logger.warn(`[luals] Failed to parse config file for file counting at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	const normIgnoreDirs = new Set(ignoreDirs.map((d) => d.replace(/\\/g, "/").toLowerCase()));
-	function isExcluded(relPath) {
-		const norm = relPath.replace(/\\/g, "/");
-		const baseName = path.posix.basename(norm);
-		for (const pat of excludePatterns) {
-			const normPat = pat.replace(/\\/g, "/");
-			if (norm === normPat || baseName === normPat) return true;
-			if (normPat.endsWith("/**")) {
-				const dir = normPat.slice(0, -3);
-				if (norm === dir || norm.startsWith(`${dir}/`)) return true;
-			}
-			if (norm.startsWith(`${normPat}/`)) return true;
-			if (normPat.includes("*") || normPat.includes("?")) {
-				if (!normPat.includes("/")) {
-					const baseRegexStr = "^" + normPat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
-					try {
-						if (new RegExp(baseRegexStr, "i").test(baseName)) return true;
-					} catch (err) {
-						logger.debug(`[luals] Invalid regex for pattern "${normPat}": ${err instanceof Error ? err.message : String(err)}`);
-					}
-				}
-				let regexStr = normPat;
-				const hasLeadingDoubleStar = regexStr.startsWith("**/");
-				if (hasLeadingDoubleStar) regexStr = regexStr.slice(3);
-				const hasTrailingDoubleStar = regexStr.endsWith("/**");
-				if (hasTrailingDoubleStar) regexStr = regexStr.slice(0, -3);
-				let escaped = regexStr.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*\//g, "/(?:.*/)?").replace(/\*\*/g, ".*").replace(/(?<!\.)\*/g, "[^/]*").replace(/\?/g, "[^/]");
-				if (hasLeadingDoubleStar) escaped = `(?:^|.*/)${escaped}`;
-				if (hasTrailingDoubleStar) escaped = `${escaped}(?:/.*)?`;
-				try {
-					if (new RegExp(`^${escaped}$`, "i").test(norm)) return true;
-				} catch (err) {
-					logger.debug(`[luals] Invalid glob regex for pattern "${normPat}": ${err instanceof Error ? err.message : String(err)}`);
-				}
-			}
-		}
-		return false;
-	}
-	let count = 0;
-	function walk(currentDir, relDir = "") {
-		let entries;
-		try {
-			entries = fs.readdirSync(currentDir, { withFileTypes: true });
-		} catch (err) {
-			logger.debug(`[luals] Failed to read directory ${currentDir}: ${err instanceof Error ? err.message : String(err)}`);
-			return;
-		}
-		for (const entry of entries) {
-			const name = entry.name;
-			const relPath = relDir ? `${relDir}/${name}` : name;
-			const fullPath = path.join(currentDir, name);
-			if (entry.isDirectory() || entry.isSymbolicLink() && (() => {
-				try {
-					return fs.statSync(fullPath).isDirectory();
-				} catch (err) {
-					logger.debug(`[luals] Failed to stat symlink target ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
-					return false;
-				}
-			})()) {
-				const lowerName = name.toLowerCase();
-				if (normIgnoreDirs.has(lowerName) || normIgnoreDirs.has(relPath.toLowerCase())) continue;
-				if (isExcluded(relPath) || isExcluded(`${relPath}/**`)) continue;
-				walk(fullPath, relPath);
-			} else if (entry.isFile() && name.toLowerCase().endsWith(".lua")) {
-				if (!isExcluded(relPath)) count++;
-			}
-		}
-	}
-	walk(absPath);
-	return count;
-}
 //#endregion
 //#region src/reporter.ts
 const SEVERITY_NAMES = {
@@ -5013,11 +8799,44 @@ function readAnnotationsMetadata(cacheDir = getAnnotationsCacheDir()) {
 		const content = fs.readFileSync(metaPath, "utf-8");
 		const parsed = JSON.parse(content);
 		if (typeof parsed?.commitId === "string" && typeof parsed?.lastChecked === "string") return parsed;
+		try {
+			fs.unlinkSync(metaPath);
+			logger.warn(`[annotations] Stale or invalid annotations metadata at ${metaPath} purged.`);
+		} catch (unlinkErr) {
+			logger.debug(`[annotations] Failed to unlink invalid metadata: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
+		}
 	} catch (err) {
 		logger.debug(`Failed to parse annotations metadata: ${err instanceof Error ? err.message : String(err)}`);
+		try {
+			fs.unlinkSync(metaPath);
+			logger.warn(`[annotations] Corrupted annotations metadata at ${metaPath} purged.`);
+		} catch (unlinkErr) {
+			logger.debug(`[annotations] Failed to unlink corrupted metadata: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}`);
+		}
 	}
 	return null;
 }
+const MIN_ANNOTATIONS_SIZE_BYTES = 1e3;
+/**
+* Verifies that an annotations file exists, is a regular file, is of non-trivial size (>= MIN_ANNOTATIONS_SIZE_BYTES),
+* and begins with valid LuaLS metadata or nanos world definitions.
+*/
+function isAnnotationsValid(filePath) {
+	if (!fs.existsSync(filePath)) return false;
+	try {
+		const stat = fs.statSync(filePath);
+		if (!stat.isFile() || stat.size < 1e3) return false;
+		const fd = fs.openSync(filePath, "r");
+		const buffer = Buffer.alloc(512);
+		const bytesRead = fs.readSync(fd, buffer, 0, 512, 0);
+		fs.closeSync(fd);
+		const header = buffer.toString("utf-8", 0, bytesRead).trimStart();
+		return header.startsWith("---@meta") || header.includes("nanos world") || header.includes("nanos-world");
+	} catch (err) {
+		logger.debug(`[annotations] Annotation validation failed for ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+}
 async function fetchLatestCommitId() {
 	try {
 		const headers = { "User-Agent": "nanos-lint" };
@@ -5035,14 +8854,22 @@ async function fetchLatestCommitId() {
 	}
 	return null;
 }
-async function fetchRawAnnotationsContent() {
-	const res = await fetch(RAW_ANNOTATIONS_URL, {
+/**
+* Returns raw annotations URL, pinned to commit SHA if provided and valid.
+*/
+function getRawAnnotationsUrl(commitSha) {
+	if (commitSha && /^[0-9a-fA-F]{7,40}$/.test(commitSha)) return `https://raw.githubusercontent.com/${DOCGEN_REPO}/${commitSha}/annotations.lua`;
+	return RAW_ANNOTATIONS_URL;
+}
+async function fetchRawAnnotationsContent(commitSha) {
+	const url = getRawAnnotationsUrl(commitSha);
+	const res = await fetch(url, {
 		headers: { "User-Agent": "nanos-lint" },
 		signal: AbortSignal.timeout(15e3)
 	});
-	if (!res.ok) throw new Error(`Failed to download annotations.lua: ${res.status} ${res.statusText}`);
+	if (!res.ok) throw new AnnotationsError(`Failed to download annotations.lua: ${res.status} ${res.statusText}`, "ERR_ANNOTATIONS_DOWNLOAD", "Verify your internet connection and that GitHub raw endpoints are accessible.");
 	const text = await res.text();
-	if (!text || text.length < 1e3) throw new Error("Downloaded annotations.lua appears truncated or invalid");
+	if (!text || text.length < 1e3) throw new AnnotationsError("Downloaded annotations.lua appears truncated or invalid", "ERR_ANNOTATIONS_INVALID", "Retry downloading or pass a local annotations file via --annotations <path>.");
 	return text;
 }
 async function copyFileWithRetry(src, dest, maxRetries = 10) {
@@ -5100,7 +8927,7 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 			if (commitId && commitId !== "unknown") logger.info(`[annotations] Downloading nanos world API annotations (${commitId.slice(0, 7)})...`);
 			else logger.info("[annotations] Downloading nanos world API annotations...");
 		}
-		const content = await fetchRawAnnotationsContent();
+		const content = await fetchRawAnnotationsContent(commitId);
 		const tempAnnotationsPath = path.join(tempDir, ANNOTATIONS_FILENAME);
 		fs.writeFileSync(tempAnnotationsPath, content, "utf-8");
 		const { dateStr, dateObj } = getTodayDateString();
@@ -5112,7 +8939,7 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 		const tempMetaPath = path.join(tempDir, METADATA_FILENAME);
 		fs.writeFileSync(tempMetaPath, JSON.stringify(metadata, null, 2), "utf-8");
 		const existingMeta = readAnnotationsMetadata(cacheDir);
-		if (existingMeta && existingMeta.commitId === commitId && fs.existsSync(finalAnnotationsPath) && fs.statSync(finalAnnotationsPath).size >= 1e3) return finalAnnotationsPath;
+		if (existingMeta && existingMeta.commitId === commitId && fs.existsSync(finalAnnotationsPath) && isAnnotationsValid(finalAnnotationsPath)) return finalAnnotationsPath;
 		const oldAnnotationsExists = fs.existsSync(finalAnnotationsPath);
 		const oldMetaExists = fs.existsSync(finalMetaPath);
 		if (oldAnnotationsExists || oldMetaExists) {
@@ -5153,6 +8980,26 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 		}
 	}
 }
+function validateCustomAnnotationsPath(filePath, source) {
+	const resolved = path.resolve(filePath);
+	if (!fs.existsSync(resolved)) {
+		if (source === "custom") throw new AnnotationsError(`Custom annotations file not found: ${resolved}`, "ERR_ANNOTATIONS_NOT_FOUND", "Verify that the path specified in --annotations exists and is accessible.");
+		else throw new AnnotationsError(`Annotations file specified in environment not found: ${resolved}`, "ERR_ANNOTATIONS_ENV_NOT_FOUND", "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS exists.");
+	}
+	const stat = fs.statSync(resolved);
+	if (!stat.isFile()) throw new AnnotationsError(source === "custom" ? `Custom annotations path is not a file: ${resolved}` : `Annotations path specified in environment is not a file: ${resolved}`, "ERR_ANNOTATIONS_NOT_A_FILE", source === "custom" ? "Verify that the path specified in --annotations points to a regular file, not a directory." : "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS points to a regular file, not a directory.");
+	if (stat.size === 0) throw new AnnotationsError(source === "custom" ? `Custom annotations file is empty: ${resolved}` : `Annotations file specified in environment is empty: ${resolved}`, "ERR_ANNOTATIONS_INVALID", source === "custom" ? "Verify that the path specified in --annotations is a valid non-empty Lua annotations file." : "Verify that the path specified in NANOS_ANNOTATIONS_PATH or NANOS_ANNOTATIONS is a valid non-empty Lua annotations file.");
+	try {
+		const fd = fs.openSync(resolved, "r");
+		const buffer = Buffer.alloc(Math.min(stat.size, 512));
+		const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+		fs.closeSync(fd);
+		if (buffer.subarray(0, bytesRead).includes(0)) throw new AnnotationsError(source === "custom" ? `Custom annotations file appears to be a binary file: ${resolved}` : `Annotations file specified in environment appears to be a binary file: ${resolved}`, "ERR_ANNOTATIONS_INVALID", "Verify that the annotations file is a valid Lua text annotations file.");
+	} catch (err) {
+		if (err instanceof AnnotationsError) throw err;
+	}
+	return resolved;
+}
 /**
 * Resolves the nanos world annotations.lua definitions file path.
 * Resolution precedence:
@@ -5162,33 +9009,33 @@ async function downloadAndCacheAnnotations(commitId, cacheDir = getAnnotationsCa
 * 4. User cache (checked once per day from upstream GitHub)
 */
 async function resolveAnnotations(options = {}) {
-	if (options.customPath) {
-		const resolved = path.resolve(options.customPath);
-		if (!fs.existsSync(resolved)) throw new Error(`Custom annotations file not found: ${resolved}`);
-		return resolved;
-	}
+	if (options.customPath) return validateCustomAnnotationsPath(options.customPath, "custom");
 	const envPath = process.env.NANOS_ANNOTATIONS_PATH || process.env.NANOS_ANNOTATIONS;
-	if (envPath) {
-		const resolved = path.resolve(envPath);
-		if (!fs.existsSync(resolved)) throw new Error(`Annotations file specified in environment not found: ${resolved}`);
-		return resolved;
-	}
+	if (envPath) return validateCustomAnnotationsPath(envPath, "env");
 	const bundled = path.join(getPackageRoot(), "annotations.lua");
-	if (fs.existsSync(bundled)) return bundled;
+	if (fs.existsSync(bundled) && isAnnotationsValid(bundled)) return bundled;
 	const cacheDir = options.cacheDir ?? getAnnotationsCacheDir();
 	const cachedAnnotationsFile = path.join(cacheDir, ANNOTATIONS_FILENAME);
 	const metadata = readAnnotationsMetadata(cacheDir);
 	const { dateStr } = getTodayDateString();
-	if (metadata && metadata.lastChecked === dateStr && fs.existsSync(cachedAnnotationsFile)) return cachedAnnotationsFile;
+	if (fs.existsSync(cachedAnnotationsFile) && !isAnnotationsValid(cachedAnnotationsFile)) {
+		logger.warn("[annotations] Cached annotations.lua is corrupted or empty. Purging and refreshing...");
+		try {
+			fs.unlinkSync(cachedAnnotationsFile);
+		} catch (err) {
+			logger.warn(`[annotations] Failed to remove corrupted cached annotations: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	if (metadata && metadata.lastChecked === dateStr && fs.existsSync(cachedAnnotationsFile) && isAnnotationsValid(cachedAnnotationsFile)) return cachedAnnotationsFile;
 	const latestCommitId = await fetchLatestCommitId();
 	if (latestCommitId) {
-		if (metadata && metadata.commitId === latestCommitId && fs.existsSync(cachedAnnotationsFile)) {
+		if (metadata && metadata.commitId === latestCommitId && fs.existsSync(cachedAnnotationsFile) && isAnnotationsValid(cachedAnnotationsFile)) {
 			updateLastCheckedDate(latestCommitId, cacheDir);
 			return cachedAnnotationsFile;
 		}
 		return await downloadAndCacheAnnotations(latestCommitId, cacheDir, options);
 	}
-	if (fs.existsSync(cachedAnnotationsFile)) {
+	if (fs.existsSync(cachedAnnotationsFile) && isAnnotationsValid(cachedAnnotationsFile)) {
 		try {
 			updateLastCheckedDate(metadata?.commitId || "unknown", cacheDir);
 		} catch (err) {
@@ -5199,6 +9046,10 @@ async function resolveAnnotations(options = {}) {
 	try {
 		return await downloadAndCacheAnnotations("unknown", cacheDir, options);
 	} catch (err) {
+		if (fs.existsSync(bundled) && isAnnotationsValid(bundled)) {
+			logger.info("[annotations] Network offline and cache unavailable. Falling back to bundled annotations.");
+			return bundled;
+		}
 		if (Boolean(err && typeof err === "object" && "code" in err && typeof err.code === "string" && [
 			"EACCES",
 			"EPERM",
@@ -5206,9 +9057,100 @@ async function resolveAnnotations(options = {}) {
 			"EROFS",
 			"EEXIST",
 			"ENOENT"
-		].includes(err.code)) || err instanceof Error && /permission denied|read-only|no space left/i.test(err.message)) throw new Error(`Failed to resolve nanos world API annotations due to a filesystem error: ${err instanceof Error ? err.message : String(err)}. Please check directory permissions or pass a custom file with --annotations.`, { cause: err });
-		throw new Error(`Failed to resolve nanos world API annotations. Please check your network connection or pass a custom file with --annotations. (${err instanceof Error ? err.message : String(err)})`, { cause: err });
+		].includes(err.code)) || err instanceof Error && /permission denied|read-only|no space left/i.test(err.message)) throw new AnnotationsError(`Failed to resolve nanos world API annotations due to a filesystem error: ${err instanceof Error ? err.message : String(err)}. Please check directory permissions or pass a custom file with --annotations.`, "ERR_ANNOTATIONS_FS", "Check directory permissions for the cache directory or specify --annotations <path>.", { cause: err });
+		throw new AnnotationsError(`Failed to resolve nanos world API annotations. Please check your network connection or pass a custom file with --annotations. (${err instanceof Error ? err.message : String(err)})`, "ERR_ANNOTATIONS_NETWORK", "Check your network connection, run 'nanos-lint warmup' when online, or specify --annotations <path>.", { cause: err });
+	}
+}
+//#endregion
+//#region src/cache-status.ts
+function getCacheStatus(baseCacheDir = systemPaths.cache) {
+	const totalSize = getDirectorySize(baseCacheDir);
+	const totalSizeFormatted = formatBytes(totalSize);
+	const lualsBaseDir = path.join(baseCacheDir, "luals");
+	const lualsMeta = readLuaLSMetadata(lualsBaseDir);
+	const candidateVersions = listCachedLuaLSVersionDirs(lualsBaseDir);
+	const versionInfos = [];
+	for (const ver of candidateVersions) {
+		const versionDir = getCacheDir(ver, lualsBaseDir);
+		const marker = path.join(versionDir, ".complete");
+		const info = getPlatformInfo(ver);
+		const binPath = path.join(versionDir, info.binaryRelativePath);
+		let isValid = false;
+		if (fs.existsSync(marker) && fs.existsSync(binPath)) try {
+			isValid = fs.readFileSync(marker, "utf-8").trim() === ver && isBinaryValid(binPath);
+		} catch {
+			isValid = false;
+		}
+		const dirSize = getDirectorySize(versionDir);
+		versionInfos.push({
+			version: ver,
+			status: isValid ? "valid" : "corrupted",
+			size: dirSize,
+			sizeFormatted: formatBytes(dirSize),
+			path: versionDir
+		});
+	}
+	const lualsStatus = {
+		weeklyCheck: lualsMeta?.lastCheckedWeek ?? null,
+		lastCheckedDate: lualsMeta?.lastCheckedDate ?? null,
+		targetVersion: lualsMeta?.latestVersion ?? null,
+		versions: versionInfos
+	};
+	const annotationsDir = path.join(baseCacheDir, "annotations");
+	const annotationsFile = path.join(annotationsDir, "annotations.lua");
+	const annMeta = readAnnotationsMetadata(annotationsDir);
+	let annStatus = "missing";
+	let annSize = 0;
+	if (fs.existsSync(annotationsFile)) {
+		annSize = getDirectorySize(annotationsFile);
+		annStatus = isAnnotationsValid(annotationsFile) ? "valid" : "corrupted";
+	}
+	return {
+		cacheDirectory: baseCacheDir,
+		totalSize,
+		totalSizeFormatted,
+		luals: lualsStatus,
+		annotations: {
+			status: annStatus,
+			size: annSize,
+			sizeFormatted: formatBytes(annSize),
+			path: annotationsFile,
+			commitId: annMeta?.commitId ?? null,
+			lastChecked: annMeta?.lastChecked ?? null
+		}
+	};
+}
+function formatCacheStatusPretty(report) {
+	const lines = [];
+	lines.push("nanos-lint Cache Status");
+	lines.push("");
+	lines.push(`Cache Directory:   ${report.cacheDirectory}`);
+	lines.push(`Total Disk Usage:  ${report.totalSizeFormatted}`);
+	lines.push("");
+	lines.push("Lua Language Server (LuaLS):");
+	const weeklyStr = report.luals.weeklyCheck ? `${report.luals.weeklyCheck}${report.luals.lastCheckedDate ? ` (last checked: ${report.luals.lastCheckedDate})` : ""}` : "none";
+	lines.push(`  - Weekly Check:   ${weeklyStr}`);
+	const targetVer = report.luals.targetVersion ?? "none";
+	lines.push(`  - Target Version: ${targetVer}`);
+	if (report.luals.versions.length === 0) lines.push("  - Cached Copies:  none");
+	else {
+		lines.push("  - Cached Copies:");
+		for (const v of report.luals.versions) lines.push(`      * ${v.version} (status: ${v.status}, size: ${v.sizeFormatted})`);
+	}
+	lines.push("");
+	lines.push("nanos world Annotations:");
+	if (report.annotations.status === "missing") lines.push("  - Status:         Not cached");
+	else {
+		const statusCap = report.annotations.status === "valid" ? "Valid" : "Corrupted";
+		lines.push(`  - Status:         ${statusCap} (${report.annotations.sizeFormatted})`);
+		if (report.annotations.commitId) {
+			const sha = report.annotations.commitId;
+			const shaDisplay = sha.length >= 7 && sha !== "unknown" ? `${sha.slice(0, 8)} (docgen-output)` : sha;
+			lines.push(`  - Commit SHA:     ${shaDisplay}`);
+		}
+		if (report.annotations.lastChecked) lines.push(`  - Last Checked:   ${report.annotations.lastChecked}`);
 	}
+	return lines.join("\n");
 }
 //#endregion
 //#region src/cli.ts
@@ -5278,7 +9220,7 @@ function createProgram(options) {
 		};
 		if (opts.config) {
 			const resolvedConfig = path.resolve(opts.config);
-			if (!fs.existsSync(resolvedConfig)) throw new Error(`Configuration file not found: ${resolvedConfig}`);
+			if (!fs.existsSync(resolvedConfig)) throw new ConfigError(`Configuration file not found: ${resolvedConfig}`, "ERR_CONFIG_NOT_FOUND", "Verify the path passed to --config exists and is readable.");
 		}
 		const annotationsPath = await resolveAnnotations({
 			customPath: opts.annotations,
@@ -5311,13 +9253,24 @@ function createProgram(options) {
 		})}`);
 		setExitCode(0);
 	});
+	program.command("warmup").alias("download").description("Pre-fetch and cache both LuaLS binary and annotations for offline execution").option("--luals-version <ver>", `Version of LuaLS to use (default: ${DEFAULT_LUALS_VERSION})`).option("--annotations <path>", "Path to custom annotations.lua file").option("-q, --quiet", "Suppress download progress logging").action(async (opts) => {
+		writeOutput(`[warmup] LuaLS binary ready: ${await resolveLuaLSBinary(opts?.lualsVersion || "latest", { quiet: opts?.quiet })}`);
+		const annotationsPath = await resolveAnnotations({
+			customPath: opts?.annotations,
+			quiet: opts?.quiet
+		});
+		const meta = readAnnotationsMetadata();
+		writeOutput(`[warmup] nanos world annotations ready: ${annotationsPath}${meta?.commitId && meta.commitId !== "unknown" ? ` (commit ${meta.commitId.slice(0, 7)})` : ""}`);
+		writeOutput("[warmup] Cache pre-warmed successfully. Ready for offline execution.");
+		setExitCode(0);
+	});
 	program.command("download-luals [version]").description("Download and cache the LuaLS binary").option("--luals-version <ver>", `Version of LuaLS to use (default: ${DEFAULT_LUALS_VERSION})`).action(async (version, opts) => {
 		const ver = version || opts?.lualsVersion || "latest";
 		writeOutput(`[luals] Downloading LuaLS ${ver}...`);
 		writeOutput(`[luals] Ready at: ${await resolveLuaLSBinary(ver)}`);
 		setExitCode(0);
 	});
-	program.command("clean-cache").alias("clean").description("Clear the nanos-lint cache").action(() => {
+	const handleCleanCache = () => {
 		try {
 			const cleared = cleanCache();
 			if (cleared) writeOutput(`[cache] Cleared cache at: ${cleared}`);
@@ -5327,6 +9280,26 @@ function createProgram(options) {
 			logger.error(`[cache] Failed to clear cache: ${err instanceof Error ? err.message : String(err)}`);
 			setExitCode(1);
 		}
+	};
+	const handleCacheStatus = (opts) => {
+		const report = getCacheStatus();
+		if (opts?.json) writeOutput(JSON.stringify(report, null, 2));
+		else writeOutput(formatCacheStatusPretty(report));
+		setExitCode(0);
+	};
+	const cacheCmd = program.command("cache").description("Inspect or manage the nanos-lint cache").option("--json", "Output cache state in JSON format");
+	cacheCmd.command("status", { isDefault: true }).alias("info").description("Show cache status, installed versions, and disk usage").option("--json", "Output cache state in JSON format").action((opts, cmd) => {
+		const json = opts?.json || (cmd.parent ? Boolean(cmd.parent.opts()?.json) : false);
+		handleCacheStatus({ json });
+	});
+	cacheCmd.command("clean").description("Clear the nanos-lint cache").action(() => {
+		handleCleanCache();
+	});
+	program.command("cache-status").description("Show cache status, installed versions, and disk usage").option("--json", "Output cache state in JSON format").action((opts) => {
+		handleCacheStatus(opts);
+	});
+	program.command("clean-cache").alias("clean").description("Clear the nanos-lint cache").action(() => {
+		handleCleanCache();
 	});
 	program.command("version").description("Show version information").action(() => {
 		writeOutput(getVersionString());
@@ -5336,6 +9309,8 @@ function createProgram(options) {
 	program.addHelpText("after", `
 Examples:
   $ npx nanos-lint
+  $ npx nanos-lint warmup
+  $ npx nanos-lint cache status
   $ npx nanos-lint check ./my-package
   $ npx nanos-lint check . --checklevel=Error
   $ npx nanos-lint check . --ignore "myfolder/hello-*.lua"
@@ -5347,8 +9322,10 @@ Examples:
 async function runCLI(args = process.argv.slice(2)) {
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
+		if (!arg) continue;
 		if (arg === "-l" || arg === "--log-level") {
-			if (i + 1 < args.length && isValidLogLevel(args[i + 1])) logger.setLevel(args[i + 1]);
+			const nextArg = args[i + 1];
+			if (nextArg && isValidLogLevel(nextArg)) logger.setLevel(nextArg);
 		} else if (arg.startsWith("--log-level=")) {
 			const val = arg.split("=")[1];
 			if (val && isValidLogLevel(val)) logger.setLevel(val);
@@ -5363,9 +9340,18 @@ async function runCLI(args = process.argv.slice(2)) {
 		return exitCode;
 	} catch (err) {
 		if (err instanceof CommanderError) return err.exitCode;
+		if (err instanceof NanosLintError) {
+			logger.error(`error: ${err.message}`);
+			if (err.remedy) logger.error(`hint: ${err.remedy}`);
+			if ((logger.getLevel() === "debug" || process.env.DEBUG) && err.stack) {
+				logger.error(err.stack);
+				if (err.cause) logger.error(`cause: ${err.cause instanceof Error ? err.cause.stack || err.cause.message : String(err.cause)}`);
+			}
+			return 1;
+		}
 		const message = err instanceof Error ? err.message : String(err);
 		logger.error(`error: ${message}`);
-		if (process.env.DEBUG && err instanceof Error && err.stack) logger.error(err.stack);
+		if ((logger.getLevel() === "debug" || process.env.DEBUG) && err instanceof Error && err.stack) logger.error(err.stack);
 		return 1;
 	}
 }
@@ -5405,6 +9391,6 @@ if (isDirectExecution()) runCLI().then((code) => {
 	process.exit(1);
 });
 //#endregion
-export { getDefaultAnnotationsPath as $, FALLBACK_LUALS_VERSION as A, getIsoWeek as B, formatProblemSummary as C, pluralize as D, getColors as E, escapePowerShellSingleQuote as F, listCachedLuaLSVersions as G, getLuaLSMetadataPath as H, fetchLatestLuaLSVersionFromGitHub as I, resolveLuaLSBinary as J, readLuaLSMetadata as K, findExistingLuaLSDir as L, cleanupOldCachedLuaLSVersions as M, countCheckedFiles as N, shouldEnableColor as O, downloadAndExtractLuaLS as P, writeLuaLSMetadata as Q, getBaseLuaLSCacheDir as R, formatPretty as S, formatSeverityBadge as T, getPlatformInfo as U, getLegacyCacheDir as V, isBinaryValid as W, runLuaLSCheck as X, resolveLuaLSVersion as Y, sanitizeLuaLSVersion as Z, getTodayDateString as _, isValidLogLevel as _t, ANNOTATIONS_FILENAME as a, mergeConfigs as at, updateLastCheckedDate as b, GITHUB_COMMITS_API as c, stripJsonComments as ct, downloadAndCacheAnnotations as d, systemPaths as dt, getDefaultTemplatePath as et, fetchLatestCommitId as f, fileUriToPath as ft, getCachedAnnotationsFilePath as g, Logger as gt, getAnnotationsMetadataFilePath as h, LOG_LEVEL_PRIORITY as ht, runCLI as i, loadConfigFile as it, LUALS_METADATA_FILENAME as j, DEFAULT_LUALS_VERSION as k, METADATA_FILENAME as l, stripTrailingSlashes as lt, getAnnotationsCacheDir as m, LOG_LEVELS as mt, createProgram as n, getPackageRoot as nt, DOCGEN_BRANCH as o, parseJsonc as ot, fetchRawAnnotationsContent as p, DEFAULT_LOG_LEVEL as pt, resolveLatestLuaLSVersion as q, isDirectExecution as r, initWorkspace as rt, DOCGEN_REPO as s, resolveWorkspaceConfig as st, collectIgnorePatterns as t, getDefinitionsDir as tt, RAW_ANNOTATIONS_URL as u, cleanCache as ut, readAnnotationsMetadata as v, logger as vt, formatReport as w, formatGitHubAnnotations as x, resolveAnnotations as y, parseLogLevel as yt, getCacheDir as z };
+export { listCachedLuaLSVersionDirs as $, formatSeverityBadge as A, NanosLintError as At, computeFileSha256 as B, isValidLogLevel as Bt, readAnnotationsMetadata as C, resolveWorkspaceConfig as Ct, formatPretty as D, CacheError as Dt, formatGitHubAnnotations as E, AnnotationsError as Et, runLuaLSCheck as F, fileUriToPath as Ft, LUALS_METADATA_FILENAME as G, escapePowerShellSingleQuote as H, parseLogLevel as Ht, countCheckedFiles as I, DEFAULT_LOG_LEVEL as It, getBaseLuaLSCacheDir as J, cleanupOldCachedLuaLSVersions as K, ALLOWED_DOWNLOAD_DOMAINS as L, LOG_LEVELS as Lt, pluralize as M, formatBytes as Mt, shouldEnableColor as N, getDirectorySize as Nt, formatProblemSummary as O, ConfigError as Ot, resolveLuaLSBinary as P, systemPaths as Pt, getLuaLSMetadataPath as Q, DOWNLOAD_TIMEOUT_MS as R, LOG_LEVEL_PRIORITY as Rt, isAnnotationsValid as S, parseJsonc as St, updateLastCheckedDate as T, stripTrailingSlashes as Tt, isAllowedDownloadUrl as U, downloadAndExtractLuaLS as V, logger as Vt, limitDownloadStream as W, getIsoWeek as X, getCacheDir as Y, getLegacyCacheDir as Z, getAnnotationsCacheDir as _, getDefinitionsDir as _t, formatCacheStatusPretty as a, isBinaryRunnable as at, getRawAnnotationsUrl as b, loadConfigFile as bt, DOCGEN_BRANCH as c, DEFAULT_LUALS_VERSION as ct, METADATA_FILENAME as d, resolveLatestLuaLSVersion as dt, listCachedLuaLSVersions as et, MIN_ANNOTATIONS_SIZE_BYTES as f, resolveLuaLSVersion as ft, fetchRawAnnotationsContent as g, getDefaultTemplatePath as gt, fetchLatestCommitId as h, getDefaultAnnotationsPath as ht, runCLI as i, assertValidLuaLSBinary as it, getColors as j, cleanCache as jt, formatReport as k, LuaLSError as kt, DOCGEN_REPO as l, FALLBACK_LUALS_VERSION as lt, downloadAndCacheAnnotations as m, VALID_LUALS_DIAGNOSTIC_CODES as mt, createProgram as n, writeLuaLSMetadata as nt, getCacheStatus as o, isBinaryValid as ot, RAW_ANNOTATIONS_URL as p, sanitizeLuaLSVersion as pt, findExistingLuaLSDir as q, isDirectExecution as r, MIN_DOWNLOADED_BINARY_SIZE_BYTES as rt, ANNOTATIONS_FILENAME as s, getPlatformInfo as st, collectIgnorePatterns as t, readLuaLSMetadata as tt, GITHUB_COMMITS_API as u, fetchLatestLuaLSVersionFromGitHub as ut, getAnnotationsMetadataFilePath as v, getPackageRoot as vt, resolveAnnotations as w, stripJsonComments as wt, getTodayDateString as x, mergeConfigs as xt, getCachedAnnotationsFilePath as y, initWorkspace as yt, MAX_ARCHIVE_SIZE_BYTES as z, Logger as zt };
 
-//# sourceMappingURL=cli-sEO_MZ-K.js.map
+//# sourceMappingURL=cli-BAy_Ztvh.js.map