nanos-lint 3.0.0 → 3.1.0

package/dist/{cli-DUsLr0tU.js → cli-Cb3wLBCr.js}

@@ -1186,10 +1186,12 @@ function mergeConfigs(base, override = {}, definitionsPath = getDefaultAnnotatio
 	const normalizedDefPath = resolvedPath.split(path.sep).join("/");
 	const baseLibraries = base.workspace?.library ?? [];
 	const overrideLibraries = override.workspace?.library ?? [];
+	const depLibraries = (options?.dependencyLibraries ?? []).map((p) => p.replace(/\\/g, "/"));
 	const librarySet = /* @__PURE__ */ new Set([
 		normalizedDefPath,
 		...baseLibraries,
-		...overrideLibraries
+		...overrideLibraries,
+		...depLibraries
 	]);
 	const baseGlobals = base.diagnostics?.globals ?? [];
 	const overrideGlobals = override.diagnostics?.globals ?? [];
@@ -1328,7 +1330,10 @@ function buildWorkspaceConfig(workspacePath, customConfigPath, options) {
 		}
 		cliIgnore = expanded;
 	}
-	const merged = mergeConfigs(defaultTemplate, userConfig, activeAnnotationsPath, { cliIgnore });
+	const merged = mergeConfigs(defaultTemplate, userConfig, activeAnnotationsPath, {
+		cliIgnore,
+		dependencyLibraries: options?.dependencyLibraries
+	});
 	if (!hasCliIgnore) {
 		const resolvedTarget = path.resolve(workspacePath);
 		if (fs.existsSync(path.join(resolvedTarget, "main.lua")) && (fs.existsSync(path.join(resolvedTarget, "bin", "lua-language-server.exe")) || fs.existsSync(path.join(resolvedTarget, "bin", "lua-language-server")))) {
@@ -1343,6 +1348,11 @@ function buildWorkspaceConfig(workspacePath, customConfigPath, options) {
 			])];
 		}
 	}
+	if (options?.unrequestedExclusions && options.unrequestedExclusions.length > 0) {
+		merged.files = merged.files ?? {};
+		const existingExclude = merged.files.exclude ?? [];
+		merged.files.exclude = [.../* @__PURE__ */ new Set([...existingExclude, ...options.unrequestedExclusions])];
+	}
 	return merged;
 }
 /**
@@ -4740,9 +4750,11 @@ var Ze = Object.assign(Je, {
 });
 Ze.glob = Ze;
 /** A lock file older than this, or owned by a dead process, is treated as abandoned. */
-const DEFAULT_LOCK_STALE_MS = 12e4;
+const DEFAULT_LOCK_STALE_MS = 3e4;
 /** Upper bound for the polling interval, so a long wait stays responsive. */
 const MAX_LOCK_POLL_INTERVAL_MS = 500;
+/** Upper bound for the automatic heartbeat interval, keeping it responsive. */
+const MAX_LOCK_HEARTBEAT_INTERVAL_MS = 15e3;
 /** Default rename attempts used to absorb transient Windows file-lock errors. */
 const DEFAULT_RENAME_RETRIES = 5;
 /** Create failures that mean "the lock is there / being swapped", not "cannot lock". */
@@ -4788,18 +4800,26 @@ function readLockMetadata(lockPath) {
 		return null;
 	}
 }
-/** Returns true when a lock was left behind by a dead owner or has expired. */
-function isLockStale(lockPath, staleMs = DEFAULT_LOCK_STALE_MS) {
-	const metadata = readLockMetadata(lockPath);
-	if (typeof metadata?.pid === "number" && !isProcessAlive(metadata.pid)) return true;
-	const createdAt = typeof metadata?.createdAt === "number" ? metadata.createdAt : null;
-	if (createdAt !== null) return Date.now() - createdAt > staleMs;
+/** Returns the most recent activity timestamp (createdAt or mtime) for a lock file. */
+function readLockActiveTime(lockPath, metadata) {
+	const meta = metadata !== void 0 ? metadata : readLockMetadata(lockPath);
+	let mtimeMs = null;
 	try {
-		return Date.now() - fs.statSync(lockPath).mtimeMs > staleMs;
+		mtimeMs = fs.statSync(lockPath).mtimeMs;
 	} catch (err) {
 		logger.debug(`[lock] Could not stat lock file ${lockPath}: ${err instanceof Error ? err.message : String(err)}`);
-		return false;
 	}
+	const createdAt = typeof meta?.createdAt === "number" ? meta.createdAt : null;
+	if (createdAt !== null && mtimeMs !== null) return Math.max(createdAt, mtimeMs);
+	return createdAt ?? mtimeMs;
+}
+/** Returns true when a lock was left behind by a dead owner or has expired. */
+function isLockStale(lockPath, staleMs = DEFAULT_LOCK_STALE_MS) {
+	const metadata = readLockMetadata(lockPath);
+	if (typeof metadata?.pid === "number" && !isProcessAlive(metadata.pid)) return true;
+	const activeTime = readLockActiveTime(lockPath, metadata);
+	if (activeTime !== null) return Date.now() - activeTime > staleMs;
+	return false;
 }
 /**
 * Atomically creates the lock file with `O_CREAT | O_EXCL` semantics, so exactly one
@@ -4831,14 +4851,9 @@ function tryCreateLockFile(lockPath, token) {
 }
 /** Returns the age of a lock file in milliseconds, from its metadata or its mtime. */
 function lockAgeMs(lockPath) {
-	const metadata = readLockMetadata(lockPath);
-	if (typeof metadata?.createdAt === "number") return Math.max(0, Date.now() - metadata.createdAt);
-	try {
-		return Math.max(0, Date.now() - fs.statSync(lockPath).mtimeMs);
-	} catch (err) {
-		logger.debug(`[lock] Could not read the age of ${lockPath}: ${err instanceof Error ? err.message : String(err)}`);
-		return Number.POSITIVE_INFINITY;
-	}
+	const activeTime = readLockActiveTime(lockPath);
+	if (activeTime !== null) return Math.max(0, Date.now() - activeTime);
+	return Number.POSITIVE_INFINITY;
 }
 /** Confirms that a lock file still carries the token written by this process. */
 function ownsLockFile(lockPath, token) {
@@ -4878,7 +4893,7 @@ function nextPollDelay(attempt, baseMs) {
 */
 async function acquireFileLock(lockPath, options) {
 	const timeoutMs = options.timeoutMs ?? 6e4;
-	const staleMs = options.staleMs ?? 12e4;
+	const staleMs = options.staleMs ?? 3e4;
 	const reclaimGraceMs = options.reclaimGraceMs ?? 1e3;
 	const pollIntervalMs = options.pollIntervalMs ?? 25;
 	const label = options.label ?? path.basename(lockPath);
@@ -4910,15 +4925,70 @@ function releaseFileLock(lockPath, token) {
 	}
 }
 /**
+* Refreshes the active timestamp of a lock file if the caller still owns it.
+* Uses `fs.utimesSync` non-destructively so it never overwrites another owner's lock metadata.
+*/
+function touchLockFile(lockPath, token) {
+	if (readLockMetadata(lockPath)?.token !== token) {
+		logger.debug(`[lock] Cannot touch lock at ${lockPath}: token mismatch or missing lock.`);
+		return false;
+	}
+	try {
+		const now = /* @__PURE__ */ new Date();
+		fs.utimesSync(lockPath, now, now);
+		return true;
+	} catch (err) {
+		logger.debug(`[lock] Could not touch lock at ${lockPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+}
+/** Calculates the default heartbeat interval for a given staleness threshold. */
+function defaultHeartbeatInterval(staleMs) {
+	if (staleMs <= 0) return 0;
+	return Math.min(Math.max(1, Math.floor(staleMs / 4)), MAX_LOCK_HEARTBEAT_INTERVAL_MS);
+}
+/**
 * Runs `task` while holding an exclusive cross-process lock at `lockPath`, releasing it
 * in a `finally` block. Concurrent callers queue with jittered exponential backoff, so
 * parallel CI jobs and monorepo linters sharing one cache serialize instead of racing.
 */
 async function withFileLock(lockPath, task, options = {}) {
-	const token = await acquireFileLock(lockPath, options);
+	const staleMs = options.staleMs ?? 3e4;
+	const label = options.label ?? path.basename(lockPath);
+	const token = await acquireFileLock(lockPath, {
+		...options,
+		staleMs,
+		label
+	});
+	const heartbeatIntervalMs = options.heartbeatIntervalMs ?? defaultHeartbeatInterval(staleMs);
+	let heartbeatTimer;
+	let hasWarnedFailure = false;
+	if (heartbeatIntervalMs > 0) {
+		heartbeatTimer = setInterval(() => {
+			if (readLockMetadata(lockPath)?.token !== token) {
+				if (heartbeatTimer !== void 0) {
+					clearInterval(heartbeatTimer);
+					heartbeatTimer = void 0;
+				}
+				logger.warn(`[lock] Lost ownership of ${label} lock at ${lockPath}; stopping heartbeat.`);
+				return;
+			}
+			if (!touchLockFile(lockPath, token)) {
+				if (!hasWarnedFailure) {
+					hasWarnedFailure = true;
+					logger.warn(`[lock] Failed to touch ${label} lock at ${lockPath}; heartbeat could not update timestamp.`);
+				}
+			}
+		}, heartbeatIntervalMs);
+		heartbeatTimer.unref();
+	}
 	try {
 		return await task();
 	} finally {
+		if (heartbeatTimer !== void 0) {
+			clearInterval(heartbeatTimer);
+			heartbeatTimer = void 0;
+		}
 		releaseFileLock(lockPath, token);
 	}
 }
@@ -6146,24 +6216,27 @@ async function downloadAndPromoteLuaLS(resolvedVersion, info, destDir, binaryPat
 				try {
 					const res = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
 					if (res.url && !isAllowedDownloadUrl(res.url)) {
-						await res.body?.cancel();
+						if (typeof res.body?.cancel === "function") try {
+							await res.body.cancel();
+						} catch (cancelErr) {}
+						logger.warn(`[luals] Redirect to untrusted URL blocked: ${res.url}`);
 						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;
 					}
-					await res.body?.cancel();
+					if (typeof res.body?.cancel === "function") try {
+						await res.body.cancel();
+					} catch (cancelErr) {}
 					lastErr = /* @__PURE__ */ new Error(`Failed to download ${url}: ${res.status} ${res.statusText}`);
 				} catch (err) {
+					if (err instanceof LuaLSError) throw err;
 					lastErr = err;
 				}
 				if (attempt < 3) await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
 			}
-			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 });
-			}
+			if (!response || !response.body) 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);
@@ -6277,6 +6350,236 @@ async function downloadAndPromoteLuaLS(resolvedVersion, info, destDir, binaryPat
 	}
 }
 //#endregion
+//#region src/target-resolver.ts
+/** Resolves the canonical filesystem path, falling back to original path on failure. */
+function getCanonicalPath(p) {
+	try {
+		return fs.realpathSync.native ? fs.realpathSync.native(p) : fs.realpathSync(p);
+	} catch {
+		return p;
+	}
+}
+/** Determines whether a path points to the root of a filesystem volume. */
+function isFilesystemRoot(dir) {
+	const stripped = dir.trim();
+	if (stripped === "/" || stripped === "\\" || stripped === "") return true;
+	if (/^[a-zA-Z]:[\\/]?$/.test(stripped)) return true;
+	const norm = path.resolve(stripped);
+	if (norm === "/" || norm === "\\") return true;
+	return /^[a-zA-Z]:[\\/]?$/.test(norm);
+}
+/**
+* Computes the lowest common ancestor directory for a set of paths.
+* All paths must reside on the same filesystem root or volume.
+*/
+function findCommonAncestorDirectory(paths) {
+	if (paths.length === 0) return path.resolve(".");
+	const resolved = paths.map((p) => {
+		const abs = path.resolve(p);
+		try {
+			if (fs.existsSync(abs)) return fs.statSync(abs).isDirectory() ? abs : path.dirname(abs);
+		} catch (err) {}
+		return path.dirname(abs);
+	});
+	if (resolved.length === 1 && resolved[0]) return resolved[0];
+	const isWin = process.platform === "win32";
+	const splitPaths = resolved.map((p) => path.resolve(p).split(path.sep));
+	const first = splitPaths[0];
+	if (!first || first.length === 0) return path.resolve(".");
+	const firstRoot = first[0];
+	if (!splitPaths.every((p) => {
+		const rootSeg = p[0];
+		if (rootSeg === void 0) return false;
+		return isWin ? rootSeg.toLowerCase() === firstRoot?.toLowerCase() : rootSeg === firstRoot;
+	}) || firstRoot === void 0) throw new ConfigError(`Cannot check paths across different root drives or volumes: ${paths.join(", ")}`, "ERR_MULTIPLE_ROOTS", "Ensure all checked paths are within the same workspace or project root.");
+	const minLen = Math.min(...splitPaths.map((p) => p.length));
+	let commonLen = 0;
+	for (let i = 0; i < minLen; i++) {
+		const segment = first[i];
+		if (segment === void 0) break;
+		if (!splitPaths.every((p) => {
+			const seg = p[i];
+			if (seg === void 0) return false;
+			return isWin ? seg.toLowerCase() === segment.toLowerCase() : seg === segment;
+		})) break;
+		commonLen++;
+	}
+	if (commonLen === 0) throw new ConfigError(`Cannot check paths across different root drives or volumes: ${paths.join(", ")}`, "ERR_MULTIPLE_ROOTS", "Ensure all checked paths are within the same workspace or project root.");
+	let commonPath = first.slice(0, commonLen).join(path.sep);
+	if (!commonPath) commonPath = path.sep;
+	if (isWin && /^[a-zA-Z]:$/.test(commonPath)) commonPath = `${commonPath}\\`;
+	return path.resolve(commonPath);
+}
+/**
+* Searches upward from a starting directory to locate an enclosing project root
+* containing `.luarc.json`. Returns the start directory if not found.
+*/
+function findProjectRoot(startDir) {
+	let curr = path.resolve(startDir);
+	while (true) {
+		if (fs.existsSync(path.join(curr, ".luarc.json"))) return curr;
+		if (fs.existsSync(path.join(curr, ".git"))) break;
+		const parent = path.dirname(curr);
+		if (parent === curr) break;
+		curr = parent;
+	}
+	return startDir;
+}
+/**
+* Characters the LuaLS glob matcher treats as syntax.
+*
+* LuaLS compiles `files.exclude` with `glob.gitignore` (see its
+* `script/glob/glob.lua`), whose grammar only understands backslash escapes:
+* bracket expressions such as `[[]` are parsed as character ranges and match
+* nothing useful. Escaping is therefore done with `\`.
+*/
+const GLOB_METACHARACTERS = /* @__PURE__ */ new Set([
+	"*",
+	"?",
+	"[",
+	"]",
+	"{",
+	"}",
+	",",
+	"\\"
+]);
+/**
+* Escapes the glob metacharacters of a single path segment so it matches literally.
+*
+* Note: `normalizePattern()` in `src/luals/files.ts` rewrites backslashes to path
+* separators when counting checked files, so these escapes only reach LuaLS. That is
+* harmless: the counted file set is filtered by the requested target paths anyway.
+*/
+function escapeGlobSegment(segment) {
+	let escaped = "";
+	for (const char of segment) escaped += GLOB_METACHARACTERS.has(char) ? `\\${char}` : char;
+	return escaped;
+}
+/** Escapes glob metacharacters in every segment of a slash-separated relative path. */
+function escapeGlobPath(relativePath) {
+	return relativePath.split("/").map(escapeGlobSegment).join("/");
+}
+/**
+* Computes glob exclusion patterns for directories and files under workspace root
+* that are completely outside the requested target paths.
+*/
+function computeUnrequestedExclusions(root, targetPaths) {
+	const resolvedRoot = path.resolve(root);
+	if (targetPaths.length === 0 || targetPaths.some((t) => t === "." || t === "" || path.resolve(resolvedRoot, t) === resolvedRoot)) return [];
+	const isWin = process.platform === "win32";
+	const canonicalRoot = getCanonicalPath(resolvedRoot);
+	const relTargets = targetPaths.map((t) => {
+		const canonical = getCanonicalPath(path.isAbsolute(t) ? t : path.resolve(canonicalRoot, t));
+		const rel = path.relative(canonicalRoot, canonical).replace(/\\/g, "/");
+		return isWin ? rel.toLowerCase() : rel;
+	}).filter((rel) => !rel.startsWith("../") && rel !== "..");
+	if (relTargets.length === 0 || relTargets.includes("") || relTargets.includes(".")) return [];
+	const exclusions = [];
+	/** Recursively scans directory entries to identify unrequested paths. */
+	function scanDir(dir, relPrefix) {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const entryRel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+			const normEntry = isWin ? entryRel.toLowerCase() : entryRel;
+			let isExactTarget = false;
+			let isAncestorOfTarget = false;
+			let isDescendantOfTarget = false;
+			for (const target of relTargets) {
+				if (normEntry === target) {
+					isExactTarget = true;
+					break;
+				}
+				if (target.startsWith(`${normEntry}/`)) {
+					isAncestorOfTarget = true;
+					break;
+				}
+				if (normEntry.startsWith(`${target}/`)) {
+					isDescendantOfTarget = true;
+					break;
+				}
+			}
+			if (isExactTarget || isDescendantOfTarget) continue;
+			if (isAncestorOfTarget) {
+				if (entry.isDirectory()) scanDir(path.join(dir, entry.name), entryRel);
+				continue;
+			}
+			if (entry.isDirectory()) exclusions.push(`${escapeGlobPath(entryRel)}/**`);
+			else if (entry.isFile() && entry.name.toLowerCase().endsWith(".lua")) exclusions.push(escapeGlobPath(entryRel));
+		}
+	}
+	scanDir(canonicalRoot, "");
+	return exclusions;
+}
+/** Determines whether a workspace-relative file path matches any of the target paths. */
+function matchesTargetPaths(relativePath, root, targetPaths) {
+	if (targetPaths.length === 0 || targetPaths.length === 1 && (targetPaths[0] === "." || targetPaths[0] === "")) return true;
+	const isWin = process.platform === "win32";
+	const canonicalRoot = getCanonicalPath(root);
+	const normRel = isWin ? relativePath.replace(/\\/g, "/").toLowerCase() : relativePath.replace(/\\/g, "/");
+	for (const rawTarget of targetPaths) {
+		const fromCwd = path.resolve(rawTarget);
+		const canonicalTarget = getCanonicalPath(fs.existsSync(fromCwd) ? fromCwd : path.isAbsolute(rawTarget) ? rawTarget : path.resolve(canonicalRoot, rawTarget));
+		let relTarget = path.relative(canonicalRoot, canonicalTarget).replace(/\\/g, "/");
+		relTarget = stripTrailingSlashes(relTarget).replace(/^\.\//, "");
+		const normTarget = isWin ? relTarget.toLowerCase() : relTarget;
+		if (normTarget === "" || normTarget === ".") return true;
+		if (normRel === normTarget || normRel.startsWith(`${normTarget}/`)) return true;
+	}
+	return false;
+}
+/** Keeps only diagnostics for files that match the requested target paths. */
+function filterReportByTargetPaths(report, root, targetPaths) {
+	if (targetPaths.length === 0 || targetPaths.length === 1 && (targetPaths[0] === "." || targetPaths[0] === "")) return report;
+	const filtered = {};
+	const canonicalRoot = getCanonicalPath(root);
+	for (const [uri, diags] of Object.entries(report)) {
+		const filePath = fileUriToPath(uri);
+		const canonicalFile = getCanonicalPath(path.resolve(filePath));
+		if (matchesTargetPaths(path.relative(canonicalRoot, canonicalFile).replace(/\\/g, "/"), canonicalRoot, targetPaths)) filtered[uri] = diags;
+	}
+	return filtered;
+}
+/** Validates and resolves CLI target paths into a common root directory and target list. */
+function resolveCheckTargets(rawPaths) {
+	const paths = rawPaths && rawPaths.length > 0 ? rawPaths : ["."];
+	const canonicalTargets = paths.map((targetPath) => {
+		const resolved = path.resolve(targetPath);
+		if (!fs.existsSync(resolved)) throw new LuaLSError(`Target path does not exist: ${targetPath}`, "ERR_TARGET_NOT_FOUND", "Verify that the target path exists and is accessible.");
+		return getCanonicalPath(resolved);
+	});
+	const first = paths[0];
+	if (paths.length === 1 && first) {
+		const canonicalFirst = canonicalTargets[0];
+		const startDir = fs.statSync(canonicalFirst).isFile() ? path.dirname(canonicalFirst) : canonicalFirst;
+		const projRoot = findProjectRoot(startDir);
+		if (projRoot !== startDir) {
+			if (isFilesystemRoot(projRoot)) throw new ConfigError(`Cannot check targets across the root filesystem (${projRoot}): checked paths must share a common project directory.`, "ERR_ROOT_ANCESTOR", "Ensure all checked paths reside within a common project directory.");
+			logger.debug(`[targets] Using discovered project root "${projRoot}" for "${first}".`);
+			return {
+				rootPath: projRoot,
+				targetPaths: canonicalTargets
+			};
+		}
+		return {
+			rootPath: first,
+			targetPaths: canonicalTargets
+		};
+	}
+	const ancestor = findCommonAncestorDirectory(canonicalTargets);
+	if (isFilesystemRoot(ancestor)) throw new ConfigError(`Cannot check targets across the root filesystem (${ancestor}): checked paths must share a common project directory.`, "ERR_ROOT_ANCESTOR", "Ensure all checked paths reside within a common project directory.");
+	const rootPath = findProjectRoot(ancestor);
+	if (rootPath !== ancestor) logger.debug(`[targets] Using discovered project root "${rootPath}" for "${ancestor}".`);
+	return {
+		rootPath,
+		targetPaths: canonicalTargets
+	};
+}
+//#endregion
 //#region src/luals/files.ts
 /** Directories skipped unless the workspace config overrides `workspace.ignoreDir`. */
 const DEFAULT_IGNORE_DIRS = [
@@ -6400,7 +6703,7 @@ function resolveTargetPath(targetPath) {
 * honoring `workspace.ignoreDir` and `files.exclude` (#27). Absolute paths are returned
 * for single-file targets, and an empty list is returned when the walk fails.
 */
-function listCheckedFiles(targetPath, configPath) {
+function listCheckedFiles(targetPath, configPath, targetPaths) {
 	const absPath = resolveTargetPath(targetPath);
 	if (!absPath) return [];
 	if (fs.statSync(absPath).isFile()) return absPath.toLowerCase().endsWith(".lua") ? [absPath] : [];
@@ -6415,7 +6718,7 @@ function listCheckedFiles(targetPath, configPath) {
 	}
 	const ignore = [...toIgnorePatterns(ignoreDirs), ...toIgnorePatterns(excludePatterns)];
 	try {
-		return ts(LUA_FILE_PATTERN, {
+		const files = ts(LUA_FILE_PATTERN, {
 			cwd: absPath,
 			ignore,
 			dot: true,
@@ -6423,14 +6726,16 @@ function listCheckedFiles(targetPath, configPath) {
 			follow: false,
 			withFileTypes: true
 		}).filter((entry) => entry.isFile()).map((entry) => entry.relativePosix());
+		if (targetPaths && targetPaths.length > 0) return files.filter((f) => matchesTargetPaths(f, absPath, targetPaths));
+		return files;
 	} catch (err) {
 		logger.warn(`[luals] Failed to walk ${absPath} while listing checked files: ${err instanceof Error ? err.message : String(err)}`);
 		return [];
 	}
 }
 /** Counts candidate Lua files within targetPath, taking workspace ignoreDir and files.exclude into account (#27). */
-function countCheckedFiles(targetPath, configPath) {
-	return listCheckedFiles(targetPath, configPath).length;
+function countCheckedFiles(targetPath, configPath, targetPaths) {
+	return listCheckedFiles(targetPath, configPath, targetPaths).length;
 }
 //#endregion
 //#region src/luals/runner.ts
@@ -6642,7 +6947,7 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 		const normTarget = normalizeComparable(targetFileOnly);
 		for (const [rawUri, diags] of Object.entries(diagnostics)) if (normalizeComparable(fileUriToPath(rawUri)) === normTarget) filtered[rawUri] = diags;
 		diagnostics = filtered;
-	}
+	} else if (options.paths && options.paths.length > 0) diagnostics = filterReportByTargetPaths(diagnostics, checkDir, options.paths);
 	let totalProblems = 0;
 	let totalErrors = 0;
 	let totalWarnings = 0;
@@ -6654,7 +6959,7 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 		else if (d.severity === 2) totalWarnings += 1;
 	}
 	const passed = totalProblems === 0;
-	const filesChecked = countCheckedFiles(targetPath, configPath);
+	const filesChecked = countCheckedFiles(targetPath, configPath, options.paths);
 	return {
 		passed,
 		totalProblems,
@@ -6666,6 +6971,179 @@ async function runLuaLSCheck(targetPath, configPath, options) {
 	};
 }
 //#endregion
+//#region src/deps.ts
+/** Accumulates repeatable --dep arguments. */
+function collectDeps(val, prev) {
+	const trimmed = val.trim();
+	if (!trimmed) return prev ?? [];
+	return (prev ?? []).concat(trimmed);
+}
+/** Normalizes a filesystem path to forward slashes for LuaLS compatibility. */
+function normalizeSlash(p) {
+	return p.replace(/\\/g, "/");
+}
+/**
+* Resolves package dependencies declared in .luarc.json (nanos.deps) or via CLI (--dep),
+* resolving transitive dependencies with cycle detection and partitioning them by realm.
+*/
+function resolvePackageDependencies(root, userConfig, cliDeps) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [];
+	if (cliDeps && cliDeps.length > 0) {
+		for (const dep of cliDeps) if (typeof dep === "string" && dep.trim()) queue.push({
+			rawPath: dep.trim(),
+			fromDir: process.cwd()
+		});
+	}
+	const rawConfigDeps = userConfig.nanos?.deps;
+	if (rawConfigDeps !== void 0) {
+		if (Array.isArray(rawConfigDeps)) for (const dep of rawConfigDeps) if (typeof dep === "string" && dep.trim()) queue.push({
+			rawPath: dep.trim(),
+			fromDir: root
+		});
+		else logger.warn(`[deps] Skipping invalid nanos.deps entry: expected a string path.`);
+		else logger.warn(`[deps] Ignoring nanos.deps: expected an array of path strings.`);
+	}
+	const resolvedFiles = [];
+	const resolvedDirs = [];
+	const depConfigMap = /* @__PURE__ */ new Map();
+	const isWin = process.platform === "win32";
+	while (queue.length > 0) {
+		const item = queue.shift();
+		if (!item) continue;
+		const { rawPath, fromDir } = item;
+		const absPath = path.resolve(fromDir, rawPath);
+		if (!fs.existsSync(absPath)) {
+			logger.warn(`[deps] Dependency path not found: "${rawPath}" (skipping).`);
+			continue;
+		}
+		let canonical;
+		try {
+			canonical = fs.realpathSync.native(absPath);
+		} catch (err) {
+			try {
+				canonical = fs.realpathSync(absPath);
+			} catch (innerErr) {
+				canonical = absPath;
+			}
+		}
+		const cycleKey = isWin ? canonical.toLowerCase() : canonical;
+		if (visited.has(cycleKey)) continue;
+		visited.add(cycleKey);
+		let stat;
+		try {
+			stat = fs.statSync(canonical);
+		} catch (err) {
+			continue;
+		}
+		if (stat.isFile()) {
+			if (canonical.toLowerCase().endsWith(".lua")) resolvedFiles.push(normalizeSlash(canonical));
+			else logger.warn(`[deps] Skipping non-Lua dependency file: "${rawPath}".`);
+			continue;
+		}
+		if (stat.isDirectory()) {
+			resolvedDirs.push(canonical);
+			const candidateLuarc = path.join(canonical, ".luarc.json");
+			if (fs.existsSync(candidateLuarc)) try {
+				const depConfig = loadUserConfig(canonical);
+				depConfigMap.set(canonical, depConfig);
+				const transDeps = depConfig.nanos?.deps;
+				if (transDeps !== void 0) {
+					if (Array.isArray(transDeps)) for (const trans of transDeps) if (typeof trans === "string" && trans.trim()) queue.push({
+						rawPath: trans.trim(),
+						fromDir: canonical
+					});
+					else logger.warn(`[deps] Skipping invalid nanos.deps entry in "${canonical}": expected a string path.`);
+					else logger.warn(`[deps] Ignoring nanos.deps in "${canonical}": expected an array of path strings.`);
+				}
+			} catch (err) {
+				logger.warn(`[deps] Failed to parse transitive dependency configuration at "${candidateLuarc}": ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+	}
+	const serverSet = /* @__PURE__ */ new Set();
+	const clientSet = /* @__PURE__ */ new Set();
+	const sharedSet = /* @__PURE__ */ new Set();
+	const allSet = /* @__PURE__ */ new Set();
+	for (const file of resolvedFiles) {
+		serverSet.add(file);
+		clientSet.add(file);
+		sharedSet.add(file);
+		allSet.add(file);
+	}
+	for (const depDir of resolvedDirs) {
+		const normDepDir = normalizeSlash(depDir);
+		allSet.add(normDepDir);
+		let depConfig = depConfigMap.get(depDir);
+		if (!depConfig) try {
+			depConfig = loadUserConfig(depDir);
+		} catch (err) {
+			depConfig = {};
+		}
+		const { enabled, mappings } = resolveRealmMappings(depConfig);
+		if (!enabled) {
+			serverSet.add(normDepDir);
+			clientSet.add(normDepDir);
+			sharedSet.add(normDepDir);
+			continue;
+		}
+		const serverFolder = path.join(depDir, "Server");
+		const clientFolder = path.join(depDir, "Client");
+		const sharedFolder = path.join(depDir, "Shared");
+		const hasServer = fs.existsSync(serverFolder);
+		const hasClient = fs.existsSync(clientFolder);
+		const hasShared = fs.existsSync(sharedFolder);
+		if (hasServer || hasClient || hasShared) {
+			if (hasServer) serverSet.add(normalizeSlash(serverFolder));
+			if (hasClient) clientSet.add(normalizeSlash(clientFolder));
+			if (hasShared) {
+				const normShared = normalizeSlash(sharedFolder);
+				serverSet.add(normShared);
+				clientSet.add(normShared);
+				sharedSet.add(normShared);
+			}
+			try {
+				const entries = fs.readdirSync(depDir, { withFileTypes: true });
+				for (const entry of entries) if (entry.isFile() && entry.name.toLowerCase().endsWith(".lua")) {
+					const rootFile = normalizeSlash(path.join(depDir, entry.name));
+					serverSet.add(rootFile);
+					clientSet.add(rootFile);
+					sharedSet.add(rootFile);
+				}
+			} catch (err) {}
+			continue;
+		}
+		if (depConfig.nanos?.realms) {
+			let matchedAnyCustom = false;
+			for (const { pattern, realm } of mappings) {
+				const baseFolder = pattern.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "");
+				const targetPath = path.join(depDir, baseFolder);
+				if (fs.existsSync(targetPath)) {
+					matchedAnyCustom = true;
+					const norm = normalizeSlash(targetPath);
+					if (realm === "server") serverSet.add(norm);
+					else if (realm === "client") clientSet.add(norm);
+					else {
+						serverSet.add(norm);
+						clientSet.add(norm);
+						sharedSet.add(norm);
+					}
+				}
+			}
+			if (matchedAnyCustom) continue;
+		}
+		serverSet.add(normDepDir);
+		clientSet.add(normDepDir);
+		sharedSet.add(normDepDir);
+	}
+	return {
+		server: Array.from(serverSet),
+		client: Array.from(clientSet),
+		shared: Array.from(sharedSet),
+		all: Array.from(allSet)
+	};
+}
+//#endregion
 //#region src/realms.ts
 /** Normalizes a workspace-relative path for case-insensitive comparison on Windows. */
 function normalizeRelative(candidate) {
@@ -6723,13 +7201,17 @@ function selectedRealms(selection) {
 	return ["shared", selection];
 }
 /** Builds a pass config from the merged base config by swapping library and exclusions. */
-function buildPassConfig(baseConfig, realm, annotationsPath, realmAnnotationPath, excludedPatterns) {
+function buildPassConfig(baseConfig, realm, annotationsPath, realmAnnotationPath, excludedPatterns, dependencyLibraries = []) {
 	const config = JSON.parse(JSON.stringify(baseConfig));
 	const normalizedFull = annotationsPath.replace(/\\/g, "/");
 	const libraries = (config.workspace?.library ?? []).filter((entry) => entry.replace(/\\/g, "/") !== normalizedFull);
 	config.workspace = {
 		...config.workspace ?? {},
-		library: [realmAnnotationPath, ...libraries]
+		library: Array.from(/* @__PURE__ */ new Set([
+			realmAnnotationPath,
+			...libraries,
+			...dependencyLibraries
+		]))
 	};
 	if (realm !== "shared" && excludedPatterns.length > 0) config.files = {
 		...config.files ?? {},
@@ -6751,19 +7233,25 @@ function planRealmCheck(options) {
 		logger.debug("[realms] Realm mapping disabled; running a single standard pass.");
 		return null;
 	}
+	const unrequestedExclusions = options.targetPaths ? computeUnrequestedExclusions(resolvedTarget, options.targetPaths) : [];
 	const baseConfig = buildWorkspaceConfig(resolvedTarget, options.customConfigPath, {
 		ignore: options.ignore,
-		annotationsPath
+		annotationsPath,
+		unrequestedExclusions
 	});
 	const tempConfigs = [];
 	const baseConfigPath = writeTempConfig(baseConfig);
 	tempConfigs.push(baseConfigPath);
 	try {
 		const realmFiles = collectRealmFiles(resolvedTarget, mappings, listCheckedFiles(resolvedTarget, baseConfigPath));
+		const isTargetFile = (file) => {
+			if (!options.targetPaths || options.targetPaths.length === 0) return true;
+			return matchesTargetPaths(file, resolvedTarget, options.targetPaths);
+		};
 		const realmReportFiles = {
-			client: new Set(realmFiles.client.map(normalizeRelative)),
-			server: new Set(realmFiles.server.map(normalizeRelative)),
-			shared: new Set([...realmFiles.shared, ...realmFiles.unmatched].map(normalizeRelative))
+			client: new Set(realmFiles.client.filter(isTargetFile).map(normalizeRelative)),
+			server: new Set(realmFiles.server.filter(isTargetFile).map(normalizeRelative)),
+			shared: new Set([...realmFiles.shared, ...realmFiles.unmatched].filter(isTargetFile).map(normalizeRelative))
 		};
 		const hasRealmFolders = realmFiles.client.length > 0 || realmFiles.server.length > 0 || realmFiles.shared.length > 0;
 		if (selection === "all" && !hasRealmFolders) {
@@ -6772,14 +7260,22 @@ function planRealmCheck(options) {
 			return null;
 		}
 		const wanted = selectedRealms(selection).filter((realm) => realmReportFiles[realm].size > 0);
+		if (wanted.length === 0) {
+			if (selection !== "all") logger.warn(`[realms] No target files match the requested realm "${selection}"; falling back to a standard check.`);
+			else logger.debug("[realms] No files to report for selected realm pass; running a single standard pass.");
+			for (const tempConfig of tempConfigs) removeTempConfig(tempConfig);
+			return null;
+		}
 		const derived = wanted.some((realm) => realm !== "shared") ? deriveRealmAnnotationFiles(annotationsPath) : {
 			client: annotationsPath,
 			server: annotationsPath
 		};
+		const resolvedDeps = resolvePackageDependencies(resolvedTarget, userConfig, options.cliDeps);
 		const passes = [];
 		for (const realm of wanted) {
 			const excluded = mappings.filter((mapping) => mapping.realm !== realm && mapping.realm !== "shared").map((mapping) => mapping.pattern);
-			const configPath = writeTempConfig(buildPassConfig(baseConfig, realm, annotationsPath, realm === "client" ? derived.client : realm === "server" ? derived.server : annotationsPath, excluded));
+			const depLibraries = realm === "server" ? resolvedDeps.server : realm === "client" ? resolvedDeps.client : resolvedDeps.shared;
+			const configPath = writeTempConfig(buildPassConfig(baseConfig, realm, annotationsPath, realm === "client" ? derived.client : realm === "server" ? derived.server : annotationsPath, excluded, depLibraries));
 			tempConfigs.push(configPath);
 			passes.push({
 				realm,
@@ -6810,9 +7306,15 @@ function removeTempConfig(configPath) {
 /** Keeps only the diagnostics of files owned by the pass. */
 function filterReportByFiles(report, root, reportFiles) {
 	const filtered = {};
+	const canonicalRoot = getCanonicalPath(root);
 	for (const [uri, diagnostics] of Object.entries(report)) {
 		const filePath = fileUriToPath(uri);
-		const relative = normalizeRelative(path.relative(root, path.resolve(filePath)));
+		const resolvedFile = path.resolve(filePath);
+		let relative = normalizeRelative(path.relative(root, resolvedFile));
+		if (!reportFiles.has(relative)) {
+			const canonicalFile = getCanonicalPath(resolvedFile);
+			relative = normalizeRelative(path.relative(canonicalRoot, canonicalFile));
+		}
 		if (reportFiles.has(relative)) filtered[uri] = diagnostics;
 	}
 	return filtered;
@@ -10388,7 +10890,7 @@ function createProgram(options) {
 		writeOut: (str) => console.log(str.trimEnd()),
 		writeErr: (str) => logger.error(str.trimEnd())
 	});
-	program.command("check [path]", { isDefault: true }).description("Check a workspace or Lua file (default command)").addOption(new Option("--checklevel <level>", "Minimum diagnostic level: Error, Warning, Information, Hint").choices([
+	program.command("check [paths...]", { isDefault: true }).description("Check workspace files or directories (default command)").addOption(new Option("--checklevel <level>", "Minimum diagnostic level: Error, Warning, Information, Hint").choices([
 		"Error",
 		"Warning",
 		"Information",
@@ -10397,7 +10899,7 @@ function createProgram(options) {
 		"pretty",
 		"json",
 		"github"
-	])).option("-i, --ignore <pattern>", "Files or directories to ignore (supports glob patterns, repeatable)", collectIgnorePatterns).option("--luals-version <ver>", `Version of LuaLS to use (default: ${DEFAULT_LUALS_VERSION})`, DEFAULT_LUALS_VERSION).option("--no-fail", "Do not exit with code 1 if diagnostics are found").addOption(new Option("-l, --log-level <level>", "Logging level: error, warn, info, debug, silent").choices([
+	])).option("-i, --ignore <pattern>", "Files or directories to ignore (supports glob patterns, repeatable)", collectIgnorePatterns).option("-d, --dep <path>", "Path to package dependency or Lua definition file (repeatable)", collectDeps).option("--luals-version <ver>", `Version of LuaLS to use (default: ${DEFAULT_LUALS_VERSION})`, DEFAULT_LUALS_VERSION).option("--no-fail", "Do not exit with code 1 if diagnostics are found").addOption(new Option("-l, --log-level <level>", "Logging level: error, warn, info, debug, silent").choices([
 		"error",
 		"warn",
 		"info",
@@ -10408,44 +10910,54 @@ function createProgram(options) {
 		"client",
 		"server",
 		"shared"
-	]).default("all")).action(async (targetPath = ".", opts) => {
+	]).default("all")).action(async (targetPaths = ["."], opts) => {
 		if (opts.logLevel && isValidLogLevel(opts.logLevel)) logger.setLevel(opts.logLevel);
+		const { rootPath, targetPaths: canonicalTargets } = resolveCheckTargets(targetPaths && targetPaths.length > 0 ? targetPaths : ["."]);
 		const format = opts.github ? "github" : opts.format || (process.env.GITHUB_ACTIONS ? "github" : "pretty");
 		const checkOptions = {
-			path: targetPath,
+			path: rootPath,
+			paths: canonicalTargets,
 			configpath: opts.config,
 			checklevel: opts.checklevel,
 			format,
 			lualsVersion: opts.lualsVersion,
 			failOnError: opts.fail !== false,
-			ignore: opts.ignore
+			ignore: opts.ignore,
+			deps: opts.dep
 		};
 		if (opts.config) {
 			const resolvedConfig = path.resolve(opts.config);
 			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 });
+		const userConfig = loadUserConfig(rootPath, checkOptions.configpath);
 		const realmPlan = planRealmCheck({
-			targetPath,
-			userConfig: loadUserConfig(targetPath, checkOptions.configpath),
+			targetPath: rootPath,
+			userConfig,
 			selection: opts.realm ?? "all",
 			annotationsPath,
 			customConfigPath: checkOptions.configpath,
-			ignore: checkOptions.ignore
+			ignore: checkOptions.ignore,
+			targetPaths: canonicalTargets,
+			cliDeps: checkOptions.deps
 		});
 		let result;
 		if (realmPlan) try {
-			result = await runRealmAwareCheck(realmPlan, targetPath, checkOptions);
+			result = await runRealmAwareCheck(realmPlan, rootPath, checkOptions);
 		} finally {
 			realmPlan.cleanup();
 		}
 		else {
-			const resolved = resolveWorkspaceConfig(targetPath, checkOptions.configpath, {
+			const resolvedDeps = resolvePackageDependencies(rootPath, userConfig, checkOptions.deps);
+			const unrequestedExclusions = computeUnrequestedExclusions(rootPath, canonicalTargets);
+			const resolved = resolveWorkspaceConfig(rootPath, checkOptions.configpath, {
 				ignore: checkOptions.ignore,
-				annotationsPath
+				annotationsPath,
+				dependencyLibraries: resolvedDeps.all,
+				unrequestedExclusions
 			});
 			try {
-				result = await runLuaLSCheck(targetPath, resolved.configPath, checkOptions);
+				result = await runLuaLSCheck(rootPath, resolved.configPath, checkOptions);
 			} finally {
 				if (resolved.isTemp && fs.existsSync(resolved.configPath)) try {
 					fs.unlinkSync(resolved.configPath);
@@ -10526,6 +11038,7 @@ Examples:
   $ npx nanos-lint check . --checklevel=Error
   $ npx nanos-lint check . --ignore "myfolder/hello-*.lua"
   $ npx nanos-lint check . --realm server
+  $ npx nanos-lint check Shared/ Server/ --realm server
   $ npx nanos-lint init
   $ npx nanos-lint clean-cache
 `);
@@ -10605,6 +11118,6 @@ if (isDirectExecution()) runCLI().then((code) => {
 	process.exit(1);
 });
 //#endregion
-export { getBaseLuaLSCacheDir as $, getDirectorySize as $t, formatProblemSummary as A, VALID_LUALS_DIAGNOSTIC_CODES as At, runLuaLSCheck as B, parseJsonc as Bt, getCachedAnnotationsFilePath as C, fetchLatestLuaLSVersionFromGitHub as Ct, updateLastCheckedDate as D, deriveRealmAnnotationFiles as Dt, readAnnotationsMetadata as E, sanitizeLuaLSVersion as Et, shouldEnableColor as F, getPackageRoot as Ft, MAX_ARCHIVE_SIZE_BYTES as G, writeTempConfig as Gt, listCheckedFiles as H, resolveWorkspaceConfig as Ht, collectRealmFiles as I, initWorkspace as It, isAllowedDownloadUrl as J, ConfigError as Jt, computeFileSha256 as K, AnnotationsError as Kt, planRealmCheck as L, loadConfigFile as Lt, formatSeverityBadge as M, getDefaultAnnotationsPath as Mt, getColors as N, getDefaultTemplatePath as Nt, formatGitHubAnnotations as O, splitAnnotationsByRealm as Ot, pluralize as P, getDefinitionsDir as Pt, findExistingLuaLSDir as Q, formatBytes as Qt, runRealmAwareCheck as R, loadUserConfig as Rt, getAnnotationsMetadataFilePath as S, FALLBACK_LUALS_VERSION as St, isAnnotationsValid as T, resolveLuaLSVersion as Tt, ALLOWED_DOWNLOAD_DOMAINS as U, stripJsonComments as Ut, countCheckedFiles as V, resolveRealmMappings as Vt, DOWNLOAD_TIMEOUT_MS as W, stripTrailingSlashes as Wt, LUALS_METADATA_FILENAME as X, NanosLintError as Xt, limitDownloadStream as Y, LuaLSError as Yt, cleanupOldCachedLuaLSVersions as Z, cleanCache as Zt, MAX_ANNOTATIONS_SIZE_BYTES as _, isZipArchive as _t, formatCacheStatusPretty as a, Logger as an, readLuaLSMetadata as at, MIN_ANNOTATIONS_SIZE_BYTES as b, getPlatformInfo as bt, DOCGEN_BRANCH as c, parseLogLevel as cn, MAX_DECOMPRESSED_SIZE_BYTES as ct, RAW_ANNOTATIONS_URL as d, escapePowerShellSingleQuote as dt, systemPaths as en, getCacheDir as et, downloadAndCacheAnnotations as f, getTarBinary as ft, ANNOTATIONS_FILENAME as g, isGzipArchive as gt, getRawAnnotationsUrl as h, isBinaryValid as ht, runCLI as i, LOG_LEVEL_PRIORITY as in, listCachedLuaLSVersions as it, formatReport as j, buildWorkspaceConfig as jt, formatPretty as k, DEFAULT_REALM_MAPPINGS as kt, DOCGEN_REPO as l, MIN_DOWNLOADED_BINARY_SIZE_BYTES as lt, fetchRawAnnotationsContent as m, isBinaryRunnable as mt, createProgram as n, DEFAULT_LOG_LEVEL as nn, getLuaLSMetadataPath as nt, getCacheStatus as o, isValidLogLevel as on, writeLuaLSMetadata as ot, fetchLatestCommitId as p, inspectZipMembers as pt, downloadAndExtractLuaLS as q, CacheError as qt, isDirectExecution as r, LOG_LEVELS as rn, listCachedLuaLSVersionDirs as rt, resolveAnnotations as s, logger as sn, MAX_ARCHIVE_MEMBER_COUNT as st, collectIgnorePatterns as t, fileUriToPath as tn, getIsoWeek as tt, GITHUB_COMMITS_API as u, assertValidLuaLSBinary as ut, MAX_COMMIT_JSON_SIZE_BYTES as v, parseTarTvSize as vt, getTodayDateString as w, resolveLatestLuaLSVersion as wt, getAnnotationsCacheDir as x, DEFAULT_LUALS_VERSION as xt, METADATA_FILENAME as y, validateArchiveMembers as yt, resolveLuaLSBinary as z, mergeConfigs as zt };
+export { ALLOWED_DOWNLOAD_DOMAINS as $, stripJsonComments as $t, formatProblemSummary as A, getPlatformInfo as At, resolvePackageDependencies as B, VALID_LUALS_DIAGNOSTIC_CODES as Bt, getCachedAnnotationsFilePath as C, inspectZipMembers as Ct, updateLastCheckedDate as D, isZipArchive as Dt, readAnnotationsMetadata as E, isGzipArchive as Et, shouldEnableColor as F, resolveLuaLSVersion as Ft, computeUnrequestedExclusions as G, getPackageRoot as Gt, runLuaLSCheck as H, getDefaultAnnotationsPath as Ht, collectRealmFiles as I, sanitizeLuaLSVersion as It, findProjectRoot as J, loadUserConfig as Jt, filterReportByTargetPaths as K, initWorkspace as Kt, planRealmCheck as L, deriveRealmAnnotationFiles as Lt, formatSeverityBadge as M, FALLBACK_LUALS_VERSION as Mt, getColors as N, fetchLatestLuaLSVersionFromGitHub as Nt, formatGitHubAnnotations as O, parseTarTvSize as Ot, pluralize as P, resolveLatestLuaLSVersion as Pt, resolveCheckTargets as Q, resolveWorkspaceConfig as Qt, runRealmAwareCheck as R, splitAnnotationsByRealm as Rt, getAnnotationsMetadataFilePath as S, getTarBinary as St, isAnnotationsValid as T, isBinaryValid as Tt, countCheckedFiles as U, getDefaultTemplatePath as Ut, resolveLuaLSBinary as V, buildWorkspaceConfig as Vt, listCheckedFiles as W, getDefinitionsDir as Wt, isFilesystemRoot as X, parseJsonc as Xt, getCanonicalPath as Y, mergeConfigs as Yt, matchesTargetPaths as Z, resolveRealmMappings as Zt, MAX_ANNOTATIONS_SIZE_BYTES as _, logger as _n, MAX_ARCHIVE_MEMBER_COUNT as _t, formatCacheStatusPretty as a, LuaLSError as an, limitDownloadStream as at, MIN_ANNOTATIONS_SIZE_BYTES as b, assertValidLuaLSBinary as bt, DOCGEN_BRANCH as c, formatBytes as cn, findExistingLuaLSDir as ct, RAW_ANNOTATIONS_URL as d, fileUriToPath as dn, getIsoWeek as dt, stripTrailingSlashes as en, DOWNLOAD_TIMEOUT_MS as et, downloadAndCacheAnnotations as f, DEFAULT_LOG_LEVEL as fn, getLuaLSMetadataPath as ft, ANNOTATIONS_FILENAME as g, isValidLogLevel as gn, writeLuaLSMetadata as gt, getRawAnnotationsUrl as h, Logger as hn, readLuaLSMetadata as ht, runCLI as i, ConfigError as in, isAllowedDownloadUrl as it, formatReport as j, DEFAULT_LUALS_VERSION as jt, formatPretty as k, validateArchiveMembers as kt, DOCGEN_REPO as l, getDirectorySize as ln, getBaseLuaLSCacheDir as lt, fetchRawAnnotationsContent as m, LOG_LEVEL_PRIORITY as mn, listCachedLuaLSVersions as mt, createProgram as n, AnnotationsError as nn, computeFileSha256 as nt, getCacheStatus as o, NanosLintError as on, LUALS_METADATA_FILENAME as ot, fetchLatestCommitId as p, LOG_LEVELS as pn, listCachedLuaLSVersionDirs as pt, findCommonAncestorDirectory as q, loadConfigFile as qt, isDirectExecution as r, CacheError as rn, downloadAndExtractLuaLS as rt, resolveAnnotations as s, cleanCache as sn, cleanupOldCachedLuaLSVersions as st, collectIgnorePatterns as t, writeTempConfig as tn, MAX_ARCHIVE_SIZE_BYTES as tt, GITHUB_COMMITS_API as u, systemPaths as un, getCacheDir as ut, MAX_COMMIT_JSON_SIZE_BYTES as v, parseLogLevel as vn, MAX_DECOMPRESSED_SIZE_BYTES as vt, getTodayDateString as w, isBinaryRunnable as wt, getAnnotationsCacheDir as x, escapePowerShellSingleQuote as xt, METADATA_FILENAME as y, MIN_DOWNLOADED_BINARY_SIZE_BYTES as yt, collectDeps as z, DEFAULT_REALM_MAPPINGS as zt };
 
-//# sourceMappingURL=cli-DUsLr0tU.js.map
+//# sourceMappingURL=cli-Cb3wLBCr.js.map