deslop-js 0.0.10 → 0.0.12

package/dist/index.cjs

@@ -35,6 +35,8 @@ let node_fs_promises = require("node:fs/promises");
 let oxc_parser = require("oxc-parser");
 let oxc_resolver = require("oxc-resolver");
 let minimatch = require("minimatch");
+let typescript = require("typescript");
+typescript = __toESM(typescript, 1);
 
 //#region src/constants.ts
 const DEFAULT_EXTENSIONS = [
@@ -292,6 +294,173 @@ const RESOLVER_EXTENSIONS = [
 	".graphql",
 	".gql"
 ];
+const SEMANTIC_MAX_PROGRAM_FILES = 5e3;
+const MAX_PARSE_FILE_SIZE_BYTES = 2e6;
+const MAX_ANALYSIS_ERRORS = 5e3;
+const MAX_ERROR_DETAIL_LENGTH = 1e3;
+const BINARY_DETECTION_SAMPLE_BYTES = 2048;
+const MINIFIED_DETECTION_MIN_BYTES = 5e3;
+/**
+* Numeric literals below 1000 are dominated by indices, counters, small
+* ranges, ports, percentages, and array sizes that coincide by accident
+* (every `MAX_RETRIES = 3` is not a duplicate of every `LIMIT = 3`).
+* 1000 admits real shared constants (timeouts in ms, byte sizes, polling
+* intervals) without producing the noise floor that smaller magnitudes do.
+* NOTE: even at 1000, the rule still produces medium-confidence false
+* positives when constants share a value coincidentally with different
+* names (e.g. `STEP_DELAY_MS` vs `MINIMUM_TOKENS`); the report explicitly
+* downgrades those to `confidence: "medium"`.
+*/
+const MIN_NUMERIC_LITERAL_MAGNITUDE_FOR_DUPLICATE = 1e3;
+const DEFAULT_SEMANTIC_DECORATOR_ALLOWLIST = [
+	"Component",
+	"Injectable",
+	"NgModule",
+	"Pipe",
+	"Directive",
+	"Controller",
+	"Module",
+	"Resolver",
+	"Query",
+	"Mutation",
+	"Get",
+	"Post",
+	"Put",
+	"Patch",
+	"Delete",
+	"Head",
+	"Options",
+	"All",
+	"Sse",
+	"WebSocketGateway",
+	"SubscribeMessage"
+];
+const DEFAULT_SEMANTIC_TSCONFIG_NAMES = [
+	"tsconfig.json",
+	"tsconfig.app.json",
+	"tsconfig.build.json",
+	"tsconfig.src.json",
+	"jsconfig.json"
+];
+
+//#endregion
+//#region src/errors.ts
+const truncateDetail = (text) => {
+	if (text.length <= 1e3) return text;
+	return `${text.slice(0, MAX_ERROR_DETAIL_LENGTH)}… [truncated ${text.length - MAX_ERROR_DETAIL_LENGTH} chars]`;
+};
+const describeUnknownError = (caughtValue) => {
+	let rawText;
+	if (caughtValue instanceof Error) rawText = caughtValue.message || caughtValue.name || "unknown error";
+	else if (typeof caughtValue === "string") rawText = caughtValue;
+	else try {
+		rawText = JSON.stringify(caughtValue);
+	} catch {
+		rawText = String(caughtValue);
+	}
+	return truncateDetail(rawText ?? "");
+};
+var DeslopError = class DeslopError extends Error {
+	constructor(input) {
+		super(input.message);
+		this.name = "DeslopError";
+		this.code = input.code;
+		this.module = input.module;
+		this.severity = input.severity ?? "warning";
+		if (input.path !== void 0) this.path = input.path;
+		if (input.detail !== void 0) this.detail = input.detail;
+	}
+	toJSON() {
+		const payload = {
+			name: this.name,
+			code: this.code,
+			module: this.module,
+			severity: this.severity,
+			message: this.message
+		};
+		if (this.path !== void 0) payload.path = this.path;
+		if (this.detail !== void 0) payload.detail = this.detail;
+		return payload;
+	}
+	static fromCaught(input) {
+		return new DeslopError({
+			code: input.code,
+			module: input.module,
+			severity: input.severity,
+			message: input.message,
+			path: input.path,
+			detail: describeUnknownError(input.caught)
+		});
+	}
+};
+var ConfigError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			code: input.code ?? "config-invalid",
+			module: "config",
+			severity: input.severity ?? "fatal"
+		});
+		this.name = "ConfigError";
+	}
+};
+var FileReadError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			module: "parse"
+		});
+		this.name = "FileReadError";
+	}
+};
+var ParseError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			module: "parse"
+		});
+		this.name = "ParseError";
+	}
+};
+var TypeScriptError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			module: "semantic"
+		});
+		this.name = "TypeScriptError";
+	}
+};
+var WorkspaceError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			module: "collect"
+		});
+		this.name = "WorkspaceError";
+	}
+};
+var ResolverError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			code: input.code ?? "resolver-init-failed",
+			module: "resolver",
+			severity: input.severity ?? "fatal"
+		});
+		this.name = "ResolverError";
+	}
+};
+var DetectorError = class extends DeslopError {
+	constructor(input) {
+		super({
+			...input,
+			code: input.code ?? "detector-failed",
+			module: input.module ?? "report"
+		});
+		this.name = "DetectorError";
+	}
+};
 
 //#endregion
 //#region src/utils/line-column.ts
@@ -309,6 +478,1070 @@ const getColumnFromOffset = (source, offset) => {
 	return column;
 };
 
+//#endregion
+//#region src/utils/extract-default-export-local-name.ts
+const extractIdentifierFromCallArguments = (expression) => {
+	if (expression.type !== "CallExpression") return void 0;
+	for (const argument of expression.arguments) {
+		if (argument.type === "Identifier" && argument.name) return argument.name;
+		if (argument.type === "CallExpression") {
+			const nestedName = extractIdentifierFromCallArguments(argument);
+			if (nestedName) return nestedName;
+		}
+	}
+	if (expression.callee.type === "CallExpression") return extractIdentifierFromCallArguments(expression.callee);
+};
+const extractDefaultExportLocalName = (declaration) => {
+	if (!declaration) return void 0;
+	if (declaration.type === "Identifier" && declaration.name) return declaration.name;
+	if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") return declaration.id?.name;
+	if (declaration.type === "CallExpression") return extractIdentifierFromCallArguments(declaration);
+};
+
+//#endregion
+//#region src/utils/detect-redundant-type-pattern.ts
+const isTypeNode = (value) => Boolean(value) && typeof value === "object" && typeof value.type === "string";
+const isEmptyTypeLiteral = (node) => {
+	if (node.type !== "TSTypeLiteral") return false;
+	const members = node.members;
+	return Array.isArray(members) && members.length === 0;
+};
+const typeReferenceName = (node) => {
+	if (node.type !== "TSTypeReference") return void 0;
+	const typeName = node.typeName;
+	if (!typeName || typeName.type !== "Identifier") return void 0;
+	return typeName.name;
+};
+const isKeyofOfType = (candidate, expectedReferenceName) => {
+	if (candidate.type !== "TSTypeOperator") return false;
+	if (candidate.operator !== "keyof") return false;
+	const operand = candidate.typeAnnotation;
+	if (!operand) return false;
+	return typeReferenceName(operand) === expectedReferenceName;
+};
+const isNeverKeyword = (node) => node.type === "TSNeverKeyword";
+const isLiterallyEqualByJson = (left, right) => {
+	const stripPositions = (key, value) => {
+		if (key === "start" || key === "end") return void 0;
+		return value;
+	};
+	return JSON.stringify(left, stripPositions) === JSON.stringify(right, stripPositions);
+};
+const detectIntersectionWithEmpty = (node) => {
+	if (node.type !== "TSIntersectionType") return void 0;
+	const operands = node.types;
+	if (!Array.isArray(operands) || operands.length < 2) return void 0;
+	if (!operands.some(isEmptyTypeLiteral)) return void 0;
+	return {
+		kind: "intersection-with-empty-object",
+		reason: "intersection with `{}` is a no-op; the empty object type does not constrain anything",
+		suggestion: "drop the `& {}` term"
+	};
+};
+const detectSelfUnion = (node) => {
+	if (node.type !== "TSUnionType") return void 0;
+	const operands = node.types;
+	if (!Array.isArray(operands) || operands.length < 2) return void 0;
+	for (let leftIndex = 0; leftIndex < operands.length; leftIndex++) for (let rightIndex = leftIndex + 1; rightIndex < operands.length; rightIndex++) if (isLiterallyEqualByJson(operands[leftIndex], operands[rightIndex])) return {
+		kind: "self-union",
+		reason: "union contains the same member twice",
+		suggestion: "deduplicate the union members"
+	};
+};
+const detectSelfIntersection = (node) => {
+	if (node.type !== "TSIntersectionType") return void 0;
+	const operands = node.types;
+	if (!Array.isArray(operands) || operands.length < 2) return void 0;
+	for (let leftIndex = 0; leftIndex < operands.length; leftIndex++) for (let rightIndex = leftIndex + 1; rightIndex < operands.length; rightIndex++) if (isLiterallyEqualByJson(operands[leftIndex], operands[rightIndex])) return {
+		kind: "self-intersection",
+		reason: "intersection contains the same operand twice",
+		suggestion: "deduplicate the intersection operands"
+	};
+};
+const detectNestedUtility = (node, utilityName, kind) => {
+	if (node.type !== "TSTypeReference") return void 0;
+	if (typeReferenceName(node) !== utilityName) return void 0;
+	const typeArguments = node.typeArguments;
+	if (!typeArguments) return void 0;
+	const params = typeArguments.params;
+	if (!Array.isArray(params) || params.length === 0) return void 0;
+	const firstArg = params[0];
+	if (firstArg.type !== "TSTypeReference") return void 0;
+	if (typeReferenceName(firstArg) !== utilityName) return void 0;
+	return {
+		kind,
+		reason: `${utilityName}<${utilityName}<T>> collapses to ${utilityName}<T>`,
+		suggestion: `flatten the nested ${utilityName}<...>`
+	};
+};
+const detectPickAllKeys = (node) => {
+	if (node.type !== "TSTypeReference") return void 0;
+	if (typeReferenceName(node) !== "Pick") return void 0;
+	const typeArguments = node.typeArguments;
+	if (!typeArguments) return void 0;
+	const params = typeArguments.params;
+	if (!Array.isArray(params) || params.length !== 2) return void 0;
+	const targetType = params[0];
+	const keys = params[1];
+	const targetName = typeReferenceName(targetType);
+	if (!targetName) return void 0;
+	if (!isKeyofOfType(keys, targetName)) return void 0;
+	return {
+		kind: "pick-all-keys",
+		reason: `Pick<${targetName}, keyof ${targetName}> is equivalent to ${targetName} itself`,
+		suggestion: `replace with ${targetName}`
+	};
+};
+const detectOmitNoKeys = (node) => {
+	if (node.type !== "TSTypeReference") return void 0;
+	if (typeReferenceName(node) !== "Omit") return void 0;
+	const typeArguments = node.typeArguments;
+	if (!typeArguments) return void 0;
+	const params = typeArguments.params;
+	if (!Array.isArray(params) || params.length !== 2) return void 0;
+	const targetType = params[0];
+	const keys = params[1];
+	const targetName = typeReferenceName(targetType);
+	if (!targetName) return void 0;
+	if (!isNeverKeyword(keys)) return void 0;
+	return {
+		kind: "omit-no-keys",
+		reason: `Omit<${targetName}, never> is equivalent to ${targetName} itself`,
+		suggestion: `replace with ${targetName}`
+	};
+};
+const isZodInferDeclarationMergingExtension = (parentExpression) => {
+	if (!parentExpression || parentExpression.type !== "MemberExpression") return false;
+	const propertyNode = parentExpression.property;
+	if (!propertyNode || propertyNode.type !== "Identifier") return false;
+	return propertyNode.name === "infer";
+};
+const isRadixStylePropsAliasExtension = (parentExpression) => {
+	if (!parentExpression || parentExpression.type !== "MemberExpression") return false;
+	const propertyNode = parentExpression.property;
+	if (!propertyNode || propertyNode.type !== "Identifier") return false;
+	return propertyNode.name === "Props";
+};
+const detectEmptyInterfaceExtendsOne = (declarationNode) => {
+	if (declarationNode.type !== "TSInterfaceDeclaration") return void 0;
+	const body = declarationNode.body;
+	if (!body || !Array.isArray(body.body) || body.body.length !== 0) return void 0;
+	const extendsClauses = declarationNode.extends;
+	if (!Array.isArray(extendsClauses) || extendsClauses.length !== 1) return void 0;
+	const declarationName = declarationNode.id?.name;
+	const parentExpression = extendsClauses[0]?.expression;
+	if (isZodInferDeclarationMergingExtension(parentExpression)) return void 0;
+	if (isRadixStylePropsAliasExtension(parentExpression)) return void 0;
+	const parentName = parentExpression && parentExpression.type === "Identifier" ? parentExpression.name : void 0;
+	return {
+		kind: "empty-interface-extends-one",
+		reason: `interface ${declarationName ?? "<anon>"} extends ${parentName ?? "<base>"} with no new members`,
+		suggestion: `replace with \`type ${declarationName ?? "X"} = ${parentName ?? "Base"}\``
+	};
+};
+const detectRedundantTypePatternForTypeAnnotation = (typeAnnotation) => {
+	if (!isTypeNode(typeAnnotation)) return void 0;
+	return detectIntersectionWithEmpty(typeAnnotation) ?? detectSelfUnion(typeAnnotation) ?? detectSelfIntersection(typeAnnotation) ?? detectNestedUtility(typeAnnotation, "Partial", "nested-partial") ?? detectNestedUtility(typeAnnotation, "Readonly", "nested-readonly") ?? detectNestedUtility(typeAnnotation, "Required", "nested-required") ?? detectPickAllKeys(typeAnnotation) ?? detectOmitNoKeys(typeAnnotation);
+};
+const detectRedundantInterfaceDeclaration = (declarationNode) => {
+	if (!isTypeNode(declarationNode)) return void 0;
+	return detectEmptyInterfaceExtendsOne(declarationNode);
+};
+
+//#endregion
+//#region src/utils/oxc-ast-node.ts
+const isOxcAstNode = (value) => Boolean(value) && typeof value === "object" && typeof value.type === "string";
+const getNodeStringField = (node, key) => {
+	const value = node[key];
+	return typeof value === "string" ? value : void 0;
+};
+const getIdentifierName = (node) => {
+	if (!isOxcAstNode(node)) return void 0;
+	if (node.type !== "Identifier") return void 0;
+	return getNodeStringField(node, "name");
+};
+
+//#endregion
+//#region src/utils/detect-identity-wrapper.ts
+const getCalleeText = (calleeNode) => {
+	if (calleeNode.type === "Identifier") return getIdentifierName(calleeNode);
+	if (calleeNode.type === "MemberExpression") {
+		if (calleeNode.computed) return void 0;
+		const objectNode = calleeNode.object;
+		const propertyNode = calleeNode.property;
+		if (!objectNode || !propertyNode) return void 0;
+		const objectText = getCalleeText(objectNode);
+		const propertyText = propertyNode.type === "Identifier" ? propertyNode.name : void 0;
+		if (!objectText || !propertyText) return void 0;
+		return `${objectText}.${propertyText}`;
+	}
+};
+const collectParameterNames = (parameters) => {
+	const names = [];
+	let hasRest = false;
+	let hasDefault = false;
+	let restName;
+	for (const parameter of parameters) {
+		if (!isOxcAstNode(parameter)) return {
+			names,
+			hasRest: true,
+			hasDefault,
+			restName
+		};
+		if (parameter.type === "RestElement") {
+			const restArgument = parameter.argument;
+			if (restArgument && restArgument.type === "Identifier") {
+				hasRest = true;
+				restName = restArgument.name;
+				continue;
+			}
+			return {
+				names,
+				hasRest: true,
+				hasDefault,
+				restName
+			};
+		}
+		if (parameter.type === "AssignmentPattern") {
+			hasDefault = true;
+			return {
+				names,
+				hasRest,
+				hasDefault,
+				restName
+			};
+		}
+		if (parameter.type === "Identifier") {
+			names.push(parameter.name);
+			continue;
+		}
+		return {
+			names: [],
+			hasRest,
+			hasDefault,
+			restName
+		};
+	}
+	return {
+		names,
+		hasRest,
+		hasDefault,
+		restName
+	};
+};
+const argumentsMatchParameters = (callArguments, parameterNames, restName) => {
+	if (restName !== void 0) {
+		if (callArguments.length !== 1) return false;
+		const onlyArgument = callArguments[0];
+		if (!isOxcAstNode(onlyArgument)) return false;
+		if (onlyArgument.type !== "SpreadElement") return false;
+		const spreadArgumentNode = onlyArgument.argument;
+		return Boolean(spreadArgumentNode && spreadArgumentNode.type === "Identifier" && spreadArgumentNode.name === restName);
+	}
+	if (callArguments.length !== parameterNames.length) return false;
+	for (let argumentIndex = 0; argumentIndex < callArguments.length; argumentIndex++) {
+		const argumentNode = callArguments[argumentIndex];
+		if (!isOxcAstNode(argumentNode)) return false;
+		if (argumentNode.type !== "Identifier") return false;
+		if (argumentNode.name !== parameterNames[argumentIndex]) return false;
+	}
+	return true;
+};
+const extractCallExpressionFromBody = (bodyNode) => {
+	if (bodyNode.type === "CallExpression") return bodyNode;
+	if (bodyNode.type === "BlockStatement") {
+		const blockBody = bodyNode.body;
+		if (!Array.isArray(blockBody) || blockBody.length !== 1) return void 0;
+		const onlyStatement = blockBody[0];
+		if (!isOxcAstNode(onlyStatement)) return void 0;
+		if (onlyStatement.type !== "ReturnStatement") return void 0;
+		const returnedExpression = onlyStatement.argument;
+		if (!returnedExpression) return void 0;
+		if (returnedExpression.type !== "CallExpression") return void 0;
+		return returnedExpression;
+	}
+};
+const detectIdentityWrapperFromInitializer = (initializerNode, wrapperName) => {
+	if (!isOxcAstNode(initializerNode)) return void 0;
+	if (initializerNode.type !== "ArrowFunctionExpression" && initializerNode.type !== "FunctionExpression") return;
+	if (initializerNode.async) return void 0;
+	if (initializerNode.generator) return void 0;
+	const { names: parameterNames, hasRest, hasDefault, restName } = collectParameterNames(initializerNode.params ?? []);
+	if (hasDefault) return void 0;
+	const bodyNode = initializerNode.body;
+	if (!bodyNode) return void 0;
+	const callExpression = extractCallExpressionFromBody(bodyNode);
+	if (!callExpression) return void 0;
+	const calleeNode = callExpression.callee;
+	if (!calleeNode) return void 0;
+	const calleeText = getCalleeText(calleeNode);
+	if (!calleeText) return void 0;
+	if (calleeText === wrapperName) return void 0;
+	if (!argumentsMatchParameters(callExpression.arguments ?? [], parameterNames, hasRest ? restName : void 0)) return;
+	return { wrappedExpression: calleeText };
+};
+
+//#endregion
+//#region src/utils/normalize-type-hash.ts
+const POSITION_KEYS = new Set([
+	"start",
+	"end",
+	"loc",
+	"range"
+]);
+const NOISY_KEYS = new Set([
+	"decorators",
+	"leadingComments",
+	"trailingComments",
+	"innerComments",
+	"directive",
+	"optional",
+	"computed",
+	"static",
+	"accessibility",
+	"declare",
+	"readonly"
+]);
+const NAME_KEYS_TO_STRIP = new Set(["id"]);
+const sanitizeNode = (input) => {
+	if (input === null || input === void 0) return input;
+	if (Array.isArray(input)) return input.map((element) => sanitizeNode(element));
+	if (typeof input !== "object") return input;
+	const record = input;
+	const cleaned = {};
+	for (const key of Object.keys(record)) {
+		if (POSITION_KEYS.has(key)) continue;
+		if (NOISY_KEYS.has(key)) continue;
+		if (NAME_KEYS_TO_STRIP.has(key)) continue;
+		cleaned[key] = sanitizeNode(record[key]);
+	}
+	if (cleaned.type === "TSTypeLiteral" && Array.isArray(cleaned.members)) cleaned.members = sortMembersByKey(cleaned.members);
+	if (cleaned.type === "TSInterfaceBody" && Array.isArray(cleaned.body)) cleaned.body = sortMembersByKey(cleaned.body);
+	return cleaned;
+};
+const extractMemberKey = (member) => {
+	if (!member || typeof member !== "object") return "";
+	const record = member;
+	if (record.key) {
+		const candidate = record.key.name ?? record.key.value;
+		if (candidate === void 0 || candidate === null) return "";
+		return String(candidate);
+	}
+	return `__${record.type ?? ""}__`;
+};
+const sortMembersByKey = (members) => {
+	const tagged = members.map((member) => ({
+		key: extractMemberKey(member),
+		member
+	}));
+	tagged.sort((leftEntry, rightEntry) => {
+		if (leftEntry.key < rightEntry.key) return -1;
+		if (leftEntry.key > rightEntry.key) return 1;
+		return 0;
+	});
+	return tagged.map((entry) => entry.member);
+};
+const normalizeTypeAstHash = (typeAnnotation) => {
+	const sanitized = sanitizeNode(typeAnnotation);
+	return JSON.stringify(sanitized);
+};
+
+//#endregion
+//#region src/utils/collect-inline-type-literals.ts
+const isTypeLiteralNode = (node) => node.type === "TSTypeLiteral";
+const buildPreview = (typeLiteralNode) => {
+	const members = typeLiteralNode.members ?? [];
+	const propertyKeys = [];
+	for (const memberCandidate of members) {
+		if (!isOxcAstNode(memberCandidate)) continue;
+		if (memberCandidate.type !== "TSPropertySignature") continue;
+		const keyNode = memberCandidate.key;
+		const keyName = keyNode?.name ?? keyNode?.value;
+		if (keyName) propertyKeys.push(String(keyName));
+	}
+	propertyKeys.sort();
+	const truncatedKeys = propertyKeys.slice(0, 4);
+	const suffix = propertyKeys.length > 4 ? `, +${propertyKeys.length - 4} more` : "";
+	return `{ ${truncatedKeys.join(", ")}${suffix} }`;
+};
+const countPropertySignatures = (typeLiteralNode) => {
+	const members = typeLiteralNode.members ?? [];
+	let signatureCount = 0;
+	for (const memberCandidate of members) {
+		if (!isOxcAstNode(memberCandidate)) continue;
+		if (memberCandidate.type === "TSPropertySignature") signatureCount++;
+	}
+	return signatureCount;
+};
+const captureIfTypeLiteral = (candidateNode, captures, context, nearestName) => {
+	if (!isOxcAstNode(candidateNode)) return;
+	if (!isTypeLiteralNode(candidateNode)) return;
+	const memberCount = countPropertySignatures(candidateNode);
+	if (memberCount < 3) return;
+	captures.push({
+		structuralHash: `inline:${normalizeTypeAstHash(candidateNode)}`,
+		memberCount,
+		preview: buildPreview(candidateNode),
+		context,
+		nearestName,
+		startOffset: candidateNode.start ?? 0
+	});
+};
+const GENERIC_WRAPPERS_TO_RECURSE = new Set([
+	"Array",
+	"ReadonlyArray",
+	"Promise",
+	"Set",
+	"ReadonlySet",
+	"Map",
+	"ReadonlyMap",
+	"Record",
+	"Partial",
+	"Required",
+	"Readonly",
+	"NonNullable",
+	"Awaited"
+]);
+const inspectAnyTypeNode = (candidateNode, captures, context, nearestName, recursionDepth) => {
+	if (!isOxcAstNode(candidateNode)) return;
+	if (recursionDepth > 6) return;
+	if (isTypeLiteralNode(candidateNode)) {
+		captureIfTypeLiteral(candidateNode, captures, context, nearestName);
+		const members = candidateNode.members ?? [];
+		for (const memberCandidate of members) {
+			if (!isOxcAstNode(memberCandidate)) continue;
+			if (memberCandidate.type !== "TSPropertySignature") continue;
+			const memberKey = memberCandidate.key?.name;
+			const nested = memberCandidate.typeAnnotation;
+			inspectAnyTypeNode(nested, captures, "interface-property", memberKey ?? nearestName, recursionDepth + 1);
+		}
+		return;
+	}
+	if (candidateNode.type === "TSTypeAnnotation") {
+		inspectAnyTypeNode(candidateNode.typeAnnotation, captures, context, nearestName, recursionDepth + 1);
+		return;
+	}
+	if (candidateNode.type === "TSArrayType") {
+		inspectAnyTypeNode(candidateNode.elementType, captures, context, nearestName, recursionDepth + 1);
+		return;
+	}
+	if (candidateNode.type === "TSUnionType" || candidateNode.type === "TSIntersectionType") {
+		const operands = candidateNode.types ?? [];
+		for (const operand of operands) inspectAnyTypeNode(operand, captures, context, nearestName, recursionDepth + 1);
+		return;
+	}
+	if (candidateNode.type === "TSTupleType") {
+		const elements = candidateNode.elementTypes ?? [];
+		for (const element of elements) inspectAnyTypeNode(element, captures, context, nearestName, recursionDepth + 1);
+		return;
+	}
+	if (candidateNode.type === "TSTypeReference") {
+		const referenceTypeName = candidateNode.typeName?.name;
+		const typeArguments = candidateNode.typeArguments;
+		if (referenceTypeName && typeArguments?.params && GENERIC_WRAPPERS_TO_RECURSE.has(referenceTypeName)) for (const param of typeArguments.params) inspectAnyTypeNode(param, captures, context, nearestName, recursionDepth + 1);
+	}
+};
+const inspectTypeAnnotation = (typeAnnotationNode, captures, context, nearestName) => {
+	inspectAnyTypeNode(typeAnnotationNode, captures, context, nearestName, 0);
+};
+const visitFunctionParameters = (parameters, captures, functionName) => {
+	if (!parameters) return;
+	for (const parameter of parameters) {
+		if (!isOxcAstNode(parameter)) continue;
+		const parameterIdentifierName = getIdentifierName(parameter);
+		inspectTypeAnnotation(parameter.typeAnnotation, captures, "function-parameter", functionName ? `${functionName}(${parameterIdentifierName ?? "?"})` : parameterIdentifierName);
+	}
+};
+const visitFunctionLike = (functionNode, captures, functionName) => {
+	const parameters = functionNode.params;
+	visitFunctionParameters(parameters, captures, functionName);
+	const returnTypeNode = functionNode.returnType;
+	if (returnTypeNode) inspectTypeAnnotation(returnTypeNode, captures, "function-return", functionName);
+	const bodyNode = functionNode.body;
+	if (bodyNode) walkBodyForInlineTypes(bodyNode, captures, functionName);
+};
+const visitVariableDeclaration = (declarationNode, captures, enclosingName) => {
+	const declarators = declarationNode.declarations ?? [];
+	for (const declarator of declarators) {
+		if (!isOxcAstNode(declarator)) continue;
+		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);
+		else walkExpressionForInlineTypes(initializerNode, captures, declarationName ?? enclosingName);
+	}
+};
+const walkBodyForInlineTypes = (bodyNode, captures, enclosingName, recursionDepth = 0) => {
+	if (recursionDepth > 200) return;
+	if (!isOxcAstNode(bodyNode)) return;
+	const statements = bodyNode.body ?? [];
+	if (!Array.isArray(statements)) return;
+	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 === "TSTypeAliasDeclaration") {
+			const typeAliasName = getIdentifierName(statement.id);
+			captureIfTypeLiteral(statement.typeAnnotation, captures, "local-type-alias", typeAliasName);
+		} else if (statement.type === "ReturnStatement") walkExpressionForInlineTypes(statement.argument, captures, enclosingName, recursionDepth + 1);
+		else if (statement.type === "BlockStatement") walkBodyForInlineTypes(statement, captures, enclosingName, recursionDepth + 1);
+		else if (statement.type === "ExpressionStatement") walkExpressionForInlineTypes(statement.expression, captures, enclosingName, recursionDepth + 1);
+	}
+};
+const walkExpressionForInlineTypes = (expressionNode, captures, enclosingName, recursionDepth = 0) => {
+	if (recursionDepth > 200) return;
+	if (!isOxcAstNode(expressionNode)) return;
+	if (expressionNode.type === "ArrowFunctionExpression" || expressionNode.type === "FunctionExpression") {
+		visitFunctionLike(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);
+	else if (isOxcAstNode(value)) walkExpressionForInlineTypes(value, captures, enclosingName, recursionDepth + 1);
+};
+const visitTopLevelStatement = (statementNode, captures) => {
+	if (!isOxcAstNode(statementNode)) return;
+	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));
+		return;
+	}
+	if (targetNode.type === "VariableDeclaration") {
+		visitVariableDeclaration(targetNode, captures, void 0);
+		return;
+	}
+	if (targetNode.type === "ClassDeclaration") {
+		const className = getIdentifierName(targetNode.id);
+		const members = targetNode.body?.body ?? [];
+		for (const memberCandidate of members) {
+			if (!isOxcAstNode(memberCandidate)) continue;
+			const memberKeyName = getIdentifierName(memberCandidate.key);
+			const qualifiedName = className && memberKeyName ? `${className}.${memberKeyName}` : memberKeyName;
+			if (memberCandidate.type === "PropertyDefinition") {
+				inspectTypeAnnotation(memberCandidate.typeAnnotation, captures, "class-property", qualifiedName);
+				continue;
+			}
+			if (memberCandidate.type === "MethodDefinition" || memberCandidate.type === "TSAbstractMethodDefinition") {
+				const methodValue = memberCandidate.value;
+				if (isOxcAstNode(methodValue)) visitFunctionLike(methodValue, captures, qualifiedName);
+			}
+		}
+		return;
+	}
+	if (targetNode.type === "TSInterfaceDeclaration") {
+		const interfaceName = getIdentifierName(targetNode.id);
+		const interfaceMembers = targetNode.body?.body ?? [];
+		for (const memberCandidate of interfaceMembers) {
+			if (!isOxcAstNode(memberCandidate)) continue;
+			if (memberCandidate.type !== "TSPropertySignature") continue;
+			const memberKeyName = getIdentifierName(memberCandidate.key);
+			const qualifiedName = interfaceName && memberKeyName ? `${interfaceName}.${memberKeyName}` : memberKeyName;
+			inspectTypeAnnotation(memberCandidate.typeAnnotation, captures, "interface-property", qualifiedName);
+		}
+	}
+};
+const collectInlineTypeLiterals = (programBody) => {
+	const captures = [];
+	for (const statement of programBody) visitTopLevelStatement(statement, captures);
+	return captures;
+};
+
+//#endregion
+//#region src/utils/detect-simplifiable-function.ts
+const containsAwaitExpression = (node, recursionDepth = 0) => {
+	if (recursionDepth > 30) return false;
+	if (!isOxcAstNode(node)) return false;
+	if (node.type === "AwaitExpression") return true;
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+	for (const value of Object.values(node)) if (Array.isArray(value)) {
+		for (const element of value) if (containsAwaitExpression(element, recursionDepth + 1)) return true;
+	} else if (isOxcAstNode(value)) {
+		if (containsAwaitExpression(value, recursionDepth + 1)) return true;
+	}
+	return false;
+};
+const containsCallOrPromiseSurface = (node, recursionDepth = 0) => {
+	if (recursionDepth > 30) return false;
+	if (!isOxcAstNode(node)) return false;
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+	if (node.type === "CallExpression" || node.type === "NewExpression" || node.type === "TaggedTemplateExpression" || node.type === "ThrowStatement" || node.type === "YieldExpression") return true;
+	if (node.type === "MemberExpression") {
+		const objectNode = node.object;
+		if (objectNode && isOxcAstNode(objectNode) && objectNode.type === "Identifier") {
+			if (objectNode.name === "Promise") return true;
+		}
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) {
+		for (const element of value) if (containsCallOrPromiseSurface(element, recursionDepth + 1)) return true;
+	} else if (isOxcAstNode(value)) {
+		if (containsCallOrPromiseSurface(value, recursionDepth + 1)) return true;
+	}
+	return false;
+};
+const unwrapParenthesizedExpression = (node) => {
+	let current = node;
+	while (current.type === "ParenthesizedExpression") {
+		const inner = current.expression;
+		if (!inner || !isOxcAstNode(inner)) return current;
+		current = inner;
+	}
+	return current;
+};
+const isSimpleReturnArgument = (argumentNode) => {
+	if (!isOxcAstNode(argumentNode)) return false;
+	const unwrapped = unwrapParenthesizedExpression(argumentNode);
+	if (unwrapped.type === "BlockStatement") return false;
+	if (unwrapped.type === "ObjectExpression") return false;
+	if (unwrapped.type === "JSXElement") return false;
+	if (unwrapped.type === "JSXFragment") return false;
+	return true;
+};
+const detectBlockArrowSingleReturn = (functionNode) => {
+	if (functionNode.type !== "ArrowFunctionExpression") return void 0;
+	if (functionNode.async) return void 0;
+	const bodyNode = functionNode.body;
+	if (!bodyNode || bodyNode.type !== "BlockStatement") return void 0;
+	const statements = bodyNode.body ?? [];
+	if (statements.length !== 1) return void 0;
+	const onlyStatement = statements[0];
+	if (!isOxcAstNode(onlyStatement)) return void 0;
+	if (onlyStatement.type !== "ReturnStatement") return void 0;
+	const returnArgument = onlyStatement.argument;
+	if (!returnArgument) return void 0;
+	if (!isSimpleReturnArgument(returnArgument)) return void 0;
+	return {
+		kind: "block-arrow-single-return",
+		startOffset: functionNode.start ?? 0,
+		reason: "arrow body is a single `return` statement; the block can be replaced by the expression directly",
+		suggestion: "rewrite as `() => expression` without `{}`"
+	};
+};
+const detectRedundantAwaitReturn = (functionNode) => {
+	const bodyNode = functionNode.body;
+	if (!bodyNode || bodyNode.type !== "BlockStatement") return void 0;
+	const statements = bodyNode.body ?? [];
+	if (statements.length < 2) return void 0;
+	const penultimate = statements[statements.length - 2];
+	const last = statements[statements.length - 1];
+	if (!isOxcAstNode(penultimate) || !isOxcAstNode(last)) return void 0;
+	if (penultimate.type !== "VariableDeclaration") return void 0;
+	if (last.type !== "ReturnStatement") return void 0;
+	const declarators = penultimate.declarations ?? [];
+	if (declarators.length !== 1) return void 0;
+	const declarator = declarators[0];
+	if (!isOxcAstNode(declarator)) return void 0;
+	const declaredIdentifier = declarator.id;
+	const initializer = declarator.init;
+	if (!declaredIdentifier?.name) return void 0;
+	if (!isOxcAstNode(initializer)) return void 0;
+	if (initializer.type !== "AwaitExpression") return void 0;
+	const returnedArgument = last.argument;
+	if (!isOxcAstNode(returnedArgument)) return void 0;
+	if (returnedArgument.type !== "Identifier") return void 0;
+	if (returnedArgument.name !== declaredIdentifier.name) return void 0;
+	return {
+		kind: "redundant-await-return",
+		startOffset: penultimate.start ?? 0,
+		reason: `\`const ${declaredIdentifier.name} = await …; return ${declaredIdentifier.name};\` can be \`return …;\` (the await is preserved by the implicit promise chain)`,
+		suggestion: `replace the await/assign/return sequence with a single \`return await …\` or \`return …\` if no try/catch wraps it`
+	};
+};
+const isAsyncFunction = (functionNode) => Boolean(functionNode.async);
+const containsPromiseTypeReference = (node, recursionDepth = 0) => {
+	if (recursionDepth > 30) return false;
+	if (!isOxcAstNode(node)) return false;
+	if (node.type === "TSTypeReference") {
+		const typeName = node.typeName;
+		if (typeName?.name === "Promise") return true;
+		if (typeName?.right?.name === "Promise") return true;
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) {
+		for (const element of value) if (containsPromiseTypeReference(element, recursionDepth + 1)) return true;
+	} else if (isOxcAstNode(value)) {
+		if (containsPromiseTypeReference(value, recursionDepth + 1)) return true;
+	}
+	return false;
+};
+const hasExplicitPromiseReturnType = (functionNode) => {
+	const returnType = functionNode.returnType;
+	if (!returnType || !isOxcAstNode(returnType)) return false;
+	const annotation = returnType.typeAnnotation;
+	if (!annotation || !isOxcAstNode(annotation)) return false;
+	return containsPromiseTypeReference(annotation);
+};
+const detectUselessAsync = (functionNode, context) => {
+	if (!isAsyncFunction(functionNode)) return void 0;
+	if (functionNode.type === "ClassDeclaration" || functionNode.type === "MethodDefinition") return;
+	if (context.isMethodContext) return void 0;
+	if (context.isInlineCallback) return void 0;
+	if (hasExplicitPromiseReturnType(functionNode)) return void 0;
+	const bodyNode = functionNode.body;
+	if (!isOxcAstNode(bodyNode)) return void 0;
+	if (containsAwaitExpression(bodyNode)) return void 0;
+	if (containsCallOrPromiseSurface(bodyNode)) return void 0;
+	return {
+		kind: "useless-async-no-await",
+		startOffset: functionNode.start ?? 0,
+		reason: "async function body contains no `await`, no function calls, and no Promise surface — the implicit Promise wrap is purely decorative",
+		suggestion: "drop `async` (caller's existing `await` keeps the type identical) or add an explicit return type"
+	};
+};
+const detectSimplifiableFunctionPatterns = (functionNode, context = {}) => {
+	if (!isOxcAstNode(functionNode)) return [];
+	const findings = [];
+	const blockArrow = detectBlockArrowSingleReturn(functionNode);
+	if (blockArrow) findings.push(blockArrow);
+	const awaitReturn = detectRedundantAwaitReturn(functionNode);
+	if (awaitReturn) findings.push(awaitReturn);
+	const uselessAsync = detectUselessAsync(functionNode, context);
+	if (uselessAsync) findings.push(uselessAsync);
+	return findings;
+};
+
+//#endregion
+//#region src/utils/collect-simplifiable-functions.ts
+const looksLikeFunction = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+const inferFunctionName = (functionNode, parentContext) => {
+	const declaredId = functionNode.id;
+	if (declaredId?.name) return declaredId.name;
+	return parentContext;
+};
+const visitFunctionAndDescend = (functionNode, captures, contextName, recursionDepth, isMethodContext, isInlineCallback) => {
+	const functionName = inferFunctionName(functionNode, contextName);
+	const detections = detectSimplifiableFunctionPatterns(functionNode, {
+		isMethodContext,
+		isInlineCallback
+	});
+	for (const detection of detections) captures.push({
+		kind: detection.kind,
+		functionName,
+		startOffset: detection.startOffset,
+		reason: detection.reason,
+		suggestion: detection.suggestion
+	});
+	const bodyNode = functionNode.body;
+	if (isOxcAstNode(bodyNode)) walkForFunctions(bodyNode, captures, functionName, recursionDepth + 1);
+	const parameters = functionNode.params ?? [];
+	for (const parameter of parameters) if (isOxcAstNode(parameter)) walkForFunctions(parameter, captures, functionName, recursionDepth + 1);
+};
+const isObjectMethodShorthand = (node) => (node.type === "Property" || node.type === "ObjectProperty") && node.method === true;
+const isObjectPropertyAssignment = (node) => (node.type === "Property" || node.type === "ObjectProperty") && node.method !== true;
+const isCallOrNewExpression = (node) => node.type === "CallExpression" || node.type === "NewExpression";
+const walkForFunctions = (node, captures, contextName, recursionDepth = 0) => {
+	if (recursionDepth > 200) return;
+	if (looksLikeFunction(node)) {
+		visitFunctionAndDescend(node, captures, contextName, recursionDepth, false, false);
+		return;
+	}
+	let nextContext = contextName;
+	if (node.type === "VariableDeclarator") {
+		const declaredName = getIdentifierName(node.id);
+		if (declaredName) nextContext = declaredName;
+	}
+	if (node.type === "MethodDefinition" || node.type === "PropertyDefinition") {
+		const propertyKeyName = getIdentifierName(node.key);
+		if (propertyKeyName) nextContext = propertyKeyName;
+	}
+	if (node.type === "ClassDeclaration") {
+		const className = getIdentifierName(node.id);
+		if (className) nextContext = className;
+	}
+	if (node.type === "MethodDefinition" || isObjectMethodShorthand(node)) {
+		const methodValue = node.value;
+		if (methodValue && isOxcAstNode(methodValue) && looksLikeFunction(methodValue)) {
+			visitFunctionAndDescend(methodValue, captures, getIdentifierName(node.key) ?? nextContext, recursionDepth + 1, true, false);
+			const keyNode = node.key;
+			if (keyNode && isOxcAstNode(keyNode) && node.computed) walkForFunctions(keyNode, captures, nextContext, recursionDepth + 1);
+			return;
+		}
+	}
+	if (isObjectPropertyAssignment(node)) {
+		const propertyValue = node.value;
+		if (propertyValue && isOxcAstNode(propertyValue) && looksLikeFunction(propertyValue)) {
+			visitFunctionAndDescend(propertyValue, captures, getIdentifierName(node.key) ?? nextContext, recursionDepth + 1, false, true);
+			const keyNode = node.key;
+			if (keyNode && isOxcAstNode(keyNode) && node.computed) walkForFunctions(keyNode, captures, nextContext, recursionDepth + 1);
+			return;
+		}
+	}
+	if (isCallOrNewExpression(node)) {
+		const callee = node.callee;
+		if (callee && isOxcAstNode(callee)) walkForFunctions(callee, captures, nextContext, recursionDepth + 1);
+		const callArguments = node.arguments ?? [];
+		for (const argument of callArguments) {
+			if (!isOxcAstNode(argument)) continue;
+			if (looksLikeFunction(argument)) visitFunctionAndDescend(argument, captures, nextContext, recursionDepth + 1, false, true);
+			else walkForFunctions(argument, captures, nextContext, recursionDepth + 1);
+		}
+		return;
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) {
+		for (const element of value) if (isOxcAstNode(element)) walkForFunctions(element, captures, nextContext, recursionDepth + 1);
+	} else if (isOxcAstNode(value)) walkForFunctions(value, captures, nextContext, recursionDepth + 1);
+};
+const collectSimplifiableFunctions = (programBody) => {
+	const captures = [];
+	for (const statement of programBody) if (isOxcAstNode(statement)) walkForFunctions(statement, captures, void 0, 0);
+	return captures;
+};
+
+//#endregion
+//#region src/utils/collect-simplifiable-expressions.ts
+const memberAccessText = (node, depth = 0) => {
+	if (depth > 6) return void 0;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "ThisExpression") return "this";
+	if (node.type === "MemberExpression") {
+		if (node.computed) return void 0;
+		const objectNode = node.object;
+		const propertyNode = node.property;
+		if (!objectNode || !propertyNode) return void 0;
+		const objectText = memberAccessText(objectNode, depth + 1);
+		const propertyText = propertyNode.type === "Identifier" ? propertyNode.name : void 0;
+		if (!objectText || !propertyText) return void 0;
+		return `${objectText}.${propertyText}`;
+	}
+};
+const isBooleanLiteral = (node, expected) => {
+	if (node.type !== "Literal") return false;
+	return node.value === expected;
+};
+const detectSelfFallbackTernary = (conditionalNode) => {
+	if (conditionalNode.type !== "ConditionalExpression") return void 0;
+	const testNode = conditionalNode.test;
+	const consequentNode = conditionalNode.consequent;
+	if (!testNode || !consequentNode) return void 0;
+	const testText = memberAccessText(testNode);
+	const consequentText = memberAccessText(consequentNode);
+	if (!testText || !consequentText) return void 0;
+	if (testText !== consequentText) return void 0;
+	return {
+		kind: "self-fallback-ternary",
+		snippet: `${testText} ? ${consequentText} : ...`,
+		startOffset: conditionalNode.start ?? 0,
+		reason: `\`${testText} ? ${testText} : x\` is a self-fallback ternary`,
+		suggestion: `use \`${testText} ?? x\` (nullish-only) or \`${testText} || x\` (falsy fallback) depending on intent`
+	};
+};
+const detectTernaryReturnsBoolean = (conditionalNode) => {
+	if (conditionalNode.type !== "ConditionalExpression") return void 0;
+	const consequentNode = conditionalNode.consequent;
+	const alternateNode = conditionalNode.alternate;
+	if (!consequentNode || !alternateNode) return void 0;
+	const isTrueFalse = isBooleanLiteral(consequentNode, true) && isBooleanLiteral(alternateNode, false);
+	const isFalseTrue = isBooleanLiteral(consequentNode, false) && isBooleanLiteral(alternateNode, true);
+	if (!isTrueFalse && !isFalseTrue) return void 0;
+	return {
+		kind: "ternary-returns-boolean",
+		snippet: isTrueFalse ? "cond ? true : false" : "cond ? false : true",
+		startOffset: conditionalNode.start ?? 0,
+		reason: isTrueFalse ? "`cond ? true : false` collapses to `Boolean(cond)`" : "`cond ? false : true` collapses to `!cond`",
+		suggestion: isTrueFalse ? "replace with `Boolean(cond)` or just `cond` when types match" : "replace with `!cond`"
+	};
+};
+const isNullLiteral = (node) => node.type === "Literal" && node.value === null;
+const isUndefinedIdentifier = (node) => node.type === "Identifier" && node.name === "undefined";
+const detectNullishCoalescingWithNullish = (logicalNode) => {
+	if (logicalNode.type !== "LogicalExpression") return void 0;
+	if (logicalNode.operator !== "??") return void 0;
+	const rightNode = logicalNode.right;
+	if (!rightNode) return void 0;
+	if (!(isNullLiteral(rightNode) || isUndefinedIdentifier(rightNode))) return void 0;
+	const leftNode = logicalNode.left;
+	const leftText = leftNode ? memberAccessText(leftNode) ?? "expr" : "expr";
+	const rightLabel = isNullLiteral(rightNode) ? "null" : "undefined";
+	return {
+		kind: "nullish-coalescing-with-nullish",
+		snippet: `${leftText} ?? ${rightLabel}`,
+		startOffset: logicalNode.start ?? 0,
+		reason: `\`x ?? ${rightLabel}\` looks like a no-op — but may be intentional when a caller's signature requires \`${rightLabel}\` (PropTypes, form-control onChange, etc.)`,
+		suggestion: `if \`x\` is already \`T | ${rightLabel}\`, drop the \`?? ${rightLabel}\`; otherwise keep — the coercion changes the resolved type`
+	};
+};
+const detectRedundantNullAndUndefinedCheck = (logicalNode) => {
+	if (logicalNode.type !== "LogicalExpression") return void 0;
+	if (logicalNode.operator !== "&&") return void 0;
+	const leftNode = logicalNode.left;
+	const rightNode = logicalNode.right;
+	if (!leftNode || !rightNode) return void 0;
+	if (leftNode.type !== "BinaryExpression" || rightNode.type !== "BinaryExpression") return void 0;
+	const leftOp = leftNode.operator;
+	const rightOp = rightNode.operator;
+	if (leftOp !== "!==" || rightOp !== "!==") return void 0;
+	const leftLeft = leftNode.left;
+	const leftRight = leftNode.right;
+	const rightLeft = rightNode.left;
+	const rightRight = rightNode.right;
+	if (!leftLeft || !leftRight || !rightLeft || !rightRight) return void 0;
+	const leftLeftText = memberAccessText(leftLeft);
+	const rightLeftText = memberAccessText(rightLeft);
+	if (!leftLeftText || leftLeftText !== rightLeftText) return void 0;
+	const leftRhsIsNull = isNullLiteral(leftRight);
+	const leftRhsIsUndefined = isUndefinedIdentifier(leftRight);
+	const rightRhsIsNull = isNullLiteral(rightRight);
+	const rightRhsIsUndefined = isUndefinedIdentifier(rightRight);
+	if (!(leftRhsIsNull && rightRhsIsUndefined || leftRhsIsUndefined && rightRhsIsNull)) return void 0;
+	return {
+		kind: "redundant-null-and-undefined-check",
+		snippet: `${leftLeftText} !== null && ${leftLeftText} !== undefined`,
+		startOffset: logicalNode.start ?? 0,
+		reason: `\`x !== null && x !== undefined\` is equivalent to \`x != null\` (loose comparison checks both)`,
+		suggestion: `replace with \`${leftLeftText} != null\``
+	};
+};
+const detectDoubleBangBoolean = (unaryNode) => {
+	if (unaryNode.type !== "UnaryExpression") return void 0;
+	if (unaryNode.operator !== "!") return void 0;
+	const inner = unaryNode.argument;
+	if (!inner || inner.type !== "UnaryExpression") return void 0;
+	if (inner.operator !== "!") return void 0;
+	const coerced = inner.argument;
+	if (!coerced) return void 0;
+	const coercedText = memberAccessText(coerced) ?? "expr";
+	return {
+		kind: "double-bang-boolean",
+		snippet: `!!${coercedText}`,
+		startOffset: unaryNode.start ?? 0,
+		reason: "`!!x` is a double-negation boolean coercion",
+		suggestion: `replace with \`Boolean(${coercedText})\``
+	};
+};
+const visit = (node, captures, depth) => {
+	if (depth > 100) return;
+	const conditionalCapture = detectSelfFallbackTernary(node) ?? detectTernaryReturnsBoolean(node);
+	if (conditionalCapture) captures.push(conditionalCapture);
+	const doubleBangCapture = detectDoubleBangBoolean(node);
+	if (doubleBangCapture) captures.push(doubleBangCapture);
+	const logicalCapture = detectNullishCoalescingWithNullish(node) ?? detectRedundantNullAndUndefinedCheck(node);
+	if (logicalCapture) captures.push(logicalCapture);
+	for (const value of Object.values(node)) if (Array.isArray(value)) {
+		for (const element of value) if (isOxcAstNode(element)) visit(element, captures, depth + 1);
+	} else if (isOxcAstNode(value)) visit(value, captures, depth + 1);
+};
+const collectSimplifiableExpressions = (programBody) => {
+	const captures = [];
+	for (const statement of programBody) if (isOxcAstNode(statement)) visit(statement, captures, 0);
+	return captures;
+};
+
+//#endregion
+//#region src/utils/collect-duplicate-constants.ts
+const FRAMEWORK_RESERVED_CONSTANT_NAMES = new Set([
+	"dynamic",
+	"dynamicParams",
+	"revalidate",
+	"runtime",
+	"fetchCache",
+	"preferredRegion",
+	"maxDuration",
+	"metadata",
+	"viewport",
+	"generateStaticParams",
+	"generateMetadata",
+	"config",
+	"loader",
+	"action",
+	"links",
+	"meta",
+	"headers",
+	"handle",
+	"shouldRevalidate",
+	"ErrorBoundary",
+	"HydrateFallback",
+	"Layout"
+]);
+const isLiteralCandidate = (node) => {
+	if (node.type === "Literal") {
+		const value = node.value;
+		if (typeof value === "string") {
+			if (value.length < 8) return false;
+			return true;
+		}
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) return false;
+			if (Math.abs(value) < 1e3) return false;
+			return true;
+		}
+		return false;
+	}
+	if (node.type === "TemplateLiteral") {
+		const expressions = node.expressions;
+		if (Array.isArray(expressions) && expressions.length > 0) return false;
+		const quasis = node.quasis;
+		if (!Array.isArray(quasis) || quasis.length === 0) return false;
+		return (quasis[0].value?.cooked ?? "").length >= 8;
+	}
+	if (node.type === "ArrayExpression") {
+		const elements = node.elements ?? [];
+		if (elements.length === 0) return false;
+		for (const element of elements) {
+			if (!isOxcAstNode(element)) return false;
+			if (element.type !== "Literal") return false;
+		}
+		return true;
+	}
+	return false;
+};
+const hashLiteralNode = (node) => {
+	if (node.type === "Literal") return `lit:${typeof node.value}:${JSON.stringify(node.value)}`;
+	if (node.type === "TemplateLiteral") {
+		const quasis = node.quasis ?? [];
+		return `tpl:${JSON.stringify(quasis[0]?.value?.cooked ?? "")}`;
+	}
+	if (node.type === "ArrayExpression") return `arr:[${(node.elements ?? []).map((element) => {
+		if (!isOxcAstNode(element)) return "?";
+		if (element.type !== "Literal") return "?";
+		return JSON.stringify(element.value);
+	}).join(",")}]`;
+	return "?";
+};
+const previewLiteralNode = (node) => {
+	if (node.type === "Literal") {
+		const value = node.value;
+		if (typeof value === "string") return `"${value.length > 60 ? value.slice(0, 57) + "..." : value}"`;
+		return String(value);
+	}
+	if (node.type === "TemplateLiteral") {
+		const cooked = (node.quasis ?? [])[0]?.value?.cooked ?? "";
+		return `\`${cooked.length > 60 ? cooked.slice(0, 57) + "..." : cooked}\``;
+	}
+	if (node.type === "ArrayExpression") {
+		const elements = node.elements ?? [];
+		return `[${elements.slice(0, 3).map((element) => isOxcAstNode(element) && element.type === "Literal" ? JSON.stringify(element.value) : "?").join(", ")}${elements.length > 3 ? `, +${elements.length - 3} more` : ""}]`;
+	}
+	return "<literal>";
+};
+const visitForConstants = (statementNode, candidates) => {
+	if (!isOxcAstNode(statementNode)) return;
+	const inner = (statementNode.type === "ExportNamedDeclaration" || statementNode.type === "ExportDefaultDeclaration") && statementNode.declaration ? statementNode.declaration : statementNode;
+	if (!isOxcAstNode(inner)) return;
+	if (inner.type !== "VariableDeclaration") return;
+	if (inner.kind !== "const") return;
+	const declarators = inner.declarations ?? [];
+	for (const declarator of declarators) {
+		if (!isOxcAstNode(declarator)) continue;
+		const idNode = declarator.id;
+		const initializerNode = declarator.init;
+		if (!idNode || !initializerNode) continue;
+		if (idNode.type !== "Identifier") continue;
+		const constantName = idNode.name;
+		if (!constantName) continue;
+		if (FRAMEWORK_RESERVED_CONSTANT_NAMES.has(constantName)) continue;
+		if (!isLiteralCandidate(initializerNode)) continue;
+		candidates.push({
+			constantName,
+			literalHash: hashLiteralNode(initializerNode),
+			literalPreview: previewLiteralNode(initializerNode),
+			startOffset: declarator.start ?? inner.start ?? 0
+		});
+	}
+};
+const collectDuplicateConstantCandidates = (programBody) => {
+	const candidates = [];
+	for (const statement of programBody) visitForConstants(statement, candidates);
+	return candidates;
+};
+
 //#endregion
 //#region src/collect/parse.ts
 const extractMdxImportsExports = (sourceText) => {
@@ -374,10 +1607,15 @@ const CSS_EXTENSIONS = [
 ];
 const CSS_IMPORT_PATTERN = /@import\s+(?:url\()?['"]([^'"]+)['"]\)?/g;
 const SCSS_USE_FORWARD_PATTERN = /@(?:use|forward)\s+['"]([^'"]+)['"]/g;
+const TAILWIND_PLUGIN_REFERENCE_PATTERN = /@(?:plugin|reference|config)\s+['"]([^'"]+)['"]/g;
 const parseCssImports = (filePath) => {
 	const sourceText = (0, node_fs.readFileSync)(filePath, "utf-8");
 	const imports = [];
-	const patterns = [CSS_IMPORT_PATTERN, SCSS_USE_FORWARD_PATTERN];
+	const patterns = [
+		CSS_IMPORT_PATTERN,
+		SCSS_USE_FORWARD_PATTERN,
+		TAILWIND_PLUGIN_REFERENCE_PATTERN
+	];
 	for (const pattern of patterns) {
 		let match;
 		pattern.lastIndex = 0;
@@ -398,19 +1636,158 @@ const parseCssImports = (filePath) => {
 		imports,
 		exports: [],
 		memberAccesses: [],
-		wholeObjectUses: []
+		wholeObjectUses: [],
+		localIdentifierReferences: [],
+		referencedFilenames: [],
+		redundantTypePatterns: [],
+		identityWrappers: [],
+		typeDefinitionHashes: [],
+		inlineTypeLiterals: [],
+		simplifiableFunctions: [],
+		simplifiableExpressions: [],
+		duplicateConstantCandidates: [],
+		errors: []
 	};
 };
 const NON_JS_EXTENSIONS = [".graphql", ".gql"];
+const collectLocalIdentifierReferences = (statements) => {
+	const references = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	const visitNode = (node) => {
+		if (!node || typeof node !== "object") return;
+		const record = node;
+		if (record.type === "Identifier" && typeof record.name === "string") {
+			if (!seenNames.has(record.name)) {
+				seenNames.add(record.name);
+				references.push(record.name);
+			}
+			return;
+		}
+		for (const value of Object.values(record)) if (Array.isArray(value)) for (const innerValue of value) visitNode(innerValue);
+		else if (value && typeof value === "object") visitNode(value);
+	};
+	for (const statement of statements) {
+		if (statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" || statement.type === "ExportAllDeclaration") continue;
+		visitNode(statement);
+	}
+	return references;
+};
+const createEmptyParsedSource = () => ({
+	imports: [],
+	exports: [],
+	memberAccesses: [],
+	wholeObjectUses: [],
+	localIdentifierReferences: [],
+	referencedFilenames: [],
+	redundantTypePatterns: [],
+	identityWrappers: [],
+	typeDefinitionHashes: [],
+	inlineTypeLiterals: [],
+	simplifiableFunctions: [],
+	simplifiableExpressions: [],
+	duplicateConstantCandidates: [],
+	errors: []
+});
+const stripByteOrderMark = (sourceText) => {
+	if (sourceText.charCodeAt(0) === 65279) return sourceText.slice(1);
+	return sourceText;
+};
+const looksLikeBinaryContent = (sourceText) => {
+	const sampleLength = Math.min(sourceText.length, BINARY_DETECTION_SAMPLE_BYTES);
+	let nullByteCount = 0;
+	for (let scanIndex = 0; scanIndex < sampleLength; scanIndex++) {
+		if (sourceText.charCodeAt(scanIndex) === 0) nullByteCount++;
+		if (nullByteCount > 4) return true;
+	}
+	return false;
+};
+const looksLikeMinifiedSource = (sourceText) => {
+	if (sourceText.length < 5e3) return false;
+	let newlineCount = 0;
+	for (let scanIndex = 0; scanIndex < sourceText.length; scanIndex++) if (sourceText.charCodeAt(scanIndex) === 10) newlineCount++;
+	return sourceText.length / (newlineCount + 1) > 500;
+};
+const safeReadSourceFile = (filePath, errors) => {
+	try {
+		const stats = (0, node_fs.statSync)(filePath);
+		if (stats.size === 0) {
+			errors.push(new FileReadError({
+				code: "file-empty",
+				severity: "info",
+				message: "file is empty — nothing to analyze",
+				path: filePath
+			}));
+			return;
+		}
+		if (stats.size > 2e6) {
+			errors.push(new FileReadError({
+				code: "file-too-large",
+				message: `file size ${stats.size}B exceeds MAX_PARSE_FILE_SIZE_BYTES (${MAX_PARSE_FILE_SIZE_BYTES})`,
+				path: filePath
+			}));
+			return;
+		}
+	} catch (statError) {
+		errors.push(new FileReadError({
+			code: "file-read-failed",
+			message: "could not stat source file",
+			path: filePath,
+			detail: describeUnknownError(statError)
+		}));
+		return;
+	}
+	try {
+		const sourceText = stripByteOrderMark((0, node_fs.readFileSync)(filePath, "utf-8"));
+		if (looksLikeBinaryContent(sourceText)) {
+			errors.push(new FileReadError({
+				code: "file-binary",
+				severity: "info",
+				message: "file appears to be binary — skipping",
+				path: filePath
+			}));
+			return;
+		}
+		if (looksLikeMinifiedSource(sourceText)) {
+			errors.push(new FileReadError({
+				code: "file-minified",
+				severity: "info",
+				message: "file appears to be a minified/bundled artifact — skipping redundancy analysis",
+				path: filePath
+			}));
+			return;
+		}
+		return sourceText;
+	} catch (readError) {
+		errors.push(new FileReadError({
+			code: "file-read-failed",
+			message: "could not read source file",
+			path: filePath,
+			detail: describeUnknownError(readError)
+		}));
+		return;
+	}
+};
 const parseSourceFile = (filePath) => {
-	if (CSS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) return parseCssImports(filePath);
-	if (NON_JS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) return {
-		imports: [],
-		exports: [],
-		memberAccesses: [],
-		wholeObjectUses: []
+	if (CSS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) try {
+		return parseCssImports(filePath);
+	} catch (cssError) {
+		return {
+			...createEmptyParsedSource(),
+			errors: [new ParseError({
+				code: "parse-failed",
+				message: "CSS import parsing crashed",
+				path: filePath,
+				detail: describeUnknownError(cssError)
+			})]
+		};
+	}
+	if (NON_JS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) return createEmptyParsedSource();
+	const earlyErrors = [];
+	const sourceText = safeReadSourceFile(filePath, earlyErrors);
+	if (sourceText === void 0) return {
+		...createEmptyParsedSource(),
+		errors: earlyErrors
 	};
-	const sourceText = (0, node_fs.readFileSync)(filePath, "utf-8");
 	const imports = [];
 	const exports = [];
 	const isMdx = filePath.endsWith(".mdx");
@@ -419,51 +1796,223 @@ const parseSourceFile = (filePath) => {
 	const isSvelte = filePath.endsWith(".svelte");
 	const textToParse = isMdx ? extractMdxImportsExports(sourceText) : isAstro ? extractAstroFrontmatter(sourceText) : isVue ? extractVueScriptContent(sourceText) : isSvelte ? extractSvelteScriptContent(sourceText) : sourceText;
 	const parseFileName = isMdx || isAstro || isVue || isSvelte ? filePath.replace(/\.(mdx|astro|vue|svelte)$/, ".tsx") : filePath;
-	let result = (0, oxc_parser.parseSync)(parseFileName, textToParse);
-	const isPlainJsFile = parseFileName.endsWith(".js") || parseFileName.endsWith(".mjs") || parseFileName.endsWith(".cjs");
-	if (result.errors.length > 0 && isPlainJsFile && result.errors.some((parseError) => {
-		const errorMessage = String(parseError.message ?? "");
-		return errorMessage.includes("JSX") || errorMessage.includes("Unexpected token");
-	})) result = (0, oxc_parser.parseSync)(parseFileName.replace(/\.(m?js|cjs)$/, ".jsx"), textToParse);
+	let result;
+	try {
+		result = (0, oxc_parser.parseSync)(parseFileName, textToParse);
+	} catch (parseError) {
+		return {
+			...createEmptyParsedSource(),
+			errors: [...earlyErrors, new ParseError({
+				code: "parse-failed",
+				message: "oxc-parser threw during initial parse",
+				path: filePath,
+				detail: describeUnknownError(parseError)
+			})]
+		};
+	}
+	if ((parseFileName.endsWith(".js") || parseFileName.endsWith(".mjs") || parseFileName.endsWith(".cjs")) && result.errors.length > 0) try {
+		const jsxResult = (0, oxc_parser.parseSync)(parseFileName.replace(/\.(m?js|cjs)$/, ".jsx"), textToParse);
+		if (jsxResult.errors.length === 0) result = jsxResult;
+		else {
+			const tsxResult = (0, oxc_parser.parseSync)(parseFileName.replace(/\.(m?js|cjs)$/, ".tsx"), textToParse);
+			if (tsxResult.errors.length === 0) result = tsxResult;
+		}
+	} catch {}
 	if (result.errors.length > 0) return {
+		...createEmptyParsedSource(),
 		imports,
 		exports,
-		memberAccesses: [],
-		wholeObjectUses: []
+		referencedFilenames: extractReferencedFilenames(sourceText),
+		errors: [...earlyErrors, new ParseError({
+			code: "parse-recovered",
+			severity: "info",
+			message: `oxc-parser reported ${result.errors.length} syntax issue(s); skipping deep analysis for this file`,
+			path: filePath
+		})]
 	};
 	const program = result.program;
 	if (!program?.body) return {
+		...createEmptyParsedSource(),
 		imports,
 		exports,
-		memberAccesses: [],
-		wholeObjectUses: []
+		referencedFilenames: extractReferencedFilenames(sourceText),
+		errors: [...earlyErrors, new ParseError({
+			code: "parse-failed",
+			message: "oxc-parser returned no program body",
+			path: filePath
+		})]
 	};
-	for (const node of program.body) switch (node.type) {
-		case "ImportDeclaration":
-			extractImportDeclaration(node, sourceText, imports);
-			break;
-		case "ExportNamedDeclaration":
-			extractNamedExportDeclaration(node, sourceText, exports);
-			break;
-		case "ExportDefaultDeclaration":
-			extractDefaultExportDeclaration(node, sourceText, exports);
-			break;
-		case "ExportAllDeclaration":
-			extractExportAllDeclaration(node, sourceText, exports);
-			break;
-	}
-	collectDynamicImports(program.body, sourceText, imports);
-	const namespaceLocalNames = collectNamespaceLocalNames(imports);
-	const memberAccesses = [];
-	const wholeObjectUses = [];
-	if (namespaceLocalNames.size > 0) collectMemberAccesses(program.body, namespaceLocalNames, memberAccesses, wholeObjectUses);
+	const detectorErrors = [];
+	const safeWalk = (walkerName, walker, fallback) => {
+		try {
+			return walker();
+		} catch (walkError) {
+			detectorErrors.push(new ParseError({
+				code: "ast-walk-failed",
+				message: `${walkerName} threw during AST traversal`,
+				path: filePath,
+				detail: describeUnknownError(walkError)
+			}));
+			return fallback;
+		}
+	};
+	safeWalk("extractImportsAndExports", () => {
+		for (const node of program.body) switch (node.type) {
+			case "ImportDeclaration":
+				extractImportDeclaration(node, sourceText, imports);
+				break;
+			case "ExportNamedDeclaration":
+				extractNamedExportDeclaration(node, sourceText, exports);
+				break;
+			case "ExportDefaultDeclaration":
+				extractDefaultExportDeclaration(node, sourceText, exports);
+				break;
+			case "ExportAllDeclaration":
+				extractExportAllDeclaration(node, sourceText, exports);
+				break;
+		}
+	}, void 0);
+	safeWalk("collectDynamicImports", () => {
+		collectDynamicImports(program.body, sourceText, imports);
+	}, void 0);
+	const namespaceLocalNames = collectNamespaceLocalNames(imports);
+	const memberAccesses = [];
+	const wholeObjectUses = [];
+	if (namespaceLocalNames.size > 0) safeWalk("collectMemberAccesses", () => {
+		collectMemberAccesses(program.body, namespaceLocalNames, memberAccesses, wholeObjectUses);
+	}, void 0);
+	const localIdentifierReferences = safeWalk("collectLocalIdentifierReferences", () => collectLocalIdentifierReferences(program.body), []);
+	const redundantTypePatterns = [];
+	const identityWrappers = [];
+	const typeDefinitionHashes = [];
+	safeWalk("collectDryPatterns", () => {
+		collectDryPatterns(program.body, sourceText, redundantTypePatterns, identityWrappers, typeDefinitionHashes);
+	}, void 0);
+	const inlineTypeLiterals = safeWalk("collectInlineTypeLiterals", () => collectInlineTypeLiterals(program.body), []).map((capture) => ({
+		structuralHash: capture.structuralHash,
+		memberCount: capture.memberCount,
+		preview: capture.preview,
+		context: capture.context,
+		nearestName: capture.nearestName,
+		line: getLineFromOffset(sourceText, capture.startOffset),
+		column: getColumnFromOffset(sourceText, capture.startOffset)
+	}));
+	const simplifiableFunctions = safeWalk("collectSimplifiableFunctions", () => collectSimplifiableFunctions(program.body), []).map((capture) => ({
+		kind: capture.kind,
+		functionName: capture.functionName,
+		line: getLineFromOffset(sourceText, capture.startOffset),
+		column: getColumnFromOffset(sourceText, capture.startOffset),
+		reason: capture.reason,
+		suggestion: capture.suggestion
+	}));
+	const simplifiableExpressions = safeWalk("collectSimplifiableExpressions", () => collectSimplifiableExpressions(program.body), []).map((capture) => ({
+		kind: capture.kind,
+		snippet: capture.snippet,
+		line: getLineFromOffset(sourceText, capture.startOffset),
+		column: getColumnFromOffset(sourceText, capture.startOffset),
+		reason: capture.reason,
+		suggestion: capture.suggestion
+	}));
+	const duplicateConstantCandidates = safeWalk("collectDuplicateConstantCandidates", () => collectDuplicateConstantCandidates(program.body), []).map((capture) => ({
+		constantName: capture.constantName,
+		literalHash: capture.literalHash,
+		literalPreview: capture.literalPreview,
+		line: getLineFromOffset(sourceText, capture.startOffset),
+		column: getColumnFromOffset(sourceText, capture.startOffset)
+	}));
 	return {
 		imports,
 		exports,
 		memberAccesses,
-		wholeObjectUses
+		wholeObjectUses,
+		localIdentifierReferences,
+		referencedFilenames: extractReferencedFilenames(sourceText),
+		redundantTypePatterns,
+		identityWrappers,
+		typeDefinitionHashes,
+		inlineTypeLiterals,
+		simplifiableFunctions,
+		simplifiableExpressions,
+		duplicateConstantCandidates,
+		errors: [...earlyErrors, ...detectorErrors]
 	};
 };
+const REFERENCED_FILENAME_LITERAL_PATTERN = /(?<![./@\w-])(?:["'`])([a-z][\w-]*\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:["'`])/g;
+const extractReferencedFilenames = (sourceText) => {
+	const captured = /* @__PURE__ */ new Set();
+	REFERENCED_FILENAME_LITERAL_PATTERN.lastIndex = 0;
+	let match;
+	while ((match = REFERENCED_FILENAME_LITERAL_PATTERN.exec(sourceText)) !== null) captured.add(match[1]);
+	return [...captured];
+};
+const collectDryPatterns = (bodyNodes, sourceText, redundantTypePatterns, identityWrappers, typeDefinitionHashes) => {
+	for (const statement of bodyNodes) inspectStatement(statement, sourceText, redundantTypePatterns, identityWrappers, typeDefinitionHashes);
+};
+const inspectStatement = (statementNode, sourceText, redundantTypePatterns, identityWrappers, typeDefinitionHashes) => {
+	let declarationOfInterest = statementNode;
+	if (statementNode.type === "ExportNamedDeclaration" && statementNode.declaration) declarationOfInterest = statementNode.declaration;
+	if (declarationOfInterest && typeof declarationOfInterest === "object") {
+		const declarationNode = declarationOfInterest;
+		if (declarationNode.type === "TSTypeAliasDeclaration") {
+			const typeAliasName = declarationNode.id?.name;
+			const typeAnnotation = declarationNode.typeAnnotation;
+			const startOffset = declarationNode.start ?? 0;
+			if (typeAliasName && typeAnnotation) {
+				const redundantPattern = detectRedundantTypePatternForTypeAnnotation(typeAnnotation);
+				if (redundantPattern) redundantTypePatterns.push({
+					typeName: typeAliasName,
+					kind: redundantPattern.kind,
+					line: getLineFromOffset(sourceText, startOffset),
+					column: getColumnFromOffset(sourceText, startOffset),
+					reason: redundantPattern.reason,
+					suggestion: redundantPattern.suggestion
+				});
+				typeDefinitionHashes.push({
+					typeName: typeAliasName,
+					structuralHash: `alias:${normalizeTypeAstHash(typeAnnotation)}`,
+					line: getLineFromOffset(sourceText, startOffset),
+					column: getColumnFromOffset(sourceText, startOffset)
+				});
+			}
+		} else if (declarationNode.type === "TSInterfaceDeclaration") {
+			const interfaceName = declarationNode.id?.name;
+			const startOffset = declarationNode.start ?? 0;
+			if (interfaceName) {
+				const redundantPattern = detectRedundantInterfaceDeclaration(declarationNode);
+				if (redundantPattern) redundantTypePatterns.push({
+					typeName: interfaceName,
+					kind: redundantPattern.kind,
+					line: getLineFromOffset(sourceText, startOffset),
+					column: getColumnFromOffset(sourceText, startOffset),
+					reason: redundantPattern.reason,
+					suggestion: redundantPattern.suggestion
+				});
+				const declarationCopy = {
+					...declarationNode,
+					id: void 0
+				};
+				typeDefinitionHashes.push({
+					typeName: interfaceName,
+					structuralHash: `interface:${normalizeTypeAstHash(declarationCopy)}`,
+					line: getLineFromOffset(sourceText, startOffset),
+					column: getColumnFromOffset(sourceText, startOffset)
+				});
+			}
+		} else if (declarationNode.type === "VariableDeclaration") for (const declarator of declarationNode.declarations ?? []) {
+			const wrapperName = declarator.id?.name;
+			const initializerNode = declarator.init;
+			const startOffset = declarator.start ?? declarationNode.start ?? 0;
+			if (!wrapperName || !initializerNode) continue;
+			const wrapperDetection = detectIdentityWrapperFromInitializer(initializerNode, wrapperName);
+			if (wrapperDetection) identityWrappers.push({
+				wrapperName,
+				wrappedExpression: wrapperDetection.wrappedExpression,
+				line: getLineFromOffset(sourceText, startOffset),
+				column: getColumnFromOffset(sourceText, startOffset)
+			});
+		}
+	}
+};
 const WHOLE_OBJECT_FUNCTION_NAMES = new Set([
 	"keys",
 	"values",
@@ -557,12 +2106,14 @@ const extractImportDeclaration = (node, sourceText, imports) => {
 		case "ImportSpecifier": {
 			const importedName = getModuleExportNameValue(specifierNode.imported);
 			const localName = specifierNode.local.name;
+			const isSelfAlias = localName === importedName && specifierNode.imported.type === "Identifier" && specifierNode.imported.start !== specifierNode.local.start;
 			importedNames.push({
 				name: importedName,
 				alias: localName !== importedName ? localName : void 0,
 				isNamespace: false,
 				isDefault: importedName === "default",
-				isTypeOnly: isTypeOnly || specifierNode.importKind === "type"
+				isTypeOnly: isTypeOnly || specifierNode.importKind === "type",
+				isRedundantAlias: isSelfAlias || void 0
 			});
 			break;
 		}
@@ -587,11 +2138,12 @@ const extractImportDeclaration = (node, sourceText, imports) => {
 };
 const extractNamedExportDeclaration = (node, sourceText, exports) => {
 	const isTypeOnly = node.exportKind === "type";
-	const reExportSource = node.source?.value ?? void 0;
+	const reExportSource = node.source?.value;
 	if (node.declaration) extractDeclarationNames(node.declaration, isTypeOnly, sourceText, exports, node.start);
 	for (const specifierNode of node.specifiers) {
 		const exportedName = getModuleExportNameValue(specifierNode.exported);
 		const localName = getModuleExportNameValue(specifierNode.local);
+		const isSelfAlias = exportedName === localName && specifierNode.exported.type === "Identifier" && specifierNode.local.type === "Identifier" && specifierNode.exported.start !== specifierNode.local.start;
 		exports.push({
 			name: exportedName,
 			isDefault: exportedName === "default",
@@ -602,15 +2154,13 @@ const extractNamedExportDeclaration = (node, sourceText, exports) => {
 			reExportOriginalName: reExportSource !== void 0 ? localName : void 0,
 			isNamespaceReExport: false,
 			line: getLineFromOffset(sourceText, specifierNode.start ?? node.start),
-			column: getColumnFromOffset(sourceText, specifierNode.start ?? node.start)
+			column: getColumnFromOffset(sourceText, specifierNode.start ?? node.start),
+			isRedundantAlias: isSelfAlias || void 0
 		});
 	}
 };
 const extractDefaultExportDeclaration = (node, sourceText, exports) => {
-	const defaultExpression = node.declaration;
-	let defaultExportLocalName;
-	if (defaultExpression?.type === "Identifier" && typeof defaultExpression.name === "string") defaultExportLocalName = defaultExpression.name;
-	else if ((defaultExpression?.type === "FunctionDeclaration" || defaultExpression?.type === "ClassDeclaration") && defaultExpression.id?.name) defaultExportLocalName = defaultExpression.id.name;
+	const defaultExportLocalName = extractDefaultExportLocalName(node.declaration);
 	exports.push({
 		name: "default",
 		isDefault: true,
@@ -1718,6 +3268,198 @@ const findMonorepoRoot = (rootDir) => {
 	}
 };
 
+//#endregion
+//#region src/utils/resolve-entry-with-extensions.ts
+const RESOLVABLE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".cjs",
+	".cts"
+];
+const resolveEntryWithExtensions = (basePath) => {
+	if ((0, node_fs.existsSync)(basePath)) return basePath;
+	for (const extension of RESOLVABLE_EXTENSIONS) {
+		const withExtension = basePath + extension;
+		if ((0, node_fs.existsSync)(withExtension)) return withExtension;
+	}
+	for (const extension of RESOLVABLE_EXTENSIONS) {
+		const indexCandidate = (0, node_path.join)(basePath, `index${extension}`);
+		if ((0, node_fs.existsSync)(indexCandidate)) return indexCandidate;
+	}
+};
+const resolveEntryPathWithExtensions = (entryPath, rootDirectory) => {
+	return resolveEntryWithExtensions((0, node_path.resolve)(rootDirectory, entryPath));
+};
+
+//#endregion
+//#region src/collect/config-string-entries.ts
+const CONFIG_STRING_ENTRY_GLOBS = [
+	"webpack.config.{js,ts,mjs,cjs}",
+	"**/webpack*.config.{js,ts,mjs,cjs,babel.js}",
+	"**/configs/webpack.config.{js,ts,mjs,cjs,babel.js}",
+	"**/configs/webpack*.config.{js,ts,mjs,cjs,babel.js}",
+	"jest.config.{js,ts,mjs,cjs,cts}",
+	"**/jest.config.{js,ts,mjs,cjs,cts}",
+	"vitest.config.{js,ts,mjs,mts}",
+	"**/vitest.config.{js,ts,mjs,mts}",
+	"**/vitest.*.config.{js,ts,mjs,mts}",
+	"vite.config.{js,ts,mjs,mts}",
+	"tailwind.config.{js,ts,cjs,mjs}",
+	"**/tailwind.config.{js,ts,cjs,mjs}",
+	"electron.vite.config.{js,ts,mjs}",
+	"electron-builder.config.{js,ts,cjs}",
+	"esbuild*.ts",
+	"**/esbuild.entrypoints.ts",
+	"metro.config.{js,ts}",
+	"playwright.config.{js,ts}",
+	"cypress.config.{js,ts}",
+	"rollup.config.{js,ts,mjs,cjs}",
+	"rollup.*.config.js",
+	"**/.erb/configs/webpack*.config.{js,ts}",
+	"**/.erb/configs/webpack.config.*.{js,ts}",
+	"**/astro-tina-directive/register.js",
+	"rspack.config.{js,ts,mjs,cjs}",
+	"rsbuild.config.{js,ts,mjs,cjs}",
+	"**/scripts/build.ts",
+	"**/scripts/utils/createJestConfig.js"
+];
+const CONFIG_RELATIVE_PATH_PATTERN = /['"`]((\.{1,2}\/|\.\.\/)[^'"`\n]+?|\.\/[^'"`\n]+?)['"`]/g;
+const JEST_ROOT_DIR_PATH_PATTERN = /<rootDir>\/([^'"`\n]+?)(?:['"`]|$)/g;
+const RESOLVE_CALL_PATH_PATTERN = /resolve\s*\(\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const PATH_JOIN_STRING_PATTERN = /path\.(?:join|resolve)\(\s*[^,]+,\s*['"`]([^'"`\n]+?)['"`]/g;
+const ENTRY_POINTS_STRING_PATTERN = /entryPoints:\s*\[\s*['"`]([^'"`\n]+?)['"`]/g;
+const ADD_PREAMBLE_PATTERN = /addPreamble\s*\(\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const ROLLUP_INPUT_PATTERN = /\binput\s*:\s*['"`]([^'"`\n]+?)['"`]/g;
+const VITEST_ENVIRONMENT_PATTERN = /environment\s*:\s*['"`](\.\/[^'"`\n]+?)['"`]/g;
+const ASTRO_ENTRYPOINT_PATTERN = /entrypoint\s*:\s*['"`](\.\/[^'"`\n]+?)['"`]/g;
+const WEBPACK_PATH_JOIN_ENTRY_PATTERN = /path\.join\(\s*[^,]+,\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const WEBPACK_RENDERER_PATH_JOIN_PATTERN = /path\.join\(\s*webpackPaths\.srcRendererPath\s*,\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const WEBPACK_MAIN_PATH_JOIN_PATTERN = /path\.join\(\s*webpackPaths\.srcMainPath\s*,\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const BARE_CONFIG_PATH_PATTERN = /['"`](config\/[^'"`\n]+?)['"`]/g;
+const stripModuleImportStatements = (content) => content.replace(/^\s*import\s+(?:type\s+)?[\s\S]*?\sfrom\s+['"`][^'"`\n]+['"`]\s*;?\s*$/gm, "").replace(/^\s*import\s+['"`][^'"`\n]+['"`]\s*;?\s*$/gm, "");
+const shouldSkipConfigPath = (rawPath) => {
+	if (rawPath.includes("*") || rawPath.includes("?")) return true;
+	if (rawPath.endsWith(".json") && !rawPath.includes("/src/")) return true;
+	if (rawPath.startsWith("node:")) return true;
+	if (rawPath.startsWith("@")) return true;
+	return false;
+};
+const addResolvedConfigPath = (rawPath, configDirectory, projectRootDirectory, entries) => {
+	if (shouldSkipConfigPath(rawPath)) return;
+	const resolvedEntry = resolveEntryWithExtensions((0, node_path.resolve)(rawPath.startsWith(".") ? configDirectory : projectRootDirectory, rawPath.startsWith(".") ? rawPath : `./${rawPath}`));
+	if (resolvedEntry) {
+		entries.add(resolvedEntry);
+		return;
+	}
+	if (rawPath.startsWith(".")) {
+		const projectRootResolvedEntry = resolveEntryWithExtensions((0, node_path.resolve)(projectRootDirectory, rawPath));
+		if (projectRootResolvedEntry) entries.add(projectRootResolvedEntry);
+	}
+};
+const collectResolvedPathsFromStrings = (content, configDirectory, projectRootDirectory, entries) => {
+	const contentWithoutImports = stripModuleImportStatements(content);
+	const patterns = [
+		CONFIG_RELATIVE_PATH_PATTERN,
+		RESOLVE_CALL_PATH_PATTERN,
+		PATH_JOIN_STRING_PATTERN,
+		ENTRY_POINTS_STRING_PATTERN,
+		ADD_PREAMBLE_PATTERN,
+		ROLLUP_INPUT_PATTERN,
+		VITEST_ENVIRONMENT_PATTERN,
+		ASTRO_ENTRYPOINT_PATTERN,
+		WEBPACK_PATH_JOIN_ENTRY_PATTERN,
+		BARE_CONFIG_PATH_PATTERN
+	];
+	for (const pattern of patterns) {
+		let pathMatch;
+		pattern.lastIndex = 0;
+		while ((pathMatch = pattern.exec(contentWithoutImports)) !== null) addResolvedConfigPath(pathMatch[1], configDirectory, projectRootDirectory, entries);
+	}
+	let rendererEntryMatch;
+	WEBPACK_RENDERER_PATH_JOIN_PATTERN.lastIndex = 0;
+	while ((rendererEntryMatch = WEBPACK_RENDERER_PATH_JOIN_PATTERN.exec(contentWithoutImports)) !== null) addResolvedConfigPath(`src/renderer/${rendererEntryMatch[1]}`, configDirectory, projectRootDirectory, entries);
+	let mainEntryMatch;
+	WEBPACK_MAIN_PATH_JOIN_PATTERN.lastIndex = 0;
+	while ((mainEntryMatch = WEBPACK_MAIN_PATH_JOIN_PATTERN.exec(contentWithoutImports)) !== null) addResolvedConfigPath(`src/main/${mainEntryMatch[1]}`, configDirectory, projectRootDirectory, entries);
+	let rootDirMatch;
+	JEST_ROOT_DIR_PATH_PATTERN.lastIndex = 0;
+	while ((rootDirMatch = JEST_ROOT_DIR_PATH_PATTERN.exec(content)) !== null) addResolvedConfigPath(rootDirMatch[1], configDirectory, projectRootDirectory, entries);
+};
+const extractConfigStringReferencedEntries = (directory) => {
+	const entries = /* @__PURE__ */ new Set();
+	const configPaths = fast_glob.default.sync(CONFIG_STRING_ENTRY_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 6
+	});
+	for (const configPath of configPaths) try {
+		collectResolvedPathsFromStrings((0, node_fs.readFileSync)(configPath, "utf-8"), (0, node_path.dirname)(configPath), directory, entries);
+	} catch {
+		continue;
+	}
+	return [...entries];
+};
+
+//#endregion
+//#region src/collect/sections-module-entries.ts
+const SECTIONS_FILE_GLOBS = ["sections.js", "**/sections.js"];
+const CALYPSO_MODULE_PATTERN = /module:\s*['"]calypso\/([^'"]+)['"]/g;
+const SECTION_BOOTSTRAP_SUFFIXES = [
+	"",
+	"/index",
+	"/index.js",
+	"/index.jsx",
+	"/index.ts",
+	"/index.tsx",
+	"/main",
+	"/controller",
+	"/controller.js",
+	"/controller.jsx"
+];
+const addSectionModuleEntry = (modulePath, projectRootDirectory, entries) => {
+	const moduleBasePath = (0, node_path.resolve)(projectRootDirectory, modulePath.replace(/^calypso\//, ""));
+	for (const suffix of SECTION_BOOTSTRAP_SUFFIXES) {
+		const resolvedEntry = resolveEntryWithExtensions(suffix ? `${moduleBasePath}${suffix}` : moduleBasePath);
+		if (resolvedEntry) entries.add(resolvedEntry);
+	}
+};
+const extractSectionsModuleEntries = (directory) => {
+	const entries = /* @__PURE__ */ new Set();
+	const sectionsFilePaths = fast_glob.default.sync(SECTIONS_FILE_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 4
+	});
+	for (const sectionsFilePath of sectionsFilePaths) {
+		if (!sectionsFilePath.endsWith("/client/sections.js")) continue;
+		try {
+			const content = (0, node_fs.readFileSync)(sectionsFilePath, "utf-8");
+			let moduleMatch;
+			CALYPSO_MODULE_PATTERN.lastIndex = 0;
+			while ((moduleMatch = CALYPSO_MODULE_PATTERN.exec(content)) !== null) addSectionModuleEntry(moduleMatch[1], directory, entries);
+		} catch {
+			continue;
+		}
+	}
+	return [...entries];
+};
+
 //#endregion
 //#region src/collect/entries.ts
 const collectSourceFiles = async (config) => {
@@ -1804,8 +3546,11 @@ const resolveEntries = async (config) => {
 	}
 	const frameworkEntries = detectFrameworkEntries(absoluteRoot);
 	const entryEligiblePackages = workspacePackages.filter(isEntryEligible);
+	const monorepoRootForEntries = findMonorepoRoot(absoluteRoot);
+	const ancestorPackageJsonRoots = monorepoRootForEntries && monorepoRootForEntries !== absoluteRoot ? [monorepoRootForEntries] : [];
 	const scriptEntries = extractScriptEntries(absoluteRoot);
 	for (const workspacePackage of entryEligiblePackages) scriptEntries.push(...extractScriptEntries(workspacePackage.directory));
+	for (const ancestorRoot of ancestorPackageJsonRoots) for (const entryPath of extractScriptEntries(ancestorRoot)) if (entryPath.startsWith(`${absoluteRoot}/`)) scriptEntries.push(entryPath);
 	const webpackEntries = extractWebpackEntryPoints(absoluteRoot);
 	for (const workspacePackage of entryEligiblePackages) webpackEntries.push(...extractWebpackEntryPoints(workspacePackage.directory));
 	const viteEntries = extractViteEntryPoints(absoluteRoot);
@@ -1829,6 +3574,9 @@ const resolveEntries = async (config) => {
 	for (const workspacePackage of entryEligiblePackages) webWorkerEntries.push(...extractWebWorkerEntries(workspacePackage.directory));
 	const tsConfigIncludeEntries = extractTsConfigIncludeFilesEntries(absoluteRoot);
 	for (const workspacePackage of entryEligiblePackages) tsConfigIncludeEntries.push(...extractTsConfigIncludeFilesEntries(workspacePackage.directory));
+	const configStringEntries = extractConfigStringReferencedEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) configStringEntries.push(...extractConfigStringReferencedEntries(workspacePackage.directory));
+	const sectionsModuleEntries = extractSectionsModuleEntries(absoluteRoot);
 	const wranglerEntries = extractWranglerEntries(absoluteRoot);
 	for (const workspacePackage of entryEligiblePackages) wranglerEntries.push(...extractWranglerEntries(workspacePackage.directory));
 	const testSetupEntries = extractTestSetupFiles(absoluteRoot);
@@ -1855,6 +3603,8 @@ const resolveEntries = async (config) => {
 			...browserExtensionEntries,
 			...webWorkerEntries,
 			...tsConfigIncludeEntries,
+			...configStringEntries,
+			...sectionsModuleEntries,
 			...wranglerEntries,
 			...pluginFileEntries,
 			...toolingDiscovery.entryFiles,
@@ -1992,15 +3742,21 @@ const extractPackageJsonEntries = async (packageJsonPath) => {
 		if (packageJson.exports) {
 			const exportEntries = [];
 			collectExportPaths(packageJson.exports, rootDir, exportEntries);
-			for (const exportEntry of exportEntries) if ((0, node_fs.existsSync)(exportEntry)) entries.push(exportEntry);
-			else {
-				const sourcePath = resolveSourcePath(exportEntry, rootDir);
-				if (sourcePath) entries.push(sourcePath);
-				else if (exportEntry.endsWith(".ts")) {
+			for (const exportEntry of exportEntries) {
+				const resolvedExportEntry = resolveEntryWithExtensions(exportEntry) ?? resolveEntryPathWithExtensions(exportEntry, rootDir) ?? resolveSourcePath(exportEntry, rootDir);
+				if (resolvedExportEntry && (0, node_fs.existsSync)(resolvedExportEntry)) {
+					entries.push(resolvedExportEntry);
+					continue;
+				}
+				if (exportEntry.endsWith(".ts")) {
 					const tsxFallback = exportEntry.replace(/\.ts$/, ".tsx");
-					if ((0, node_fs.existsSync)(tsxFallback)) entries.push(tsxFallback);
-					else entries.push(exportEntry);
-				} else entries.push(resolveEntryPath(exportEntry, rootDir));
+					if ((0, node_fs.existsSync)(tsxFallback)) {
+						entries.push(tsxFallback);
+						continue;
+					}
+				}
+				if ((0, node_fs.existsSync)(exportEntry)) entries.push(exportEntry);
+				else entries.push(resolveEntryPath(exportEntry, rootDir));
 			}
 		}
 		if (packageJson.bin) {
@@ -2009,9 +3765,52 @@ const extractPackageJsonEntries = async (packageJsonPath) => {
 				for (const binPath of Object.values(packageJson.bin)) if (typeof binPath === "string") entries.push(resolveEntryPath(binPath, rootDir));
 			}
 		}
+		if (Array.isArray(packageJson.sideEffects)) for (const sideEffectPattern of packageJson.sideEffects) {
+			if (typeof sideEffectPattern !== "string") continue;
+			const sourcePatterns = expandSideEffectGlobToSourcePatterns(sideEffectPattern);
+			for (const sourcePattern of sourcePatterns) {
+				const matchedSideEffectFiles = fast_glob.default.sync(sourcePattern, {
+					cwd: rootDir,
+					absolute: true,
+					onlyFiles: true,
+					ignore: [
+						"**/node_modules/**",
+						"**/dist/**",
+						"**/build/**"
+					]
+				});
+				for (const matchedSideEffectFile of matchedSideEffectFiles) if (isImportableSourceFile(matchedSideEffectFile)) entries.push(matchedSideEffectFile);
+			}
+		}
+		if (packageJson.build && typeof packageJson.build === "object") {
+			const buildConfig = packageJson.build;
+			if (Array.isArray(buildConfig.files)) for (const buildFileEntry of buildConfig.files) {
+				if (typeof buildFileEntry !== "string") continue;
+				if (buildFileEntry.includes("*")) continue;
+				const resolvedBuildFile = resolveEntryWithExtensions((0, node_path.resolve)(rootDir, buildFileEntry)) ?? resolveEntryPathWithExtensions(buildFileEntry, rootDir);
+				if (resolvedBuildFile && (0, node_fs.existsSync)(resolvedBuildFile)) entries.push(resolvedBuildFile);
+			}
+		}
+		if (packageJson.jest && typeof packageJson.jest === "object") {
+			const jestRootDirMatches = JSON.stringify(packageJson.jest).matchAll(/<rootDir>\/([^"\\]+)/g);
+			for (const jestRootDirMatch of jestRootDirMatches) {
+				const resolvedJestFile = resolveEntryPathWithExtensions(jestRootDirMatch[1], rootDir);
+				if (resolvedJestFile && (0, node_fs.existsSync)(resolvedJestFile)) entries.push(resolvedJestFile);
+			}
+		}
 	} catch {}
 	return entries;
 };
+const expandSideEffectGlobToSourcePatterns = (pattern) => {
+	const patterns = new Set([pattern]);
+	if (pattern.endsWith(".js")) {
+		patterns.add(pattern.replace(/\.js$/, ".ts"));
+		patterns.add(pattern.replace(/\.js$/, ".tsx"));
+	}
+	if (pattern.includes("/lib/") || pattern.startsWith("lib/")) patterns.add(pattern.replace(/\blib\b/g, "src"));
+	if (pattern.includes("/esm/") || pattern.startsWith("esm/")) patterns.add(pattern.replace(/\besm\b/g, "src"));
+	return [...patterns];
+};
 const SHELL_OPERATORS_PATTERN = /\s*(?:&&|\|\||[;&|])\s*/;
 const SCRIPT_MULTIPLEXERS = new Set([
 	"concurrently",
@@ -2389,23 +4188,6 @@ const WEBPACK_ENTRY_BLOCK_PATTERN = /entry\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'
 const WEBPACK_ENTRY_FILE_PATTERN = /['"]([^'"]+)['"]/g;
 const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"]\s*,?\s*)+)\)/g;
 const REQUIRE_RESOLVE_PATTERN = /require\.resolve\(\s*['"]([^'"]+)['"]\s*\)/g;
-const RESOLVABLE_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	".mjs",
-	".mts"
-];
-const resolveEntryWithExtensions = (basePath) => {
-	if ((0, node_fs.existsSync)(basePath)) return basePath;
-	for (const extension of RESOLVABLE_EXTENSIONS) {
-		const withExtension = basePath + extension;
-		if ((0, node_fs.existsSync)(withExtension)) return withExtension;
-	}
-	const indexCandidates = RESOLVABLE_EXTENSIONS.map((extension) => (0, node_path.resolve)(basePath, `index${extension}`));
-	for (const candidate of indexCandidates) if ((0, node_fs.existsSync)(candidate)) return candidate;
-};
 const extractWebpackEntryPoints = (directory) => {
 	const entries = [];
 	const webpackConfigPaths = fast_glob.default.sync([
@@ -2451,7 +4233,7 @@ const extractWebpackEntryPoints = (directory) => {
 			while ((valueMatch = WEBPACK_ENTRY_FILE_PATTERN.exec(entryBlock)) !== null) {
 				const entryPath = valueMatch[1];
 				if (entryPath.startsWith("./") || entryPath.startsWith("../") || !entryPath.startsWith("/")) {
-					const resolvedEntry = resolveEntryWithExtensions((0, node_path.resolve)(directory, entryPath));
+					const resolvedEntry = resolveEntryWithExtensions((0, node_path.resolve)(configDirectory, entryPath));
 					if (resolvedEntry) entries.push(resolvedEntry);
 				}
 			}
@@ -2941,15 +4723,15 @@ const extractTestSetupFiles = (directory) => {
 			const arrayContent = setupMatch[1];
 			const singleValue = setupMatch[2];
 			if (singleValue) {
-				const absolutePath = (0, node_path.resolve)(configDirectory, singleValue);
-				if ((0, node_fs.existsSync)(absolutePath)) entries.push(absolutePath);
+				const resolvedPath = resolveEntryWithExtensions((0, node_path.resolve)(configDirectory, singleValue));
+				if (resolvedPath) entries.push(resolvedPath);
 			}
 			if (arrayContent) {
 				let pathMatch;
 				SETUP_FILE_PATH_PATTERN.lastIndex = 0;
 				while ((pathMatch = SETUP_FILE_PATH_PATTERN.exec(arrayContent)) !== null) {
-					const absolutePath = (0, node_path.resolve)(configDirectory, pathMatch[1]);
-					if ((0, node_fs.existsSync)(absolutePath)) entries.push(absolutePath);
+					const resolvedPath = resolveEntryWithExtensions((0, node_path.resolve)(configDirectory, pathMatch[1]));
+					if (resolvedPath) entries.push(resolvedPath);
 				}
 			}
 		}
@@ -3686,13 +5468,16 @@ const FRAMEWORK_PATTERNS = [
 			"electron-builder",
 			"@electron-forge/cli",
 			"electron-vite",
-			"electron-webpack"
+			"electron-webpack",
+			"electron-next"
 		],
 		enablerPrefixes: ["@electron-forge/", "@electron/"],
 		entryPatterns: [
 			"src/main/**/*.{ts,tsx,js,jsx}",
 			"src/preload/**/*.{ts,tsx,js,jsx}",
-			"electron/main.{ts,js}"
+			"electron/main.{ts,js}",
+			"main/index.{ts,tsx,js,jsx}",
+			"renderer/pages/**/*.{ts,tsx,js,jsx}"
 		],
 		alwaysUsed: [
 			"electron-builder.{yml,yaml,json,json5,toml}",
@@ -4105,7 +5890,7 @@ const TSCONFIG_FILENAMES = [
 	"tsconfig.base.json",
 	"jsconfig.json"
 ];
-const findNearestTsconfig = (fromDir, rootDir, monorepoRootDir) => {
+const findNearestTsconfig$1 = (fromDir, rootDir, monorepoRootDir) => {
 	let currentDirectory = fromDir;
 	const stopAt = monorepoRootDir ? (0, node_path.resolve)(monorepoRootDir) : (0, node_path.resolve)(rootDir);
 	while (currentDirectory.length >= stopAt.length) {
@@ -4307,7 +6092,7 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 		const fileDir = (0, node_path.dirname)(filePath);
 		const cached = tsconfigPathCache.get(fileDir);
 		if (cached !== void 0) return cached;
-		const tsconfigResult = findNearestTsconfig(fileDir, config.rootDir, options.monorepoRoot) ?? rootTsconfigPath;
+		const tsconfigResult = findNearestTsconfig$1(fileDir, config.rootDir, options.monorepoRoot) ?? rootTsconfigPath;
 		tsconfigPathCache.set(fileDir, tsconfigResult);
 		return tsconfigResult;
 	};
@@ -4731,6 +6516,18 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			resolveResultCache.set(cacheKey, resolvedResult);
 			return resolvedResult;
 		}
+		if (cleanedSpecifier.startsWith(".")) {
+			const relativeResolved = tryResolveFromDirectory(fromDir, cleanedSpecifier);
+			if (relativeResolved && existsAsFile(relativeResolved)) {
+				const resolvedResult = {
+					resolvedPath: relativeResolved,
+					isExternal: false,
+					packageName: void 0
+				};
+				resolveResultCache.set(cacheKey, resolvedResult);
+				return resolvedResult;
+			}
+		}
 		const unresolvedResult = {
 			resolvedPath: void 0,
 			isExternal: false,
@@ -4826,6 +6623,16 @@ const buildDependencyGraph = (inputs) => {
 		exports: input.parsed.exports,
 		memberAccesses: input.parsed.memberAccesses,
 		wholeObjectUses: input.parsed.wholeObjectUses,
+		localIdentifierReferences: input.parsed.localIdentifierReferences,
+		referencedFilenames: input.parsed.referencedFilenames,
+		redundantTypePatterns: input.parsed.redundantTypePatterns,
+		identityWrappers: input.parsed.identityWrappers,
+		typeDefinitionHashes: input.parsed.typeDefinitionHashes,
+		inlineTypeLiterals: input.parsed.inlineTypeLiterals,
+		simplifiableFunctions: input.parsed.simplifiableFunctions,
+		simplifiableExpressions: input.parsed.simplifiableExpressions,
+		duplicateConstantCandidates: input.parsed.duplicateConstantCandidates,
+		parseErrors: input.parsed.errors,
 		isEntryPoint: input.isEntryPoint,
 		isTestEntry: input.isTestEntry,
 		isReachable: false,
@@ -5145,6 +6952,21 @@ const hasExcludedExtension = (filePath) => {
 	return EXCLUDED_EXTENSIONS.has(filePath.slice(lastDot));
 };
 const isExcludedByPattern = (filePath) => TEST_FILE_PATTERN.test(filePath) || EXCLUDED_DIRECTORY_PATTERN.test(filePath) || CONFIG_FILE_PATTERN.test(filePath);
+/**
+* Files the parser couldn't analyze (minified bundles, oversized files, binaries)
+* have no detectable imports — they're effectively opaque. Flagging them as
+* "unused" is a false positive because we can't see who imports them, and they
+* may be static assets, generated bundles, or build artifacts that get loaded
+* outside the JS module graph (HTML `<script src>`, `vite-plugin-string`, etc.).
+* The parser already records a `file-minified`/`file-too-large`/`file-binary`
+* info-level entry in `analysisErrors`, which is the actionable signal.
+*/
+const PARSE_OPAQUE_ERROR_CODES = new Set([
+	"file-minified",
+	"file-too-large",
+	"file-binary"
+]);
+const isOpaqueToAnalysis = (module) => module.parseErrors.some((parseError) => parseError.code && PARSE_OPAQUE_ERROR_CODES.has(parseError.code));
 const detectOrphanFiles = (graph) => {
 	const unusedFiles = [];
 	for (const module of graph.modules) {
@@ -5154,6 +6976,7 @@ const detectOrphanFiles = (graph) => {
 		if (module.isConfigFile) continue;
 		if (hasExcludedExtension(module.fileId.path)) continue;
 		if (isExcludedByPattern(module.fileId.path)) continue;
+		if (isOpaqueToAnalysis(module)) continue;
 		if (isBarrelWithReachableSources(module, graph)) continue;
 		if (hasReachableDirectImporter(module.fileId.index, graph)) continue;
 		unusedFiles.push({ path: module.fileId.path });
@@ -5194,6 +7017,7 @@ const detectDeadExports = (graph, config) => {
 			if (!config.reportTypes && exportInfo.isTypeOnly) continue;
 			const usageKey = `${module.fileId.path}::${exportInfo.name}`;
 			if (usageMap.has(usageKey)) continue;
+			if (module.localIdentifierReferences.includes(exportInfo.name)) continue;
 			if (!exportInfo.isDefault && defaultExportLinkedNames.has(exportInfo.name)) continue;
 			unusedExports.push({
 				path: module.fileId.path,
@@ -5227,6 +7051,11 @@ const buildUsageMap = (graph) => {
 		else {
 			const importName = symbol.isDefault ? "default" : symbol.importedName;
 			markExportUsedRecursive(targetModule.fileId.path, importName, graph, sourceToTargetMap, usedExportKeys, /* @__PURE__ */ new Set());
+			if (symbol.isDefault) {
+				if (!targetModule.exports.some((exportInfo) => exportInfo.isDefault) && symbol.localName !== "default") {
+					if (targetModule.exports.find((exportInfo) => exportInfo.name === symbol.localName)) markExportUsedRecursive(targetModule.fileId.path, symbol.localName, graph, sourceToTargetMap, usedExportKeys, /* @__PURE__ */ new Set());
+				}
+			}
 		}
 	}
 	return usedExportKeys;
@@ -5437,6 +7266,7 @@ const matchesPackageImportReference = (content, packageName) => {
 		new RegExp(`\\bfrom\\s+['"]${escapedPackageName}${subpathPattern}['"]`),
 		new RegExp(`\\bimport\\s+(?:[^'";\\n]*?\\sfrom\\s+)?['"]${escapedPackageName}${subpathPattern}['"]`),
 		new RegExp(`\\brequire\\s*\\(\\s*['"]${escapedPackageName}${subpathPattern}['"]\\s*\\)`),
+		new RegExp(`\\brequire\\s*\\(\\s*\`${escapedPackageName}${subpathPattern}`),
 		new RegExp(`\\bimport\\s*\\(\\s*['"]${escapedPackageName}${subpathPattern}['"]`)
 	].some((pattern) => pattern.test(content));
 };
@@ -5477,13 +7307,13 @@ const detectStalePackages = (graph, config) => {
 	const declaredNames = new Set(declaredDependencies.keys());
 	const usedPackageNames = collectUsedPackages(graph);
 	const monorepoRoot = findMonorepoRoot(config.rootDir);
-	const nodeModulesRoot = monorepoRoot ?? config.rootDir;
+	const nodeModulesSearchRoots = monorepoRoot && monorepoRoot !== config.rootDir ? [config.rootDir, monorepoRoot] : [config.rootDir];
 	const allPackageJsonPaths = discoverAllPackageJsonPaths(config.rootDir);
 	if (monorepoRoot) {
 		const monorepoPackageJson = (0, node_path.join)(monorepoRoot, "package.json");
 		if (!allPackageJsonPaths.includes(monorepoPackageJson) && (0, node_fs.existsSync)(monorepoPackageJson)) allPackageJsonPaths.push(monorepoPackageJson);
 	}
-	const binToPackage = buildBinToPackageMap(nodeModulesRoot, declaredNames);
+	const binToPackage = buildBinToPackageMap(nodeModulesSearchRoots, declaredNames);
 	for (const workspacePackageJsonPath of allPackageJsonPaths) {
 		const scriptReferenced = collectScriptReferencedPackages(workspacePackageJsonPath, declaredNames, binToPackage);
 		for (const packageName of scriptReferenced) usedPackageNames.add(packageName);
@@ -5529,7 +7359,7 @@ const detectStalePackages = (graph, config) => {
 			if ("react-dom" in peerDeps && declaredDependencies.get("react-dom") === true) usedPackageNames.add("react-dom");
 		} catch {}
 	}
-	const peerSatisfied = collectPeerSatisfiedPackages(nodeModulesRoot, declaredNames, usedPackageNames);
+	const peerSatisfied = collectPeerSatisfiedPackages(nodeModulesSearchRoots, declaredNames, usedPackageNames);
 	for (const packageName of peerSatisfied) usedPackageNames.add(packageName);
 	const staticPeerSatisfied = collectStaticPeerSatisfiedPackages(declaredNames, usedPackageNames);
 	for (const packageName of staticPeerSatisfied) usedPackageNames.add(packageName);
@@ -5575,14 +7405,14 @@ const hasJsxFiles = (graph) => graph.modules.some((module) => {
 	const filePath = module.fileId.path;
 	return filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
 });
-const collectPeerSatisfiedPackages = (rootDir, declaredNames, confirmedUsedNames) => {
+const collectPeerSatisfiedPackages = (nodeModulesSearchRoots, declaredNames, confirmedUsedNames) => {
 	const peerSatisfied = /* @__PURE__ */ new Set();
-	const nodeModulesDir = (0, node_path.join)(rootDir, "node_modules");
 	for (const installedName of declaredNames) {
 		if (!confirmedUsedNames.has(installedName)) continue;
-		const packageJsonPath = installedName.startsWith("@") ? (0, node_path.join)(nodeModulesDir, ...installedName.split("/"), "package.json") : (0, node_path.join)(nodeModulesDir, installedName, "package.json");
+		const installedPackageJsonPath = findInstalledPackageJsonPath(installedName, nodeModulesSearchRoots);
+		if (!installedPackageJsonPath) continue;
 		try {
-			const content = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
+			const content = (0, node_fs.readFileSync)(installedPackageJsonPath, "utf-8");
 			const peerDeps = JSON.parse(content).peerDependencies;
 			if (peerDeps && typeof peerDeps === "object") {
 				for (const peerName of Object.keys(peerDeps)) if (declaredNames.has(peerName)) peerSatisfied.add(peerName);
@@ -5593,6 +7423,12 @@ const collectPeerSatisfiedPackages = (rootDir, declaredNames, confirmedUsedNames
 	}
 	return peerSatisfied;
 };
+const findInstalledPackageJsonPath = (packageName, nodeModulesSearchRoots) => {
+	for (const searchRoot of nodeModulesSearchRoots) {
+		const candidatePath = packageName.startsWith("@") ? (0, node_path.join)(searchRoot, "node_modules", ...packageName.split("/"), "package.json") : (0, node_path.join)(searchRoot, "node_modules", packageName, "package.json");
+		if ((0, node_fs.existsSync)(candidatePath)) return candidatePath;
+	}
+};
 const STATIC_PEER_DEPENDENCY_MAP = {
 	"@apollo/client": ["graphql"],
 	"@docusaurus/core": ["@mdx-js/react"],
@@ -5686,7 +7522,9 @@ const CLI_BINARY_TO_PACKAGE = {
 };
 const CLI_BINARY_FALLBACK_PACKAGES = {
 	babel: ["babel-cli"],
-	jest: ["jest-cli"]
+	jest: ["jest-cli"],
+	remark: ["remark-cli"],
+	dumi: ["dumi"]
 };
 const ENV_WRAPPER_BINARY_SET = new Set([
 	"cross-env",
@@ -5695,11 +7533,12 @@ const ENV_WRAPPER_BINARY_SET = new Set([
 	"env-cmd"
 ]);
 const INLINE_ENV_VAR_PATTERN = /^[A-Z_][A-Z0-9_]*=/;
-const buildBinToPackageMap = (rootDir, declaredNames) => {
+const buildBinToPackageMap = (nodeModulesSearchRoots, declaredNames) => {
 	const binToPackage = /* @__PURE__ */ new Map();
 	for (const [binary, packageName] of Object.entries(CLI_BINARY_TO_PACKAGE)) binToPackage.set(binary, packageName);
 	for (const packageName of declaredNames) {
-		const packageBinJsonPath = packageName.startsWith("@") ? (0, node_path.join)(rootDir, "node_modules", ...packageName.split("/"), "package.json") : (0, node_path.join)(rootDir, "node_modules", packageName, "package.json");
+		const packageBinJsonPath = findInstalledPackageJsonPath(packageName, nodeModulesSearchRoots);
+		if (!packageBinJsonPath) continue;
 		try {
 			const binContent = (0, node_fs.readFileSync)(packageBinJsonPath, "utf-8");
 			const binPackageJson = JSON.parse(binContent);
@@ -5791,7 +7630,12 @@ const CONFIG_FILE_GLOBS = [
 	".lintstagedrc.{js,cjs,mjs,json}",
 	"commitlint.config.{js,cjs,mjs,ts}",
 	".commitlintrc.{js,cjs,mjs,json,yaml,yml}",
-	"tslint.json"
+	"tslint.json",
+	".remarkrc",
+	".remarkrc.{js,cjs,mjs,json}",
+	".dumirc.ts",
+	".dumirc.js",
+	"dumi.config.{ts,js}"
 ];
 const collectConfigReferencedPackages = (rootDir, graph, declaredNames) => {
 	const referenced = /* @__PURE__ */ new Set();
@@ -5818,6 +7662,24 @@ const collectConfigReferencedPackages = (rootDir, graph, declaredNames) => {
 	} catch {
 		continue;
 	}
+	const documentationFiles = fast_glob.default.sync(["**/*.{mdx,md}"], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/CHANGELOG.md"
+		],
+		deep: 6
+	});
+	for (const documentationPath of documentationFiles) try {
+		const content = (0, node_fs.readFileSync)(documentationPath, "utf-8");
+		for (const packageName of declaredNames) if (matchesPackageImportReference(content, packageName)) referenced.add(packageName);
+	} catch {
+		continue;
+	}
 	return referenced;
 };
 const PACKAGE_JSON_CONFIG_SECTIONS = [
@@ -6140,103 +8002,1495 @@ const findStronglyConnectedComponents = (adjacencyList) => {
 			}
 		}
 	}
-	return components;
+	return components;
+};
+const canonicalizeCycle = (cycle, graph) => {
+	if (cycle.length === 0) return [];
+	let minPosition = 0;
+	let minPath = graph.modules[cycle[0]].fileId.path;
+	for (let position = 1; position < cycle.length; position++) {
+		const currentPath = graph.modules[cycle[position]].fileId.path;
+		if (currentPath < minPath) {
+			minPath = currentPath;
+			minPosition = position;
+		}
+	}
+	return [...cycle.slice(minPosition), ...cycle.slice(0, minPosition)];
+};
+const enumerateElementaryCycles = (componentNodes, adjacencyList, graph) => {
+	if (componentNodes.length === 2) {
+		const [nodeA, nodeB] = componentNodes;
+		return [graph.modules[nodeA].fileId.path <= graph.modules[nodeB].fileId.path ? [nodeA, nodeB] : [nodeB, nodeA]];
+	}
+	const componentSet = new Set(componentNodes);
+	const cycles = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	for (const startNode of componentNodes) {
+		if (cycles.length >= 20) break;
+		const visitedInThisSearch = /* @__PURE__ */ new Set();
+		visitedInThisSearch.add(startNode);
+		const pathStack = [startNode];
+		const successorPositionStack = [0];
+		while (pathStack.length > 0 && cycles.length < 20) {
+			const currentNode = pathStack[pathStack.length - 1];
+			const currentSuccessorPosition = successorPositionStack[successorPositionStack.length - 1];
+			const successors = adjacencyList[currentNode].filter((successor) => componentSet.has(successor));
+			if (currentSuccessorPosition < successors.length) {
+				successorPositionStack[successorPositionStack.length - 1]++;
+				const successor = successors[currentSuccessorPosition];
+				if (successor === startNode) {
+					const canonical = canonicalizeCycle([...pathStack], graph);
+					const key = canonical.join(",");
+					if (!seenKeys.has(key)) {
+						seenKeys.add(key);
+						cycles.push(canonical);
+					}
+				} else if (!visitedInThisSearch.has(successor)) {
+					visitedInThisSearch.add(successor);
+					pathStack.push(successor);
+					successorPositionStack.push(0);
+				}
+			} else {
+				visitedInThisSearch.delete(pathStack.pop());
+				successorPositionStack.pop();
+			}
+		}
+	}
+	return cycles;
+};
+const detectCycles = (graph) => {
+	const adjacencyList = buildAdjacencyList(graph);
+	const components = findStronglyConnectedComponents(adjacencyList);
+	const allCycles = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	const sortedComponents = [...components].sort((componentA, componentB) => componentA.length - componentB.length);
+	for (const component of sortedComponents) {
+		if (allCycles.length >= 200) break;
+		if (component.length > 50) continue;
+		const elementaryCycles = enumerateElementaryCycles(component, adjacencyList, graph);
+		for (const cycle of elementaryCycles) {
+			const key = cycle.join(",");
+			if (!seenKeys.has(key)) {
+				seenKeys.add(key);
+				allCycles.push(cycle);
+			}
+			if (allCycles.length >= 200) break;
+		}
+	}
+	allCycles.sort((cycleA, cycleB) => {
+		const lengthDiff = cycleA.length - cycleB.length;
+		if (lengthDiff !== 0) return lengthDiff;
+		return graph.modules[cycleA[0]].fileId.path.localeCompare(graph.modules[cycleB[0]].fileId.path);
+	});
+	return allCycles.map((cycle) => ({ files: cycle.map((nodeIndex) => graph.modules[nodeIndex].fileId.path) }));
+};
+
+//#endregion
+//#region src/report/redundancy.ts
+const isPlatformSpecificModulePath = (modulePath) => {
+	const extensionIndex = modulePath.lastIndexOf(".");
+	if (extensionIndex === -1) return false;
+	const withoutExtension = modulePath.slice(0, extensionIndex);
+	return PLATFORM_SUFFIXES.some((suffix) => withoutExtension.endsWith(suffix));
+};
+const platformStrippedBasePath = (modulePath) => {
+	const extensionIndex = modulePath.lastIndexOf(".");
+	if (extensionIndex === -1) return modulePath;
+	const withoutExtension = modulePath.slice(0, extensionIndex);
+	for (const suffix of PLATFORM_SUFFIXES) if (withoutExtension.endsWith(suffix)) return withoutExtension.slice(0, -suffix.length) + modulePath.slice(extensionIndex);
+	return modulePath;
+};
+const buildPlatformSiblingGroupSizes = (graph) => {
+	const baseToCount = /* @__PURE__ */ new Map();
+	for (const module of graph.modules) {
+		const base = platformStrippedBasePath(module.fileId.path);
+		baseToCount.set(base, (baseToCount.get(base) ?? 0) + 1);
+	}
+	return baseToCount;
+};
+const detectUselessAliasedReExports = (graph) => {
+	const findings = [];
+	const moduleConsumerImportedNames = /* @__PURE__ */ new Map();
+	const moduleConsumedWholesale = /* @__PURE__ */ new Set();
+	const platformSiblingGroupSizes = buildPlatformSiblingGroupSizes(graph);
+	for (const edge of graph.edges) {
+		if (edge.isReExportEdge) {
+			const reExportedSet = moduleConsumerImportedNames.get(edge.target);
+			if (edge.reExportedNames.includes("*")) moduleConsumedWholesale.add(edge.target);
+			if (reExportedSet) for (const reExportedName of edge.reExportedNames) reExportedSet.add(reExportedName);
+			else moduleConsumerImportedNames.set(edge.target, new Set(edge.reExportedNames));
+			continue;
+		}
+		if (edge.importedSymbols.length === 0) {
+			moduleConsumedWholesale.add(edge.target);
+			continue;
+		}
+		const importedSet = moduleConsumerImportedNames.get(edge.target);
+		for (const symbol of edge.importedSymbols) {
+			if (symbol.isNamespace || symbol.importedName === "*") {
+				moduleConsumedWholesale.add(edge.target);
+				continue;
+			}
+			const importedName = symbol.isDefault ? "default" : symbol.importedName;
+			if (importedSet) importedSet.add(importedName);
+			else moduleConsumerImportedNames.set(edge.target, new Set([importedName]));
+		}
+	}
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		if (moduleConsumedWholesale.has(module.fileId.index)) continue;
+		if (isPlatformSpecificModulePath(module.fileId.path)) continue;
+		const platformBase = platformStrippedBasePath(module.fileId.path);
+		if ((platformSiblingGroupSizes.get(platformBase) ?? 0) > 1) continue;
+		const consumerImportedNames = moduleConsumerImportedNames.get(module.fileId.index) ?? /* @__PURE__ */ new Set();
+		for (const exportInfo of module.exports) {
+			if (exportInfo.isSynthetic) continue;
+			if (!exportInfo.isReExport) continue;
+			if (!exportInfo.reExportOriginalName) continue;
+			const exportedName = exportInfo.name;
+			const originalName = exportInfo.reExportOriginalName;
+			if (exportedName === originalName) continue;
+			if (exportedName === "*") continue;
+			if (originalName === "*") continue;
+			if (originalName === "default") continue;
+			if (exportInfo.isNamespaceReExport) continue;
+			if (consumerImportedNames.has(exportedName)) continue;
+			findings.push({
+				path: module.fileId.path,
+				kind: "reexport-aliased-not-used",
+				name: exportedName,
+				aliasedFrom: originalName,
+				line: exportInfo.line,
+				column: exportInfo.column,
+				confidence: "medium",
+				reason: `\`export { ${originalName} as ${exportedName} } from ...\` renames the symbol but no consumer imports it as \`${exportedName}\` — either drop the alias or have consumers use the new name`
+			});
+		}
+	}
+	return findings;
+};
+const detectRedundantAliases = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		if (!module.isReachable) continue;
+		for (const importInfo of module.imports) for (const binding of importInfo.importedNames) {
+			if (!binding.isRedundantAlias) continue;
+			findings.push({
+				path: module.fileId.path,
+				kind: "import-self-alias",
+				name: binding.name,
+				aliasedFrom: binding.name,
+				line: importInfo.line,
+				column: importInfo.column,
+				confidence: "high",
+				reason: `\`import { ${binding.name} as ${binding.name} }\` aliases an identifier to its own name`
+			});
+		}
+		for (const exportInfo of module.exports) {
+			if (exportInfo.isSynthetic) continue;
+			if (!exportInfo.isRedundantAlias) continue;
+			const kind = exportInfo.isReExport ? "reexport-self-alias" : "export-self-alias";
+			const sourceSuffix = exportInfo.reExportSource ? ` from "${exportInfo.reExportSource}"` : "";
+			findings.push({
+				path: module.fileId.path,
+				kind,
+				name: exportInfo.name,
+				aliasedFrom: exportInfo.name,
+				line: exportInfo.line,
+				column: exportInfo.column,
+				confidence: "high",
+				reason: `\`export { ${exportInfo.name} as ${exportInfo.name} }${sourceSuffix}\` aliases an identifier to its own name`
+			});
+		}
+	}
+	return findings;
+};
+const detectDuplicateExports = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		const nameToOccurrences = /* @__PURE__ */ new Map();
+		const nameHasReExport = /* @__PURE__ */ new Map();
+		for (const exportInfo of module.exports) {
+			if (exportInfo.isSynthetic) continue;
+			if (exportInfo.name === "*" && exportInfo.isNamespaceReExport) continue;
+			const occurrence = {
+				line: exportInfo.line,
+				column: exportInfo.column,
+				reExportSource: exportInfo.reExportSource,
+				isReExport: exportInfo.isReExport
+			};
+			const existing = nameToOccurrences.get(exportInfo.name);
+			if (existing) existing.push(occurrence);
+			else nameToOccurrences.set(exportInfo.name, [occurrence]);
+			if (exportInfo.isReExport) nameHasReExport.set(exportInfo.name, true);
+		}
+		for (const [name, occurrences] of nameToOccurrences) {
+			if (occurrences.length < 2) continue;
+			if (!nameHasReExport.get(name)) continue;
+			findings.push({
+				path: module.fileId.path,
+				name,
+				occurrences,
+				confidence: "high",
+				reason: `"${name}" is exported ${occurrences.length} times from the same module`
+			});
+		}
+	}
+	return findings;
+};
+
+//#endregion
+//#region src/report/dry-patterns.ts
+const detectDuplicateImports = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		const groupedByKindAndSpecifier = /* @__PURE__ */ new Map();
+		for (const importInfo of module.imports) {
+			if (importInfo.isSideEffect) continue;
+			if (importInfo.isDynamic) continue;
+			if (importInfo.isGlob) continue;
+			const occurrence = {
+				line: importInfo.line,
+				column: importInfo.column,
+				importedNames: importInfo.importedNames.map((binding) => binding.isNamespace ? `* as ${binding.alias ?? ""}` : binding.alias ?? binding.name),
+				isTypeOnly: importInfo.isTypeOnly
+			};
+			const groupKey = `${importInfo.isTypeOnly ? "type" : "value"}:${importInfo.specifier}`;
+			const existing = groupedByKindAndSpecifier.get(groupKey);
+			if (existing) existing.push(occurrence);
+			else groupedByKindAndSpecifier.set(groupKey, [occurrence]);
+		}
+		for (const [groupKey, occurrences] of groupedByKindAndSpecifier) {
+			if (occurrences.length < 2) continue;
+			const specifier = groupKey.slice(groupKey.indexOf(":") + 1);
+			const kindLabel = groupKey.startsWith("type:") ? "type-only " : "";
+			findings.push({
+				path: module.fileId.path,
+				specifier,
+				occurrences,
+				confidence: "high",
+				reason: `"${specifier}" is imported ${occurrences.length} times in this file as ${kindLabel}imports — merge into a single statement`
+			});
+		}
+	}
+	return findings;
+};
+const detectRedundantTypePatterns = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const parsedPattern of module.redundantTypePatterns) findings.push({
+			path: module.fileId.path,
+			typeName: parsedPattern.typeName,
+			kind: parsedPattern.kind,
+			line: parsedPattern.line,
+			column: parsedPattern.column,
+			confidence: "high",
+			reason: parsedPattern.reason,
+			suggestion: parsedPattern.suggestion
+		});
+	}
+	return findings;
+};
+const detectIdentityWrappers = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const parsedWrapper of module.identityWrappers) findings.push({
+			path: module.fileId.path,
+			wrapperName: parsedWrapper.wrapperName,
+			wrappedExpression: parsedWrapper.wrappedExpression,
+			line: parsedWrapper.line,
+			column: parsedWrapper.column,
+			confidence: "high",
+			reason: `\`${parsedWrapper.wrapperName}\` is a thin wrapper that forwards every argument to \`${parsedWrapper.wrappedExpression}\` unchanged`
+		});
+	}
+	return findings;
+};
+const detectDuplicateTypeDefinitions = (graph) => {
+	const hashToInstances = /* @__PURE__ */ new Map();
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const typeHash of module.typeDefinitionHashes) {
+			const instance = {
+				path: module.fileId.path,
+				typeName: typeHash.typeName,
+				line: typeHash.line,
+				column: typeHash.column
+			};
+			const existing = hashToInstances.get(typeHash.structuralHash);
+			if (existing) existing.push(instance);
+			else hashToInstances.set(typeHash.structuralHash, [instance]);
+		}
+	}
+	const findings = [];
+	for (const [structuralHash, instances] of hashToInstances) {
+		if (instances.length < 2) continue;
+		const uniquePaths = new Set(instances.map((instance) => instance.path));
+		if (uniquePaths.size < 2) continue;
+		const uniqueNames = new Set(instances.map((instance) => instance.typeName));
+		const isAllSameName = uniqueNames.size === 1;
+		findings.push({
+			structuralHash,
+			instances,
+			confidence: isAllSameName ? "high" : "medium",
+			reason: isAllSameName ? `${instances.length} identically-named type definitions of the same shape across ${uniquePaths.size} files — extract a shared definition` : `${instances.length} structurally-identical type definitions detected across ${uniquePaths.size} files under different names (${[...uniqueNames].join(", ")}) — confirm whether the rename is intentional`
+		});
+	}
+	return findings;
+};
+const detectDuplicateConstants = (graph) => {
+	const hashToBuckets = /* @__PURE__ */ new Map();
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const candidate of module.duplicateConstantCandidates) {
+			const occurrence = {
+				path: module.fileId.path,
+				constantName: candidate.constantName,
+				line: candidate.line,
+				column: candidate.column
+			};
+			const existing = hashToBuckets.get(candidate.literalHash);
+			if (existing) existing.occurrences.push(occurrence);
+			else hashToBuckets.set(candidate.literalHash, {
+				literalPreview: candidate.literalPreview,
+				occurrences: [occurrence]
+			});
+		}
+	}
+	const findings = [];
+	for (const [literalHash, bucket] of hashToBuckets) {
+		const uniqueFilePaths = new Set(bucket.occurrences.map((occurrence) => occurrence.path));
+		if (uniqueFilePaths.size < 3) continue;
+		const uniqueNames = new Set(bucket.occurrences.map((occurrence) => occurrence.constantName));
+		if (uniqueNames.size > 1 && hasDistinctUnitSuffixes([...uniqueNames])) continue;
+		findings.push({
+			literalHash,
+			literalPreview: bucket.literalPreview,
+			occurrences: bucket.occurrences,
+			confidence: uniqueNames.size === 1 ? "high" : "medium",
+			reason: uniqueNames.size === 1 ? `${bucket.occurrences.length} copies of \`const ${[...uniqueNames][0]} = ${bucket.literalPreview}\` across ${uniqueFilePaths.size} files — extract to a shared module` : `${bucket.occurrences.length} constants across ${uniqueFilePaths.size} files share the same literal value ${bucket.literalPreview} under different names (${[...uniqueNames].join(", ")}) — consider extracting`
+		});
+	}
+	return findings;
+};
+const TRAILING_NAME_TOKEN_PATTERN = /_([A-Z][A-Z0-9]*)$/;
+const extractTrailingNameToken = (constantName) => {
+	const match = constantName.match(TRAILING_NAME_TOKEN_PATTERN);
+	return match ? match[1] : void 0;
+};
+/**
+* AGENTS.md requires magic numbers to use trailing unit suffixes (`_MS`, `_PX`,
+* `_TOKENS`, `_WIDTH`, …). When same-value constants carry DIFFERENT trailing
+* tokens (e.g. `STEP_DELAY_MS = 1000` vs `MINIMUM_TOKENS = 1000`), they
+* represent semantically distinct quantities that cannot be consolidated —
+* flagging them as duplicates is misleading. Constants sharing the same
+* trailing token (e.g. `CACHE_INTERVAL_MS` + `RECONNECT_DELAY_MS`, both `_MS`)
+* stay flagged because they are at least same-unit and might be extractable.
+*/
+const hasDistinctUnitSuffixes = (constantNames) => {
+	const trailingTokens = /* @__PURE__ */ new Set();
+	for (const name of constantNames) {
+		const token = extractTrailingNameToken(name);
+		if (!token) return false;
+		trailingTokens.add(token);
+	}
+	return trailingTokens.size > 1;
+};
+const detectSimplifiableExpressions = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const parsedExpression of module.simplifiableExpressions) findings.push({
+			path: module.fileId.path,
+			kind: parsedExpression.kind,
+			snippet: parsedExpression.snippet,
+			line: parsedExpression.line,
+			column: parsedExpression.column,
+			confidence: parsedExpression.kind === "double-bang-boolean" || parsedExpression.kind === "ternary-returns-boolean" || parsedExpression.kind === "redundant-null-and-undefined-check" ? "high" : "medium",
+			reason: parsedExpression.reason,
+			suggestion: parsedExpression.suggestion
+		});
+	}
+	return findings;
+};
+const detectSimplifiableFunctions = (graph) => {
+	const findings = [];
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const parsedFunction of module.simplifiableFunctions) findings.push({
+			path: module.fileId.path,
+			kind: parsedFunction.kind,
+			functionName: parsedFunction.functionName,
+			line: parsedFunction.line,
+			column: parsedFunction.column,
+			confidence: parsedFunction.kind === "useless-async-no-await" ? "low" : "high",
+			reason: parsedFunction.reason,
+			suggestion: parsedFunction.suggestion
+		});
+	}
+	return findings;
+};
+const detectDuplicateInlineTypes = (graph) => {
+	const hashToOccurrences = /* @__PURE__ */ new Map();
+	for (const module of graph.modules) {
+		if (module.isDeclarationFile) continue;
+		for (const inlineLiteral of module.inlineTypeLiterals) {
+			const occurrence = {
+				path: module.fileId.path,
+				line: inlineLiteral.line,
+				column: inlineLiteral.column,
+				context: inlineLiteral.context,
+				nearestName: inlineLiteral.nearestName
+			};
+			const existing = hashToOccurrences.get(inlineLiteral.structuralHash);
+			if (existing) existing.occurrences.push(occurrence);
+			else hashToOccurrences.set(inlineLiteral.structuralHash, {
+				memberCount: inlineLiteral.memberCount,
+				preview: inlineLiteral.preview,
+				occurrences: [occurrence]
+			});
+		}
+	}
+	const findings = [];
+	for (const [structuralHash, group] of hashToOccurrences) {
+		if (group.occurrences.length < 2) continue;
+		if (new Set(group.occurrences.map((occurrence) => `${occurrence.path}:${occurrence.line}`)).size < 2) continue;
+		const uniquePaths = new Set(group.occurrences.map((occurrence) => occurrence.path));
+		const confidence = uniquePaths.size >= 2 || group.memberCount >= 5 ? "medium" : "low";
+		findings.push({
+			structuralHash,
+			memberCount: group.memberCount,
+			preview: group.preview,
+			occurrences: group.occurrences,
+			confidence,
+			reason: `inline object shape ${group.preview} appears at ${group.occurrences.length} sites across ${uniquePaths.size} file(s) — extract a named type`
+		});
+	}
+	return findings;
+};
+
+//#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) => {
+	const jsDocContainer = node;
+	if (!jsDocContainer.jsDoc) return;
+	for (const jsDocNode of jsDocContainer.jsDoc) visit(jsDocNode);
+};
+const buildReferenceIndex = (program, checker) => {
+	const keyedToReferences = /* @__PURE__ */ new Map();
+	const recordIdentifier = (identifier, sourceFile) => {
+		const resolvedSymbol = resolveSymbolForIdentifier(identifier, checker);
+		if (!resolvedSymbol) return;
+		const key = canonicalKeyForSymbol(resolvedSymbol);
+		const site = {
+			sourceFile,
+			identifier,
+			isDeclarationName: isDeclarationNameIdentifier(identifier),
+			isExportSpecifier: isExportSpecifierIdentifier(identifier),
+			isImportSpecifier: isImportSpecifierIdentifier(identifier),
+			isTypeContext: isInTypeContext(identifier)
+		};
+		const existing = keyedToReferences.get(key);
+		if (existing) existing.push(site);
+		else keyedToReferences.set(key, [site]);
+	};
+	const visitNode = (node, sourceFile, recursionDepth) => {
+		if (recursionDepth > 200) return;
+		if (typescript.default.isIdentifier(node)) recordIdentifier(node, sourceFile);
+		visitJsDocNodes(node, (jsDocNode) => visitNode(jsDocNode, sourceFile, recursionDepth + 1));
+		node.forEachChild((child) => visitNode(child, sourceFile, recursionDepth + 1));
+	};
+	for (const sourceFile of program.getSourceFiles()) {
+		if (sourceFile.isDeclarationFile) continue;
+		visitNode(sourceFile, sourceFile, 0);
+	}
+	return {
+		getReferences: (symbol) => keyedToReferences.get(canonicalKeyForSymbol(symbol)) ?? [],
+		size: keyedToReferences.size
+	};
+};
+
+//#endregion
+//#region src/semantic/utils/source-file-lookup.ts
+const normalizeSourcePath = node_path.resolve;
+const buildSourceFileLookup = (program) => {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const sourceFile of program.getSourceFiles()) {
+		if (sourceFile.isDeclarationFile) continue;
+		lookup.set(normalizeSourcePath(sourceFile.fileName), sourceFile);
+	}
+	return lookup;
+};
+
+//#endregion
+//#region src/semantic/unused-types.ts
+const TYPE_DECLARATION_FLAGS = typescript.default.SymbolFlags.Interface | typescript.default.SymbolFlags.TypeAlias | typescript.default.SymbolFlags.Enum | typescript.default.SymbolFlags.ConstEnum | typescript.default.SymbolFlags.RegularEnum;
+const VALUE_DECLARATION_FLAGS = typescript.default.SymbolFlags.Variable | typescript.default.SymbolFlags.Function | typescript.default.SymbolFlags.Class | typescript.default.SymbolFlags.BlockScopedVariable | typescript.default.SymbolFlags.FunctionScopedVariable;
+const collectTypeExportCandidates = (graph, config) => {
+	const candidates = [];
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		if (module.isEntryPoint && !config.includeEntryExports) continue;
+		for (const exportInfo of module.exports) {
+			if (exportInfo.isSynthetic) continue;
+			if (!exportInfo.isTypeOnly) continue;
+			if (exportInfo.isReExport) continue;
+			if (exportInfo.name === "*") continue;
+			candidates.push({
+				module,
+				exportName: exportInfo.name,
+				line: exportInfo.line,
+				column: exportInfo.column
+			});
+		}
+	}
+	return candidates;
+};
+const resolveExportSymbol = (sourceFile, exportName, checker) => {
+	const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+	if (!moduleSymbol) return void 0;
+	const matchingExport = checker.getExportsOfModule(moduleSymbol).find((exportSymbol) => exportSymbol.name === exportName);
+	if (!matchingExport) return void 0;
+	if (matchingExport.flags & typescript.default.SymbolFlags.Alias) try {
+		return checker.getAliasedSymbol(matchingExport);
+	} catch {
+		return matchingExport;
+	}
+	return matchingExport;
+};
+const isPureTypeSymbol = (symbol) => {
+	const hasTypeFlags = (symbol.flags & TYPE_DECLARATION_FLAGS) !== 0;
+	const hasValueFlags = (symbol.flags & VALUE_DECLARATION_FLAGS) !== 0;
+	return hasTypeFlags && !hasValueFlags;
+};
+const classifyTypeKind = (symbol) => {
+	if (symbol.flags & typescript.default.SymbolFlags.Interface) return "interface";
+	if (symbol.flags & typescript.default.SymbolFlags.TypeAlias) return "type-alias";
+	if (symbol.flags & (typescript.default.SymbolFlags.Enum | typescript.default.SymbolFlags.ConstEnum | typescript.default.SymbolFlags.RegularEnum)) return "enum-type";
+};
+const isReferenceMeaningful = (site) => {
+	if (site.isDeclarationName) return false;
+	return true;
+};
+const buildTrace = (candidate, meaningfulReferenceCount, totalReferenceCount, reExportSiteCount) => {
+	return [
+		`${candidate.module.fileId.path}:${candidate.line}:${candidate.column} declares "${candidate.exportName}"`,
+		`total identifier references resolved to symbol: ${totalReferenceCount}`,
+		`references excluding declaration site: ${meaningfulReferenceCount}`,
+		`re-export specifier sites: ${reExportSiteCount}`
+	].slice(0, 5);
+};
+const detectUnusedTypes = (graph, config, context, referenceIndex) => {
+	const findings = [];
+	const candidates = collectTypeExportCandidates(graph, config);
+	if (candidates.length === 0) return findings;
+	const sourceFileLookup = buildSourceFileLookup(context.program);
+	for (const candidate of candidates) {
+		const sourceFile = sourceFileLookup.get(normalizeSourcePath(candidate.module.fileId.path));
+		if (!sourceFile) continue;
+		const exportSymbol = resolveExportSymbol(sourceFile, candidate.exportName, context.checker);
+		if (!exportSymbol) continue;
+		if (!isPureTypeSymbol(exportSymbol)) continue;
+		const kind = classifyTypeKind(exportSymbol);
+		if (!kind) continue;
+		const allReferences = referenceIndex.getReferences(exportSymbol);
+		const reExportSites = allReferences.filter((site) => site.isExportSpecifier);
+		const meaningfulReferences = allReferences.filter(isReferenceMeaningful);
+		if (meaningfulReferences.filter((site) => !site.isExportSpecifier).length > 0) continue;
+		const declarations = exportSymbol.declarations ?? [];
+		if (declarations.length > 1) {
+			const declarationFiles = new Set(declarations.map((decl) => normalizeSourcePath(decl.getSourceFile().fileName)));
+			if (declarationFiles.size > 1) {
+				if (meaningfulReferences.some((site) => {
+					const referenceFileName = normalizeSourcePath(site.sourceFile.fileName);
+					return !declarationFiles.has(referenceFileName);
+				})) continue;
+			}
+		}
+		findings.push({
+			path: candidate.module.fileId.path,
+			name: candidate.exportName,
+			line: candidate.line,
+			column: candidate.column,
+			kind,
+			confidence: reExportSites.length > 0 ? "medium" : "high",
+			reason: reExportSites.length > 0 ? `type "${candidate.exportName}" is only re-exported through ${reExportSites.length} barrel(s) and never used` : `type "${candidate.exportName}" has no references in the project`,
+			trace: buildTrace(candidate, meaningfulReferences.length, allReferences.length, reExportSites.length)
+		});
+	}
+	return findings;
+};
+
+//#endregion
+//#region src/semantic/unused-enum-members.ts
+const collectEnumDeclarations = (graph, config, sourceFileLookup) => {
+	const declarations = [];
+	const visitTopLevel = (sourceFile, modulePath) => {
+		for (const statement of sourceFile.statements) if (typescript.default.isEnumDeclaration(statement)) declarations.push({
+			sourceFile,
+			declaration: statement,
+			modulePath
+		});
+	};
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		if (module.isEntryPoint && !config.includeEntryExports) continue;
+		const sourceFile = sourceFileLookup.get(normalizeSourcePath(module.fileId.path));
+		if (!sourceFile) continue;
+		visitTopLevel(sourceFile, module.fileId.path);
+	}
+	return declarations;
+};
+const isStringLiteralEnum = (declaration) => {
+	if (declaration.members.length === 0) return false;
+	for (const member of declaration.members) {
+		if (!member.initializer) return false;
+		if (!typescript.default.isStringLiteral(member.initializer)) return false;
+	}
+	return true;
+};
+const isConstEnum = (declaration) => {
+	const modifiers = typescript.default.canHaveModifiers(declaration) ? typescript.default.getModifiers(declaration) : void 0;
+	if (!modifiers) return false;
+	return modifiers.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ConstKeyword);
+};
+const enumHasComputedAccess = (enumSymbol, referenceIndex) => {
+	const references = referenceIndex.getReferences(enumSymbol);
+	for (const referenceSite of references) {
+		const parent = referenceSite.identifier.parent;
+		if (!parent) continue;
+		if (typescript.default.isElementAccessExpression(parent) && parent.expression === referenceSite.identifier) return true;
+	}
+	return false;
+};
+const enumHasWholeObjectUse = (enumSymbol, referenceIndex) => {
+	const references = referenceIndex.getReferences(enumSymbol);
+	for (const referenceSite of references) {
+		if (referenceSite.isDeclarationName) continue;
+		if (referenceSite.isExportSpecifier) continue;
+		if (referenceSite.isImportSpecifier) continue;
+		const parent = referenceSite.identifier.parent;
+		if (!parent) continue;
+		if (typescript.default.isPropertyAccessExpression(parent) && parent.expression === referenceSite.identifier) continue;
+		if (typescript.default.isQualifiedName(parent) && parent.left === referenceSite.identifier) continue;
+		if (typescript.default.isElementAccessExpression(parent) && parent.expression === referenceSite.identifier) continue;
+		if (typescript.default.isTypeReferenceNode(parent)) continue;
+		if (typescript.default.isTypeQueryNode(parent)) continue;
+		return true;
+	}
+	return false;
+};
+const memberHasExternalReference$1 = (memberSymbol, referenceIndex) => {
+	const references = referenceIndex.getReferences(memberSymbol);
+	for (const referenceSite of references) {
+		if (referenceSite.isDeclarationName) continue;
+		return true;
+	}
+	return false;
+};
+const buildEnumMemberTrace = (enumName, memberName, declarationPath, line, column, hasComputedAccess, hasWholeObjectUse) => {
+	const trace = [`${declarationPath}:${line}:${column} declares ${enumName}.${memberName}`, `no static \`${enumName}.${memberName}\` reference found in the project`];
+	if (hasComputedAccess) trace.push(`${enumName}[...] computed access observed — confidence downgraded`);
+	if (hasWholeObjectUse) trace.push(`${enumName} used as a whole value — confidence downgraded`);
+	return trace.slice(0, 5);
+};
+const detectUnusedEnumMembers = (graph, config, context, referenceIndex) => {
+	const findings = [];
+	const enumDeclarations = collectEnumDeclarations(graph, config, buildSourceFileLookup(context.program));
+	if (enumDeclarations.length === 0) return findings;
+	const { checker } = context;
+	for (const { sourceFile, declaration, modulePath } of enumDeclarations) {
+		const enumSymbol = checker.getSymbolAtLocation(declaration.name);
+		if (!enumSymbol) continue;
+		const hasComputedAccess = enumHasComputedAccess(enumSymbol, referenceIndex);
+		const hasWholeObjectUse = enumHasWholeObjectUse(enumSymbol, referenceIndex);
+		const isPureStringEnum = isStringLiteralEnum(declaration);
+		const isConst = isConstEnum(declaration);
+		if (hasWholeObjectUse) continue;
+		if (hasComputedAccess) continue;
+		let confidence;
+		if (isConst) confidence = "low";
+		else if (isPureStringEnum) confidence = "high";
+		else confidence = "medium";
+		for (const member of declaration.members) {
+			const memberSymbol = checker.getSymbolAtLocation(member.name);
+			if (!memberSymbol) continue;
+			if (memberHasExternalReference$1(memberSymbol, referenceIndex)) continue;
+			const memberName = member.name.getText(sourceFile);
+			const { line: zeroIndexedLine, character: zeroIndexedColumn } = sourceFile.getLineAndCharacterOfPosition(member.getStart(sourceFile));
+			const line = zeroIndexedLine + 1;
+			const column = zeroIndexedColumn + 1;
+			findings.push({
+				path: modulePath,
+				enumName: declaration.name.text,
+				memberName,
+				line,
+				column,
+				confidence,
+				reason: `${declaration.name.text}.${memberName} is declared but never referenced`,
+				trace: buildEnumMemberTrace(declaration.name.text, memberName, modulePath, line, column, false, false)
+			});
+		}
+	}
+	return findings;
+};
+
+//#endregion
+//#region src/semantic/unused-class-members.ts
+const isClassExported = (declaration) => {
+	const modifiers = typescript.default.canHaveModifiers(declaration) ? typescript.default.getModifiers(declaration) : void 0;
+	if (!modifiers) return false;
+	return modifiers.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword || modifier.kind === typescript.default.SyntaxKind.DefaultKeyword);
+};
+const collectClassDeclarations = (graph, config, sourceFileLookup) => {
+	const contexts = [];
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		if (module.isEntryPoint && !config.includeEntryExports) continue;
+		const sourceFile = sourceFileLookup.get(normalizeSourcePath(module.fileId.path));
+		if (!sourceFile) continue;
+		for (const statement of sourceFile.statements) {
+			if (!typescript.default.isClassDeclaration(statement)) continue;
+			if (!statement.name) continue;
+			contexts.push({
+				sourceFile,
+				declaration: statement,
+				modulePath: module.fileId.path,
+				isExported: isClassExported(statement)
+			});
+		}
+	}
+	return contexts;
+};
+const buildSubclassMemberIndex = (classContexts, checker) => {
+	const parentToOverriddenMemberNames = /* @__PURE__ */ new Map();
+	const addOverrideNames = (parentSymbol, memberNames) => {
+		const existing = parentToOverriddenMemberNames.get(parentSymbol);
+		if (existing) for (const memberName of memberNames) existing.add(memberName);
+		else parentToOverriddenMemberNames.set(parentSymbol, new Set(memberNames));
+	};
+	const collectMemberNames = (declaration) => {
+		const names = [];
+		for (const member of declaration.members) {
+			if (!member.name || !typescript.default.isIdentifier(member.name)) continue;
+			names.push(member.name.text);
+		}
+		return names;
+	};
+	for (const { declaration } of classContexts) {
+		if (!declaration.heritageClauses) continue;
+		for (const heritageClause of declaration.heritageClauses) {
+			if (heritageClause.token !== typescript.default.SyntaxKind.ExtendsKeyword) continue;
+			for (const heritageType of heritageClause.types) {
+				const baseSymbol = checker.getSymbolAtLocation(heritageType.expression);
+				if (!baseSymbol) continue;
+				const resolvedBaseSymbol = baseSymbol.flags & typescript.default.SymbolFlags.Alias ? safeGetAliasedSymbol$1(baseSymbol, checker) : baseSymbol;
+				if (!resolvedBaseSymbol) continue;
+				addOverrideNames(resolvedBaseSymbol, collectMemberNames(declaration));
+			}
+		}
+	}
+	return { getOverridingMemberNames: (parentClassSymbol) => parentToOverriddenMemberNames.get(parentClassSymbol) ?? /* @__PURE__ */ new Set() };
 };
-const canonicalizeCycle = (cycle, graph) => {
-	if (cycle.length === 0) return [];
-	let minPosition = 0;
-	let minPath = graph.modules[cycle[0]].fileId.path;
-	for (let position = 1; position < cycle.length; position++) {
-		const currentPath = graph.modules[cycle[position]].fileId.path;
-		if (currentPath < minPath) {
-			minPath = currentPath;
-			minPosition = position;
+const safeGetAliasedSymbol$1 = (symbol, checker) => {
+	try {
+		return checker.getAliasedSymbol(symbol);
+	} catch {
+		return;
+	}
+};
+const isPrivateMember = (member) => {
+	if (typescript.default.isPrivateIdentifier(member.name)) return true;
+	const modifiers = typescript.default.canHaveModifiers(member) ? typescript.default.getModifiers(member) : void 0;
+	if (!modifiers) return false;
+	return modifiers.some((modifier) => modifier.kind === typescript.default.SyntaxKind.PrivateKeyword);
+};
+const isStaticMember = (member) => {
+	const modifiers = typescript.default.canHaveModifiers(member) ? typescript.default.getModifiers(member) : void 0;
+	if (!modifiers) return false;
+	return modifiers.some((modifier) => modifier.kind === typescript.default.SyntaxKind.StaticKeyword);
+};
+const hasAllowedDecorator = (member, decoratorAllowlist) => {
+	const decorators = typescript.default.canHaveDecorators(member) ? typescript.default.getDecorators(member) : void 0;
+	if (!decorators || decorators.length === 0) return false;
+	for (const decorator of decorators) {
+		const expression = decorator.expression;
+		let decoratorName;
+		if (typescript.default.isIdentifier(expression)) decoratorName = expression.text;
+		else if (typescript.default.isCallExpression(expression) && typescript.default.isIdentifier(expression.expression)) decoratorName = expression.expression.text;
+		else if (typescript.default.isPropertyAccessExpression(expression) && typescript.default.isIdentifier(expression.name)) decoratorName = expression.name.text;
+		if (decoratorName && decoratorAllowlist.has(decoratorName)) return true;
+	}
+	return false;
+};
+const classifyMemberKind = (member) => {
+	if (typescript.default.isMethodDeclaration(member)) return "method";
+	if (typescript.default.isPropertyDeclaration(member)) return "property";
+	if (typescript.default.isGetAccessorDeclaration(member) || typescript.default.isSetAccessorDeclaration(member)) return "accessor";
+};
+const memberHasExternalReference = (memberSymbol, referenceIndex) => {
+	const references = referenceIndex.getReferences(memberSymbol);
+	for (const referenceSite of references) {
+		if (referenceSite.isDeclarationName) continue;
+		return true;
+	}
+	return false;
+};
+const buildClassMemberTrace = (className, memberName, modulePath, line, column, isOverriddenInSubclass, isExportedClass) => {
+	const trace = [`${modulePath}:${line}:${column} declares ${className}.${memberName}`, `no \`${className}.${memberName}\` reference found outside the declaration`];
+	if (isExportedClass) trace.push(`${className} is exported — confidence reduced for public-API safety`);
+	if (isOverriddenInSubclass) trace.push(`subclass override observed — polymorphic call path possible`);
+	return trace.slice(0, 5);
+};
+const detectUnusedClassMembers = (graph, config, context, referenceIndex, decoratorAllowlist) => {
+	const findings = [];
+	const classContexts = collectClassDeclarations(graph, config, buildSourceFileLookup(context.program));
+	if (classContexts.length === 0) return findings;
+	const { checker } = context;
+	const decoratorAllowSet = new Set(decoratorAllowlist);
+	const subclassMemberIndex = buildSubclassMemberIndex(classContexts, checker);
+	for (const { sourceFile, declaration, modulePath, isExported } of classContexts) {
+		const classSymbol = checker.getSymbolAtLocation(declaration.name);
+		if (!classSymbol) continue;
+		const overriddenMemberNames = subclassMemberIndex.getOverridingMemberNames(classSymbol);
+		for (const member of declaration.members) {
+			if (typescript.default.isConstructorDeclaration(member)) continue;
+			if (!member.name) continue;
+			const memberKind = classifyMemberKind(member);
+			if (!memberKind) continue;
+			if (isPrivateMember(member)) continue;
+			if (hasAllowedDecorator(member, decoratorAllowSet)) continue;
+			const memberSymbol = checker.getSymbolAtLocation(member.name);
+			if (!memberSymbol) continue;
+			if (memberHasExternalReference(memberSymbol, referenceIndex)) continue;
+			const memberName = typescript.default.isIdentifier(member.name) ? member.name.text : member.name.getText(sourceFile);
+			if (overriddenMemberNames.has(memberName)) continue;
+			const { line: zeroIndexedLine, character: zeroIndexedColumn } = sourceFile.getLineAndCharacterOfPosition(member.getStart(sourceFile));
+			const line = zeroIndexedLine + 1;
+			const column = zeroIndexedColumn + 1;
+			const confidence = isExported ? "low" : "high";
+			findings.push({
+				path: modulePath,
+				className: declaration.name.text,
+				memberName,
+				memberKind,
+				isStatic: isStaticMember(member),
+				line,
+				column,
+				confidence,
+				reason: isExported ? `${declaration.name.text}.${memberName} has no internal references; flagged at low confidence because ${declaration.name.text} is part of the public API surface` : `${declaration.name.text}.${memberName} is declared but never referenced`,
+				trace: buildClassMemberTrace(declaration.name.text, memberName, modulePath, line, column, false, isExported)
+			});
 		}
 	}
-	return [...cycle.slice(minPosition), ...cycle.slice(0, minPosition)];
+	return findings;
 };
-const enumerateElementaryCycles = (componentNodes, adjacencyList, graph) => {
-	if (componentNodes.length === 2) {
-		const [nodeA, nodeB] = componentNodes;
-		return [graph.modules[nodeA].fileId.path <= graph.modules[nodeB].fileId.path ? [nodeA, nodeB] : [nodeB, nodeA]];
+
+//#endregion
+//#region src/semantic/misclassified-dependencies.ts
+const TYPES_PACKAGE_PREFIX = "@types/";
+const recordImportSite = (summary, sitePath) => {
+	if (summary.importSites.length >= 5) return;
+	if (summary.importSites.includes(sitePath)) return;
+	summary.importSites.push(sitePath);
+};
+const isImportEffectivelyTypeOnly = (isTypeOnlyDeclaration, importedBindings) => {
+	if (isTypeOnlyDeclaration) return true;
+	if (importedBindings.length === 0) return false;
+	return importedBindings.every((binding) => binding.isTypeOnly);
+};
+const collectPackageUsageSummaries = (graph) => {
+	const summaries = /* @__PURE__ */ new Map();
+	const upsertSummary = (packageName) => {
+		const existing = summaries.get(packageName);
+		if (existing) return existing;
+		const fresh = {
+			packageName,
+			hasValueUse: false,
+			hasTypeOnlyUse: false,
+			importSites: []
+		};
+		summaries.set(packageName, fresh);
+		return fresh;
+	};
+	for (const module of graph.modules) {
+		for (const importInfo of module.imports) {
+			const packageName = extractPackageName(importInfo.specifier);
+			if (!packageName) continue;
+			const summary = upsertSummary(packageName);
+			const sitePath = `${module.fileId.path}:${importInfo.line}`;
+			if (importInfo.isSideEffect) {
+				summary.hasValueUse = true;
+				recordImportSite(summary, sitePath);
+				continue;
+			}
+			if (importInfo.isDynamic) {
+				summary.hasValueUse = true;
+				recordImportSite(summary, sitePath);
+				continue;
+			}
+			if (isImportEffectivelyTypeOnly(importInfo.isTypeOnly, importInfo.importedNames)) summary.hasTypeOnlyUse = true;
+			else summary.hasValueUse = true;
+			recordImportSite(summary, sitePath);
+		}
+		for (const exportInfo of module.exports) {
+			if (!exportInfo.isReExport || !exportInfo.reExportSource) continue;
+			const packageName = extractPackageName(exportInfo.reExportSource);
+			if (!packageName) continue;
+			const summary = upsertSummary(packageName);
+			const sitePath = `${module.fileId.path}:${exportInfo.line}`;
+			if (exportInfo.isTypeOnly) summary.hasTypeOnlyUse = true;
+			else summary.hasValueUse = true;
+			recordImportSite(summary, sitePath);
+		}
 	}
-	const componentSet = new Set(componentNodes);
-	const cycles = [];
-	const seenKeys = /* @__PURE__ */ new Set();
-	for (const startNode of componentNodes) {
-		if (cycles.length >= 20) break;
-		const visitedInThisSearch = /* @__PURE__ */ new Set();
-		visitedInThisSearch.add(startNode);
-		const pathStack = [startNode];
-		const successorPositionStack = [0];
-		while (pathStack.length > 0 && cycles.length < 20) {
-			const currentNode = pathStack[pathStack.length - 1];
-			const currentSuccessorPosition = successorPositionStack[successorPositionStack.length - 1];
-			const successors = adjacencyList[currentNode].filter((successor) => componentSet.has(successor));
-			if (currentSuccessorPosition < successors.length) {
-				successorPositionStack[successorPositionStack.length - 1]++;
-				const successor = successors[currentSuccessorPosition];
-				if (successor === startNode) {
-					const canonical = canonicalizeCycle([...pathStack], graph);
-					const key = canonical.join(",");
-					if (!seenKeys.has(key)) {
-						seenKeys.add(key);
-						cycles.push(canonical);
-					}
-				} else if (!visitedInThisSearch.has(successor)) {
-					visitedInThisSearch.add(successor);
-					pathStack.push(successor);
-					successorPositionStack.push(0);
-				}
-			} else {
-				visitedInThisSearch.delete(pathStack.pop());
-				successorPositionStack.pop();
+	return summaries;
+};
+const readDeclaredDependencies = (rootDir) => {
+	const packageJsonPath = (0, node_path.resolve)(rootDir, "package.json");
+	let packageJson;
+	try {
+		const contents = (0, node_fs.readFileSync)(packageJsonPath, "utf-8");
+		packageJson = JSON.parse(contents);
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const name of Object.keys(packageJson.dependencies ?? {})) entries.push({
+		name,
+		declaredAs: "dependencies"
+	});
+	return entries;
+};
+const detectMisclassifiedDependencies = (graph, config) => {
+	const declaredEntries = readDeclaredDependencies(config.rootDir);
+	if (declaredEntries.length === 0) return [];
+	const packageUsage = collectPackageUsageSummaries(graph);
+	const findings = [];
+	for (const declaredEntry of declaredEntries) {
+		const usage = packageUsage.get(declaredEntry.name);
+		if (!usage) continue;
+		if (usage.hasValueUse) continue;
+		if (!usage.hasTypeOnlyUse) continue;
+		const isTypesPackage = declaredEntry.name.startsWith(TYPES_PACKAGE_PREFIX);
+		findings.push({
+			name: declaredEntry.name,
+			declaredAs: declaredEntry.declaredAs,
+			suggestedAs: "devDependencies",
+			confidence: isTypesPackage ? "high" : "medium",
+			reason: isTypesPackage ? `"${declaredEntry.name}" is a @types/* package in dependencies but is only consumed via type imports — should be in devDependencies` : `"${declaredEntry.name}" is in dependencies but only consumed via \`import type\` / \`export type\` — consider devDependencies (or keep here if downstream consumers need its types)`,
+			trace: usage.importSites
+		});
+	}
+	return findings;
+};
+
+//#endregion
+//#region src/semantic/variable-aliases.ts
+const isSimpleIdentifierInitializer = (initializer) => Boolean(initializer && typescript.default.isIdentifier(initializer));
+const isModuleLevelDeclaration = (declaration) => {
+	const variableDeclarationList = declaration.parent;
+	if (!variableDeclarationList || !typescript.default.isVariableDeclarationList(variableDeclarationList)) return false;
+	const statement = variableDeclarationList.parent;
+	return Boolean(statement && typescript.default.isSourceFile(statement.parent));
+};
+const isDeclarationExported = (declaration) => {
+	const variableDeclarationList = declaration.parent;
+	if (!variableDeclarationList || !typescript.default.isVariableDeclarationList(variableDeclarationList)) return false;
+	const statement = variableDeclarationList.parent;
+	if (!statement || !typescript.default.isVariableStatement(statement)) return false;
+	const modifiers = typescript.default.canHaveModifiers(statement) ? typescript.default.getModifiers(statement) : void 0;
+	if (!modifiers) return false;
+	return modifiers.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword || modifier.kind === typescript.default.SyntaxKind.DefaultKeyword);
+};
+const collectVariableAliasCandidates = (graph, sourceFileLookup) => {
+	const candidates = [];
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		const sourceFile = sourceFileLookup.get(normalizeSourcePath(module.fileId.path));
+		if (!sourceFile) continue;
+		for (const statement of sourceFile.statements) {
+			if (!typescript.default.isVariableStatement(statement)) continue;
+			for (const declaration of statement.declarationList.declarations) {
+				if (!typescript.default.isIdentifier(declaration.name)) continue;
+				if (!isSimpleIdentifierInitializer(declaration.initializer)) continue;
+				if (!isModuleLevelDeclaration(declaration)) continue;
+				const aliasName = declaration.name.text;
+				const aliasedFromName = declaration.initializer.text;
+				if (aliasName === aliasedFromName) continue;
+				candidates.push({
+					sourceFile,
+					declaration,
+					aliasName,
+					aliasedFromName,
+					modulePath: module.fileId.path
+				});
 			}
 		}
 	}
-	return cycles;
+	return candidates;
 };
-const detectCycles = (graph) => {
-	const adjacencyList = buildAdjacencyList(graph);
-	const components = findStronglyConnectedComponents(adjacencyList);
-	const allCycles = [];
-	const seenKeys = /* @__PURE__ */ new Set();
-	const sortedComponents = [...components].sort((componentA, componentB) => componentA.length - componentB.length);
-	for (const component of sortedComponents) {
-		if (allCycles.length >= 200) break;
-		if (component.length > 50) continue;
-		const elementaryCycles = enumerateElementaryCycles(component, adjacencyList, graph);
-		for (const cycle of elementaryCycles) {
-			const key = cycle.join(",");
-			if (!seenKeys.has(key)) {
-				seenKeys.add(key);
-				allCycles.push(cycle);
+const isMeaningfulReference = (site) => {
+	if (site.isDeclarationName) return false;
+	if (site.isImportSpecifier) return false;
+	if (site.isExportSpecifier) return false;
+	return true;
+};
+const resolveThroughAliasChain = (symbol, checker) => {
+	if (symbol.flags & typescript.default.SymbolFlags.Alias) try {
+		return checker.getAliasedSymbol(symbol);
+	} catch {
+		return symbol;
+	}
+	return symbol;
+};
+const detectRedundantVariableAliases = (graph, context, referenceIndex) => {
+	const findings = [];
+	const candidates = collectVariableAliasCandidates(graph, buildSourceFileLookup(context.program));
+	if (candidates.length === 0) return findings;
+	const { checker } = context;
+	for (const candidate of candidates) {
+		if (isDeclarationExported(candidate.declaration)) continue;
+		const aliasNameIdentifier = candidate.declaration.name;
+		if (!typescript.default.isIdentifier(aliasNameIdentifier)) continue;
+		if (!candidate.declaration.initializer || !typescript.default.isIdentifier(candidate.declaration.initializer)) continue;
+		const rawAliasSymbol = checker.getSymbolAtLocation(aliasNameIdentifier);
+		const rawSourceSymbol = checker.getSymbolAtLocation(candidate.declaration.initializer);
+		if (!rawAliasSymbol || !rawSourceSymbol) continue;
+		const aliasSymbol = resolveThroughAliasChain(rawAliasSymbol, checker);
+		const sourceSymbol = resolveThroughAliasChain(rawSourceSymbol, checker);
+		if (aliasSymbol === sourceSymbol) continue;
+		const sourceMeaningfulRefs = referenceIndex.getReferences(sourceSymbol).filter(isMeaningfulReference);
+		const aliasMeaningfulRefs = referenceIndex.getReferences(aliasSymbol).filter(isMeaningfulReference);
+		if (sourceMeaningfulRefs.filter((site) => site.identifier !== candidate.declaration.initializer).length > 0) continue;
+		if (aliasMeaningfulRefs.length === 0) continue;
+		const { line: zeroIndexedLine, character: zeroIndexedColumn } = candidate.sourceFile.getLineAndCharacterOfPosition(candidate.declaration.getStart(candidate.sourceFile));
+		findings.push({
+			path: candidate.modulePath,
+			kind: "variable-alias",
+			name: candidate.aliasName,
+			aliasedFrom: candidate.aliasedFromName,
+			line: zeroIndexedLine + 1,
+			column: zeroIndexedColumn + 1,
+			confidence: "high",
+			reason: `\`const ${candidate.aliasName} = ${candidate.aliasedFromName}\` is the only consumer of \`${candidate.aliasedFromName}\` — rename or inline`
+		});
+	}
+	return findings;
+};
+
+//#endregion
+//#region src/semantic/redundant-reexports.ts
+const safeGetAliasedSymbol = (symbol, checker) => {
+	try {
+		return checker.getAliasedSymbol(symbol);
+	} catch {
+		return;
+	}
+};
+const collectImportSpecifierRoundTrips = (graph, sourceFileLookup) => {
+	const entries = [];
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		const sourceFile = sourceFileLookup.get(normalizeSourcePath(module.fileId.path));
+		if (!sourceFile) continue;
+		for (const statement of sourceFile.statements) {
+			if (!typescript.default.isImportDeclaration(statement)) continue;
+			const importClause = statement.importClause;
+			if (!importClause?.namedBindings) continue;
+			if (!typescript.default.isNamedImports(importClause.namedBindings)) continue;
+			for (const importSpecifier of importClause.namedBindings.elements) {
+				if (!importSpecifier.propertyName) continue;
+				const importedName = importSpecifier.propertyName.text;
+				const localName = importSpecifier.name.text;
+				if (importedName === localName) continue;
+				entries.push({
+					modulePath: module.fileId.path,
+					sourceFile,
+					importSpecifier,
+					importedName,
+					localName
+				});
 			}
-			if (allCycles.length >= 200) break;
 		}
 	}
-	allCycles.sort((cycleA, cycleB) => {
-		const lengthDiff = cycleA.length - cycleB.length;
-		if (lengthDiff !== 0) return lengthDiff;
-		return graph.modules[cycleA[0]].fileId.path.localeCompare(graph.modules[cycleB[0]].fileId.path);
+	return entries;
+};
+const detectRoundTripAliases = (graph, context) => {
+	const findings = [];
+	const importEntries = collectImportSpecifierRoundTrips(graph, buildSourceFileLookup(context.program));
+	if (importEntries.length === 0) return findings;
+	const { checker } = context;
+	for (const entry of importEntries) {
+		const localBindingSymbol = checker.getSymbolAtLocation(entry.importSpecifier.name);
+		if (!localBindingSymbol) continue;
+		if (!(localBindingSymbol.flags & typescript.default.SymbolFlags.Alias)) continue;
+		const resolvedTargetSymbol = safeGetAliasedSymbol(localBindingSymbol, checker);
+		if (!resolvedTargetSymbol) continue;
+		const originalDeclarationName = resolvedTargetSymbol.name;
+		if (!originalDeclarationName) continue;
+		if (originalDeclarationName !== entry.localName) continue;
+		if (originalDeclarationName === entry.importedName) continue;
+		const { line: zeroIndexedLine, character: zeroIndexedColumn } = entry.sourceFile.getLineAndCharacterOfPosition(entry.importSpecifier.getStart(entry.sourceFile));
+		findings.push({
+			path: entry.modulePath,
+			kind: "roundtrip-alias",
+			name: entry.localName,
+			aliasedFrom: entry.importedName,
+			line: zeroIndexedLine + 1,
+			column: zeroIndexedColumn + 1,
+			confidence: "high",
+			reason: `\`import { ${entry.importedName} as ${entry.localName} }\` renames back to the original declaration name — the upstream rename can be removed`
+		});
+	}
+	return findings;
+};
+
+//#endregion
+//#region src/semantic/index.ts
+const createDisabledSemanticResult = () => ({
+	unusedTypes: [],
+	unusedEnumMembers: [],
+	unusedClassMembers: [],
+	misclassifiedDependencies: [],
+	redundantAliases: [],
+	errors: [],
+	contextStatus: "disabled"
+});
+const runSemanticAnalysis = (graph, config) => {
+	const semanticConfig = config.semantic;
+	if (!semanticConfig?.enabled) return createDisabledSemanticResult();
+	const errors = [];
+	const safeDetector = (detectorName, detector, fallback) => runSafeDetector({
+		detectorName,
+		detector,
+		fallback,
+		errorSink: errors,
+		module: "semantic",
+		contextDescription: "during semantic analysis"
 	});
-	return allCycles.map((cycle) => ({ files: cycle.map((nodeIndex) => graph.modules[nodeIndex].fileId.path) }));
+	const misclassifiedDependencies = semanticConfig.reportMisclassifiedDependencies ? safeDetector("detectMisclassifiedDependencies", () => detectMisclassifiedDependencies(graph, config), []) : [];
+	if (!(semanticConfig.reportUnusedTypes || semanticConfig.reportUnusedEnumMembers || semanticConfig.reportUnusedClassMembers || semanticConfig.reportRedundantVariableAliases || semanticConfig.reportRoundTripAliases)) return {
+		unusedTypes: [],
+		unusedEnumMembers: [],
+		unusedClassMembers: [],
+		misclassifiedDependencies,
+		redundantAliases: [],
+		errors,
+		contextStatus: "no-context-required"
+	};
+	let contextResult;
+	try {
+		contextResult = createSemanticContext(config.rootDir, config.tsConfigPath);
+	} catch (contextError) {
+		return {
+			unusedTypes: [],
+			unusedEnumMembers: [],
+			unusedClassMembers: [],
+			misclassifiedDependencies,
+			redundantAliases: [],
+			errors: [...errors, new TypeScriptError({
+				code: "ts-not-loadable",
+				message: "createSemanticContext threw before returning a result",
+				detail: describeUnknownError(contextError)
+			})],
+			contextStatus: "typescript-load-failed"
+		};
+	}
+	if (!contextResult.ok) return {
+		unusedTypes: [],
+		unusedEnumMembers: [],
+		unusedClassMembers: [],
+		misclassifiedDependencies,
+		redundantAliases: [],
+		errors: [...errors, contextResult.failure.error],
+		contextStatus: contextResult.failure.reason,
+		contextMessage: contextResult.failure.message
+	};
+	const { context } = contextResult;
+	let referenceIndex;
+	const getReferenceIndex = () => {
+		if (!referenceIndex) referenceIndex = buildReferenceIndex(context.program, context.checker);
+		return referenceIndex;
+	};
+	const unusedTypes = semanticConfig.reportUnusedTypes ? safeDetector("detectUnusedTypes", () => detectUnusedTypes(graph, config, context, getReferenceIndex()), []) : [];
+	const unusedEnumMembers = semanticConfig.reportUnusedEnumMembers ? safeDetector("detectUnusedEnumMembers", () => detectUnusedEnumMembers(graph, config, context, getReferenceIndex()), []) : [];
+	const unusedClassMembers = semanticConfig.reportUnusedClassMembers ? safeDetector("detectUnusedClassMembers", () => detectUnusedClassMembers(graph, config, context, getReferenceIndex(), semanticConfig.decoratorAllowlist), []) : [];
+	const variableAliases = semanticConfig.reportRedundantVariableAliases ? safeDetector("detectRedundantVariableAliases", () => detectRedundantVariableAliases(graph, context, getReferenceIndex()), []) : [];
+	const roundTripAliases = semanticConfig.reportRoundTripAliases ? safeDetector("detectRoundTripAliases", () => detectRoundTripAliases(graph, context), []) : [];
+	return {
+		unusedTypes,
+		unusedEnumMembers,
+		unusedClassMembers,
+		misclassifiedDependencies,
+		redundantAliases: [...variableAliases, ...roundTripAliases],
+		errors,
+		contextStatus: "ready"
+	};
 };
 
 //#endregion
 //#region src/report/generate.ts
+const safeReportDetector = (detectorName, detector, fallback, errorSink) => runSafeDetector({
+	detectorName,
+	detector,
+	fallback,
+	errorSink,
+	module: "report",
+	contextDescription: "while building findings"
+});
 const generateReport = (graph, config) => {
 	const analysisStartTime = performance.now();
-	const unusedFiles = detectOrphanFiles(graph);
-	const unusedExports = detectDeadExports(graph, config);
-	const unusedDependencies = detectStalePackages(graph, config);
-	const circularDependencies = detectCycles(graph);
+	const errorSink = [];
+	for (const module of graph.modules) {
+		for (const parseError of module.parseErrors) {
+			if (errorSink.length >= 5e3) break;
+			errorSink.push(parseError);
+		}
+		if (errorSink.length >= 5e3) break;
+	}
+	const unusedFiles = safeReportDetector("detectOrphanFiles", () => detectOrphanFiles(graph), [], errorSink);
+	const unusedExports = safeReportDetector("detectDeadExports", () => detectDeadExports(graph, config), [], errorSink);
+	const unusedDependencies = safeReportDetector("detectStalePackages", () => detectStalePackages(graph, config), [], errorSink);
+	const circularDependencies = safeReportDetector("detectCycles", () => detectCycles(graph), [], errorSink);
+	const syntacticRedundantAliases = config.reportRedundancy ? [...safeReportDetector("detectRedundantAliases", () => detectRedundantAliases(graph), [], errorSink), ...safeReportDetector("detectUselessAliasedReExports", () => detectUselessAliasedReExports(graph), [], errorSink)] : [];
+	const duplicateExports = config.reportRedundancy ? safeReportDetector("detectDuplicateExports", () => detectDuplicateExports(graph), [], errorSink) : [];
+	const duplicateImports = config.reportRedundancy ? safeReportDetector("detectDuplicateImports", () => detectDuplicateImports(graph), [], errorSink) : [];
+	const redundantTypePatterns = config.reportRedundancy ? safeReportDetector("detectRedundantTypePatterns", () => detectRedundantTypePatterns(graph), [], errorSink) : [];
+	const identityWrappers = config.reportRedundancy ? safeReportDetector("detectIdentityWrappers", () => detectIdentityWrappers(graph), [], errorSink) : [];
+	const duplicateTypeDefinitions = config.reportRedundancy ? safeReportDetector("detectDuplicateTypeDefinitions", () => detectDuplicateTypeDefinitions(graph), [], errorSink) : [];
+	const duplicateInlineTypes = config.reportRedundancy ? safeReportDetector("detectDuplicateInlineTypes", () => detectDuplicateInlineTypes(graph), [], errorSink) : [];
+	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) : [];
+	let semanticResult;
+	try {
+		semanticResult = runSemanticAnalysis(graph, config);
+	} catch (semanticError) {
+		errorSink.push(new DetectorError({
+			module: "semantic",
+			message: "runSemanticAnalysis threw at the top level",
+			detail: describeUnknownError(semanticError)
+		}));
+		semanticResult = {
+			unusedTypes: [],
+			unusedEnumMembers: [],
+			unusedClassMembers: [],
+			misclassifiedDependencies: [],
+			redundantAliases: [],
+			errors: [],
+			contextStatus: "typescript-load-failed"
+		};
+	}
+	for (const semanticError of semanticResult.errors) {
+		if (errorSink.length >= 5e3) break;
+		errorSink.push(semanticError);
+	}
+	const redundantAliases = config.reportRedundancy ? [...syntacticRedundantAliases, ...semanticResult.redundantAliases] : [];
 	const totalExports = graph.modules.reduce((exportCount, module) => exportCount + module.exports.filter((exportInfo) => !(exportInfo.name === "*" && exportInfo.isNamespaceReExport)).length, 0);
 	return {
 		unusedFiles,
 		unusedExports,
 		unusedDependencies,
 		circularDependencies,
+		unusedTypes: semanticResult.unusedTypes,
+		misclassifiedDependencies: semanticResult.misclassifiedDependencies,
+		unusedEnumMembers: semanticResult.unusedEnumMembers,
+		unusedClassMembers: semanticResult.unusedClassMembers,
+		redundantAliases,
+		duplicateExports,
+		duplicateImports,
+		redundantTypePatterns,
+		identityWrappers,
+		duplicateTypeDefinitions,
+		duplicateInlineTypes,
+		simplifiableFunctions,
+		simplifiableExpressions,
+		duplicateConstants,
+		analysisErrors: errorSink,
 		totalFiles: graph.modules.length,
 		totalExports,
 		analysisTimeMs: performance.now() - analysisStartTime
@@ -6247,6 +9501,39 @@ const generateReport = (graph, config) => {
 //#region src/index.ts
 const STYLE_EXTENSIONS = [".css", ".scss"];
 const REACT_NATIVE_ENABLERS = ["react-native", "expo"];
+const basenameFromPath = (filePath) => {
+	const lastSlashIndex = filePath.lastIndexOf("/");
+	return lastSlashIndex === -1 ? filePath : filePath.slice(lastSlashIndex + 1);
+};
+/**
+* Dynamic registry pattern: many codebases use a central "schema/registry"
+* module that lists tool/command/page filenames as string literals, then a
+* runner spawns them via `path.resolve(dir, file)` or `import()`. Static
+* analysis can't follow the indirection, so those targets get falsely
+* flagged as unused.
+*
+* Heuristic: if a parsed string literal exactly matches the basename of
+* exactly one file in the project, treat that file as an entry point.
+* Uniqueness guards against false-positives from common names like
+* `index.ts` matching dozens of unrelated files.
+*/
+const markFilenameRegistryEntries = (moduleGraph) => {
+	const basenameToModuleIndex = /* @__PURE__ */ new Map();
+	for (const module of moduleGraph.modules) {
+		const basename = basenameFromPath(module.fileId.path);
+		const existing = basenameToModuleIndex.get(basename);
+		if (existing === void 0) basenameToModuleIndex.set(basename, module.fileId.index);
+		else if (existing !== "ambiguous") basenameToModuleIndex.set(basename, "ambiguous");
+	}
+	for (const module of moduleGraph.modules) for (const referencedFilename of module.referencedFilenames) {
+		const targetIndex = basenameToModuleIndex.get(referencedFilename);
+		if (typeof targetIndex !== "number") continue;
+		const targetModule = moduleGraph.modules[targetIndex];
+		if (!targetModule || targetModule.isEntryPoint) continue;
+		if (targetModule.fileId.index === module.fileId.index) continue;
+		targetModule.isEntryPoint = true;
+	}
+};
 const detectReactNative = (rootDir, workspacePackages) => {
 	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
 	for (const directory of directoriesToCheck) {
@@ -6267,32 +9554,144 @@ const detectReactNative = (rootDir, workspacePackages) => {
 	}
 	return false;
 };
+/**
+* Default flags below mark rules off-by-default. Rationale for each:
+*
+* - `reportUnusedClassMembers: false` — class-member dead-code detection
+*   requires whole-program semantic analysis to be sound (subclass overrides,
+*   structural typing, framework method-by-name invocation like `@HttpGet`).
+*   When enabled on real React/Effect/NestJS codebases it produces a high
+*   rate of stylistic-FP findings (lifecycle methods, framework hooks). Off
+*   by default until the heuristics are tightened. Opt in via
+*   `semantic.reportUnusedClassMembers = true` when you accept the noise.
+*
+* - `reportTypes: false` — type-only exports are over-represented in
+*   barrel re-exports (the canonical `export type * from "./types"` pattern)
+*   and are rarely actionable signal. Off by default; opt in when auditing
+*   a type-heavy package.
+*
+* - `includeEntryExports: false` — exports from entry-point files are
+*   "API surface" and intentionally exported for external consumers; flagging
+*   them as "unused" is noise within a single repo scan. Opt in when auditing
+*   a package boundary (e.g. before deleting public APIs).
+*
+* - `reportRedundancy: true` — on because redundancy findings are mostly
+*   high-signal and the detectors carry their own confidence tiers.
+*/
+const fillSemanticConfig = (semanticOverrides) => {
+	if (semanticOverrides === void 0) return void 0;
+	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
+	};
+};
 const defineConfig = (options) => ({
 	rootDir: (0, node_path.resolve)(options.rootDir),
 	entryPatterns: options.entryPatterns ?? DEFAULT_ENTRY_GLOBS,
 	ignorePatterns: options.ignorePatterns ?? [],
 	includeExtensions: options.includeExtensions ?? DEFAULT_EXTENSIONS,
-	tsConfigPath: options.tsConfigPath ?? void 0,
+	tsConfigPath: options.tsConfigPath,
 	reportTypes: options.reportTypes ?? false,
-	includeEntryExports: options.includeEntryExports ?? false
+	includeEntryExports: options.includeEntryExports ?? false,
+	reportRedundancy: options.reportRedundancy ?? true,
+	semantic: fillSemanticConfig(options.semantic)
+});
+const buildEmptyScanResult = (errors, elapsedMs) => ({
+	unusedFiles: [],
+	unusedExports: [],
+	unusedDependencies: [],
+	circularDependencies: [],
+	unusedTypes: [],
+	misclassifiedDependencies: [],
+	unusedEnumMembers: [],
+	unusedClassMembers: [],
+	redundantAliases: [],
+	duplicateExports: [],
+	duplicateImports: [],
+	redundantTypePatterns: [],
+	identityWrappers: [],
+	duplicateTypeDefinitions: [],
+	duplicateInlineTypes: [],
+	simplifiableFunctions: [],
+	simplifiableExpressions: [],
+	duplicateConstants: [],
+	analysisErrors: errors,
+	totalFiles: 0,
+	totalExports: 0,
+	analysisTimeMs: elapsedMs
 });
+const validateConfig = (config) => {
+	if (!config.rootDir || typeof config.rootDir !== "string") return new ConfigError({ message: "config.rootDir must be a non-empty string" });
+	if (!(0, node_fs.existsSync)(config.rootDir)) return new ConfigError({
+		message: `config.rootDir does not exist: ${config.rootDir}`,
+		path: config.rootDir
+	});
+};
 const analyze = async (config) => {
 	const pipelineStartTime = performance.now();
-	const workspaceDiscovery = resolveWorkspaces((0, node_path.resolve)(config.rootDir));
+	const setupErrors = [];
+	const configValidationError = validateConfig(config);
+	if (configValidationError) return buildEmptyScanResult([configValidationError], performance.now() - pipelineStartTime);
+	let workspaceDiscovery;
+	try {
+		workspaceDiscovery = resolveWorkspaces((0, node_path.resolve)(config.rootDir));
+	} catch (workspaceError) {
+		setupErrors.push(new WorkspaceError({
+			code: "workspace-discovery-failed",
+			message: "resolveWorkspaces threw — falling back to single-package mode",
+			path: config.rootDir,
+			detail: describeUnknownError(workspaceError)
+		}));
+		workspaceDiscovery = {
+			packages: [],
+			excludedDirectories: [],
+			hasRootLevelWorkspacePatterns: false
+		};
+	}
 	const workspacePackages = [...workspaceDiscovery.packages];
-	const monorepoRoot = findMonorepoRoot(config.rootDir);
-	if (monorepoRoot) {
+	let monorepoRoot;
+	try {
+		monorepoRoot = findMonorepoRoot(config.rootDir);
+	} catch (monorepoError) {
+		setupErrors.push(new WorkspaceError({
+			code: "monorepo-discovery-failed",
+			message: "findMonorepoRoot threw",
+			path: config.rootDir,
+			detail: describeUnknownError(monorepoError)
+		}));
+		monorepoRoot = void 0;
+	}
+	if (monorepoRoot) try {
 		const monorepoWorkspaces = resolveWorkspaces(monorepoRoot);
 		const existingDirectories = new Set(workspacePackages.map((workspacePackage) => workspacePackage.directory));
 		for (const monorepoPackage of monorepoWorkspaces.packages) if (!existingDirectories.has(monorepoPackage.directory)) workspacePackages.push(monorepoPackage);
+	} catch (monorepoWorkspaceError) {
+		setupErrors.push(new WorkspaceError({
+			code: "workspace-discovery-failed",
+			message: "resolveWorkspaces threw on monorepo root",
+			path: monorepoRoot,
+			detail: describeUnknownError(monorepoWorkspaceError)
+		}));
+	}
+	let frameworkIgnorePatterns = [];
+	try {
+		frameworkIgnorePatterns = getFrameworkExclusions(config.rootDir);
+	} catch (frameworkError) {
+		setupErrors.push(new WorkspaceError({
+			code: "workspace-discovery-failed",
+			message: "getFrameworkExclusions failed — proceeding without framework exclusion patterns",
+			path: config.rootDir,
+			detail: describeUnknownError(frameworkError)
+		}));
 	}
-	const frameworkIgnorePatterns = getFrameworkExclusions(config.rootDir);
 	const absoluteRoot = (0, node_path.resolve)(config.rootDir);
-	const outputDirectoryExclusions = OUTPUT_DIRECTORIES.flatMap((outputDirectory) => {
-		const exclusions = [`${absoluteRoot}/${outputDirectory}/**`];
-		for (const workspacePackage of workspacePackages) exclusions.push(`${workspacePackage.directory}/${outputDirectory}/**`);
-		return exclusions;
-	});
+	const outputDirectoryExclusions = OUTPUT_DIRECTORIES.flatMap((outputDirectory) => [`${absoluteRoot}/${outputDirectory}/**`, `${absoluteRoot}/**/${outputDirectory}/**`]);
 	const allExclusionPatterns = [
 		...workspaceDiscovery.excludedDirectories.map((directory) => `${directory}/**`),
 		...frameworkIgnorePatterns,
@@ -6302,32 +9701,101 @@ const analyze = async (config) => {
 		...config,
 		ignorePatterns: [...config.ignorePatterns, ...allExclusionPatterns]
 	} : config;
-	const files = await collectSourceFiles(configWithExclusions);
-	const discoveredEntries = await resolveEntries(configWithExclusions);
+	let files;
+	try {
+		files = await collectSourceFiles(configWithExclusions);
+	} catch (collectError) {
+		setupErrors.push(new WorkspaceError({
+			code: "workspace-discovery-failed",
+			severity: "fatal",
+			message: "collectSourceFiles failed",
+			path: config.rootDir,
+			detail: describeUnknownError(collectError)
+		}));
+		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
+	}
+	let discoveredEntries;
+	try {
+		discoveredEntries = await resolveEntries(configWithExclusions);
+	} catch (entriesError) {
+		setupErrors.push(new WorkspaceError({
+			code: "workspace-discovery-failed",
+			message: "resolveEntries failed — defaulting to empty entry set",
+			path: config.rootDir,
+			detail: describeUnknownError(entriesError)
+		}));
+		discoveredEntries = {
+			productionEntries: [],
+			testEntries: [],
+			alwaysUsedFiles: []
+		};
+	}
 	const productionEntrySet = new Set(discoveredEntries.productionEntries);
 	const testEntrySet = new Set(discoveredEntries.testEntries);
 	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
-	const hasReactNative = detectReactNative(config.rootDir, workspacePackages);
-	const moduleResolver = createResolver(config, workspacePackages.map((workspacePackage) => ({
-		name: workspacePackage.name,
-		directory: workspacePackage.directory
-	})), {
-		hasReactNative,
-		monorepoRoot
-	});
+	let hasReactNative = false;
+	try {
+		hasReactNative = detectReactNative(config.rootDir, workspacePackages);
+	} catch {
+		hasReactNative = false;
+	}
+	let moduleResolver;
+	try {
+		moduleResolver = createResolver(config, workspacePackages.map((workspacePackage) => ({
+			name: workspacePackage.name,
+			directory: workspacePackage.directory
+		})), {
+			hasReactNative,
+			monorepoRoot
+		});
+	} catch (resolverError) {
+		setupErrors.push(new ResolverError({
+			message: "createResolver failed",
+			path: config.rootDir,
+			detail: describeUnknownError(resolverError)
+		}));
+		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
+	}
 	const graphInputs = [];
 	for (const file of files) {
 		const parsedModule = parseSourceFile(file.path);
 		const resolvedImportMap = /* @__PURE__ */ new Map();
+		const safeResolveImport = (specifier) => {
+			try {
+				return moduleResolver.resolveModule(specifier, file.path);
+			} catch (resolveError) {
+				setupErrors.push(new ResolverError({
+					severity: "warning",
+					message: `moduleResolver.resolveModule threw on specifier "${specifier}"`,
+					path: file.path,
+					detail: describeUnknownError(resolveError)
+				}));
+				return {
+					resolvedPath: void 0,
+					isExternal: false,
+					packageName: void 0
+				};
+			}
+		};
 		for (const importInfo of parsedModule.imports) {
 			if (importInfo.isGlob) {
 				const fileDir = (0, node_path.dirname)(file.path);
-				const expandedFiles = fast_glob.default.sync(importInfo.specifier, {
-					cwd: fileDir,
-					absolute: true,
-					onlyFiles: true,
-					ignore: ["**/node_modules/**"]
-				});
+				let expandedFiles = [];
+				try {
+					expandedFiles = fast_glob.default.sync(importInfo.specifier, {
+						cwd: fileDir,
+						absolute: true,
+						onlyFiles: true,
+						ignore: ["**/node_modules/**"]
+					});
+				} catch (globError) {
+					setupErrors.push(new WorkspaceError({
+						code: "workspace-discovery-failed",
+						message: `fast-glob threw on import glob "${importInfo.specifier}"`,
+						path: file.path,
+						detail: describeUnknownError(globError)
+					}));
+				}
 				for (const expandedFile of expandedFiles) resolvedImportMap.set(expandedFile, {
 					resolvedPath: expandedFile,
 					isExternal: false,
@@ -6340,14 +9808,10 @@ const analyze = async (config) => {
 				});
 				continue;
 			}
-			const resolvedImport = moduleResolver.resolveModule(importInfo.specifier, file.path);
-			resolvedImportMap.set(importInfo.specifier, resolvedImport);
+			resolvedImportMap.set(importInfo.specifier, safeResolveImport(importInfo.specifier));
 		}
 		for (const exportInfo of parsedModule.exports) if (exportInfo.isReExport && exportInfo.reExportSource) {
-			if (!resolvedImportMap.has(exportInfo.reExportSource)) {
-				const resolvedImport = moduleResolver.resolveModule(exportInfo.reExportSource, file.path);
-				resolvedImportMap.set(exportInfo.reExportSource, resolvedImport);
-			}
+			if (!resolvedImportMap.has(exportInfo.reExportSource)) resolvedImportMap.set(exportInfo.reExportSource, safeResolveImport(exportInfo.reExportSource));
 		}
 		const isAlwaysUsed = alwaysUsedFileSet.has(file.path);
 		graphInputs.push({
@@ -6375,7 +9839,22 @@ const analyze = async (config) => {
 		const parsedStyleModule = parseSourceFile(styleFilePath);
 		const resolvedStyleImportMap = /* @__PURE__ */ new Map();
 		for (const importInfo of parsedStyleModule.imports) {
-			const resolvedImport = moduleResolver.resolveModule(importInfo.specifier, styleFilePath);
+			let resolvedImport;
+			try {
+				resolvedImport = moduleResolver.resolveModule(importInfo.specifier, styleFilePath);
+			} catch (styleResolveError) {
+				setupErrors.push(new ResolverError({
+					severity: "warning",
+					message: `moduleResolver.resolveModule threw on style import "${importInfo.specifier}"`,
+					path: styleFilePath,
+					detail: describeUnknownError(styleResolveError)
+				}));
+				resolvedImport = {
+					resolvedPath: void 0,
+					isExternal: false,
+					packageName: void 0
+				};
+			}
 			resolvedStyleImportMap.set(importInfo.specifier, resolvedImport);
 			if (resolvedImport.resolvedPath && !discoveredFilePaths.has(resolvedImport.resolvedPath)) {
 				if (STYLE_EXTENSIONS.some((ext) => resolvedImport.resolvedPath.endsWith(ext)) && (0, node_fs.existsSync)(resolvedImport.resolvedPath)) styleFilesToAdd.add(resolvedImport.resolvedPath);
@@ -6391,10 +9870,51 @@ const analyze = async (config) => {
 		discoveredFilePaths.add(styleFilePath);
 		nextFileIndex++;
 	}
-	const moduleGraph = buildDependencyGraph(graphInputs);
-	resolveReExportChains(moduleGraph);
-	traceReachability(moduleGraph);
-	const analysisResult = generateReport(moduleGraph, config);
+	let moduleGraph;
+	try {
+		moduleGraph = buildDependencyGraph(graphInputs);
+	} catch (graphError) {
+		setupErrors.push(new DetectorError({
+			module: "linker",
+			severity: "fatal",
+			message: "buildDependencyGraph threw",
+			detail: describeUnknownError(graphError)
+		}));
+		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
+	}
+	try {
+		resolveReExportChains(moduleGraph);
+	} catch (reExportError) {
+		setupErrors.push(new DetectorError({
+			module: "linker",
+			message: "resolveReExportChains threw — re-export propagation skipped",
+			detail: describeUnknownError(reExportError)
+		}));
+	}
+	markFilenameRegistryEntries(moduleGraph);
+	try {
+		traceReachability(moduleGraph);
+	} catch (reachabilityError) {
+		setupErrors.push(new DetectorError({
+			module: "linker",
+			message: "traceReachability threw — every module marked reachable to avoid over-reporting",
+			detail: describeUnknownError(reachabilityError)
+		}));
+		for (const module of moduleGraph.modules) module.isReachable = true;
+	}
+	let analysisResult;
+	try {
+		analysisResult = generateReport(moduleGraph, config);
+	} catch (reportError) {
+		setupErrors.push(new DetectorError({
+			module: "report",
+			severity: "fatal",
+			message: "generateReport threw at the top level",
+			detail: describeUnknownError(reportError)
+		}));
+		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
+	}
+	if (setupErrors.length > 0) analysisResult.analysisErrors = [...setupErrors, ...analysisResult.analysisErrors];
 	analysisResult.analysisTimeMs = performance.now() - pipelineStartTime;
 	return analysisResult;
 };