deslop-js 0.0.12 → 0.0.13

package/dist/index.cjs

@@ -250,6 +250,7 @@ const BUILTIN_MODULES = new Set([
 ]);
 const PLATFORM_SUFFIXES = [
 	".web",
+	".react-native",
 	".native",
 	".ios",
 	".android",
@@ -257,6 +258,7 @@ const PLATFORM_SUFFIXES = [
 	".windows",
 	".macos",
 	".any",
+	".react-server",
 	".server",
 	".client"
 ];
@@ -952,7 +954,7 @@ const visitFunctionParameters = (parameters, captures, functionName) => {
 		inspectTypeAnnotation(parameter.typeAnnotation, captures, "function-parameter", functionName ? `${functionName}(${parameterIdentifierName ?? "?"})` : parameterIdentifierName);
 	}
 };
-const visitFunctionLike = (functionNode, captures, functionName) => {
+const visitFunctionLike$1 = (functionNode, captures, functionName) => {
 	const parameters = functionNode.params;
 	visitFunctionParameters(parameters, captures, functionName);
 	const returnTypeNode = functionNode.returnType;
@@ -967,7 +969,7 @@ const visitVariableDeclaration = (declarationNode, captures, enclosingName) => {
 		const declarationName = getIdentifierName(declarator.id);
 		inspectTypeAnnotation(declarator.typeAnnotation ?? (declarator.id && isOxcAstNode(declarator.id) ? declarator.id.typeAnnotation : void 0), captures, "variable-annotation", declarationName);
 		const initializerNode = declarator.init;
-		if (isOxcAstNode(initializerNode)) if (initializerNode.type === "ArrowFunctionExpression" || initializerNode.type === "FunctionExpression") visitFunctionLike(initializerNode, captures, declarationName ?? enclosingName);
+		if (isOxcAstNode(initializerNode)) if (initializerNode.type === "ArrowFunctionExpression" || initializerNode.type === "FunctionExpression") visitFunctionLike$1(initializerNode, captures, declarationName ?? enclosingName);
 		else walkExpressionForInlineTypes(initializerNode, captures, declarationName ?? enclosingName);
 	}
 };
@@ -979,7 +981,7 @@ const walkBodyForInlineTypes = (bodyNode, captures, enclosingName, recursionDept
 	for (const statement of statements) {
 		if (!isOxcAstNode(statement)) continue;
 		if (statement.type === "VariableDeclaration") visitVariableDeclaration(statement, captures, enclosingName);
-		else if (statement.type === "FunctionDeclaration") visitFunctionLike(statement, captures, getIdentifierName(statement.id) ?? enclosingName);
+		else if (statement.type === "FunctionDeclaration") visitFunctionLike$1(statement, captures, getIdentifierName(statement.id) ?? enclosingName);
 		else if (statement.type === "TSTypeAliasDeclaration") {
 			const typeAliasName = getIdentifierName(statement.id);
 			captureIfTypeLiteral(statement.typeAnnotation, captures, "local-type-alias", typeAliasName);
@@ -992,7 +994,7 @@ const walkExpressionForInlineTypes = (expressionNode, captures, enclosingName, r
 	if (recursionDepth > 200) return;
 	if (!isOxcAstNode(expressionNode)) return;
 	if (expressionNode.type === "ArrowFunctionExpression" || expressionNode.type === "FunctionExpression") {
-		visitFunctionLike(expressionNode, captures, enclosingName);
+		visitFunctionLike$1(expressionNode, captures, enclosingName);
 		return;
 	}
 	for (const value of Object.values(expressionNode)) if (Array.isArray(value)) for (const element of value) walkExpressionForInlineTypes(element, captures, enclosingName, recursionDepth + 1);
@@ -1003,7 +1005,7 @@ const visitTopLevelStatement = (statementNode, captures) => {
 	const innerNode = statementNode.type === "ExportNamedDeclaration" || statementNode.type === "ExportDefaultDeclaration" ? statementNode.declaration ?? statementNode : statementNode;
 	const targetNode = isOxcAstNode(innerNode) ? innerNode : statementNode;
 	if (targetNode.type === "FunctionDeclaration") {
-		visitFunctionLike(targetNode, captures, getIdentifierName(targetNode.id));
+		visitFunctionLike$1(targetNode, captures, getIdentifierName(targetNode.id));
 		return;
 	}
 	if (targetNode.type === "VariableDeclaration") {
@@ -1023,7 +1025,7 @@ const visitTopLevelStatement = (statementNode, captures) => {
 			}
 			if (memberCandidate.type === "MethodDefinition" || memberCandidate.type === "TSAbstractMethodDefinition") {
 				const methodValue = memberCandidate.value;
-				if (isOxcAstNode(methodValue)) visitFunctionLike(methodValue, captures, qualifiedName);
+				if (isOxcAstNode(methodValue)) visitFunctionLike$1(methodValue, captures, qualifiedName);
 			}
 		}
 		return;
@@ -3204,6 +3206,8 @@ const resolveSourcePath = (distPath, directory) => {
 			const sourceCandidate = (0, node_path.resolve)(directory, withoutExtension + sourceExtension);
 			if ((0, node_fs.existsSync)(sourceCandidate)) return sourceCandidate;
 		}
+		const indexPrefixedCandidate = resolveWithIndexPrefix(withoutExtension, directory);
+		if (indexPrefixedCandidate) return indexPrefixedCandidate;
 	}
 	if (matchesOutputDirectory(relativeToDist)) for (const stem of SOURCE_INDEX_FALLBACK_STEMS) for (const sourceExtension of SOURCE_EXTENSIONS$1) {
 		const fallbackCandidate = (0, node_path.resolve)(directory, stem + sourceExtension);
@@ -3217,6 +3221,15 @@ const resolveSourcePath = (distPath, directory) => {
 		}
 		const indexCandidate = (0, node_path.resolve)(directory, withoutExtension, "index.ts");
 		if ((0, node_fs.existsSync)(indexCandidate)) return indexCandidate;
+		const indexPrefixedCandidate = resolveWithIndexPrefix(withoutExtension, directory);
+		if (indexPrefixedCandidate) return indexPrefixedCandidate;
+	}
+};
+const resolveWithIndexPrefix = (stemPath, directory) => {
+	const indexPrefixedStem = `${(0, node_path.dirname)(stemPath)}/index.${(0, node_path.basename)(stemPath)}`;
+	for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+		const candidate = (0, node_path.resolve)(directory, indexPrefixedStem + sourceExtension);
+		if ((0, node_fs.existsSync)(candidate)) return candidate;
 	}
 };
 
@@ -3823,6 +3836,7 @@ const SCRIPT_MULTIPLEXERS = new Set([
 	"lerna",
 	"ultra"
 ]);
+const TSCONFIG_PROJECT_FLAGS = new Set(["--project", "-p"]);
 const CONFIG_LIKE_FLAGS = new Set([
 	"--config",
 	"-c",
@@ -3968,7 +3982,8 @@ const extractScriptFileArguments = (scriptCommand, directory) => {
 					const configPath = tokens[tokenIndex + 1].replace(/^['"]|['"]$/g, "");
 					if (looksLikeFilePath(configPath)) {
 						const absoluteConfigPath = (0, node_path.resolve)(directory, configPath);
-						if ((0, node_fs.existsSync)(absoluteConfigPath)) entries.push(absoluteConfigPath);
+						if ((0, node_fs.existsSync)(absoluteConfigPath)) if (TSCONFIG_PROJECT_FLAGS.has(token) && TSCONFIG_PROJECT_PATTERN.test(absoluteConfigPath)) entries.push(...expandTsConfigProjectEntries(absoluteConfigPath));
+						else entries.push(absoluteConfigPath);
 					}
 					tokenIndex++;
 				}
@@ -3977,9 +3992,11 @@ const extractScriptFileArguments = (scriptCommand, directory) => {
 			const equalsIndex = token.indexOf("=");
 			if (equalsIndex > 0 && CONFIG_LIKE_FLAGS.has(token.slice(0, equalsIndex))) {
 				const configValue = token.slice(equalsIndex + 1);
+				const flagName = token.slice(0, equalsIndex);
 				if (configValue && looksLikeFilePath(configValue)) {
 					const absoluteConfigPath = (0, node_path.resolve)(directory, configValue);
-					if ((0, node_fs.existsSync)(absoluteConfigPath)) entries.push(absoluteConfigPath);
+					if ((0, node_fs.existsSync)(absoluteConfigPath)) if (TSCONFIG_PROJECT_FLAGS.has(flagName) && TSCONFIG_PROJECT_PATTERN.test(absoluteConfigPath)) entries.push(...expandTsConfigProjectEntries(absoluteConfigPath));
+					else entries.push(absoluteConfigPath);
 				}
 				continue;
 			}
@@ -4282,6 +4299,7 @@ const extractScriptTagsFromHtmlFile = (htmlFilePath) => {
 	return entries;
 };
 const TSCONFIG_FILENAME_GLOBS = ["tsconfig.json", "tsconfig.*.json"];
+const TSCONFIG_PROJECT_PATTERN = /(?:^|[\\/])tsconfig(?:\.[^.]+)?\.json$/;
 const stripJsoncCommentsLocal = (sourceText) => {
 	let result = "";
 	let insideString = false;
@@ -4353,6 +4371,34 @@ const extractTsConfigIncludeFilesEntries = (directory) => {
 	} catch {}
 	return entries;
 };
+const expandTsConfigProjectEntries = (tsconfigAbsolutePath) => {
+	const entries = [];
+	try {
+		const cleaned = stripJsoncCommentsLocal((0, node_fs.readFileSync)(tsconfigAbsolutePath, "utf-8"));
+		const tsconfigJson = JSON.parse(cleaned);
+		const tsconfigDir = (0, node_path.dirname)(tsconfigAbsolutePath);
+		if (Array.isArray(tsconfigJson.files)) for (const fileItem of tsconfigJson.files) {
+			if (typeof fileItem !== "string") continue;
+			const candidatePath = (0, node_path.resolve)(tsconfigDir, fileItem);
+			if ((0, node_fs.existsSync)(candidatePath)) entries.push(candidatePath);
+		}
+		if (Array.isArray(tsconfigJson.include)) for (const includePattern of tsconfigJson.include) {
+			if (typeof includePattern !== "string") continue;
+			const expandedFiles = fast_glob.default.sync(includePattern, {
+				cwd: tsconfigDir,
+				absolute: true,
+				onlyFiles: true,
+				ignore: [
+					"**/node_modules/**",
+					"**/dist/**",
+					"**/build/**"
+				]
+			});
+			entries.push(...expandedFiles);
+		}
+	} catch {}
+	return entries;
+};
 const WRANGLER_TOML_MAIN_PATTERN = /^\s*main\s*=\s*['"]([^'"\n]+)['"]/m;
 const WRANGLER_JSON_MAIN_PATTERN = /"main"\s*:\s*"([^"]+)"/;
 const WRANGLER_SERVICE_BINDINGS_PATTERN = /entry_point\s*=\s*['"]([^'"\n]+)['"]/g;
@@ -5783,6 +5829,40 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 	};
 };
 
+//#endregion
+//#region src/utils/is-platform-builtin-or-virtual.ts
+const BUILTIN_SUBPATH_NODE_MODULES = new Set([
+	"fs",
+	"dns",
+	"stream",
+	"readline",
+	"timers",
+	"util",
+	"test",
+	"assert",
+	"inspector",
+	"path"
+]);
+/**
+* True for module specifiers that don't correspond to a real on-disk
+* package — Node / Bun / Cloudflare / Sass built-ins, the Deno `std`
+* bare specifier, and Vite `virtual:` modules — so they aren't mistakenly
+* surfaced as `unused-dependency` or `unresolved-import`.
+*/
+const isPlatformBuiltinOrVirtualSpecifier = (specifier) => {
+	if (specifier.startsWith("virtual:")) return true;
+	if (specifier === "bun" || specifier.startsWith("bun:")) return true;
+	if (specifier.startsWith("cloudflare:")) return true;
+	if (specifier.startsWith("sass:")) return true;
+	if (specifier === "std" || specifier.startsWith("std/")) return true;
+	const stripped = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
+	const slashIndex = stripped.indexOf("/");
+	if (slashIndex === -1) return BUILTIN_MODULES.has(stripped);
+	const baseName = stripped.slice(0, slashIndex);
+	if (!BUILTIN_MODULES.has(baseName)) return false;
+	return BUILTIN_SUBPATH_NODE_MODULES.has(baseName);
+};
+
 //#endregion
 //#region src/resolver/resolve.ts
 const fileExistsCache = /* @__PURE__ */ new Map();
@@ -6577,21 +6657,7 @@ const stripJsonComments = (content) => {
 	}
 	return result.replace(/,(\s*[}\]])/g, "$1");
 };
-const BUILTIN_SUBPATH_MODULES = new Set([
-	"fs",
-	"dns",
-	"stream",
-	"readline",
-	"timers",
-	"util"
-]);
-const isBuiltinModule = (specifier) => {
-	if (specifier.startsWith("node:")) return true;
-	const baseName = specifier.split("/")[0];
-	if (!BUILTIN_MODULES.has(baseName)) return false;
-	if (!specifier.includes("/")) return true;
-	return BUILTIN_SUBPATH_MODULES.has(baseName);
-};
+const isBuiltinModule = (specifier) => isPlatformBuiltinOrVirtualSpecifier(specifier);
 const isBareSpecifier = (specifier) => !specifier.startsWith(".") && !specifier.startsWith("/");
 const extractPackageNameFromSpecifier = (specifier) => {
 	if (specifier.startsWith("node:")) return specifier.slice(5).split("/")[0];
@@ -8476,177 +8542,2516 @@ const detectDuplicateInlineTypes = (graph) => {
 };
 
 //#endregion
-//#region src/utils/run-safe-detector.ts
-const runSafeDetector = (input) => {
-	try {
-		return input.detector();
-	} catch (caughtError) {
-		input.errorSink.push(new DetectorError({
-			module: input.module,
-			message: `${input.detectorName} threw ${input.contextDescription}`,
-			detail: describeUnknownError(caughtError)
+//#region src/report/cross-file-duplicate-exports.ts
+const buildReExportSourceSets = (graph) => {
+	const reExportSources = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		if (!edge.isReExportEdge) continue;
+		const existing = reExportSources.get(edge.source);
+		if (existing) existing.add(edge.target);
+		else reExportSources.set(edge.source, new Set([edge.target]));
+	}
+	return reExportSources;
+};
+/**
+* Two duplicate-export files "share a common importer" when there exists a
+* third file that imports from both, OR one duplicate file imports another.
+* This filters out coincidental duplicates among unrelated leaf modules
+* (SvelteKit/Next.js route files, scripts in different parts of a monorepo,
+* etc.) that happen to export the same name but can never be confused at any
+* import site.
+*/
+const hasCommonImporter = (moduleIndices, graph) => {
+	if (moduleIndices.length <= 1) return false;
+	const duplicateModuleSet = new Set(moduleIndices);
+	const importerOwner = /* @__PURE__ */ new Map();
+	for (const moduleIndex of moduleIndices) {
+		const importers = graph.reverseEdges.get(moduleIndex) ?? [];
+		for (const importerIndex of importers) {
+			if (duplicateModuleSet.has(importerIndex)) return true;
+			const previousOwner = importerOwner.get(importerIndex);
+			if (previousOwner === void 0) importerOwner.set(importerIndex, moduleIndex);
+			else if (previousOwner !== moduleIndex) return true;
+		}
+	}
+	return false;
+};
+/**
+* Cross-file duplicate exports: the same exported name lives in 2+ files.
+*
+* Filters applied (to keep the rule actionable):
+* - default exports are skipped (every module gets one and it's not actionable)
+* - re-export chains are pruned: if module A re-exports `Foo` from module B,
+*   the (A, B) pair is one chain, not two real declarations
+* - TypeScript value/type namespace split: `export const X` and `export type X`
+*   in the same file are distinct in TS's value/type namespaces; same name in a
+*   value file and a type file is not a true duplicate either
+* - common-importer filter: only report duplicates where two of the duplicate
+*   files share an importer or one imports another, so unrelated route files in
+*   different parts of a repo don't get flagged
+*/
+const detectCrossFileDuplicateExports = (graph) => {
+	const reExportSources = buildReExportSourceSets(graph);
+	const exportEntriesByName = /* @__PURE__ */ new Map();
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		if (module.isEntryPoint) continue;
+		for (const exportInfo of module.exports) {
+			if (exportInfo.isDefault) continue;
+			if (exportInfo.isSynthetic) continue;
+			if (exportInfo.name === "*") continue;
+			if (exportInfo.isReExport) continue;
+			const entry = {
+				moduleIndex: module.fileId.index,
+				path: module.fileId.path,
+				line: exportInfo.line,
+				column: exportInfo.column,
+				isTypeOnly: exportInfo.isTypeOnly
+			};
+			const existing = exportEntriesByName.get(exportInfo.name);
+			if (existing) existing.push(entry);
+			else exportEntriesByName.set(exportInfo.name, [entry]);
+		}
+	}
+	const findings = [];
+	const sortedEntries = [...exportEntriesByName.entries()].sort(([nameA], [nameB]) => nameA.localeCompare(nameB));
+	for (const [name, entries] of sortedEntries) {
+		if (entries.length <= 1) continue;
+		const hasValueExport = entries.some((entry) => !entry.isTypeOnly);
+		const hasTypeExport = entries.some((entry) => entry.isTypeOnly);
+		if (hasValueExport && hasTypeExport) {
+			const valueModuleIndices = new Set(entries.filter((entry) => !entry.isTypeOnly).map((entry) => entry.moduleIndex));
+			const typeModuleIndices = new Set(entries.filter((entry) => entry.isTypeOnly).map((entry) => entry.moduleIndex));
+			if (valueModuleIndices.size <= 1 && typeModuleIndices.size <= 1) continue;
+		}
+		const moduleIndexSet = new Set(entries.map((entry) => entry.moduleIndex));
+		const independentEntries = entries.filter((entry) => {
+			const sources = reExportSources.get(entry.moduleIndex);
+			if (!sources) return true;
+			for (const sourceIndex of sources) if (moduleIndexSet.has(sourceIndex)) return false;
+			return true;
+		});
+		if (independentEntries.length <= 1) continue;
+		if (!hasCommonImporter(independentEntries.map((entry) => entry.moduleIndex), graph)) continue;
+		const locations = independentEntries.map((entry) => ({
+			path: entry.path,
+			line: entry.line,
+			column: entry.column,
+			isTypeOnly: entry.isTypeOnly
 		}));
-		return input.fallback;
+		findings.push({
+			name,
+			locations,
+			confidence: "medium",
+			reason: `"${name}" is exported from ${locations.length} files that share a common importer — consumers may import the wrong one`
+		});
 	}
+	return findings;
 };
 
 //#endregion
-//#region src/semantic/program.ts
-const failureFor = (reason, message, options = { rootDir: "" }) => {
-	return {
-		reason,
-		message,
-		error: new TypeScriptError({
-			code: {
-				"no-tsconfig": "tsconfig-not-found",
-				"tsconfig-parse-error": "tsconfig-parse-failed",
-				"program-creation-failed": "ts-program-creation-failed",
-				"too-many-files": "ts-program-too-large",
-				"typescript-load-failed": "ts-not-loadable"
-			}[reason],
-			severity: reason === "no-tsconfig" ? "info" : "warning",
-			message,
-			path: options.rootDir || void 0,
-			detail: options.detail
-		})
-	};
+//#region src/utils/compute-line-starts.ts
+const LINE_FEED_CHAR_CODE = 10;
+const computeLineStarts = (sourceText) => {
+	const lineStarts = [0];
+	for (let charIndex = 0; charIndex < sourceText.length; charIndex++) if (sourceText.charCodeAt(charIndex) === LINE_FEED_CHAR_CODE) lineStarts.push(charIndex + 1);
+	return lineStarts;
 };
-const findNearestTsconfig = (rootDir, explicitPath) => {
-	if (explicitPath) {
-		const absoluteExplicit = (0, node_path.resolve)(rootDir, explicitPath);
-		if ((0, node_fs.existsSync)(absoluteExplicit)) return absoluteExplicit;
-		return;
-	}
-	for (const candidateName of DEFAULT_SEMANTIC_TSCONFIG_NAMES) {
-		const candidatePath = (0, node_path.resolve)(rootDir, candidateName);
-		if ((0, node_fs.existsSync)(candidatePath)) return candidatePath;
+
+//#endregion
+//#region src/utils/offset-to-line-column.ts
+const offsetToLineColumn = (byteOffset, lineStarts) => {
+	let lowIndex = 0;
+	let highIndex = lineStarts.length - 1;
+	while (lowIndex < highIndex) {
+		const middleIndex = lowIndex + highIndex + 1 >>> 1;
+		if (lineStarts[middleIndex] <= byteOffset) lowIndex = middleIndex;
+		else highIndex = middleIndex - 1;
 	}
-};
-const createSemanticContext = (rootDir, tsconfigPath) => {
-	const resolvedTsconfigPath = findNearestTsconfig(rootDir, tsconfigPath);
-	if (!resolvedTsconfigPath) return {
-		ok: false,
-		failure: failureFor("no-tsconfig", `No tsconfig found under ${rootDir}`, { rootDir })
+	return {
+		line: lowIndex + 1,
+		column: byteOffset - lineStarts[lowIndex]
 	};
-	let configFileContent;
-	try {
-		configFileContent = typescript.default.readConfigFile(resolvedTsconfigPath, typescript.default.sys.readFile);
-	} catch (readError) {
-		return {
-			ok: false,
-			failure: failureFor("tsconfig-parse-error", "ts.readConfigFile threw", {
-				rootDir: resolvedTsconfigPath,
-				detail: describeUnknownError(readError)
-			})
-		};
+};
+
+//#endregion
+//#region src/duplicate-blocks/concatenate.ts
+const SENTINEL_FILE_INDEX = Number.MAX_SAFE_INTEGER;
+/**
+* Rank-reduce token hashes to dense 0..K-1 integers and concatenate every
+* file's reduced sequence with a unique negative sentinel between files. Dense
+* ranks shrink the suffix-array's bucket counters from ~4 billion to a few
+* thousand (the standard prefix-doubling speedup), and negative sentinels
+* guarantee no real-token suffix can match across a file boundary.
+*/
+const rankReduceAndConcatenate = (filesHashedTokens) => {
+	const uniqueHashes = /* @__PURE__ */ new Set();
+	for (const fileTokens of filesHashedTokens) for (const hashedToken of fileTokens) uniqueHashes.add(hashedToken.hash);
+	const sortedUniqueHashes = [...uniqueHashes].sort((leftHash, rightHash) => leftHash - rightHash);
+	const hashToRank = /* @__PURE__ */ new Map();
+	for (let rankIndex = 0; rankIndex < sortedUniqueHashes.length; rankIndex++) hashToRank.set(sortedUniqueHashes[rankIndex], rankIndex + 1);
+	const sequenceLength = filesHashedTokens.reduce((runningSum, fileTokens) => runningSum + fileTokens.length, 0) + Math.max(0, filesHashedTokens.length - 1);
+	const tokenSequence = new Array(sequenceLength);
+	const fileOf = new Array(sequenceLength);
+	const fileOffsets = new Array(filesHashedTokens.length);
+	let writeCursor = 0;
+	let nextSentinelValue = -1;
+	for (let fileIndex = 0; fileIndex < filesHashedTokens.length; fileIndex++) {
+		fileOffsets[fileIndex] = writeCursor;
+		const fileTokens = filesHashedTokens[fileIndex];
+		for (const hashedToken of fileTokens) {
+			tokenSequence[writeCursor] = hashToRank.get(hashedToken.hash) ?? 0;
+			fileOf[writeCursor] = fileIndex;
+			writeCursor++;
+		}
+		if (fileIndex < filesHashedTokens.length - 1) {
+			tokenSequence[writeCursor] = nextSentinelValue;
+			fileOf[writeCursor] = SENTINEL_FILE_INDEX;
+			writeCursor++;
+			nextSentinelValue--;
+		}
 	}
-	if (configFileContent.error) return {
-		ok: false,
-		failure: failureFor("tsconfig-parse-error", typescript.default.flattenDiagnosticMessageText(configFileContent.error.messageText, "\n"), { rootDir: resolvedTsconfigPath })
+	return {
+		tokenSequence,
+		fileOf,
+		fileOffsets
 	};
-	let parsedCommandLine;
-	try {
-		parsedCommandLine = typescript.default.parseJsonConfigFileContent(configFileContent.config, typescript.default.sys, (0, node_path.dirname)(resolvedTsconfigPath), {
-			noEmit: true,
-			skipLibCheck: true,
-			allowJs: true,
-			isolatedModules: false
-		}, resolvedTsconfigPath);
-	} catch (parseError) {
-		return {
-			ok: false,
-			failure: failureFor("tsconfig-parse-error", "ts.parseJsonConfigFileContent threw", {
-				rootDir: resolvedTsconfigPath,
-				detail: describeUnknownError(parseError)
-			})
-		};
+};
+const SENTINEL_FILE_MARKER = SENTINEL_FILE_INDEX;
+
+//#endregion
+//#region src/duplicate-blocks/extract.ts
+const buildRawBlock = (suffixArray, fileOf, fileOffsets, filesTokenCounts, intervalBegin, intervalEnd, tokenLength) => {
+	const candidateInstances = [];
+	for (let suffixIndex = intervalBegin; suffixIndex < intervalEnd; suffixIndex++) {
+		const startPosition = suffixArray[suffixIndex];
+		const fileIndex = fileOf[startPosition];
+		if (fileIndex === SENTINEL_FILE_MARKER) continue;
+		const tokenOffsetWithinFile = startPosition - fileOffsets[fileIndex];
+		if (tokenOffsetWithinFile + tokenLength > filesTokenCounts[fileIndex]) continue;
+		candidateInstances.push({
+			fileIndex,
+			tokenOffsetWithinFile
+		});
 	}
-	if (parsedCommandLine.errors.length > 0) {
-		const fatalErrors = parsedCommandLine.errors.filter((diagnostic) => diagnostic.category === typescript.default.DiagnosticCategory.Error);
-		if (fatalErrors.length > 0 && parsedCommandLine.fileNames.length === 0) return {
-			ok: false,
-			failure: failureFor("tsconfig-parse-error", typescript.default.flattenDiagnosticMessageText(fatalErrors[0].messageText, "\n"), { rootDir: resolvedTsconfigPath })
-		};
+	if (candidateInstances.length < 2) return void 0;
+	candidateInstances.sort((leftInstance, rightInstance) => {
+		if (leftInstance.fileIndex !== rightInstance.fileIndex) return leftInstance.fileIndex - rightInstance.fileIndex;
+		return leftInstance.tokenOffsetWithinFile - rightInstance.tokenOffsetWithinFile;
+	});
+	const dedupedInstances = [];
+	for (const instance of candidateInstances) {
+		const lastInstance = dedupedInstances[dedupedInstances.length - 1];
+		if (lastInstance !== void 0 && lastInstance.fileIndex === instance.fileIndex && instance.tokenOffsetWithinFile < lastInstance.tokenOffsetWithinFile + tokenLength) continue;
+		dedupedInstances.push(instance);
 	}
-	if (parsedCommandLine.fileNames.length > 5e3) return {
-		ok: false,
-		failure: failureFor("too-many-files", `Project has ${parsedCommandLine.fileNames.length} files, exceeds SEMANTIC_MAX_PROGRAM_FILES=${SEMANTIC_MAX_PROGRAM_FILES}`, { rootDir: resolvedTsconfigPath })
+	if (dedupedInstances.length < 2) return void 0;
+	return {
+		instances: dedupedInstances,
+		tokenLength
 	};
-	try {
-		const program = typescript.default.createProgram({
-			rootNames: parsedCommandLine.fileNames,
-			options: parsedCommandLine.options,
-			projectReferences: parsedCommandLine.projectReferences
-		});
-		return {
-			ok: true,
-			context: {
-				program,
-				checker: program.getTypeChecker(),
-				rootSourceFiles: program.getSourceFiles().filter((sourceFile) => !sourceFile.isDeclarationFile || sourceFile.fileName.endsWith(".d.ts")),
-				tsconfigPath: resolvedTsconfigPath
+};
+/**
+* Walks `lcpArray` with a monotone stack to materialize every maximal
+* interval `[i, j]` whose minimum LCP is >= `minTokens`. Within-file
+* overlapping occurrences are dropped (keep the earliest non-overlapping
+* prefix), and any block left with fewer than two occurrences is discarded.
+*/
+const extractRawDuplicateBlocks = (suffixArray, lcpArray, fileOf, fileOffsets, filesTokenCounts, minTokens) => {
+	const sequenceLength = suffixArray.length;
+	if (sequenceLength < 2) return [];
+	const rawBlocks = [];
+	const monotoneStack = [];
+	for (let scanIndex = 1; scanIndex <= sequenceLength; scanIndex++) {
+		const currentLcp = scanIndex < sequenceLength ? lcpArray[scanIndex] : 0;
+		let intervalStart = scanIndex;
+		while (monotoneStack.length > 0 && monotoneStack[monotoneStack.length - 1].lcpValue > currentLcp) {
+			const popped = monotoneStack.pop();
+			intervalStart = popped.startIndex;
+			if (popped.lcpValue >= minTokens) {
+				const candidate = buildRawBlock(suffixArray, fileOf, fileOffsets, filesTokenCounts, intervalStart - 1, scanIndex, popped.lcpValue);
+				if (candidate) rawBlocks.push(candidate);
 			}
-		};
-	} catch (programError) {
-		return {
-			ok: false,
-			failure: failureFor("program-creation-failed", "ts.createProgram threw", {
-				rootDir: resolvedTsconfigPath,
-				detail: describeUnknownError(programError)
-			})
-		};
+		}
+		if (scanIndex < sequenceLength) monotoneStack.push({
+			lcpValue: currentLcp,
+			startIndex: intervalStart
+		});
 	}
+	return rawBlocks;
 };
 
 //#endregion
-//#region src/semantic/references.ts
-const canonicalKeyForSymbol = (symbol) => {
-	return symbol.declarations?.[0] ?? symbol;
+//#region src/duplicate-blocks/clusters.ts
+const baseName = (filePath) => {
+	const trailingSlashIndex = filePath.lastIndexOf("/");
+	return trailingSlashIndex === -1 ? filePath : filePath.slice(trailingSlashIndex + 1);
+};
+const buildSuggestions = (files, blocks, totalDuplicatedLines) => {
+	const fileBaseNames = files.map((filePath) => baseName(filePath));
+	if (files.length >= 2 && totalDuplicatedLines >= 50) {
+		const estimatedSavings = blocks.reduce((runningSum, block) => runningSum + block.lineCount * Math.max(0, block.instances.length - 1), 0);
+		return [{
+			kind: "extract-module",
+			description: `Extract ${blocks.length} shared duplicate block${blocks.length === 1 ? "" : "s"} (${totalDuplicatedLines} lines) from ${fileBaseNames.join(", ")} into a shared module`,
+			estimatedSavings
+		}];
+	}
+	return blocks.map((block) => ({
+		kind: "extract-function",
+		description: `Extract shared function (${block.lineCount} lines) from ${fileBaseNames.join(", ")}`,
+		estimatedSavings: block.lineCount * Math.max(0, block.instances.length - 1)
+	}));
 };
-const isDeclarationNameIdentifier = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return false;
-	if ((typescript.default.isInterfaceDeclaration(parent) || typescript.default.isTypeAliasDeclaration(parent) || typescript.default.isClassDeclaration(parent) || typescript.default.isFunctionDeclaration(parent) || typescript.default.isEnumDeclaration(parent) || typescript.default.isModuleDeclaration(parent) || typescript.default.isVariableDeclaration(parent)) && parent.name === identifier) return true;
-	if (typescript.default.isEnumMember(parent) && parent.name === identifier) return true;
-	if (typescript.default.isPropertyDeclaration(parent) && parent.name === identifier) return true;
-	if (typescript.default.isMethodDeclaration(parent) && parent.name === identifier) return true;
-	if (typescript.default.isParameter(parent) && parent.name === identifier) return true;
-	if (typescript.default.isBindingElement(parent) && parent.name === identifier) return true;
-	return false;
+const groupDuplicateBlocksIntoClusters = (duplicateBlocks) => {
+	if (duplicateBlocks.length === 0) return [];
+	const fileSetKeyToBucket = /* @__PURE__ */ new Map();
+	for (const block of duplicateBlocks) {
+		const sortedFiles = [...new Set(block.instances.map((instance) => instance.path))].sort();
+		const fileSetKey = sortedFiles.join("|");
+		const existing = fileSetKeyToBucket.get(fileSetKey);
+		if (existing) existing.blocks.push(block);
+		else fileSetKeyToBucket.set(fileSetKey, {
+			files: sortedFiles,
+			blocks: [block]
+		});
+	}
+	const clusters = [];
+	for (const bucket of fileSetKeyToBucket.values()) {
+		const totalDuplicatedLines = bucket.blocks.reduce((runningSum, block) => runningSum + block.lineCount, 0);
+		const totalDuplicatedTokens = bucket.blocks.reduce((runningSum, block) => runningSum + block.tokenCount, 0);
+		clusters.push({
+			files: bucket.files,
+			groups: bucket.blocks,
+			totalDuplicatedLines,
+			totalDuplicatedTokens,
+			suggestions: buildSuggestions(bucket.files, bucket.blocks, totalDuplicatedLines)
+		});
+	}
+	clusters.sort((leftCluster, rightCluster) => {
+		if (leftCluster.totalDuplicatedLines !== rightCluster.totalDuplicatedLines) return rightCluster.totalDuplicatedLines - leftCluster.totalDuplicatedLines;
+		return rightCluster.groups.length - leftCluster.groups.length;
+	});
+	return clusters;
 };
-const isExportSpecifierIdentifier = (identifier) => {
-	const parent = identifier.parent;
-	return Boolean(parent && typescript.default.isExportSpecifier(parent));
+
+//#endregion
+//#region src/duplicate-blocks/shadowed-directory-pairs.ts
+const splitDirectoryAndFile = (filePath) => {
+	const trailingSlashIndex = filePath.lastIndexOf("/");
+	if (trailingSlashIndex === -1) return {
+		directory: "",
+		baseName: filePath
+	};
+	return {
+		directory: filePath.slice(0, trailingSlashIndex + 1),
+		baseName: filePath.slice(trailingSlashIndex + 1)
+	};
 };
-const isImportSpecifierIdentifier = (identifier) => {
-	const parent = identifier.parent;
-	if (!parent) return false;
-	return typescript.default.isImportSpecifier(parent) || typescript.default.isImportClause(parent) || typescript.default.isNamespaceImport(parent);
+const toRelative = (filePath, rootDir) => {
+	if (filePath.startsWith(rootDir + "/")) return filePath.slice(rootDir.length + 1);
+	if (filePath === rootDir) return "";
+	return filePath;
 };
-const isInTypeContext = (identifier) => {
-	let current = identifier.parent;
-	let depth = 0;
-	while (current && depth < 12) {
-		if (typescript.default.isTypeReferenceNode(current) || typescript.default.isTypeQueryNode(current) || typescript.default.isTypeAliasDeclaration(current) || typescript.default.isInterfaceDeclaration(current) || typescript.default.isHeritageClause(current) || typescript.default.isImportTypeNode(current) || typescript.default.isTypePredicateNode(current) || typescript.default.isTypeOperatorNode(current) || typescript.default.isTypeLiteralNode(current) || typescript.default.isIndexedAccessTypeNode(current) || typescript.default.isMappedTypeNode(current) || typescript.default.isConditionalTypeNode(current) || typescript.default.isInferTypeNode(current)) return true;
-		if (typescript.default.isExpressionStatement(current) || typescript.default.isBlock(current)) return false;
-		current = current.parent;
-		depth++;
+/**
+* Collapse N two-file duplicate-block clusters that share the same
+* `(directoryA, directoryB)` and matching basenames into a single
+* `ShadowedDirectoryPair` finding — the directories themselves drifted
+* (e.g. `src/` vs `deno/lib/`, a fork, a copy-paste of a route tree).
+*/
+const detectShadowedDirectoryPairs = (duplicateBlockClusters, rootDir) => {
+	const directoryPairBuckets = /* @__PURE__ */ new Map();
+	for (const cluster of duplicateBlockClusters) {
+		if (cluster.files.length !== 2) continue;
+		const [firstFile, secondFile] = cluster.files;
+		const firstSplit = splitDirectoryAndFile(toRelative(firstFile, rootDir));
+		const secondSplit = splitDirectoryAndFile(toRelative(secondFile, rootDir));
+		if (firstSplit.baseName !== secondSplit.baseName) continue;
+		const [smallerDirectory, largerDirectory] = firstSplit.directory <= secondSplit.directory ? [firstSplit.directory, secondSplit.directory] : [secondSplit.directory, firstSplit.directory];
+		const pairKey = `${smallerDirectory}::${largerDirectory}`;
+		const entry = {
+			baseName: firstSplit.baseName,
+			duplicatedLines: cluster.totalDuplicatedLines
+		};
+		const existing = directoryPairBuckets.get(pairKey);
+		if (existing) existing.push(entry);
+		else directoryPairBuckets.set(pairKey, [entry]);
+	}
+	const shadowedDirectoryPairs = [];
+	for (const [pairKey, entries] of directoryPairBuckets) {
+		if (entries.length < 3) continue;
+		const [directoryA, directoryB] = pairKey.split("::");
+		const sharedBaseNames = [...new Set(entries.map((entry) => entry.baseName))].sort();
+		const totalDuplicatedLines = entries.reduce((runningSum, entry) => runningSum + entry.duplicatedLines, 0);
+		shadowedDirectoryPairs.push({
+			directoryA,
+			directoryB,
+			sharedFiles: sharedBaseNames,
+			totalDuplicatedLines
+		});
 	}
-	return false;
+	shadowedDirectoryPairs.sort((leftPair, rightPair) => rightPair.totalDuplicatedLines - leftPair.totalDuplicatedLines);
+	return shadowedDirectoryPairs;
 };
-const resolveSymbolForIdentifier = (identifier, checker) => {
-	let symbol;
-	try {
-		symbol = checker.getSymbolAtLocation(identifier);
-	} catch {
-		return;
-	}
-	if (!symbol) return void 0;
-	if (symbol.flags & typescript.default.SymbolFlags.Alias) try {
-		return checker.getAliasedSymbol(symbol);
-	} catch {
-		return symbol;
-	}
+
+//#endregion
+//#region src/duplicate-blocks/normalize.ts
+/**
+* 32-bit FNV-1a. Collisions are tolerable: ties are broken back to the
+* original (path, offset) tuples downstream, so a rare collision inflates a
+* duplicate block with one extra spurious instance at worst.
+*/
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+const hashString = (input) => {
+	let hash = FNV_OFFSET_BASIS;
+	for (let charIndex = 0; charIndex < input.length; charIndex++) {
+		hash ^= input.charCodeAt(charIndex);
+		hash = Math.imul(hash, FNV_PRIME);
+	}
+	return hash >>> 0;
+};
+const resolveNormalization = (mode) => {
+	if (mode === "strict") return {
+		ignoreIdentifiers: false,
+		ignoreStringValues: false,
+		ignoreNumericValues: false
+	};
+	return {
+		ignoreIdentifiers: true,
+		ignoreStringValues: true,
+		ignoreNumericValues: true
+	};
+};
+const hashSourceToken = (sourceToken, normalization) => {
+	switch (sourceToken.kind) {
+		case "node-enter": return hashString(`n:${sourceToken.payload}`);
+		case "identifier": return normalization.ignoreIdentifiers ? hashString("id:*") : hashString(`id:${sourceToken.payload}`);
+		case "string-literal": return normalization.ignoreStringValues ? hashString("s:*") : hashString(`s:${sourceToken.payload}`);
+		case "numeric-literal": return normalization.ignoreNumericValues ? hashString("num:*") : hashString(`num:${sourceToken.payload}`);
+		case "boolean-literal": return hashString(`b:${sourceToken.payload}`);
+		case "null-literal": return hashString("null");
+		case "template-literal": return hashString("tpl");
+		case "regexp-literal": return hashString("re");
+		default: return hashString("?");
+	}
+};
+const normalizeAndHashTokens = (tokens, mode) => {
+	const normalization = resolveNormalization(mode);
+	const hashedTokens = new Array(tokens.length);
+	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) hashedTokens[tokenIndex] = {
+		hash: hashSourceToken(tokens[tokenIndex], normalization),
+		originalIndex: tokenIndex
+	};
+	return hashedTokens;
+};
+
+//#endregion
+//#region src/duplicate-blocks/suffix-array.ts
+/**
+* Prefix-doubling suffix array with two-pass radix sort, O(N log N).
+*
+* Negative values in `tokenSequence` (file-separator sentinels emitted by
+* `rankReduceAndConcatenate`) are shifted up so all ranks are >= 0. The
+* shift preserves the property that sentinels sort before all real ranks,
+* which is what stops cross-file suffix matches.
+*/
+const buildSuffixArray = (tokenSequence) => {
+	const sequenceLength = tokenSequence.length;
+	if (sequenceLength === 0) return [];
+	let minimumValue = 0;
+	for (let scanIndex = 0; scanIndex < sequenceLength; scanIndex++) if (tokenSequence[scanIndex] < minimumValue) minimumValue = tokenSequence[scanIndex];
+	let currentRanks = new Array(sequenceLength);
+	for (let scanIndex = 0; scanIndex < sequenceLength; scanIndex++) currentRanks[scanIndex] = tokenSequence[scanIndex] - minimumValue;
+	let suffixArray = new Array(sequenceLength);
+	for (let positionIndex = 0; positionIndex < sequenceLength; positionIndex++) suffixArray[positionIndex] = positionIndex;
+	let nextRanks = new Array(sequenceLength);
+	let scratchSuffixArray = new Array(sequenceLength);
+	let maximumRank = 0;
+	for (let scanIndex = 0; scanIndex < sequenceLength; scanIndex++) if (currentRanks[scanIndex] > maximumRank) maximumRank = currentRanks[scanIndex];
+	let stride = 1;
+	while (stride < sequenceLength) {
+		const bucketCount = maximumRank + 2;
+		const buckets = new Array(bucketCount + 1).fill(0);
+		for (let suffixIndex = 0; suffixIndex < sequenceLength; suffixIndex++) {
+			const startPosition = suffixArray[suffixIndex];
+			const secondaryKey = startPosition + stride < sequenceLength ? currentRanks[startPosition + stride] + 1 : 0;
+			buckets[secondaryKey]++;
+		}
+		let prefixSum = 0;
+		for (let bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) {
+			const bucketCountValue = buckets[bucketIndex];
+			buckets[bucketIndex] = prefixSum;
+			prefixSum += bucketCountValue;
+		}
+		for (let suffixIndex = 0; suffixIndex < sequenceLength; suffixIndex++) {
+			const startPosition = suffixArray[suffixIndex];
+			const secondaryKey = startPosition + stride < sequenceLength ? currentRanks[startPosition + stride] + 1 : 0;
+			scratchSuffixArray[buckets[secondaryKey]] = startPosition;
+			buckets[secondaryKey]++;
+		}
+		for (let bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) buckets[bucketIndex] = 0;
+		for (let suffixIndex = 0; suffixIndex < sequenceLength; suffixIndex++) {
+			const startPosition = scratchSuffixArray[suffixIndex];
+			buckets[currentRanks[startPosition]]++;
+		}
+		prefixSum = 0;
+		for (let bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) {
+			const bucketCountValue = buckets[bucketIndex];
+			buckets[bucketIndex] = prefixSum;
+			prefixSum += bucketCountValue;
+		}
+		for (let suffixIndex = 0; suffixIndex < sequenceLength; suffixIndex++) {
+			const startPosition = scratchSuffixArray[suffixIndex];
+			suffixArray[buckets[currentRanks[startPosition]]] = startPosition;
+			buckets[currentRanks[startPosition]]++;
+		}
+		nextRanks[suffixArray[0]] = 0;
+		for (let suffixIndex = 1; suffixIndex < sequenceLength; suffixIndex++) {
+			const previousStart = suffixArray[suffixIndex - 1];
+			const currentStart = suffixArray[suffixIndex];
+			const previousSecondary = previousStart + stride < sequenceLength ? currentRanks[previousStart + stride] : -1;
+			const currentSecondary = currentStart + stride < sequenceLength ? currentRanks[currentStart + stride] : -1;
+			const isSameBucket = currentRanks[previousStart] === currentRanks[currentStart] && previousSecondary === currentSecondary;
+			nextRanks[currentStart] = nextRanks[previousStart] + (isSameBucket ? 0 : 1);
+		}
+		const newMaximumRank = nextRanks[suffixArray[sequenceLength - 1]];
+		[currentRanks, nextRanks] = [nextRanks, currentRanks];
+		if (newMaximumRank === sequenceLength - 1) break;
+		maximumRank = newMaximumRank;
+		stride *= 2;
+	}
+	return suffixArray;
+};
+/**
+* Kasai's O(N) longest-common-prefix array. The `>= 0` check inside the inner
+* loop is the only non-textbook bit: it prevents a real-token LCP from
+* accidentally crossing a sentinel boundary (sentinels are negative).
+*/
+const buildLcpArray = (tokenSequence, suffixArray) => {
+	const sequenceLength = tokenSequence.length;
+	const inverseSuffixArray = new Array(sequenceLength);
+	for (let arrayIndex = 0; arrayIndex < sequenceLength; arrayIndex++) inverseSuffixArray[suffixArray[arrayIndex]] = arrayIndex;
+	const lcpArray = new Array(sequenceLength).fill(0);
+	let runningLcp = 0;
+	for (let positionIndex = 0; positionIndex < sequenceLength; positionIndex++) {
+		if (inverseSuffixArray[positionIndex] === 0) {
+			runningLcp = 0;
+			continue;
+		}
+		const previousStart = suffixArray[inverseSuffixArray[positionIndex] - 1];
+		while (positionIndex + runningLcp < sequenceLength && previousStart + runningLcp < sequenceLength && tokenSequence[positionIndex + runningLcp] === tokenSequence[previousStart + runningLcp] && tokenSequence[positionIndex + runningLcp] >= 0) runningLcp++;
+		lcpArray[inverseSuffixArray[positionIndex]] = runningLcp;
+		if (runningLcp > 0) runningLcp--;
+	}
+	return lcpArray;
+};
+
+//#endregion
+//#region src/utils/is-ast-node.ts
+const isAstNode = (candidate) => typeof candidate === "object" && candidate !== null && "type" in candidate;
+
+//#endregion
+//#region src/duplicate-blocks/token-visitor.ts
+const NODES_DROPPED_FROM_TOKEN_STREAM = new Set([
+	"ImportDeclaration",
+	"ExportAllDeclaration",
+	"TSTypeAnnotation",
+	"TSTypeAliasDeclaration",
+	"TSInterfaceDeclaration",
+	"TSTypeParameterDeclaration",
+	"TSTypeParameterInstantiation",
+	"TSTypeReference",
+	"TSAnyKeyword",
+	"TSUnknownKeyword",
+	"TSStringKeyword",
+	"TSNumberKeyword",
+	"TSBooleanKeyword",
+	"TSVoidKeyword",
+	"TSUndefinedKeyword",
+	"TSNullKeyword",
+	"TSNeverKeyword",
+	"TSUnionType",
+	"TSIntersectionType",
+	"TSLiteralType",
+	"TSArrayType",
+	"TSTupleType",
+	"TSTypeLiteral",
+	"TSPropertySignature",
+	"TSMethodSignature",
+	"TSCallSignatureDeclaration",
+	"TSConstructSignatureDeclaration",
+	"TSIndexSignature",
+	"TSConditionalType",
+	"TSMappedType",
+	"TSInferType",
+	"TSImportType",
+	"TSQualifiedName",
+	"TSTypeOperator",
+	"TSTypePredicate",
+	"TSFunctionType",
+	"TSConstructorType"
+]);
+const visitChildrenRaw = (node, visit) => {
+	if (!isAstNode(node)) return;
+	for (const key of Object.keys(node)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+		const value = node[key];
+		if (Array.isArray(value)) for (const item of value) visit(item);
+		else if (value !== null && typeof value === "object") visit(value);
+	}
+};
+const safeNumberOrZero = (candidate) => typeof candidate === "number" ? candidate : 0;
+/**
+* Walk an oxc AST and emit a flat token stream suitable for suffix-array-based
+* duplicate-block detection. Two structurally-identical regions of code produce the same
+* token sequence (modulo identifier/literal-value normalization, applied later
+* in `normalize.ts`).
+*
+* Implementation note: rather than a hand-written keyword/operator lexer-style
+* visitor, we walk the AST generically and emit one `node-enter` token per
+* visited node. This trades a slightly different token-density profile for
+* less code. AST-shape tokens still distinguish
+* `function add(a, b) { return a + b }` from `const add = (a, b) => a + b`.
+* Identifiers and value literals get dedicated tokens so semantic-mode
+* normalization can blind them.
+*
+* Imports and type-only constructs are dropped to keep import-block boilerplate
+* and ambient type declarations from inflating the noise floor.
+*/
+const tokenizeAst = (program) => {
+	const tokens = [];
+	const visit = (node) => {
+		if (!isAstNode(node)) return;
+		const nodeType = node.type;
+		if (NODES_DROPPED_FROM_TOKEN_STREAM.has(nodeType)) return;
+		const start = safeNumberOrZero(node.start);
+		const end = safeNumberOrZero(node.end);
+		if (nodeType === "Identifier" || nodeType === "PrivateIdentifier") {
+			const identifierName = node.name;
+			tokens.push({
+				kind: "identifier",
+				payload: typeof identifierName === "string" ? identifierName : "",
+				start,
+				end
+			});
+			return;
+		}
+		if (nodeType === "Literal") {
+			const literalValue = node.value;
+			if (typeof literalValue === "string") tokens.push({
+				kind: "string-literal",
+				payload: literalValue,
+				start,
+				end
+			});
+			else if (typeof literalValue === "number") tokens.push({
+				kind: "numeric-literal",
+				payload: String(literalValue),
+				start,
+				end
+			});
+			else if (typeof literalValue === "boolean") tokens.push({
+				kind: "boolean-literal",
+				payload: literalValue ? "true" : "false",
+				start,
+				end
+			});
+			else if (literalValue === null) tokens.push({
+				kind: "null-literal",
+				payload: "null",
+				start,
+				end
+			});
+			else if (node.regex) tokens.push({
+				kind: "regexp-literal",
+				payload: "regex",
+				start,
+				end
+			});
+			else tokens.push({
+				kind: "node-enter",
+				payload: nodeType,
+				start,
+				end
+			});
+			return;
+		}
+		if (nodeType === "TemplateLiteral") {
+			tokens.push({
+				kind: "template-literal",
+				payload: "tpl",
+				start,
+				end
+			});
+			visitChildrenRaw(node, visit);
+			return;
+		}
+		tokens.push({
+			kind: "node-enter",
+			payload: nodeType,
+			start,
+			end
+		});
+		visitChildrenRaw(node, visit);
+	};
+	visit(program);
+	return tokens;
+};
+
+//#endregion
+//#region src/duplicate-blocks/index.ts
+const isBinaryFile = (sourceText) => {
+	const sampleEnd = Math.min(sourceText.length, BINARY_DETECTION_SAMPLE_BYTES);
+	let nullByteCount = 0;
+	for (let charIndex = 0; charIndex < sampleEnd; charIndex++) if (sourceText.charCodeAt(charIndex) === 0) {
+		nullByteCount++;
+		if (nullByteCount >= 4) return true;
+	}
+	return false;
+};
+const isMinifiedSource = (sourceText) => {
+	if (sourceText.length < 5e3) return false;
+	const lineCount = (sourceText.match(/\n/g)?.length ?? 0) + 1;
+	return sourceText.length / lineCount > 500;
+};
+const tokenizeFile = (filePath) => {
+	let sourceStat;
+	try {
+		sourceStat = (0, node_fs.statSync)(filePath);
+	} catch {
+		return;
+	}
+	if (sourceStat.size > 2e6) return void 0;
+	let sourceText;
+	try {
+		sourceText = (0, node_fs.readFileSync)(filePath, "utf-8");
+	} catch {
+		return;
+	}
+	if (sourceText.length === 0) return void 0;
+	if (isBinaryFile(sourceText)) return void 0;
+	if (isMinifiedSource(sourceText)) return void 0;
+	let parseResult;
+	try {
+		parseResult = (0, oxc_parser.parseSync)(filePath, sourceText);
+	} catch {
+		return;
+	}
+	const sourceTokens = tokenizeAst(parseResult.program);
+	if (sourceTokens.length === 0) return void 0;
+	const lineStarts = computeLineStarts(sourceText);
+	return {
+		path: filePath,
+		sourceTokens,
+		lineStarts,
+		lineCount: lineStarts.length
+	};
+};
+const buildCloneInstance = (rawInstance, tokenLength, tokenizedFiles) => {
+	const file = tokenizedFiles[rawInstance.fileIndex];
+	const firstToken = file.sourceTokens[rawInstance.tokenOffsetWithinFile];
+	const lastToken = file.sourceTokens[rawInstance.tokenOffsetWithinFile + tokenLength - 1];
+	const startSpan = offsetToLineColumn(firstToken.start, file.lineStarts);
+	const endSpan = offsetToLineColumn(lastToken.end, file.lineStarts);
+	return {
+		path: file.path,
+		startLine: startSpan.line,
+		endLine: endSpan.line,
+		startColumn: startSpan.column,
+		endColumn: endSpan.column
+	};
+};
+const directoryOf = (filePath) => (0, node_path.dirname)(filePath);
+const filterRawBlocksToReportableDuplicates = (rawBlocks, tokenizedFiles, config) => {
+	const duplicateBlocks = [];
+	for (const rawBlock of rawBlocks) {
+		const instances = rawBlock.instances.map((rawInstance) => buildCloneInstance(rawInstance, rawBlock.tokenLength, tokenizedFiles));
+		let lineCount = 0;
+		for (const instance of instances) {
+			const instanceLineCount = instance.endLine - instance.startLine + 1;
+			if (instanceLineCount > lineCount) lineCount = instanceLineCount;
+		}
+		if (lineCount < config.minLines) continue;
+		if (instances.length < config.minOccurrences) continue;
+		if (config.skipLocal) {
+			if (new Set(instances.map((instance) => directoryOf(instance.path))).size < 2) continue;
+		}
+		const distinctFiles = new Set(instances.map((instance) => instance.path));
+		const confidence = distinctFiles.size >= 2 ? "high" : "medium";
+		duplicateBlocks.push({
+			instances,
+			tokenCount: rawBlock.tokenLength,
+			lineCount,
+			confidence,
+			reason: distinctFiles.size >= 2 ? `${instances.length} occurrences spanning ${distinctFiles.size} files (≥${rawBlock.tokenLength} tokens, ${lineCount} lines)` : `${instances.length} occurrences within a single file (≥${rawBlock.tokenLength} tokens, ${lineCount} lines)`
+		});
+	}
+	const maximalBlocks = dropBlocksSubsumedByLongerSibling(duplicateBlocks);
+	maximalBlocks.sort((firstClone, secondClone) => {
+		if (firstClone.lineCount !== secondClone.lineCount) return secondClone.lineCount - firstClone.lineCount;
+		return secondClone.tokenCount - firstClone.tokenCount;
+	});
+	return maximalBlocks;
+};
+/**
+* The suffix-array + LCP-interval scan emits one block per LCP interval, but
+* nested intervals routinely yield the same set of source spans at multiple
+* lengths (the same maximal repeat reported at L, L-1, L-2, …). Drop any
+* block whose every instance is spatially contained inside some other block's
+* matching instance — that other block is strictly more informative.
+*
+* O(N²) worst-case, but N here is post-filter blocks (typically <1000 even on
+* large monorepos), and the early-exit on instance-count mismatch keeps it
+* tight in practice.
+*/
+const dropBlocksSubsumedByLongerSibling = (blocks) => {
+	const sorted = [...blocks].sort((firstBlock, secondBlock) => {
+		if (firstBlock.tokenCount !== secondBlock.tokenCount) return secondBlock.tokenCount - firstBlock.tokenCount;
+		return secondBlock.lineCount - firstBlock.lineCount;
+	});
+	const survivors = [];
+	for (const candidate of sorted) {
+		let subsumed = false;
+		for (const survivor of survivors) {
+			if (survivor.instances.length !== candidate.instances.length) continue;
+			if (allInstancesContainedIn(candidate, survivor)) {
+				subsumed = true;
+				break;
+			}
+		}
+		if (!subsumed) survivors.push(candidate);
+	}
+	return survivors;
+};
+const allInstancesContainedIn = (candidate, longer) => {
+	for (const candidateInstance of candidate.instances) {
+		let matched = false;
+		for (const longerInstance of longer.instances) if (candidateInstance.path === longerInstance.path && isSpanContained(candidateInstance, longerInstance)) {
+			matched = true;
+			break;
+		}
+		if (!matched) return false;
+	}
+	return true;
+};
+const isSpanContained = (inner, outer) => {
+	const innerStartsAfterOuter = inner.startLine > outer.startLine || inner.startLine === outer.startLine && inner.startColumn >= outer.startColumn;
+	const innerEndsBeforeOuter = inner.endLine < outer.endLine || inner.endLine === outer.endLine && inner.endColumn <= outer.endColumn;
+	return innerStartsAfterOuter && innerEndsBeforeOuter;
+};
+/**
+* Token-based duplicate block detector.
+*
+* Pipeline:
+*  1. Tokenize each file with the AST visitor in `token-visitor.ts`
+*  2. Hash + normalize tokens with the chosen detection mode
+*  3. Concatenate every file's hashed tokens with unique negative sentinels
+*  4. Build a suffix array (prefix doubling + radix sort) and LCP array
+*  5. Stack-based LCP-interval scan extracts maximal duplicate blocks
+*  6. Filter on min-tokens / min-lines / min-occurrences / skip-local
+*  7. Group clones into families; collapse N two-file families with matching
+*     basenames into a `ShadowedDirectoryPair` finding
+*
+* Returns empty arrays when `config.enabled` is false.
+*/
+const detectDuplicateBlocks = (graph, config, rootDir) => {
+	if (!config || !config.enabled) return {
+		duplicateBlocks: [],
+		duplicateBlockClusters: [],
+		shadowedDirectoryPairs: []
+	};
+	const tokenizedFiles = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		if (module.isConfigFile) continue;
+		const tokenizedFile = tokenizeFile(module.fileId.path);
+		if (!tokenizedFile) continue;
+		tokenizedFiles.push(tokenizedFile);
+	}
+	if (tokenizedFiles.length === 0) return {
+		duplicateBlocks: [],
+		duplicateBlockClusters: [],
+		shadowedDirectoryPairs: []
+	};
+	const filesHashedTokens = tokenizedFiles.map((file) => normalizeAndHashTokens(file.sourceTokens, config.mode));
+	const filesTokenCounts = filesHashedTokens.map((fileTokens) => fileTokens.length);
+	if (!filesTokenCounts.some((count) => count >= config.minTokens)) return {
+		duplicateBlocks: [],
+		duplicateBlockClusters: [],
+		shadowedDirectoryPairs: []
+	};
+	const concatenation = rankReduceAndConcatenate(filesHashedTokens);
+	if (concatenation.tokenSequence.length === 0) return {
+		duplicateBlocks: [],
+		duplicateBlockClusters: [],
+		shadowedDirectoryPairs: []
+	};
+	const suffixArray = buildSuffixArray(concatenation.tokenSequence);
+	const duplicateBlocks = filterRawBlocksToReportableDuplicates(extractRawDuplicateBlocks(suffixArray, buildLcpArray(concatenation.tokenSequence, suffixArray), concatenation.fileOf, concatenation.fileOffsets, filesTokenCounts, config.minTokens), tokenizedFiles, config);
+	const duplicateBlockClusters = groupDuplicateBlocksIntoClusters(duplicateBlocks);
+	return {
+		duplicateBlocks,
+		duplicateBlockClusters,
+		shadowedDirectoryPairs: detectShadowedDirectoryPairs(duplicateBlockClusters, rootDir)
+	};
+};
+
+//#endregion
+//#region src/report/re-export-cycles.ts
+/**
+* Reports cycles in the subgraph of `isReExportEdge` edges only. These are
+* a strict subset of `circularDependencies` but worth separating: every
+* general cycle can have a legitimate bidirectional-collaboration reason,
+* but a re-export cycle has none — it always tanks tree-shaking and risks
+* the "Cannot access X before initialization" TDZ runtime error.
+*/
+const detectReExportCycles = (graph) => {
+	const adjacency = Array.from({ length: graph.modules.length }, () => []);
+	const reExportTargetSets = Array.from({ length: graph.modules.length }, () => /* @__PURE__ */ new Set());
+	for (const edge of graph.edges) {
+		if (!edge.isReExportEdge) continue;
+		if (edge.target >= graph.modules.length) continue;
+		if (reExportTargetSets[edge.source].has(edge.target)) continue;
+		reExportTargetSets[edge.source].add(edge.target);
+		adjacency[edge.source].push(edge.target);
+	}
+	const sccComponents = computeStronglyConnectedComponents(adjacency);
+	const findings = [];
+	for (const component of sccComponents) {
+		if (component.length === 1) {
+			const onlyNode = component[0];
+			if (!adjacency[onlyNode].includes(onlyNode)) continue;
+			const filePath = graph.modules[onlyNode].fileId.path;
+			findings.push({
+				files: [filePath],
+				kind: "self-loop",
+				confidence: "high",
+				reason: `${filePath} re-exports from itself — the barrel imports its own root, which breaks bundler tree-shaking and risks TDZ runtime errors`
+			});
+			continue;
+		}
+		const sortedFiles = component.map((moduleIndex) => graph.modules[moduleIndex].fileId.path).sort();
+		findings.push({
+			files: sortedFiles,
+			kind: "multi-node",
+			confidence: "high",
+			reason: `${sortedFiles.length} modules form a re-export cycle — refactor consumers to import from the leaf module instead of the barrel`
+		});
+	}
+	findings.sort((firstFinding, secondFinding) => firstFinding.files[0].localeCompare(secondFinding.files[0]));
+	return findings;
+};
+/**
+* Iterative Tarjan's SCC. Singleton components are returned too so the
+* caller can distinguish a real self-loop from a node with no edges.
+*/
+const computeStronglyConnectedComponents = (adjacency) => {
+	const nodeCount = adjacency.length;
+	if (nodeCount === 0) return [];
+	const indices = new Array(nodeCount).fill(-1);
+	const lowLinks = new Array(nodeCount).fill(0);
+	const onStack = new Array(nodeCount).fill(false);
+	const tarjanStack = [];
+	const components = [];
+	let nextIndex = 0;
+	for (let startNode = 0; startNode < nodeCount; startNode++) {
+		if (indices[startNode] !== -1) continue;
+		const dfsStack = [{
+			node: startNode,
+			successorPosition: 0
+		}];
+		indices[startNode] = nextIndex;
+		lowLinks[startNode] = nextIndex;
+		nextIndex++;
+		onStack[startNode] = true;
+		tarjanStack.push(startNode);
+		while (dfsStack.length > 0) {
+			const frame = dfsStack[dfsStack.length - 1];
+			const successors = adjacency[frame.node];
+			if (frame.successorPosition < successors.length) {
+				const successorNode = successors[frame.successorPosition];
+				frame.successorPosition++;
+				if (indices[successorNode] === -1) {
+					indices[successorNode] = nextIndex;
+					lowLinks[successorNode] = nextIndex;
+					nextIndex++;
+					onStack[successorNode] = true;
+					tarjanStack.push(successorNode);
+					dfsStack.push({
+						node: successorNode,
+						successorPosition: 0
+					});
+				} else if (onStack[successorNode]) {
+					if (indices[successorNode] < lowLinks[frame.node]) lowLinks[frame.node] = indices[successorNode];
+				}
+			} else {
+				if (lowLinks[frame.node] === indices[frame.node]) {
+					const component = [];
+					let popped;
+					do {
+						popped = tarjanStack.pop();
+						onStack[popped] = false;
+						component.push(popped);
+					} while (popped !== frame.node);
+					components.push(component);
+				}
+				dfsStack.pop();
+				if (dfsStack.length > 0) {
+					const parent = dfsStack[dfsStack.length - 1];
+					if (lowLinks[frame.node] < lowLinks[parent.node]) lowLinks[parent.node] = lowLinks[frame.node];
+				}
+			}
+		}
+	}
+	return components;
+};
+
+//#endregion
+//#region src/report/feature-flags.ts
+const BUILTIN_SDK_PATTERNS = [
+	{
+		functionName: "useFlag",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "useLDFlag",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "useFeatureFlag",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "variation",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "boolVariation",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "stringVariation",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "numberVariation",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "jsonVariation",
+		nameArgIndex: 0,
+		provider: "LaunchDarkly"
+	},
+	{
+		functionName: "useGate",
+		nameArgIndex: 0,
+		provider: "Statsig"
+	},
+	{
+		functionName: "checkGate",
+		nameArgIndex: 0,
+		provider: "Statsig"
+	},
+	{
+		functionName: "useExperiment",
+		nameArgIndex: 0,
+		provider: "Statsig"
+	},
+	{
+		functionName: "useConfig",
+		nameArgIndex: 0,
+		provider: "Statsig"
+	},
+	{
+		functionName: "isEnabled",
+		nameArgIndex: 0,
+		provider: "Unleash"
+	},
+	{
+		functionName: "getVariant",
+		nameArgIndex: 0,
+		provider: "Unleash"
+	},
+	{
+		functionName: "isOn",
+		nameArgIndex: 0,
+		provider: "GrowthBook"
+	},
+	{
+		functionName: "isOff",
+		nameArgIndex: 0,
+		provider: "GrowthBook"
+	},
+	{
+		functionName: "getFeatureValue",
+		nameArgIndex: 0,
+		provider: "GrowthBook"
+	},
+	{
+		functionName: "getTreatment",
+		nameArgIndex: 0,
+		provider: "Split"
+	},
+	{
+		functionName: "useFeatureFlagEnabled",
+		nameArgIndex: 0,
+		provider: "PostHog"
+	},
+	{
+		functionName: "useFeatureFlagPayload",
+		nameArgIndex: 0,
+		provider: "PostHog"
+	},
+	{
+		functionName: "useFeatureFlagVariantKey",
+		nameArgIndex: 0,
+		provider: "PostHog"
+	},
+	{
+		functionName: "getFeatureFlagPayload",
+		nameArgIndex: 0,
+		provider: "PostHog"
+	},
+	{
+		functionName: "getValueAsync",
+		nameArgIndex: 0,
+		provider: "ConfigCat"
+	},
+	{
+		functionName: "getValueDetailsAsync",
+		nameArgIndex: 0,
+		provider: "ConfigCat"
+	},
+	{
+		functionName: "hasFeature",
+		nameArgIndex: 0,
+		provider: "Flagsmith"
+	},
+	{
+		functionName: "useDecision",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariable",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariableBoolean",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariableString",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariableInteger",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariableDouble",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariableJson",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getFeatureVariableJSON",
+		nameArgIndex: 0,
+		provider: "Optimizely"
+	},
+	{
+		functionName: "getStringAssignment",
+		nameArgIndex: 0,
+		provider: "Eppo"
+	},
+	{
+		functionName: "getBooleanAssignment",
+		nameArgIndex: 0,
+		provider: "Eppo"
+	},
+	{
+		functionName: "getNumericAssignment",
+		nameArgIndex: 0,
+		provider: "Eppo"
+	},
+	{
+		functionName: "getIntegerAssignment",
+		nameArgIndex: 0,
+		provider: "Eppo"
+	},
+	{
+		functionName: "getJSONAssignment",
+		nameArgIndex: 0,
+		provider: "Eppo"
+	}
+];
+const VERCEL_FLAGS_FUNCTION_NAMES = new Set(["flag", "evaluate"]);
+const BUILTIN_ENV_PREFIXES = [
+	"FEATURE_",
+	"NEXT_PUBLIC_FEATURE_",
+	"NEXT_PUBLIC_ENABLE_",
+	"REACT_APP_FEATURE_",
+	"REACT_APP_ENABLE_",
+	"VITE_FEATURE_",
+	"VITE_ENABLE_",
+	"NUXT_PUBLIC_FEATURE_",
+	"ENABLE_",
+	"FF_",
+	"FLAG_",
+	"TOGGLE_"
+];
+const CONFIG_OBJECT_KEYWORDS = new Set([
+	"feature",
+	"features",
+	"featureflags",
+	"featureflag",
+	"flag",
+	"flags",
+	"toggle",
+	"toggles"
+]);
+const getStaticName = (node) => {
+	if (!isAstNode(node)) return void 0;
+	if (node.type === "Identifier" || node.type === "PrivateIdentifier") {
+		const identifierName = node.name;
+		return typeof identifierName === "string" ? identifierName : void 0;
+	}
+	if (node.type === "Literal") {
+		const literalValue = node.value;
+		return typeof literalValue === "string" ? literalValue : void 0;
+	}
+};
+const extractStringArgument = (callArguments, argumentIndex) => {
+	if (!Array.isArray(callArguments)) return void 0;
+	const argumentNode = callArguments[argumentIndex];
+	if (!isAstNode(argumentNode)) return void 0;
+	if (argumentNode.type === "Literal") {
+		const literalValue = argumentNode.value;
+		return typeof literalValue === "string" ? literalValue : void 0;
+	}
+	if (argumentNode.type === "ObjectExpression") {
+		const properties = argumentNode.properties;
+		if (!Array.isArray(properties)) return void 0;
+		for (const property of properties) {
+			if (!isAstNode(property)) continue;
+			if (property.type !== "Property") continue;
+			const propertyKey = getStaticName(property.key);
+			if (propertyKey !== "key" && propertyKey !== "name") continue;
+			const propertyValueName = getStaticName(property.value);
+			if (propertyValueName !== void 0) return propertyValueName;
+		}
+	}
+};
+const extractProcessEnvName = (memberExpression) => {
+	if (!isAstNode(memberExpression)) return void 0;
+	if (memberExpression.type !== "MemberExpression" && memberExpression.type !== "StaticMemberExpression") return;
+	const propertyName = getStaticName(memberExpression.property);
+	if (propertyName === void 0) return void 0;
+	const objectNode = memberExpression.object;
+	if (!isAstNode(objectNode)) return void 0;
+	if (objectNode.type !== "MemberExpression" && objectNode.type !== "StaticMemberExpression") return;
+	const innerObjectName = getStaticName(objectNode.object);
+	const innerPropertyName = getStaticName(objectNode.property);
+	if (innerObjectName === "process" && innerPropertyName === "env") return propertyName;
+};
+const isFlagEnvName = (envName, extraEnvPrefixes) => {
+	for (const prefix of BUILTIN_ENV_PREFIXES) if (envName.startsWith(prefix)) return true;
+	for (const prefix of extraEnvPrefixes) if (envName.startsWith(prefix)) return true;
+	return false;
+};
+const collectVercelFlagsImports = (programNode) => {
+	const localNames = /* @__PURE__ */ new Set();
+	if (!isAstNode(programNode)) return localNames;
+	const body = programNode.body;
+	if (!Array.isArray(body)) return localNames;
+	for (const statement of body) {
+		if (!isAstNode(statement)) continue;
+		if (statement.type !== "ImportDeclaration") continue;
+		const sourceLiteral = statement.source;
+		const sourceValue = isAstNode(sourceLiteral) ? sourceLiteral.value : void 0;
+		if (typeof sourceValue !== "string") continue;
+		if (!(sourceValue === "flags" || sourceValue.startsWith("flags/") || sourceValue === "@vercel/flags" || sourceValue.startsWith("@vercel/flags/"))) continue;
+		const specifiers = statement.specifiers;
+		if (!Array.isArray(specifiers)) continue;
+		for (const specifier of specifiers) {
+			if (!isAstNode(specifier)) continue;
+			if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported;
+				const local = specifier.local;
+				const importedName = getStaticName(imported);
+				const localName = getStaticName(local);
+				if (importedName && VERCEL_FLAGS_FUNCTION_NAMES.has(importedName) && localName) localNames.add(localName);
+			}
+		}
+	}
+	return localNames;
+};
+const visitChildrenWithGuard = (node, visitor) => {
+	if (!isAstNode(node)) return;
+	for (const key of Object.keys(node)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+		const value = node[key];
+		if (Array.isArray(value)) for (const item of value) visitor(item);
+		else if (value !== null && typeof value === "object") visitor(value);
+	}
+};
+const recordFlag = (context, flagName, kind, byteOffset, sdkProvider) => {
+	const { line, column } = offsetToLineColumn(byteOffset, context.lineStarts);
+	context.results.push({
+		path: context.filePath,
+		name: flagName,
+		kind,
+		line,
+		column,
+		sdkProvider,
+		guardLineStart: context.guard?.startLine,
+		guardLineEnd: context.guard?.endLine,
+		guardsDeadCode: false
+	});
+};
+const visitNode$1 = (node, context) => {
+	if (!isAstNode(node)) return;
+	if (node.type === "IfStatement") {
+		const start = node.start;
+		const end = node.end;
+		const guard = typeof start === "number" && typeof end === "number" ? {
+			startLine: offsetToLineColumn(start, context.lineStarts).line,
+			endLine: offsetToLineColumn(end, context.lineStarts).line
+		} : void 0;
+		const previousGuard = context.guard;
+		context.guard = guard;
+		visitNode$1(node.test, context);
+		context.guard = previousGuard;
+		visitNode$1(node.consequent, context);
+		visitNode$1(node.alternate, context);
+		return;
+	}
+	if (node.type === "ConditionalExpression") {
+		const start = node.start;
+		const end = node.end;
+		const guard = typeof start === "number" && typeof end === "number" ? {
+			startLine: offsetToLineColumn(start, context.lineStarts).line,
+			endLine: offsetToLineColumn(end, context.lineStarts).line
+		} : void 0;
+		const previousGuard = context.guard;
+		context.guard = guard;
+		visitNode$1(node.test, context);
+		context.guard = previousGuard;
+		visitNode$1(node.consequent, context);
+		visitNode$1(node.alternate, context);
+		return;
+	}
+	visitFlagPatternsInExpression(node, context);
+	visitChildrenWithGuard(node, (child) => visitNode$1(child, context));
+};
+const visitFlagPatternsInExpression = (node, context) => {
+	if (!isAstNode(node)) return;
+	if (node.type === "MemberExpression" || node.type === "StaticMemberExpression") {
+		const envName = extractProcessEnvName(node);
+		if (envName !== void 0 && isFlagEnvName(envName, context.envPrefixes)) {
+			const start = node.start;
+			if (typeof start === "number") recordFlag(context, envName, "env-var", start, void 0);
+		} else if (context.detectConfigObjects) {
+			const objectName = getStaticName(node.object);
+			const propertyName = getStaticName(node.property);
+			if (objectName && propertyName) {
+				if (CONFIG_OBJECT_KEYWORDS.has(objectName.toLowerCase()) || CONFIG_OBJECT_KEYWORDS.has(propertyName.toLowerCase())) {
+					const start = node.start;
+					if (typeof start === "number") recordFlag(context, `${objectName}.${propertyName}`, "config-object", start, void 0);
+				}
+			}
+		}
+	}
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		let functionName;
+		if (isAstNode(callee)) {
+			if (callee.type === "Identifier") functionName = getStaticName(callee);
+			else if (callee.type === "MemberExpression" || callee.type === "StaticMemberExpression") functionName = getStaticName(callee.property);
+		}
+		if (functionName !== void 0) {
+			if (context.vercelFlagsLocalNames.has(functionName) || VERCEL_FLAGS_FUNCTION_NAMES.has(functionName)) {
+				const callArguments = node.arguments;
+				const flagName = extractStringArgument(callArguments, 0);
+				if (flagName !== void 0) {
+					const start = node.start;
+					if (typeof start === "number") recordFlag(context, flagName, "sdk-call", start, "Vercel Flags");
+				}
+				return;
+			}
+			for (const sdkPattern of context.sdkPatterns) {
+				if (sdkPattern.functionName !== functionName) continue;
+				const callArguments = node.arguments;
+				const flagName = extractStringArgument(callArguments, sdkPattern.nameArgIndex);
+				if (flagName === void 0) continue;
+				const start = node.start;
+				if (typeof start === "number") recordFlag(context, flagName, "sdk-call", start, sdkPattern.provider === "" ? void 0 : sdkPattern.provider);
+				break;
+			}
+		}
+	}
+};
+const buildSdkPatterns = (extraSdkFunctionNames) => {
+	const merged = [...BUILTIN_SDK_PATTERNS];
+	for (const extraName of extraSdkFunctionNames) merged.push({
+		functionName: extraName,
+		nameArgIndex: 0,
+		provider: ""
+	});
+	return merged;
+};
+const detectFeatureFlags = (graph, config) => {
+	if (!config?.enabled) return [];
+	const sdkPatterns = buildSdkPatterns(config.extraSdkFunctionNames);
+	const collectedFlags = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		if (module.isConfigFile) continue;
+		let sourceText;
+		try {
+			sourceText = (0, node_fs.readFileSync)(module.fileId.path, "utf-8");
+		} catch {
+			continue;
+		}
+		let parseResult;
+		try {
+			parseResult = (0, oxc_parser.parseSync)(module.fileId.path, sourceText);
+		} catch {
+			continue;
+		}
+		const lineStarts = computeLineStarts(sourceText);
+		const vercelFlagsLocalNames = collectVercelFlagsImports(parseResult.program);
+		const visitContext = {
+			filePath: module.fileId.path,
+			lineStarts,
+			results: [],
+			envPrefixes: config.extraEnvPrefixes,
+			sdkPatterns,
+			detectConfigObjects: config.detectConfigObjects,
+			vercelFlagsLocalNames,
+			guard: void 0
+		};
+		visitNode$1(parseResult.program, visitContext);
+		collectedFlags.push(...visitContext.results);
+	}
+	collectedFlags.sort((leftFlag, rightFlag) => {
+		if (leftFlag.path !== rightFlag.path) return leftFlag.path.localeCompare(rightFlag.path);
+		if (leftFlag.line !== rightFlag.line) return leftFlag.line - rightFlag.line;
+		return leftFlag.column - rightFlag.column;
+	});
+	return collectedFlags;
+};
+/**
+* Mark each flag whose guard span overlaps an unused export as
+* `guardsDeadCode: true`.
+*/
+const correlateFlagsWithDeadCode = (flags, scanResult) => {
+	if (flags.length === 0 || scanResult.unusedExports.length === 0) return;
+	const unusedByFile = /* @__PURE__ */ new Map();
+	for (const unusedExport of scanResult.unusedExports) {
+		const existing = unusedByFile.get(unusedExport.path);
+		if (existing) existing.push(unusedExport.line);
+		else unusedByFile.set(unusedExport.path, [unusedExport.line]);
+	}
+	for (const flag of flags) {
+		if (flag.guardLineStart === void 0 || flag.guardLineEnd === void 0) continue;
+		const linesInFile = unusedByFile.get(flag.path);
+		if (!linesInFile) continue;
+		const guardStart = flag.guardLineStart;
+		const guardEnd = flag.guardLineEnd;
+		for (const unusedLine of linesInFile) if (unusedLine >= guardStart && unusedLine <= guardEnd) {
+			flag.guardsDeadCode = true;
+			break;
+		}
+	}
+};
+
+//#endregion
+//#region src/report/complexity.ts
+const incrementCyclomatic = (state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (topFrame) topFrame.cyclomaticComplexity++;
+};
+const incrementCognitiveWithNesting = (state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (topFrame) topFrame.cognitiveComplexity += 1 + topFrame.nestingLevel;
+};
+const incrementCognitiveFlat = (state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (topFrame) topFrame.cognitiveComplexity++;
+};
+const handleLogicalOperator = (operator, state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (!topFrame) return;
+	if (topFrame.lastLogicalOperator === void 0) {
+		topFrame.cognitiveComplexity++;
+		topFrame.lastLogicalOperator = operator;
+		return;
+	}
+	if (topFrame.lastLogicalOperator === operator) return;
+	topFrame.cognitiveComplexity++;
+	topFrame.lastLogicalOperator = operator;
+};
+const resetLogicalOperator = (state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (topFrame) topFrame.lastLogicalOperator = void 0;
+};
+const incrementNesting = (state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (topFrame) topFrame.nestingLevel++;
+};
+const decrementNesting = (state) => {
+	const topFrame = state.frameStack[state.frameStack.length - 1];
+	if (topFrame && topFrame.nestingLevel > 0) topFrame.nestingLevel--;
+};
+const countParameters = (parametersNode) => {
+	if (!isAstNode(parametersNode)) return 0;
+	const params = parametersNode;
+	if (Array.isArray(params.params)) return params.params.length;
+	if (Array.isArray(params.items)) return params.items.length;
+	return 0;
+};
+const visitChildrenGeneric = (node, visitor) => {
+	if (!isAstNode(node)) return;
+	for (const key of Object.keys(node)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+		const value = node[key];
+		if (Array.isArray(value)) for (const item of value) visitor(item);
+		else if (value !== null && typeof value === "object") visitor(value);
+	}
+};
+const pushFunctionFrame = (functionName, startOffset, endOffset, parameterCount, state) => {
+	state.frameStack.push({
+		functionName,
+		startOffset,
+		endOffset,
+		cyclomaticComplexity: 1,
+		cognitiveComplexity: 0,
+		nestingLevel: 0,
+		lastLogicalOperator: void 0,
+		parameterCount
+	});
+};
+const popFunctionFrame = (state) => {
+	const completedFrame = state.frameStack.pop();
+	if (!completedFrame) return;
+	const { line, column } = offsetToLineColumn(completedFrame.startOffset, state.lineStarts);
+	const endLine = offsetToLineColumn(completedFrame.endOffset, state.lineStarts).line;
+	state.results.push({
+		path: state.filePath,
+		functionName: completedFrame.functionName,
+		line,
+		column,
+		cyclomatic: completedFrame.cyclomaticComplexity,
+		cognitive: completedFrame.cognitiveComplexity,
+		lineCount: Math.max(1, endLine - line + 1),
+		paramCount: completedFrame.parameterCount,
+		confidence: "medium",
+		reason: ""
+	});
+};
+const visitFunctionLike = (node, kind, state) => {
+	if (!isAstNode(node)) return;
+	const functionName = state.pendingFunctionName ?? (() => {
+		const idNode = node.id;
+		const idName = isAstNode(idNode) ? idNode.name : void 0;
+		return typeof idName === "string" ? idName : kind === "arrow" ? "<arrow>" : "<anonymous>";
+	})();
+	state.pendingFunctionName = void 0;
+	const isNested = state.frameStack.length > 0;
+	if (isNested) incrementNesting(state);
+	const startOffset = node.start;
+	const endOffset = node.end;
+	const parameterCount = countParameters(node.params);
+	pushFunctionFrame(functionName, typeof startOffset === "number" ? startOffset : 0, typeof endOffset === "number" ? endOffset : 0, parameterCount, state);
+	visitChildrenGeneric(node, (child) => visitNode(child, state));
+	popFunctionFrame(state);
+	if (isNested) decrementNesting(state);
+};
+const visitNode = (node, state) => {
+	if (!isAstNode(node)) return;
+	switch (node.type) {
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "MethodDefinition":
+			if (node.type === "MethodDefinition") {
+				const keyNode = node.key;
+				const keyName = isAstNode(keyNode) ? keyNode.name ?? keyNode.value : void 0;
+				if (typeof keyName === "string") state.pendingFunctionName = keyName;
+				visitChildrenGeneric(node, (child) => visitNode(child, state));
+				state.pendingFunctionName = void 0;
+				return;
+			}
+			visitFunctionLike(node, "function", state);
+			return;
+		case "ArrowFunctionExpression":
+			visitFunctionLike(node, "arrow", state);
+			return;
+		case "VariableDeclarator": {
+			const declaratorId = node.id;
+			const declaratorIdName = isAstNode(declaratorId) ? declaratorId.name : void 0;
+			if (typeof declaratorIdName === "string") state.pendingFunctionName = declaratorIdName;
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			state.pendingFunctionName = void 0;
+			return;
+		}
+		case "PropertyDefinition": {
+			const keyNode = node.key;
+			const keyName = isAstNode(keyNode) ? keyNode.name : void 0;
+			if (typeof keyName === "string") state.pendingFunctionName = keyName;
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			state.pendingFunctionName = void 0;
+			return;
+		}
+		case "IfStatement":
+			incrementCyclomatic(state);
+			incrementCognitiveWithNesting(state);
+			incrementNesting(state);
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			decrementNesting(state);
+			resetLogicalOperator(state);
+			return;
+		case "ForStatement":
+		case "ForInStatement":
+		case "ForOfStatement":
+		case "WhileStatement":
+		case "DoWhileStatement":
+			incrementCyclomatic(state);
+			incrementCognitiveWithNesting(state);
+			incrementNesting(state);
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			decrementNesting(state);
+			return;
+		case "SwitchCase": {
+			const testNode = node.test;
+			if (testNode !== null && testNode !== void 0) {
+				incrementCyclomatic(state);
+				incrementCognitiveFlat(state);
+			}
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			return;
+		}
+		case "CatchClause":
+			incrementCyclomatic(state);
+			incrementCognitiveWithNesting(state);
+			incrementNesting(state);
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			decrementNesting(state);
+			return;
+		case "ConditionalExpression":
+			incrementCyclomatic(state);
+			incrementCognitiveWithNesting(state);
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			return;
+		case "LogicalExpression": {
+			const operator = node.operator;
+			if (operator === "&&" || operator === "||" || operator === "??") {
+				incrementCyclomatic(state);
+				handleLogicalOperator(operator, state);
+			}
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			return;
+		}
+		case "AssignmentExpression": {
+			const operator = node.operator;
+			if (operator === "&&=" || operator === "||=" || operator === "??=") incrementCyclomatic(state);
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			return;
+		}
+		case "ChainExpression":
+			incrementCyclomatic(state);
+			visitChildrenGeneric(node, (child) => visitNode(child, state));
+			return;
+		default: visitChildrenGeneric(node, (child) => visitNode(child, state));
+	}
+};
+const annotateConfidence = (finding, config) => {
+	const breaches = [];
+	if (finding.cyclomatic >= config.cyclomaticThreshold) breaches.push(`cyclomatic ${finding.cyclomatic} ≥ ${config.cyclomaticThreshold}`);
+	if (finding.cognitive >= config.cognitiveThreshold) breaches.push(`cognitive ${finding.cognitive} ≥ ${config.cognitiveThreshold}`);
+	if (finding.paramCount >= config.paramCountThreshold) breaches.push(`paramCount ${finding.paramCount} ≥ ${config.paramCountThreshold}`);
+	if (finding.lineCount >= config.functionLineThreshold) breaches.push(`lineCount ${finding.lineCount} ≥ ${config.functionLineThreshold}`);
+	return {
+		confidence: breaches.length >= 2 ? "high" : "medium",
+		reason: `${finding.functionName} breaches ${breaches.length} threshold${breaches.length === 1 ? "" : "s"}: ${breaches.join(", ")}`
+	};
+};
+/**
+* Per-function cyclomatic + cognitive complexity.
+*
+* Cyclomatic (McCabe): 1 + decision points. Counts if/for/while/do/case/catch,
+* the ?: ternary, &&, ||, ??, &&=/||=/??=, and ?. (optional chaining).
+*
+* Cognitive (SonarSource): structural increments with nesting penalty.
+* Operator-sequence rule: a run of the same logical operator is +1 total;
+* each operator change adds another +1.
+*
+* Returns only functions whose metrics breach at least one threshold from
+* `config`. Threshold breach count tunes the `confidence` field.
+*/
+const detectComplexHotspots = (graph, config) => {
+	if (!config?.enabled) return [];
+	const hotspotFindings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		if (module.isConfigFile) continue;
+		let sourceText;
+		try {
+			sourceText = (0, node_fs.readFileSync)(module.fileId.path, "utf-8");
+		} catch {
+			continue;
+		}
+		let parseResult;
+		try {
+			parseResult = (0, oxc_parser.parseSync)(module.fileId.path, sourceText);
+		} catch {
+			continue;
+		}
+		const visitState = {
+			filePath: module.fileId.path,
+			lineStarts: computeLineStarts(sourceText),
+			results: [],
+			frameStack: [],
+			pendingFunctionName: void 0
+		};
+		visitNode(parseResult.program, visitState);
+		for (const result of visitState.results) {
+			if (!(result.cyclomatic >= config.cyclomaticThreshold || result.cognitive >= config.cognitiveThreshold || result.paramCount >= config.paramCountThreshold || result.lineCount >= config.functionLineThreshold)) continue;
+			const annotated = annotateConfidence(result, config);
+			hotspotFindings.push({
+				...result,
+				confidence: annotated.confidence,
+				reason: annotated.reason
+			});
+		}
+	}
+	hotspotFindings.sort((leftFinding, rightFinding) => {
+		const leftScore = leftFinding.cyclomatic + leftFinding.cognitive;
+		const rightScore = rightFinding.cyclomatic + rightFinding.cognitive;
+		if (leftScore !== rightScore) return rightScore - leftScore;
+		if (leftFinding.path !== rightFinding.path) return leftFinding.path.localeCompare(rightFinding.path);
+		return leftFinding.line - rightFinding.line;
+	});
+	return hotspotFindings;
+};
+
+//#endregion
+//#region src/report/private-type-leaks.ts
+const extractIdentifierName = (node) => {
+	if (!isAstNode(node)) return void 0;
+	if (node.type === "Identifier") {
+		const identifierName = node.name;
+		return typeof identifierName === "string" ? identifierName : void 0;
+	}
+};
+const collectTypeReferenceNamesFromTypeNode = (typeNode, into) => {
+	if (!isAstNode(typeNode)) return;
+	if (typeNode.type === "TSTypeReference") {
+		const referencedTypeName = typeNode.typeName;
+		if (isAstNode(referencedTypeName) && referencedTypeName.type === "Identifier") {
+			const name = referencedTypeName.name;
+			if (typeof name === "string") into.add(name);
+		}
+	}
+	for (const key of Object.keys(typeNode)) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const value = typeNode[key];
+		if (Array.isArray(value)) for (const item of value) collectTypeReferenceNamesFromTypeNode(item, into);
+		else if (value !== null && typeof value === "object") collectTypeReferenceNamesFromTypeNode(value, into);
+	}
+};
+const isExportedDeclaration = (statement) => {
+	if (!isAstNode(statement)) return false;
+	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration";
+};
+const declarationOf = (statement) => {
+	if (!isAstNode(statement)) return void 0;
+	return statement.declaration;
+};
+const exportedNameOfDeclaration = (declarationNode) => {
+	if (!isAstNode(declarationNode)) return void 0;
+	if (declarationNode.type === "FunctionDeclaration" || declarationNode.type === "ClassDeclaration") return extractIdentifierName(declarationNode.id);
+	if (declarationNode.type === "VariableDeclaration") {
+		const declarators = declarationNode.declarations;
+		if (Array.isArray(declarators) && declarators.length > 0) {
+			const firstDeclarator = declarators[0];
+			if (isAstNode(firstDeclarator)) return extractIdentifierName(firstDeclarator.id);
+		}
+	}
+	if (declarationNode.type === "TSInterfaceDeclaration" || declarationNode.type === "TSTypeAliasDeclaration") return extractIdentifierName(declarationNode.id);
+};
+const collectFromFunctionLikeSignature = (functionLikeNode, exportName, collected) => {
+	if (!isAstNode(functionLikeNode)) return;
+	const params = functionLikeNode.params;
+	if (Array.isArray(params)) for (const param of params) collectFromParameter(param, exportName, collected);
+	const returnTypeAnnotation = functionLikeNode.returnType;
+	if (isAstNode(returnTypeAnnotation)) {
+		const annotation = returnTypeAnnotation.typeAnnotation;
+		pushTypeReferences(annotation, exportName, collected, returnTypeAnnotation);
+	}
+};
+const collectFromParameter = (parameterNode, exportName, collected) => {
+	if (!isAstNode(parameterNode)) return;
+	const annotation = parameterNode.typeAnnotation;
+	if (isAstNode(annotation)) {
+		const innerTypeNode = annotation.typeAnnotation;
+		pushTypeReferences(innerTypeNode, exportName, collected, annotation);
+	}
+};
+const pushTypeReferences = (typeNode, exportName, collected, spanFallbackNode) => {
+	if (!isAstNode(typeNode)) return;
+	const referencedTypeNames = /* @__PURE__ */ new Set();
+	collectTypeReferenceNamesFromTypeNode(typeNode, referencedTypeNames);
+	for (const referencedName of referencedTypeNames) {
+		const offset = typeNode.start;
+		const fallbackOffset = isAstNode(spanFallbackNode) && typeof spanFallbackNode.start === "number" ? spanFallbackNode.start : 0;
+		collected.push({
+			exportName,
+			typeName: referencedName,
+			byteOffset: typeof offset === "number" ? offset : fallbackOffset
+		});
+	}
+};
+const collectPublicSignatureReferences = (programNode) => {
+	const collected = [];
+	if (!isAstNode(programNode)) return collected;
+	const programBody = programNode.body;
+	if (!Array.isArray(programBody)) return collected;
+	for (const statement of programBody) {
+		if (!isExportedDeclaration(statement)) continue;
+		const declarationNode = declarationOf(statement);
+		if (declarationNode === void 0 || declarationNode === null) continue;
+		const exportedName = exportedNameOfDeclaration(declarationNode);
+		if (!exportedName) continue;
+		if (isAstNode(declarationNode)) {
+			if (declarationNode.type === "FunctionDeclaration" || declarationNode.type === "ArrowFunctionExpression" || declarationNode.type === "FunctionExpression") {
+				collectFromFunctionLikeSignature(declarationNode, exportedName, collected);
+				continue;
+			}
+			if (declarationNode.type === "VariableDeclaration") {
+				const declarators = declarationNode.declarations;
+				if (Array.isArray(declarators)) for (const declarator of declarators) {
+					if (!isAstNode(declarator)) continue;
+					const id = declarator.id;
+					if (isAstNode(id)) {
+						const annotation = id.typeAnnotation;
+						if (isAstNode(annotation)) {
+							const inner = annotation.typeAnnotation;
+							pushTypeReferences(inner, exportedName, collected, annotation);
+						}
+					}
+					const init = declarator.init;
+					if (isAstNode(init) && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) collectFromFunctionLikeSignature(init, exportedName, collected);
+				}
+				continue;
+			}
+			if (declarationNode.type === "ClassDeclaration") {
+				const classBody = declarationNode.body;
+				if (isAstNode(classBody)) {
+					const members = classBody.body;
+					if (Array.isArray(members)) for (const member of members) {
+						if (!isAstNode(member)) continue;
+						if (member.type === "MethodDefinition") {
+							const value = member.value;
+							collectFromFunctionLikeSignature(value, exportedName, collected);
+						} else if (member.type === "PropertyDefinition") {
+							const annotation = member.typeAnnotation;
+							if (isAstNode(annotation)) {
+								const inner = annotation.typeAnnotation;
+								pushTypeReferences(inner, exportedName, collected, annotation);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return collected;
+};
+const collectLocalTypeNames = (programNode) => {
+	const localTypeNames = /* @__PURE__ */ new Set();
+	const exportedNames = /* @__PURE__ */ new Set();
+	if (!isAstNode(programNode)) return {
+		localTypeNames,
+		exportedNames
+	};
+	const programBody = programNode.body;
+	if (!Array.isArray(programBody)) return {
+		localTypeNames,
+		exportedNames
+	};
+	for (const statement of programBody) {
+		if (!isAstNode(statement)) continue;
+		if (statement.type === "TSInterfaceDeclaration" || statement.type === "TSTypeAliasDeclaration") {
+			const name = extractIdentifierName(statement.id);
+			if (name) localTypeNames.add(name);
+			continue;
+		}
+		if (statement.type === "ExportNamedDeclaration") {
+			const declarationNode = statement.declaration;
+			if (isAstNode(declarationNode)) {
+				if (declarationNode.type === "TSInterfaceDeclaration" || declarationNode.type === "TSTypeAliasDeclaration") {
+					const name = extractIdentifierName(declarationNode.id);
+					if (name) exportedNames.add(name);
+					continue;
+				}
+				const declaredName = exportedNameOfDeclaration(declarationNode);
+				if (declaredName) exportedNames.add(declaredName);
+			}
+			const specifiers = statement.specifiers;
+			if (Array.isArray(specifiers)) for (const specifier of specifiers) {
+				if (!isAstNode(specifier)) continue;
+				if (specifier.type === "ExportSpecifier") {
+					const exported = specifier.exported;
+					const exportedNameValue = extractIdentifierName(exported);
+					if (exportedNameValue) exportedNames.add(exportedNameValue);
+				}
+			}
+		}
+	}
+	return {
+		localTypeNames,
+		exportedNames
+	};
+};
+/**
+* Storybook CSF3 convention: a story file declares
+*
+*   const meta = { ... } satisfies Meta<...>;
+*   export default meta;
+*   type Story = StoryObj<typeof meta>;
+*   export const Primary: Story = { ... };
+*
+* `Story` is intentionally a local alias — consumers don't import it; the
+* Storybook runtime reads the default export. Flagging this as a leak
+* produces near-100% false positives on Storybook codebases, so skip
+* `*.stories.{ts,tsx,js,jsx,mts,mjs,cts,cjs}` files entirely.
+*/
+const STORYBOOK_STORY_FILE_PATTERN = /\.stories\.(?:[cm]?ts|[cm]?js|tsx|jsx)$/;
+const isStorybookStoryFile = (filePath) => STORYBOOK_STORY_FILE_PATTERN.test(filePath);
+/**
+* Detect TypeScript "private type leak": an exported declaration's signature
+* references a type that was declared locally in the same module but is not
+* itself exported. Consumers of the export need that type to satisfy the
+* signature, but cannot import it.
+*
+* Skips declaration files (`.d.ts`) — they are pure type modules where this
+* pattern is the norm. Keeps it simple: doesn't try to chase aliased re-export
+* paths (deslop-js's broader resolver work covers that elsewhere); a leak
+* that's actually re-exported gets filtered out at the `exportedNames` set.
+*/
+const detectPrivateTypeLeaks = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		if (module.isConfigFile) continue;
+		if (!module.isReachable) continue;
+		if (isStorybookStoryFile(module.fileId.path)) continue;
+		let sourceText;
+		try {
+			sourceText = (0, node_fs.readFileSync)(module.fileId.path, "utf-8");
+		} catch {
+			continue;
+		}
+		let parseResult;
+		try {
+			parseResult = (0, oxc_parser.parseSync)(module.fileId.path, sourceText);
+		} catch {
+			continue;
+		}
+		const programNode = parseResult.program;
+		const { localTypeNames, exportedNames } = collectLocalTypeNames(programNode);
+		if (localTypeNames.size === 0) continue;
+		const publicSignatureReferences = collectPublicSignatureReferences(programNode);
+		if (publicSignatureReferences.length === 0) continue;
+		const lineStarts = computeLineStarts(sourceText);
+		const seenPairs = /* @__PURE__ */ new Set();
+		for (const reference of publicSignatureReferences) {
+			if (!localTypeNames.has(reference.typeName)) continue;
+			if (exportedNames.has(reference.typeName)) continue;
+			const pairKey = `${reference.exportName}::${reference.typeName}`;
+			if (seenPairs.has(pairKey)) continue;
+			seenPairs.add(pairKey);
+			const { line, column } = offsetToLineColumn(reference.byteOffset, lineStarts);
+			findings.push({
+				path: module.fileId.path,
+				exportName: reference.exportName,
+				typeName: reference.typeName,
+				line,
+				column,
+				confidence: "high",
+				reason: `${reference.exportName}'s signature references ${reference.typeName}, declared locally but not exported — consumers can't satisfy the type without importing it`
+			});
+		}
+	}
+	findings.sort((leftLeak, rightLeak) => {
+		if (leftLeak.path !== rightLeak.path) return leftLeak.path.localeCompare(rightLeak.path);
+		return leftLeak.line - rightLeak.line;
+	});
+	return findings;
+};
+
+//#endregion
+//#region src/report/typescript-smells.ts
+const parseSource = (filePath) => {
+	let sourceText;
+	try {
+		sourceText = (0, node_fs.readFileSync)(filePath, "utf-8");
+	} catch {
+		return;
+	}
+	let parseResult;
+	try {
+		parseResult = (0, oxc_parser.parseSync)(filePath, sourceText);
+	} catch {
+		return;
+	}
+	const rawComments = parseResult.comments;
+	const comments = Array.isArray(rawComments) ? rawComments.filter(isParsedSourceComment) : [];
+	return {
+		programNode: parseResult.program,
+		sourceText,
+		lineStarts: computeLineStarts(sourceText),
+		comments
+	};
+};
+const isParsedSourceComment = (candidate) => {
+	if (typeof candidate !== "object" || candidate === null) return false;
+	const fields = candidate;
+	return (fields.type === "Line" || fields.type === "Block") && typeof fields.value === "string" && typeof fields.start === "number" && typeof fields.end === "number";
+};
+const sliceSnippet = (sourceText, start, end) => {
+	const SNIPPET_BUDGET_CHARS = 80;
+	const raw = sourceText.slice(start, Math.min(end, start + SNIPPET_BUDGET_CHARS)).replace(/\s+/g, " ").trim();
+	return end - start > SNIPPET_BUDGET_CHARS ? `${raw}…` : raw;
+};
+const isAnyOrUnknownTypeAnnotation = (typeAnnotation) => {
+	if (!isAstNode(typeAnnotation)) return void 0;
+	if (typeAnnotation.type === "TSAnyKeyword") return "any";
+	if (typeAnnotation.type === "TSUnknownKeyword") return "unknown";
+};
+const isLiteralLikeNonNull = (expression) => {
+	if (!isAstNode(expression)) return false;
+	if (expression.type === "Literal") return expression.value !== null;
+	if (expression.type === "TemplateLiteral" || expression.type === "ArrayExpression" || expression.type === "ObjectExpression" || expression.type === "FunctionExpression" || expression.type === "ArrowFunctionExpression" || expression.type === "ClassExpression") return true;
+	return false;
+};
+const collectUnnecessaryAssertionsInNode = (node, filePath, sourceText, lineStarts, results) => {
+	if (!isAstNode(node)) return;
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+		const innerExpression = node.expression;
+		const typeAnnotation = node.typeAnnotation;
+		if (node.type === "TSAsExpression") {
+			const outerKind = isAnyOrUnknownTypeAnnotation(typeAnnotation);
+			if (outerKind === void 0 && isAstNode(innerExpression) && innerExpression.type === "TSAsExpression") {
+				const innerTypeAnnotation = innerExpression.typeAnnotation;
+				const innerKind = isAnyOrUnknownTypeAnnotation(innerTypeAnnotation);
+				if (innerKind !== void 0) pushAssertion(node, "redundant-double-assertion", `\`x as ${innerKind} as T\` first widens to ${innerKind} just to assert to T — drop the intermediate ${innerKind} and assert directly`, "if you must assert, write `x as T` directly", filePath, sourceText, lineStarts, results);
+			}
+			if (outerKind === "any") pushAssertion(node, "assertion-to-any", "`as any` opts out of TypeScript's type system — narrow to a specific type or use `unknown`", "replace `as any` with the actual type, or use `as unknown as T` only when you genuinely need to discard the inferred type", filePath, sourceText, lineStarts, results);
+		}
+	}
+	if (node.type === "TSTypeAssertion") pushAssertion(node, "angle-bracket-assertion", "`<T>x` style assertion is parsed as a JSX tag in `.tsx` and is deprecated in mixed-extension projects — prefer `x as T`", "rewrite `<T>x` as `x as T`", filePath, sourceText, lineStarts, results);
+	if (node.type === "TSNonNullExpression") {
+		const innerExpression = node.expression;
+		if (isAstNode(innerExpression) && innerExpression.type === "TSNonNullExpression") pushAssertion(node, "double-non-null", "`x!!` is the non-null assertion applied twice — the second `!` is always a no-op", "drop one of the `!` operators", filePath, sourceText, lineStarts, results);
+		else if (isLiteralLikeNonNull(innerExpression)) pushAssertion(node, "redundant-non-null-on-literal", "`!` after a literal / array / object / function expression is redundant — those values are never null", "remove the trailing `!`", filePath, sourceText, lineStarts, results);
+	}
+};
+const pushAssertion = (node, kind, reason, suggestion, filePath, sourceText, lineStarts, results) => {
+	if (!isAstNode(node)) return;
+	const startOffset = node.start;
+	const endOffset = node.end;
+	if (typeof startOffset !== "number" || typeof endOffset !== "number") return;
+	const { line, column } = offsetToLineColumn(startOffset, lineStarts);
+	const isHighConfidenceKind = kind === "double-non-null" || kind === "redundant-non-null-on-literal" || kind === "redundant-double-assertion";
+	results.push({
+		path: filePath,
+		kind,
+		snippet: sliceSnippet(sourceText, startOffset, endOffset),
+		line,
+		column,
+		confidence: isHighConfidenceKind ? "high" : "medium",
+		reason,
+		suggestion
+	});
+};
+const visitForUnnecessaryAssertions = (node, filePath, sourceText, lineStarts, results) => {
+	if (!isAstNode(node)) return;
+	collectUnnecessaryAssertionsInNode(node, filePath, sourceText, lineStarts, results);
+	for (const propertyKey of Object.keys(node)) {
+		if (propertyKey === "type" || propertyKey === "start" || propertyKey === "end" || propertyKey === "loc" || propertyKey === "range") continue;
+		const value = node[propertyKey];
+		if (Array.isArray(value)) for (const item of value) visitForUnnecessaryAssertions(item, filePath, sourceText, lineStarts, results);
+		else if (value !== null && typeof value === "object") visitForUnnecessaryAssertions(value, filePath, sourceText, lineStarts, results);
+	}
+};
+const importExpressionSpecifier = (importExpression) => {
+	if (!isAstNode(importExpression)) return void 0;
+	if (importExpression.type !== "ImportExpression") return void 0;
+	const sourceNode = importExpression.source;
+	if (!isAstNode(sourceNode)) return void 0;
+	if (sourceNode.type !== "Literal") return void 0;
+	const literalValue = sourceNode.value;
+	return typeof literalValue === "string" ? literalValue : void 0;
+};
+const findThenImportInExpressionStatement = (expressionNode) => {
+	if (!isAstNode(expressionNode)) return void 0;
+	if (expressionNode.type !== "CallExpression") return void 0;
+	const callee = expressionNode.callee;
+	if (!isAstNode(callee)) return void 0;
+	if (callee.type !== "MemberExpression" && callee.type !== "StaticMemberExpression") return void 0;
+	const propertyNode = callee.property;
+	const propertyName = isAstNode(propertyNode) ? propertyNode.name : void 0;
+	if (propertyName !== "then" && propertyName !== "catch" && propertyName !== "finally") return void 0;
+	const objectNode = callee.object;
+	const specifier = importExpressionSpecifier(objectNode);
+	if (specifier === void 0) return void 0;
+	return {
+		importExpression: objectNode,
+		specifier
+	};
+};
+const findAwaitImportInExpression = (expressionNode) => {
+	if (!isAstNode(expressionNode)) return void 0;
+	if (expressionNode.type !== "AwaitExpression") return void 0;
+	const argumentNode = expressionNode.argument;
+	const specifier = importExpressionSpecifier(argumentNode);
+	if (specifier === void 0) return void 0;
+	return {
+		importExpression: argumentNode,
+		specifier
+	};
+};
+const collectLazyImportsAtTopLevel = (programNode, filePath, lineStarts, results) => {
+	if (!isAstNode(programNode)) return;
+	const programBody = programNode.body;
+	if (!Array.isArray(programBody)) return;
+	for (const topLevelStatement of programBody) {
+		if (!isAstNode(topLevelStatement)) continue;
+		if (topLevelStatement.type === "VariableDeclaration") {
+			const declarators = topLevelStatement.declarations;
+			if (!Array.isArray(declarators)) continue;
+			for (const declarator of declarators) {
+				if (!isAstNode(declarator)) continue;
+				const initializer = declarator.init;
+				const awaitImport = findAwaitImportInExpression(initializer);
+				if (awaitImport) recordLazyImport(awaitImport, "top-level-await-import", filePath, lineStarts, results);
+			}
+			continue;
+		}
+		if (topLevelStatement.type === "ExpressionStatement") {
+			const innerExpression = topLevelStatement.expression;
+			const awaitImport = findAwaitImportInExpression(innerExpression);
+			if (awaitImport) {
+				recordLazyImport(awaitImport, "top-level-await-import", filePath, lineStarts, results);
+				continue;
+			}
+			const thenImport = findThenImportInExpressionStatement(innerExpression);
+			if (thenImport) recordLazyImport(thenImport, "top-level-then-import", filePath, lineStarts, results);
+		}
+	}
+};
+const recordLazyImport = (match, kind, filePath, lineStarts, results) => {
+	if (!isAstNode(match.importExpression)) return;
+	const startOffset = match.importExpression.start;
+	if (typeof startOffset !== "number") return;
+	const { line, column } = offsetToLineColumn(startOffset, lineStarts);
+	results.push({
+		path: filePath,
+		specifier: match.specifier,
+		kind,
+		line,
+		column,
+		confidence: kind === "top-level-await-import" ? "high" : "medium",
+		reason: kind === "top-level-await-import" ? `top-level \`await import("${match.specifier}")\` runs synchronously before the module finishes loading anyway — there is no laziness benefit, prefer a static \`import\`` : `top-level \`import("${match.specifier}").then(...)\` runs at module evaluation — prefer a static \`import\` and a regular function call unless the dynamic-import contract is intentional`
+	});
+};
+const buildPackageJsonTypeCache = () => {
+	const directoryToType = /* @__PURE__ */ new Map();
+	const resolveModuleType = (filePath) => {
+		let currentDirectory = (0, node_path.dirname)((0, node_path.resolve)(filePath));
+		const visitedDirectories = [];
+		while (true) {
+			visitedDirectories.push(currentDirectory);
+			const cached = directoryToType.get(currentDirectory);
+			if (cached !== void 0) {
+				for (const visitedDirectory of visitedDirectories) directoryToType.set(visitedDirectory, cached);
+				return cached;
+			}
+			const packageJsonPath = (0, node_path.join)(currentDirectory, "package.json");
+			if ((0, node_fs.existsSync)(packageJsonPath)) try {
+				const packageJson = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf-8"));
+				const moduleType = packageJson.type === "module" ? "module" : packageJson.type === "commonjs" ? "commonjs" : void 0;
+				for (const visitedDirectory of visitedDirectories) directoryToType.set(visitedDirectory, moduleType);
+				return moduleType;
+			} catch {
+				for (const visitedDirectory of visitedDirectories) directoryToType.set(visitedDirectory, void 0);
+				return;
+			}
+			const parentDirectory = (0, node_path.dirname)(currentDirectory);
+			if (parentDirectory === currentDirectory) {
+				for (const visitedDirectory of visitedDirectories) directoryToType.set(visitedDirectory, void 0);
+				return;
+			}
+			currentDirectory = parentDirectory;
+		}
+	};
+	return { resolveModuleType };
+};
+const isEsmFilePath = (filePath, typeCache) => {
+	if (filePath.endsWith(".mts") || filePath.endsWith(".mjs")) return true;
+	if (filePath.endsWith(".cts") || filePath.endsWith(".cjs")) return false;
+	return typeCache.resolveModuleType(filePath) === "module";
+};
+const collectCommonjsInEsm = (programNode, filePath, sourceText, lineStarts, results) => {
+	if (!isAstNode(programNode)) return;
+	visitForCommonjs(programNode, filePath, sourceText, lineStarts, results);
+};
+const visitForCommonjs = (node, filePath, sourceText, lineStarts, results) => {
+	if (!isAstNode(node)) return;
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		if (isAstNode(callee) && callee.type === "Identifier") {
+			if (callee.name === "require") {
+				const callArguments = node.arguments;
+				if (Array.isArray(callArguments) && callArguments.length > 0) {
+					const firstArgument = callArguments[0];
+					if (isAstNode(firstArgument) && firstArgument.type === "Literal" && typeof firstArgument.value === "string") {
+						const startOffset = node.start;
+						const endOffset = node.end;
+						if (typeof startOffset === "number" && typeof endOffset === "number") {
+							const { line, column } = offsetToLineColumn(startOffset, lineStarts);
+							results.push({
+								path: filePath,
+								kind: "require",
+								line,
+								column,
+								confidence: "high",
+								reason: "synchronous `require()` is unavailable in native ESM — use a static `import` or top-level `await import()`",
+								snippet: sliceSnippet(sourceText, startOffset, endOffset)
+							});
+						}
+					}
+				}
+			}
+		}
+	}
+	if (node.type === "AssignmentExpression") {
+		const leftSide = node.left;
+		if (isAstNode(leftSide)) {
+			if (leftSide.type === "MemberExpression" || leftSide.type === "StaticMemberExpression") {
+				const objectNode = leftSide.object;
+				const propertyNode = leftSide.property;
+				const objectName = isAstNode(objectNode) ? objectNode.name : void 0;
+				const propertyName = isAstNode(propertyNode) ? propertyNode.name : void 0;
+				if (objectName === "module" && propertyName === "exports") {
+					const startOffset = node.start;
+					const endOffset = node.end;
+					if (typeof startOffset === "number" && typeof endOffset === "number") {
+						const { line, column } = offsetToLineColumn(startOffset, lineStarts);
+						results.push({
+							path: filePath,
+							kind: "module-exports",
+							line,
+							column,
+							confidence: "high",
+							reason: "`module.exports = ...` is CommonJS — replace with `export default` or named `export` for ESM",
+							snippet: sliceSnippet(sourceText, startOffset, endOffset)
+						});
+					}
+				} else if (objectName === "exports") {
+					const startOffset = node.start;
+					const endOffset = node.end;
+					if (typeof startOffset === "number" && typeof endOffset === "number") {
+						const { line, column } = offsetToLineColumn(startOffset, lineStarts);
+						results.push({
+							path: filePath,
+							kind: "exports-assignment",
+							line,
+							column,
+							confidence: "high",
+							reason: "`exports.x = ...` is CommonJS — replace with a named `export` for ESM",
+							snippet: sliceSnippet(sourceText, startOffset, endOffset)
+						});
+					}
+				}
+			}
+		}
+	}
+	for (const propertyKey of Object.keys(node)) {
+		if (propertyKey === "type" || propertyKey === "start" || propertyKey === "end" || propertyKey === "loc" || propertyKey === "range") continue;
+		const value = node[propertyKey];
+		if (Array.isArray(value)) for (const item of value) visitForCommonjs(item, filePath, sourceText, lineStarts, results);
+		else if (value !== null && typeof value === "object") visitForCommonjs(value, filePath, sourceText, lineStarts, results);
+	}
+};
+const TS_IGNORE_LEADING = /^\s*@ts-ignore\b/;
+const TS_NOCHECK_LEADING = /^\s*@ts-nocheck\b/;
+const TS_EXPECT_ERROR_LEADING = /^\s*@ts-expect-error\b(.*)$/;
+const collectTypeScriptEscapeHatches = (comments, filePath, lineStarts, results) => {
+	for (const comment of comments) {
+		const commentBody = comment.type === "Block" ? comment.value.split("\n")[0] : comment.value;
+		if (TS_IGNORE_LEADING.test(commentBody)) {
+			pushEscapeHatch(comment.start, "ts-ignore", "`@ts-ignore` silently swallows the next line's type errors forever — use `@ts-expect-error` so the suppression breaks if the underlying error gets fixed", "rewrite as `@ts-expect-error <why this is okay>`", "high", filePath, lineStarts, results);
+			continue;
+		}
+		if (TS_NOCHECK_LEADING.test(commentBody)) {
+			pushEscapeHatch(comment.start, "ts-nocheck", "`@ts-nocheck` disables type checking for the entire file — fix the underlying types or scope the suppression to a specific line", "remove `@ts-nocheck` and address the underlying type errors, or use per-line `@ts-expect-error` with a justification", "medium", filePath, lineStarts, results);
+			continue;
+		}
+		const expectErrorMatch = commentBody.match(TS_EXPECT_ERROR_LEADING);
+		if (expectErrorMatch) {
+			if ((expectErrorMatch[1] ?? "").trim().length === 0) pushEscapeHatch(comment.start, "ts-expect-error-without-explanation", "`@ts-expect-error` should be followed by a comment explaining why the next line legitimately produces a type error", "add a short justification: `// @ts-expect-error: <why this is okay>`", "low", filePath, lineStarts, results);
+		}
+	}
+};
+const pushEscapeHatch = (commentStartOffset, kind, reason, suggestion, confidence, filePath, lineStarts, results) => {
+	const { line, column } = offsetToLineColumn(commentStartOffset, lineStarts);
+	results.push({
+		path: filePath,
+		kind,
+		line,
+		column,
+		confidence,
+		reason,
+		suggestion
+	});
+};
+const isTypeScriptOrJsFile = (filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".mts") || filePath.endsWith(".cts") || filePath.endsWith(".js") || filePath.endsWith(".jsx") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs");
+const isTypeScriptFileExtension = (filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".mts") || filePath.endsWith(".cts");
+const detectTypeScriptSmells = (graph) => {
+	const unnecessaryAssertions = [];
+	const lazyImportsAtTopLevel = [];
+	const commonjsInEsm = [];
+	const typeScriptEscapeHatches = [];
+	const packageJsonTypeCache = buildPackageJsonTypeCache();
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		const filePath = module.fileId.path;
+		if (!isTypeScriptOrJsFile(filePath)) continue;
+		const parsedSource = parseSource(filePath);
+		if (!parsedSource) continue;
+		if (isTypeScriptFileExtension(filePath)) {
+			visitForUnnecessaryAssertions(parsedSource.programNode, filePath, parsedSource.sourceText, parsedSource.lineStarts, unnecessaryAssertions);
+			collectTypeScriptEscapeHatches(parsedSource.comments, filePath, parsedSource.lineStarts, typeScriptEscapeHatches);
+		}
+		collectLazyImportsAtTopLevel(parsedSource.programNode, filePath, parsedSource.lineStarts, lazyImportsAtTopLevel);
+		if (isEsmFilePath(filePath, packageJsonTypeCache)) collectCommonjsInEsm(parsedSource.programNode, filePath, parsedSource.sourceText, parsedSource.lineStarts, commonjsInEsm);
+	}
+	unnecessaryAssertions.sort((leftFinding, rightFinding) => {
+		if (leftFinding.path !== rightFinding.path) return leftFinding.path.localeCompare(rightFinding.path);
+		return leftFinding.line - rightFinding.line;
+	});
+	lazyImportsAtTopLevel.sort((leftFinding, rightFinding) => {
+		if (leftFinding.path !== rightFinding.path) return leftFinding.path.localeCompare(rightFinding.path);
+		return leftFinding.line - rightFinding.line;
+	});
+	commonjsInEsm.sort((leftFinding, rightFinding) => {
+		if (leftFinding.path !== rightFinding.path) return leftFinding.path.localeCompare(rightFinding.path);
+		return leftFinding.line - rightFinding.line;
+	});
+	typeScriptEscapeHatches.sort((leftFinding, rightFinding) => {
+		if (leftFinding.path !== rightFinding.path) return leftFinding.path.localeCompare(rightFinding.path);
+		return leftFinding.line - rightFinding.line;
+	});
+	return {
+		unnecessaryAssertions,
+		lazyImportsAtTopLevel,
+		commonjsInEsm,
+		typeScriptEscapeHatches
+	};
+};
+
+//#endregion
+//#region src/utils/run-safe-detector.ts
+const runSafeDetector = (input) => {
+	try {
+		return input.detector();
+	} catch (caughtError) {
+		input.errorSink.push(new DetectorError({
+			module: input.module,
+			message: `${input.detectorName} threw ${input.contextDescription}`,
+			detail: describeUnknownError(caughtError)
+		}));
+		return input.fallback;
+	}
+};
+
+//#endregion
+//#region src/semantic/program.ts
+const failureFor = (reason, message, options = { rootDir: "" }) => {
+	return {
+		reason,
+		message,
+		error: new TypeScriptError({
+			code: {
+				"no-tsconfig": "tsconfig-not-found",
+				"tsconfig-parse-error": "tsconfig-parse-failed",
+				"program-creation-failed": "ts-program-creation-failed",
+				"too-many-files": "ts-program-too-large",
+				"typescript-load-failed": "ts-not-loadable"
+			}[reason],
+			severity: reason === "no-tsconfig" ? "info" : "warning",
+			message,
+			path: options.rootDir || void 0,
+			detail: options.detail
+		})
+	};
+};
+const findNearestTsconfig = (rootDir, explicitPath) => {
+	if (explicitPath) {
+		const absoluteExplicit = (0, node_path.resolve)(rootDir, explicitPath);
+		if ((0, node_fs.existsSync)(absoluteExplicit)) return absoluteExplicit;
+		return;
+	}
+	for (const candidateName of DEFAULT_SEMANTIC_TSCONFIG_NAMES) {
+		const candidatePath = (0, node_path.resolve)(rootDir, candidateName);
+		if ((0, node_fs.existsSync)(candidatePath)) return candidatePath;
+	}
+};
+const createSemanticContext = (rootDir, tsconfigPath) => {
+	const resolvedTsconfigPath = findNearestTsconfig(rootDir, tsconfigPath);
+	if (!resolvedTsconfigPath) return {
+		ok: false,
+		failure: failureFor("no-tsconfig", `No tsconfig found under ${rootDir}`, { rootDir })
+	};
+	let configFileContent;
+	try {
+		configFileContent = typescript.default.readConfigFile(resolvedTsconfigPath, typescript.default.sys.readFile);
+	} catch (readError) {
+		return {
+			ok: false,
+			failure: failureFor("tsconfig-parse-error", "ts.readConfigFile threw", {
+				rootDir: resolvedTsconfigPath,
+				detail: describeUnknownError(readError)
+			})
+		};
+	}
+	if (configFileContent.error) return {
+		ok: false,
+		failure: failureFor("tsconfig-parse-error", typescript.default.flattenDiagnosticMessageText(configFileContent.error.messageText, "\n"), { rootDir: resolvedTsconfigPath })
+	};
+	let parsedCommandLine;
+	try {
+		parsedCommandLine = typescript.default.parseJsonConfigFileContent(configFileContent.config, typescript.default.sys, (0, node_path.dirname)(resolvedTsconfigPath), {
+			noEmit: true,
+			skipLibCheck: true,
+			allowJs: true,
+			isolatedModules: false
+		}, resolvedTsconfigPath);
+	} catch (parseError) {
+		return {
+			ok: false,
+			failure: failureFor("tsconfig-parse-error", "ts.parseJsonConfigFileContent threw", {
+				rootDir: resolvedTsconfigPath,
+				detail: describeUnknownError(parseError)
+			})
+		};
+	}
+	if (parsedCommandLine.errors.length > 0) {
+		const fatalErrors = parsedCommandLine.errors.filter((diagnostic) => diagnostic.category === typescript.default.DiagnosticCategory.Error);
+		if (fatalErrors.length > 0 && parsedCommandLine.fileNames.length === 0) return {
+			ok: false,
+			failure: failureFor("tsconfig-parse-error", typescript.default.flattenDiagnosticMessageText(fatalErrors[0].messageText, "\n"), { rootDir: resolvedTsconfigPath })
+		};
+	}
+	if (parsedCommandLine.fileNames.length > 5e3) return {
+		ok: false,
+		failure: failureFor("too-many-files", `Project has ${parsedCommandLine.fileNames.length} files, exceeds SEMANTIC_MAX_PROGRAM_FILES=${SEMANTIC_MAX_PROGRAM_FILES}`, { rootDir: resolvedTsconfigPath })
+	};
+	try {
+		const program = typescript.default.createProgram({
+			rootNames: parsedCommandLine.fileNames,
+			options: parsedCommandLine.options,
+			projectReferences: parsedCommandLine.projectReferences
+		});
+		return {
+			ok: true,
+			context: {
+				program,
+				checker: program.getTypeChecker(),
+				rootSourceFiles: program.getSourceFiles().filter((sourceFile) => !sourceFile.isDeclarationFile || sourceFile.fileName.endsWith(".d.ts")),
+				tsconfigPath: resolvedTsconfigPath
+			}
+		};
+	} catch (programError) {
+		return {
+			ok: false,
+			failure: failureFor("program-creation-failed", "ts.createProgram threw", {
+				rootDir: resolvedTsconfigPath,
+				detail: describeUnknownError(programError)
+			})
+		};
+	}
+};
+
+//#endregion
+//#region src/semantic/references.ts
+const canonicalKeyForSymbol = (symbol) => {
+	return symbol.declarations?.[0] ?? symbol;
+};
+const isDeclarationNameIdentifier = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return false;
+	if ((typescript.default.isInterfaceDeclaration(parent) || typescript.default.isTypeAliasDeclaration(parent) || typescript.default.isClassDeclaration(parent) || typescript.default.isFunctionDeclaration(parent) || typescript.default.isEnumDeclaration(parent) || typescript.default.isModuleDeclaration(parent) || typescript.default.isVariableDeclaration(parent)) && parent.name === identifier) return true;
+	if (typescript.default.isEnumMember(parent) && parent.name === identifier) return true;
+	if (typescript.default.isPropertyDeclaration(parent) && parent.name === identifier) return true;
+	if (typescript.default.isMethodDeclaration(parent) && parent.name === identifier) return true;
+	if (typescript.default.isParameter(parent) && parent.name === identifier) return true;
+	if (typescript.default.isBindingElement(parent) && parent.name === identifier) return true;
+	return false;
+};
+const isExportSpecifierIdentifier = (identifier) => {
+	const parent = identifier.parent;
+	return Boolean(parent && typescript.default.isExportSpecifier(parent));
+};
+const isImportSpecifierIdentifier = (identifier) => {
+	const parent = identifier.parent;
+	if (!parent) return false;
+	return typescript.default.isImportSpecifier(parent) || typescript.default.isImportClause(parent) || typescript.default.isNamespaceImport(parent);
+};
+const isInTypeContext = (identifier) => {
+	let current = identifier.parent;
+	let depth = 0;
+	while (current && depth < 12) {
+		if (typescript.default.isTypeReferenceNode(current) || typescript.default.isTypeQueryNode(current) || typescript.default.isTypeAliasDeclaration(current) || typescript.default.isInterfaceDeclaration(current) || typescript.default.isHeritageClause(current) || typescript.default.isImportTypeNode(current) || typescript.default.isTypePredicateNode(current) || typescript.default.isTypeOperatorNode(current) || typescript.default.isTypeLiteralNode(current) || typescript.default.isIndexedAccessTypeNode(current) || typescript.default.isMappedTypeNode(current) || typescript.default.isConditionalTypeNode(current) || typescript.default.isInferTypeNode(current)) return true;
+		if (typescript.default.isExpressionStatement(current) || typescript.default.isBlock(current)) return false;
+		current = current.parent;
+		depth++;
+	}
+	return false;
+};
+const resolveSymbolForIdentifier = (identifier, checker) => {
+	let symbol;
+	try {
+		symbol = checker.getSymbolAtLocation(identifier);
+	} catch {
+		return;
+	}
+	if (!symbol) return void 0;
+	if (symbol.flags & typescript.default.SymbolFlags.Alias) try {
+		return checker.getAliasedSymbol(symbol);
+	} catch {
+		return symbol;
+	}
 	return symbol;
 };
 const visitJsDocNodes = (node, visit) => {
@@ -8915,6 +11320,55 @@ const detectUnusedEnumMembers = (graph, config, context, referenceIndex) => {
 	return findings;
 };
 
+//#endregion
+//#region src/utils/is-framework-lifecycle-method.ts
+/**
+* Methods invoked by-name by React / Angular runtimes. Static "no caller"
+* analysis can't see those call sites, so without this allowlist
+* `unusedClassMembers` would fire on every component.
+*/
+const FRAMEWORK_LIFECYCLE_METHODS = new Set([
+	"render",
+	"componentDidMount",
+	"componentDidUpdate",
+	"componentWillUnmount",
+	"shouldComponentUpdate",
+	"getSnapshotBeforeUpdate",
+	"getDerivedStateFromProps",
+	"getDerivedStateFromError",
+	"componentDidCatch",
+	"componentWillMount",
+	"componentWillReceiveProps",
+	"componentWillUpdate",
+	"UNSAFE_componentWillMount",
+	"UNSAFE_componentWillReceiveProps",
+	"UNSAFE_componentWillUpdate",
+	"getChildContext",
+	"contextType",
+	"ngOnInit",
+	"ngOnDestroy",
+	"ngOnChanges",
+	"ngDoCheck",
+	"ngAfterContentInit",
+	"ngAfterContentChecked",
+	"ngAfterViewInit",
+	"ngAfterViewChecked",
+	"ngAcceptInputType",
+	"canActivate",
+	"canDeactivate",
+	"canActivateChild",
+	"canMatch",
+	"resolve",
+	"intercept",
+	"transform",
+	"validate",
+	"registerOnChange",
+	"registerOnTouched",
+	"writeValue",
+	"setDisabledState"
+]);
+const isFrameworkLifecycleMethod = (name) => FRAMEWORK_LIFECYCLE_METHODS.has(name);
+
 //#endregion
 //#region src/semantic/unused-class-members.ts
 const isClassExported = (declaration) => {
@@ -9046,6 +11500,7 @@ const detectUnusedClassMembers = (graph, config, context, referenceIndex, decora
 			if (memberHasExternalReference(memberSymbol, referenceIndex)) continue;
 			const memberName = typescript.default.isIdentifier(member.name) ? member.name.text : member.name.getText(sourceFile);
 			if (overriddenMemberNames.has(memberName)) continue;
+			if (isFrameworkLifecycleMethod(memberName)) continue;
 			const { line: zeroIndexedLine, character: zeroIndexedColumn } = sourceFile.getLineAndCharacterOfPosition(member.getStart(sourceFile));
 			const line = zeroIndexedLine + 1;
 			const column = zeroIndexedColumn + 1;
@@ -9446,6 +11901,22 @@ const generateReport = (graph, config) => {
 	const simplifiableFunctions = config.reportRedundancy ? safeReportDetector("detectSimplifiableFunctions", () => detectSimplifiableFunctions(graph), [], errorSink) : [];
 	const simplifiableExpressions = config.reportRedundancy ? safeReportDetector("detectSimplifiableExpressions", () => detectSimplifiableExpressions(graph), [], errorSink) : [];
 	const duplicateConstants = config.reportRedundancy ? safeReportDetector("detectDuplicateConstants", () => detectDuplicateConstants(graph), [], errorSink) : [];
+	const crossFileDuplicateExports = config.reportRedundancy ? safeReportDetector("detectCrossFileDuplicateExports", () => detectCrossFileDuplicateExports(graph), [], errorSink) : [];
+	const duplicateBlockResult = safeReportDetector("detectDuplicateBlocks", () => detectDuplicateBlocks(graph, config.duplicateBlocks, config.rootDir), {
+		duplicateBlocks: [],
+		duplicateBlockClusters: [],
+		shadowedDirectoryPairs: []
+	}, errorSink);
+	const reExportCycles = safeReportDetector("detectReExportCycles", () => detectReExportCycles(graph), [], errorSink);
+	const featureFlags = safeReportDetector("detectFeatureFlags", () => detectFeatureFlags(graph, config.featureFlags), [], errorSink);
+	const complexFunctions = safeReportDetector("detectComplexHotspots", () => detectComplexHotspots(graph, config.complexity), [], errorSink);
+	const privateTypeLeaks = safeReportDetector("detectPrivateTypeLeaks", () => detectPrivateTypeLeaks(graph), [], errorSink);
+	const typeScriptSmellsResult = safeReportDetector("detectTypeScriptSmells", () => detectTypeScriptSmells(graph), {
+		unnecessaryAssertions: [],
+		lazyImportsAtTopLevel: [],
+		commonjsInEsm: [],
+		typeScriptEscapeHatches: []
+	}, errorSink);
 	let semanticResult;
 	try {
 		semanticResult = runSemanticAnalysis(graph, config);
@@ -9470,6 +11941,7 @@ const generateReport = (graph, config) => {
 		errorSink.push(semanticError);
 	}
 	const redundantAliases = config.reportRedundancy ? [...syntacticRedundantAliases, ...semanticResult.redundantAliases] : [];
+	if (featureFlags.length > 0) correlateFlagsWithDeadCode(featureFlags, { unusedExports });
 	const totalExports = graph.modules.reduce((exportCount, module) => exportCount + module.exports.filter((exportInfo) => !(exportInfo.name === "*" && exportInfo.isNamespaceReExport)).length, 0);
 	return {
 		unusedFiles,
@@ -9490,6 +11962,18 @@ const generateReport = (graph, config) => {
 		simplifiableFunctions,
 		simplifiableExpressions,
 		duplicateConstants,
+		crossFileDuplicateExports,
+		duplicateBlocks: duplicateBlockResult.duplicateBlocks,
+		duplicateBlockClusters: duplicateBlockResult.duplicateBlockClusters,
+		shadowedDirectoryPairs: duplicateBlockResult.shadowedDirectoryPairs,
+		reExportCycles,
+		featureFlags,
+		complexFunctions,
+		privateTypeLeaks,
+		unnecessaryAssertions: typeScriptSmellsResult.unnecessaryAssertions,
+		lazyImportsAtTopLevel: typeScriptSmellsResult.lazyImportsAtTopLevel,
+		commonjsInEsm: typeScriptSmellsResult.commonjsInEsm,
+		typeScriptEscapeHatches: typeScriptSmellsResult.typeScriptEscapeHatches,
 		analysisErrors: errorSink,
 		totalFiles: graph.modules.length,
 		totalExports,
@@ -9577,18 +12061,53 @@ const detectReactNative = (rootDir, workspacePackages) => {
 *
 * - `reportRedundancy: true` — on because redundancy findings are mostly
 *   high-signal and the detectors carry their own confidence tiers.
+*
+* - `duplicateBlocks: undefined` — token-based copy-paste detection (suffix
+*   array + LCP) is opt-in. It re-parses every source
+*   file to emit a token stream and adds significant runtime to the scan.
+*   Pass `duplicateBlocks: { enabled: true }` to turn it on.
 */
 const fillSemanticConfig = (semanticOverrides) => {
-	if (semanticOverrides === void 0) return void 0;
+	const overrides = semanticOverrides ?? {};
+	return {
+		enabled: overrides.enabled ?? true,
+		reportUnusedTypes: overrides.reportUnusedTypes ?? true,
+		reportUnusedEnumMembers: overrides.reportUnusedEnumMembers ?? true,
+		reportUnusedClassMembers: overrides.reportUnusedClassMembers ?? false,
+		reportRedundantVariableAliases: overrides.reportRedundantVariableAliases ?? true,
+		reportMisclassifiedDependencies: overrides.reportMisclassifiedDependencies ?? true,
+		reportRoundTripAliases: overrides.reportRoundTripAliases ?? true,
+		decoratorAllowlist: overrides.decoratorAllowlist ?? DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST
+	};
+};
+const fillDuplicateBlocksConfig = (duplicateBlocksOverrides) => {
+	const overrides = duplicateBlocksOverrides ?? {};
+	return {
+		enabled: overrides.enabled ?? true,
+		mode: overrides.mode ?? "semantic",
+		minTokens: overrides.minTokens ?? 50,
+		minLines: overrides.minLines ?? 5,
+		minOccurrences: overrides.minOccurrences ?? 2,
+		skipLocal: overrides.skipLocal ?? false
+	};
+};
+const fillFeatureFlagsConfig = (flagsOverrides) => {
+	const overrides = flagsOverrides ?? {};
+	return {
+		enabled: overrides.enabled ?? true,
+		extraEnvPrefixes: overrides.extraEnvPrefixes ?? [],
+		extraSdkFunctionNames: overrides.extraSdkFunctionNames ?? [],
+		detectConfigObjects: overrides.detectConfigObjects ?? false
+	};
+};
+const fillComplexityConfig = (complexityOverrides) => {
+	const overrides = complexityOverrides ?? {};
 	return {
-		enabled: semanticOverrides.enabled ?? false,
-		reportUnusedTypes: semanticOverrides.reportUnusedTypes ?? true,
-		reportUnusedEnumMembers: semanticOverrides.reportUnusedEnumMembers ?? true,
-		reportUnusedClassMembers: semanticOverrides.reportUnusedClassMembers ?? false,
-		reportRedundantVariableAliases: semanticOverrides.reportRedundantVariableAliases ?? true,
-		reportMisclassifiedDependencies: semanticOverrides.reportMisclassifiedDependencies ?? true,
-		reportRoundTripAliases: semanticOverrides.reportRoundTripAliases ?? true,
-		decoratorAllowlist: semanticOverrides.decoratorAllowlist ?? DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST
+		enabled: overrides.enabled ?? true,
+		cyclomaticThreshold: overrides.cyclomaticThreshold ?? 10,
+		cognitiveThreshold: overrides.cognitiveThreshold ?? 15,
+		paramCountThreshold: overrides.paramCountThreshold ?? 5,
+		functionLineThreshold: overrides.functionLineThreshold ?? 80
 	};
 };
 const defineConfig = (options) => ({
@@ -9600,7 +12119,10 @@ const defineConfig = (options) => ({
 	reportTypes: options.reportTypes ?? false,
 	includeEntryExports: options.includeEntryExports ?? false,
 	reportRedundancy: options.reportRedundancy ?? true,
-	semantic: fillSemanticConfig(options.semantic)
+	semantic: fillSemanticConfig(options.semantic),
+	duplicateBlocks: fillDuplicateBlocksConfig(options.duplicateBlocks),
+	featureFlags: fillFeatureFlagsConfig(options.featureFlags),
+	complexity: fillComplexityConfig(options.complexity)
 });
 const buildEmptyScanResult = (errors, elapsedMs) => ({
 	unusedFiles: [],
@@ -9621,6 +12143,18 @@ const buildEmptyScanResult = (errors, elapsedMs) => ({
 	simplifiableFunctions: [],
 	simplifiableExpressions: [],
 	duplicateConstants: [],
+	crossFileDuplicateExports: [],
+	duplicateBlocks: [],
+	duplicateBlockClusters: [],
+	shadowedDirectoryPairs: [],
+	reExportCycles: [],
+	featureFlags: [],
+	complexFunctions: [],
+	privateTypeLeaks: [],
+	unnecessaryAssertions: [],
+	lazyImportsAtTopLevel: [],
+	commonjsInEsm: [],
+	typeScriptEscapeHatches: [],
 	analysisErrors: errors,
 	totalFiles: 0,
 	totalExports: 0,