deslop-js 0.0.17-dev.e47ef34 → 0.0.17-dev.e99b313

package/dist/parse-worker.mjs

@@ -0,0 +1,2248 @@
+import { parentPort } from "node:worker_threads";
+import { parseSync } from "oxc-parser";
+import { readFileSync, statSync } from "node:fs";
+
+//#region src/constants.ts
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs",
+	".mdx",
+	".astro",
+	".graphql",
+	".gql",
+	".css",
+	".scss",
+	".vue",
+	".svelte"
+];
+const RESOLVER_EXTENSIONS = [
+	...DEFAULT_EXTENSIONS,
+	".d.ts",
+	".d.mts",
+	".d.cts",
+	".json",
+	".node",
+	".css",
+	".scss",
+	".less",
+	".svg",
+	".png",
+	".jpg",
+	".graphql",
+	".gql"
+];
+const MAX_PARSE_FILE_SIZE_BYTES = 2e6;
+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;
+
+//#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 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";
+	}
+};
+
+//#endregion
+//#region src/utils/line-column.ts
+const getLineFromOffset = (source, offset) => {
+	let line = 1;
+	for (let charIndex = 0; charIndex < offset && charIndex < source.length; charIndex++) if (source[charIndex] === "\n") line++;
+	return line;
+};
+const getColumnFromOffset = (source, offset) => {
+	let column = 0;
+	for (let charIndex = offset - 1; charIndex >= 0; charIndex--) {
+		if (source[charIndex] === "\n") break;
+		column++;
+	}
+	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) => {
+	const statements = [];
+	let isInMultiline = false;
+	let braceDepth = 0;
+	for (const line of sourceText.split("\n")) {
+		const trimmedLine = line.trim();
+		if (isInMultiline) {
+			statements.push(line);
+			for (const character of trimmedLine) {
+				if (character === "{") braceDepth++;
+				if (character === "}") braceDepth--;
+			}
+			const hasFromClause = trimmedLine.includes(" from ") || trimmedLine.includes(" from'") || trimmedLine.includes(" from\"");
+			if (braceDepth <= 0 || trimmedLine.endsWith(";") || hasFromClause) {
+				isInMultiline = false;
+				braceDepth = 0;
+			}
+		} else if (trimmedLine.startsWith("import ") || trimmedLine.startsWith("import{") || trimmedLine.startsWith("export ") || trimmedLine.startsWith("export{")) {
+			statements.push(line);
+			for (const character of trimmedLine) {
+				if (character === "{") braceDepth++;
+				if (character === "}") braceDepth--;
+			}
+			if (braceDepth > 0 && !trimmedLine.includes(" from ")) isInMultiline = true;
+		}
+	}
+	return statements.join("\n");
+};
+const ASTRO_FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---/;
+const ASTRO_SCRIPT_TAG_PATTERN = /<script\b([^>]*?)\/>|<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+const ASTRO_SCRIPT_SRC_ATTRIBUTE_PATTERN = /\bsrc\s*=\s*["']([^"']+)["']/i;
+const extractAstroSources = (sourceText) => {
+	const sections = [];
+	const frontmatterMatch = sourceText.match(ASTRO_FRONTMATTER_PATTERN);
+	if (frontmatterMatch) sections.push(frontmatterMatch[1]);
+	ASTRO_SCRIPT_TAG_PATTERN.lastIndex = 0;
+	let scriptMatch;
+	while ((scriptMatch = ASTRO_SCRIPT_TAG_PATTERN.exec(sourceText)) !== null) {
+		const selfClosingAttributes = scriptMatch[1];
+		const pairedAttributes = scriptMatch[2];
+		const attributes = selfClosingAttributes ?? pairedAttributes ?? "";
+		const body = selfClosingAttributes === void 0 ? scriptMatch[3] ?? "" : "";
+		const srcMatch = attributes.match(ASTRO_SCRIPT_SRC_ATTRIBUTE_PATTERN);
+		if (srcMatch) sections.push(`import ${JSON.stringify(srcMatch[1])};`);
+		if (body) sections.push(body);
+	}
+	return sections.join("\n");
+};
+const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script>/gi;
+const extractVueScriptContent = (sourceText) => {
+	const scriptBlocks = [];
+	let scriptMatch;
+	VUE_SCRIPT_PATTERN.lastIndex = 0;
+	while ((scriptMatch = VUE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
+	return scriptBlocks.join("\n");
+};
+const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+const extractSvelteScriptContent = (sourceText) => {
+	const scriptBlocks = [];
+	let scriptMatch;
+	SVELTE_SCRIPT_PATTERN.lastIndex = 0;
+	while ((scriptMatch = SVELTE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
+	return scriptBlocks.join("\n");
+};
+const getModuleExportNameValue = (exportName) => {
+	if (exportName.type === "Identifier") return exportName.name;
+	if (exportName.type === "Literal") return exportName.value;
+	return "default";
+};
+const CSS_EXTENSIONS = [
+	".css",
+	".scss",
+	".less",
+	".sass"
+];
+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 = readFileSync(filePath, "utf-8");
+	const imports = [];
+	const patterns = [
+		CSS_IMPORT_PATTERN,
+		SCSS_USE_FORWARD_PATTERN,
+		TAILWIND_PLUGIN_REFERENCE_PATTERN
+	];
+	for (const pattern of patterns) {
+		let match;
+		pattern.lastIndex = 0;
+		while ((match = pattern.exec(sourceText)) !== null) {
+			const specifier = match[1];
+			if (specifier && !specifier.startsWith("http")) imports.push({
+				specifier,
+				importedNames: [],
+				isTypeOnly: false,
+				isDynamic: false,
+				isSideEffect: true,
+				line: sourceText.substring(0, match.index).split("\n").length,
+				column: 0
+			});
+		}
+	}
+	return {
+		imports,
+		exports: [],
+		memberAccesses: [],
+		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 = 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(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))) 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 imports = [];
+	const exports = [];
+	const isMdx = filePath.endsWith(".mdx");
+	const isAstro = filePath.endsWith(".astro");
+	const isVue = filePath.endsWith(".vue");
+	const isSvelte = filePath.endsWith(".svelte");
+	const isPreprocessed = isMdx || isAstro || isVue || isSvelte;
+	const textToParse = isMdx ? extractMdxImportsExports(sourceText) : isAstro ? extractAstroSources(sourceText) : isVue ? extractVueScriptContent(sourceText) : isSvelte ? extractSvelteScriptContent(sourceText) : sourceText;
+	const parseFileName = isMdx || isAstro || isVue || isSvelte ? filePath.replace(/\.(mdx|astro|vue|svelte)$/, ".tsx") : filePath;
+	let result;
+	try {
+		result = 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 = parseSync(parseFileName.replace(/\.(m?js|cjs)$/, ".jsx"), textToParse);
+		if (jsxResult.errors.length === 0) result = jsxResult;
+		else {
+			const tsxResult = parseSync(parseFileName.replace(/\.(m?js|cjs)$/, ".tsx"), textToParse);
+			if (tsxResult.errors.length === 0) result = tsxResult;
+		}
+	} catch {}
+	if (result.errors.length > 0 && !isPreprocessed) return {
+		...createEmptyParsedSource(),
+		imports,
+		exports,
+		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
+		})]
+	};
+	if (result.errors.length > 0) earlyErrors.push(new ParseError({
+		code: "parse-recovered-partial",
+		severity: "info",
+		message: `oxc-parser reported ${result.errors.length} syntax issue(s) in extracted ${isAstro ? "Astro" : isVue ? "Vue" : isSvelte ? "Svelte" : "MDX"} sources; continuing with partial AST`,
+		path: filePath
+	}));
+	const program = result.program;
+	if (!program?.body) return {
+		...createEmptyParsedSource(),
+		imports,
+		exports,
+		referencedFilenames: extractReferencedFilenames(sourceText),
+		errors: [...earlyErrors, new ParseError({
+			code: "parse-failed",
+			message: "oxc-parser returned no program body",
+			path: filePath
+		})]
+	};
+	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,
+		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",
+	"entries",
+	"assign",
+	"freeze",
+	"getOwnPropertyNames",
+	"getOwnPropertyDescriptors"
+]);
+const collectNamespaceLocalNames = (imports) => {
+	const namespaceNames = /* @__PURE__ */ new Set();
+	for (const importInfo of imports) for (const importedName of importInfo.importedNames) if (importedName.isNamespace && importedName.alias) namespaceNames.add(importedName.alias);
+	return namespaceNames;
+};
+const collectMemberAccesses = (bodyNodes, namespaceLocalNames, memberAccesses, wholeObjectUses) => {
+	const walkForMemberAccesses = (node) => {
+		if (node.type === "MemberExpression" && !node.computed) {
+			const memberExpression = node;
+			if (memberExpression.object.type === "Identifier" && namespaceLocalNames.has(memberExpression.object.name)) {
+				const objectName = memberExpression.object.name;
+				const memberName = memberExpression.property.name;
+				if (memberName) memberAccesses.push({
+					objectName,
+					memberName
+				});
+			}
+		}
+		if (node.type === "MemberExpression" && Boolean(node.computed)) {
+			const computedExpression = node;
+			if (computedExpression.object.type === "Identifier" && namespaceLocalNames.has(computedExpression.object.name)) {
+				const objectName = computedExpression.object.name;
+				const expressionNode = node.expression;
+				if (expressionNode?.type === "Literal") {
+					const literalValue = expressionNode.value;
+					if (typeof literalValue === "string") memberAccesses.push({
+						objectName,
+						memberName: literalValue
+					});
+					else wholeObjectUses.push(objectName);
+				} else wholeObjectUses.push(objectName);
+			}
+		}
+		if (node.type === "SpreadElement") {
+			const spreadArgument = node.argument;
+			if (spreadArgument?.type === "Identifier" && namespaceLocalNames.has(spreadArgument.name)) wholeObjectUses.push(spreadArgument.name);
+		}
+		if (node.type === "ForInStatement") {
+			const forInRight = node.right;
+			if (forInRight?.type === "Identifier" && namespaceLocalNames.has(forInRight.name)) wholeObjectUses.push(forInRight.name);
+		}
+		if (node.type === "CallExpression") {
+			const callExpression = node;
+			if (callExpression.callee.type === "MemberExpression" && !callExpression.callee.computed) {
+				const calleeMember = callExpression.callee;
+				if (calleeMember.object.type === "Identifier" && calleeMember.object.name === "Object" && WHOLE_OBJECT_FUNCTION_NAMES.has(calleeMember.property.name)) {
+					const firstArgument = callExpression.arguments[0];
+					if (firstArgument && firstArgument.type !== "SpreadElement" && firstArgument.type === "Identifier" && namespaceLocalNames.has(firstArgument.name)) wholeObjectUses.push(firstArgument.name);
+				}
+			}
+		}
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const element of value) if (isWalkableNode(element)) walkForMemberAccesses(element);
+		} else if (isWalkableNode(value)) walkForMemberAccesses(value);
+	};
+	for (const topLevelNode of bodyNodes) if (isWalkableNode(topLevelNode)) walkForMemberAccesses(topLevelNode);
+};
+const extractImportDeclaration = (node, sourceText, imports) => {
+	const specifier = node.source.value;
+	if (!specifier) return;
+	const isTypeOnly = node.importKind === "type";
+	const importedNames = [];
+	for (const specifierNode of node.specifiers) switch (specifierNode.type) {
+		case "ImportDefaultSpecifier":
+			importedNames.push({
+				name: "default",
+				alias: specifierNode.local.name,
+				isNamespace: false,
+				isDefault: true,
+				isTypeOnly
+			});
+			break;
+		case "ImportNamespaceSpecifier":
+			importedNames.push({
+				name: "*",
+				alias: specifierNode.local.name,
+				isNamespace: true,
+				isDefault: false,
+				isTypeOnly
+			});
+			break;
+		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",
+				isRedundantAlias: isSelfAlias || void 0
+			});
+			break;
+		}
+	}
+	const isSideEffectImport = importedNames.length === 0;
+	if (isSideEffectImport) importedNames.push({
+		name: "*",
+		alias: void 0,
+		isNamespace: false,
+		isDefault: false,
+		isTypeOnly: false
+	});
+	imports.push({
+		specifier,
+		importedNames,
+		isTypeOnly,
+		isDynamic: false,
+		isSideEffect: isSideEffectImport,
+		line: getLineFromOffset(sourceText, node.start),
+		column: getColumnFromOffset(sourceText, node.start)
+	});
+};
+const extractNamedExportDeclaration = (node, sourceText, exports) => {
+	const isTypeOnly = node.exportKind === "type";
+	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",
+			isTypeOnly: isTypeOnly || specifierNode.exportKind === "type",
+			isReExport: reExportSource !== void 0,
+			isSynthetic: false,
+			reExportSource,
+			reExportOriginalName: reExportSource !== void 0 ? localName : void 0,
+			isNamespaceReExport: false,
+			line: getLineFromOffset(sourceText, specifierNode.start ?? node.start),
+			column: getColumnFromOffset(sourceText, specifierNode.start ?? node.start),
+			isRedundantAlias: isSelfAlias || void 0
+		});
+	}
+};
+const extractDefaultExportDeclaration = (node, sourceText, exports) => {
+	const defaultExportLocalName = extractDefaultExportLocalName(node.declaration);
+	exports.push({
+		name: "default",
+		isDefault: true,
+		isTypeOnly: false,
+		isReExport: false,
+		isSynthetic: false,
+		reExportSource: void 0,
+		reExportOriginalName: void 0,
+		isNamespaceReExport: false,
+		line: getLineFromOffset(sourceText, node.start),
+		column: getColumnFromOffset(sourceText, node.start),
+		defaultExportLocalName
+	});
+};
+const extractExportAllDeclaration = (node, sourceText, exports) => {
+	const reExportSource = node.source.value;
+	if (!reExportSource) return;
+	const exportedName = node.exported ? getModuleExportNameValue(node.exported) : void 0;
+	exports.push({
+		name: exportedName ?? "*",
+		isDefault: false,
+		isTypeOnly: node.exportKind === "type",
+		isReExport: true,
+		isSynthetic: false,
+		reExportSource,
+		reExportOriginalName: "*",
+		isNamespaceReExport: !exportedName,
+		line: getLineFromOffset(sourceText, node.start),
+		column: getColumnFromOffset(sourceText, node.start)
+	});
+};
+const extractDeclarationNames = (declaration, isTypeOnly, sourceText, exports, fallbackStart) => {
+	const declarationType = declaration.type;
+	if (declarationType === "FunctionDeclaration" || declarationType === "ClassDeclaration" || declarationType === "TSEnumDeclaration") {
+		const declarationName = declaration.id?.name;
+		if (declarationName) exports.push({
+			name: declarationName,
+			isDefault: false,
+			isTypeOnly,
+			isReExport: false,
+			isSynthetic: false,
+			reExportSource: void 0,
+			reExportOriginalName: void 0,
+			isNamespaceReExport: false,
+			line: getLineFromOffset(sourceText, declaration.start ?? fallbackStart),
+			column: getColumnFromOffset(sourceText, declaration.start ?? fallbackStart)
+		});
+		return;
+	}
+	if (declarationType === "TSTypeAliasDeclaration" || declarationType === "TSInterfaceDeclaration") {
+		const declarationName = declaration.id.name;
+		if (declarationName) exports.push({
+			name: declarationName,
+			isDefault: false,
+			isTypeOnly: true,
+			isReExport: false,
+			isSynthetic: false,
+			reExportSource: void 0,
+			reExportOriginalName: void 0,
+			isNamespaceReExport: false,
+			line: getLineFromOffset(sourceText, declaration.start ?? fallbackStart),
+			column: getColumnFromOffset(sourceText, declaration.start ?? fallbackStart)
+		});
+		return;
+	}
+	if (declarationType === "VariableDeclaration") {
+		const variableDeclaration = declaration;
+		for (const declarator of variableDeclaration.declarations) {
+			const bindingNames = extractBindingPatternNames(declarator.id);
+			for (const bindingName of bindingNames) exports.push({
+				name: bindingName,
+				isDefault: false,
+				isTypeOnly,
+				isReExport: false,
+				isSynthetic: false,
+				reExportSource: void 0,
+				reExportOriginalName: void 0,
+				isNamespaceReExport: false,
+				line: getLineFromOffset(sourceText, declarator.start ?? fallbackStart),
+				column: getColumnFromOffset(sourceText, declarator.start ?? fallbackStart)
+			});
+		}
+	}
+};
+const extractBindingPatternNames = (pattern) => {
+	if (!pattern) return [];
+	if (pattern.type === "Identifier") return pattern.name ? [pattern.name] : [];
+	if (pattern.type === "ObjectPattern") {
+		const names = [];
+		for (const property of pattern.properties) if (property.type === "RestElement") names.push(...extractBindingPatternNames(property.argument));
+		else names.push(...extractBindingPatternNames(property.value));
+		return names;
+	}
+	if (pattern.type === "ArrayPattern") {
+		const names = [];
+		for (const element of pattern.elements) {
+			if (!element) continue;
+			if (element.type === "RestElement") names.push(...extractBindingPatternNames(element.argument));
+			else names.push(...extractBindingPatternNames(element));
+		}
+		return names;
+	}
+	if (pattern.type === "AssignmentPattern") return extractBindingPatternNames(pattern.left);
+	return [];
+};
+const createNamespaceImportBinding = () => ({
+	name: "*",
+	alias: void 0,
+	isNamespace: true,
+	isDefault: false,
+	isTypeOnly: false
+});
+const isWalkableNode = (value) => Boolean(value) && typeof value === "object" && typeof value.type === "string";
+const extractStringLiteralFromArgument = (callArguments) => {
+	const firstArgument = callArguments[0];
+	if (!firstArgument) return void 0;
+	if (firstArgument.type === "SpreadElement") return void 0;
+	if (firstArgument.type !== "Literal") return void 0;
+	const literalValue = firstArgument.value;
+	return typeof literalValue === "string" ? literalValue : void 0;
+};
+const extractGlobPatterns = (callArguments) => {
+	const firstArgument = callArguments[0];
+	if (!firstArgument || firstArgument.type === "SpreadElement") return [];
+	if (firstArgument.type === "Literal") {
+		const literalValue = firstArgument.value;
+		if (typeof literalValue === "string" && (literalValue.startsWith("./") || literalValue.startsWith("../"))) return [literalValue];
+		return [];
+	}
+	if (firstArgument.type === "ArrayExpression") return firstArgument.elements.filter((element) => element.type === "Literal" && typeof element.value === "string" && (element.value.startsWith("./") || element.value.startsWith("../"))).map((element) => element.value);
+	return [];
+};
+const extractRegexGlobSuffix = (callArguments) => {
+	const thirdArgument = callArguments[2];
+	if (!thirdArgument || thirdArgument.type === "SpreadElement") return void 0;
+	if (thirdArgument.type !== "Literal") return void 0;
+	const regExpValue = thirdArgument.regex;
+	if (!regExpValue) return void 0;
+	const extensionMatch = regExpValue.pattern.match(/^\\\.([\w|]+)\$$/);
+	if (extensionMatch) {
+		const extensions = extensionMatch[1].split("|");
+		if (extensions.length === 1) return `*.${extensions[0]}`;
+		return `*.{${extensions.join(",")}}`;
+	}
+};
+const hasMockFactoryArgument = (callExpression) => {
+	const secondArgument = callExpression.arguments[1];
+	if (!secondArgument) return false;
+	if (secondArgument.type === "SpreadElement") return false;
+	return secondArgument.type === "ArrowFunctionExpression" || secondArgument.type === "FunctionExpression";
+};
+const synthesizeAutoMockSibling = (mockSource) => {
+	if (!mockSource || mockSource.includes("://") || mockSource.startsWith("data:") || mockSource.split("/").some((segment) => segment === "__mocks__")) return;
+	const lastSlashIndex = mockSource.lastIndexOf("/");
+	if (lastSlashIndex === -1) return void 0;
+	const directory = mockSource.slice(0, lastSlashIndex);
+	const fileName = mockSource.slice(lastSlashIndex + 1);
+	if (!fileName) return void 0;
+	return `${directory}/__mocks__/${fileName}`;
+};
+const collectDynamicImports = (bodyNodes, sourceText, imports) => {
+	const walkNode = (node) => {
+		if (node.type === "ImportExpression") {
+			const importExpression = node;
+			const sourceExpression = importExpression.source;
+			if (sourceExpression.type === "Literal") {
+				const specifierValue = sourceExpression.value;
+				if (specifierValue) imports.push({
+					specifier: specifierValue,
+					importedNames: [createNamespaceImportBinding()],
+					isTypeOnly: false,
+					isDynamic: true,
+					isSideEffect: false,
+					line: getLineFromOffset(sourceText, importExpression.start),
+					column: getColumnFromOffset(sourceText, importExpression.start)
+				});
+			} else if (sourceExpression.type === "TemplateLiteral") {
+				const templateLiteral = sourceExpression;
+				if (templateLiteral.quasis.length >= 2) {
+					const globPattern = templateLiteral.quasis.map((quasi) => quasi.value.cooked).join("*");
+					if (globPattern.startsWith("./") || globPattern.startsWith("../")) imports.push({
+						specifier: globPattern,
+						importedNames: [createNamespaceImportBinding()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: false,
+						isGlob: true,
+						line: getLineFromOffset(sourceText, importExpression.start),
+						column: getColumnFromOffset(sourceText, importExpression.start)
+					});
+				}
+			}
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const callExpression = node;
+			if (callExpression.callee.type === "Identifier" && callExpression.callee.name === "require") {
+				const requireSpecifier = extractStringLiteralFromArgument(callExpression.arguments);
+				if (requireSpecifier) imports.push({
+					specifier: requireSpecifier,
+					importedNames: [createNamespaceImportBinding()],
+					isTypeOnly: false,
+					isDynamic: true,
+					isSideEffect: false,
+					line: getLineFromOffset(sourceText, callExpression.start),
+					column: getColumnFromOffset(sourceText, callExpression.start)
+				});
+			}
+			if (callExpression.callee.type === "MemberExpression" && !callExpression.callee.computed) {
+				const memberExpression = callExpression.callee;
+				if (memberExpression.object.type === "Identifier" && memberExpression.object.name === "require" && memberExpression.property.name === "resolve") {
+					const resolveSpecifier = extractStringLiteralFromArgument(callExpression.arguments);
+					if (resolveSpecifier) imports.push({
+						specifier: resolveSpecifier,
+						importedNames: [createNamespaceImportBinding()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: false,
+						line: getLineFromOffset(sourceText, callExpression.start),
+						column: getColumnFromOffset(sourceText, callExpression.start)
+					});
+				}
+				if (memberExpression.object.type === "Identifier" && (memberExpression.object.name === "vi" || memberExpression.object.name === "jest") && memberExpression.property.name === "mock") {
+					const mockSpecifier = extractStringLiteralFromArgument(callExpression.arguments);
+					if (mockSpecifier) {
+						imports.push({
+							specifier: mockSpecifier,
+							importedNames: [createNamespaceImportBinding()],
+							isTypeOnly: false,
+							isDynamic: true,
+							isSideEffect: true,
+							line: getLineFromOffset(sourceText, callExpression.start),
+							column: getColumnFromOffset(sourceText, callExpression.start)
+						});
+						const hasFactoryArgument = hasMockFactoryArgument(callExpression);
+						const autoMockSibling = synthesizeAutoMockSibling(mockSpecifier);
+						if (!hasFactoryArgument && autoMockSibling) imports.push({
+							specifier: autoMockSibling,
+							importedNames: [createNamespaceImportBinding()],
+							isTypeOnly: false,
+							isDynamic: true,
+							isSideEffect: true,
+							line: getLineFromOffset(sourceText, callExpression.start),
+							column: getColumnFromOffset(sourceText, callExpression.start)
+						});
+					}
+				}
+				if (memberExpression.object.type === "MetaProperty" && memberExpression.property.name === "glob") {
+					const globPatterns = extractGlobPatterns(callExpression.arguments);
+					for (const globPattern of globPatterns) imports.push({
+						specifier: globPattern,
+						importedNames: [createNamespaceImportBinding()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: false,
+						isGlob: true,
+						line: getLineFromOffset(sourceText, callExpression.start),
+						column: getColumnFromOffset(sourceText, callExpression.start)
+					});
+				}
+				if (memberExpression.object.type === "Identifier" && memberExpression.object.name === "require" && memberExpression.property.name === "context") {
+					const directoryArgument = extractStringLiteralFromArgument(callExpression.arguments);
+					if (directoryArgument && (directoryArgument.startsWith("./") || directoryArgument.startsWith("../"))) {
+						const hasRegexArgument = callExpression.arguments.length >= 3 && callExpression.arguments[2].type !== "SpreadElement";
+						const regexSuffix = extractRegexGlobSuffix(callExpression.arguments);
+						if (!hasRegexArgument || Boolean(regexSuffix)) {
+							const contextGlobPrefix = callExpression.arguments[1]?.type === "Literal" && callExpression.arguments[1].value === true ? `${directoryArgument}/**/` : `${directoryArgument}/`;
+							const contextGlobPattern = regexSuffix ? `${contextGlobPrefix}${regexSuffix}` : `${contextGlobPrefix}*`;
+							imports.push({
+								specifier: contextGlobPattern,
+								importedNames: [createNamespaceImportBinding()],
+								isTypeOnly: false,
+								isDynamic: true,
+								isSideEffect: false,
+								isGlob: true,
+								line: getLineFromOffset(sourceText, callExpression.start),
+								column: getColumnFromOffset(sourceText, callExpression.start)
+							});
+						}
+					}
+				}
+			}
+		}
+		if (node.type === "NewExpression") {
+			const newExpression = node;
+			if (newExpression.callee.type === "Identifier" && newExpression.callee.name === "URL" && newExpression.arguments.length >= 2) {
+				const secondArgument = newExpression.arguments[1];
+				if (secondArgument.type === "MemberExpression" && secondArgument.object.type === "MetaProperty" && secondArgument.property.name === "url") {
+					const urlSpecifier = extractStringLiteralFromArgument(newExpression.arguments);
+					if (urlSpecifier) imports.push({
+						specifier: urlSpecifier,
+						importedNames: [createNamespaceImportBinding()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: true,
+						line: getLineFromOffset(sourceText, newExpression.start),
+						column: getColumnFromOffset(sourceText, newExpression.start)
+					});
+				}
+			}
+		}
+		if (node.type === "Decorator") {
+			const expression = node.expression;
+			if (expression?.type === "CallExpression") {
+				const callNode = expression;
+				const callee = callNode.callee;
+				if (callee.type === "Identifier" && callee.name === "Component") {
+					const objectArgument = callNode.arguments[0];
+					if (objectArgument?.type === "ObjectExpression") {
+						const objectProperties = objectArgument.properties;
+						for (const property of objectProperties) {
+							if (property.type !== "ObjectProperty" && property.type !== "Property") continue;
+							const propertyKey = property.key;
+							const propertyName = propertyKey?.name ?? propertyKey?.value;
+							const propertyValue = property.value;
+							if (propertyName === "templateUrl" && propertyValue?.type === "Literal") {
+								const templatePath = propertyValue.value;
+								if (templatePath) imports.push({
+									specifier: templatePath.startsWith(".") ? templatePath : `./${templatePath}`,
+									importedNames: [],
+									isTypeOnly: false,
+									isDynamic: false,
+									isSideEffect: true,
+									line: getLineFromOffset(sourceText, property.start),
+									column: getColumnFromOffset(sourceText, property.start)
+								});
+							}
+							if ((propertyName === "styleUrl" || propertyName === "styleUrls") && propertyValue) {
+								const styleUrlValues = [];
+								if (propertyValue.type === "Literal") {
+									const singleValue = propertyValue.value;
+									if (singleValue) styleUrlValues.push(singleValue);
+								} else if (propertyValue.type === "ArrayExpression") {
+									const arrayElements = propertyValue.elements;
+									for (const element of arrayElements) if (element?.type === "Literal") {
+										const elementValue = element.value;
+										if (elementValue) styleUrlValues.push(elementValue);
+									}
+								}
+								for (const styleUrl of styleUrlValues) imports.push({
+									specifier: styleUrl.startsWith(".") ? styleUrl : `./${styleUrl}`,
+									importedNames: [],
+									isTypeOnly: false,
+									isDynamic: false,
+									isSideEffect: true,
+									line: getLineFromOffset(sourceText, property.start),
+									column: getColumnFromOffset(sourceText, property.start)
+								});
+							}
+						}
+					}
+				}
+			}
+		}
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const element of value) if (isWalkableNode(element)) walkNode(element);
+		} else if (isWalkableNode(value)) walkNode(value);
+	};
+	for (const topLevelNode of bodyNodes) if (isWalkableNode(topLevelNode)) walkNode(topLevelNode);
+};
+
+//#endregion
+//#region src/collect/parse-worker.ts
+const port = parentPort;
+port.on("message", (message) => {
+	if (message.type === "parse") try {
+		const parsed = parseSourceFile(message.filePath);
+		const response = {
+			type: "result",
+			fileIndex: message.fileIndex,
+			filePath: message.filePath,
+			parsed: {
+				imports: parsed.imports,
+				exports: parsed.exports,
+				memberAccesses: parsed.memberAccesses,
+				wholeObjectUses: parsed.wholeObjectUses,
+				localIdentifierReferences: parsed.localIdentifierReferences,
+				referencedFilenames: parsed.referencedFilenames,
+				redundantTypePatterns: parsed.redundantTypePatterns,
+				identityWrappers: parsed.identityWrappers,
+				typeDefinitionHashes: parsed.typeDefinitionHashes,
+				inlineTypeLiterals: parsed.inlineTypeLiterals,
+				simplifiableFunctions: parsed.simplifiableFunctions,
+				simplifiableExpressions: parsed.simplifiableExpressions,
+				duplicateConstantCandidates: parsed.duplicateConstantCandidates,
+				errors: parsed.errors.map((deslopError) => deslopError.toJSON())
+			}
+		};
+		port.postMessage(response);
+	} catch (taskError) {
+		const response = {
+			type: "error",
+			fileIndex: message.fileIndex,
+			filePath: message.filePath,
+			errorMessage: taskError instanceof Error ? taskError.message : String(taskError)
+		};
+		port.postMessage(response);
+	}
+});
+port.postMessage({ type: "ready" });
+
+//#endregion
+export {  };