deep-slop 1.4.1

package/dist/dead-flow-DHRkyxZT.js

@@ -0,0 +1,1422 @@
+import { _ as parseFile, a as findNodesOfType, i as findAncestorOfType, n as extractImportFromNode, o as findNodesOfTypes, r as findAncestor, y as walkAST } from "./tree-sitter-CM-cP0nl.js";
+import { i as toLines, r as readFileContent } from "./file-utils-B_HFXhCs.js";
+import { extname, join, relative } from "node:path";
+import { readdir } from "node:fs/promises";
+
+//#region src/engines/dead-flow/ast-detect.ts
+function makeDiagnostic$1(overrides) {
+	return {
+		engine: "dead-flow",
+		severity: "warning",
+		column: 1,
+		category: "dead-code",
+		fixable: true,
+		help: "",
+		...overrides
+	};
+}
+/** Get 1-indexed line from an AST node */
+function nodeLine(node) {
+	return node.startRow + 1;
+}
+/** Check if a node is inside a catch or finally clause */
+function isInCatchOrFinally(node) {
+	return findAncestor(node, (n) => n.type === "catch_clause" || n.type === "finally_clause") !== null;
+}
+/** Check if a node is inside an arrow function body */
+function isInArrowFunction(node) {
+	return findAncestor(node, (n) => n.type === "arrow_function") !== null;
+}
+/** Check if a return/throw is a guard return (inside an if without else, body is only terminators) */
+function isGuardReturn$1(node) {
+	const ifAncestor = findAncestorOfType(node, "if_statement");
+	if (!ifAncestor) return false;
+	if (ifAncestor.children.find((c) => c.type === "else" || c.type === "else_clause")) return false;
+	const consequence = ifAncestor.children.find((c) => c.type === "statement_block" || c.type === "consequence");
+	if (!consequence) return true;
+	const nonTrivial = consequence.children.filter((c) => c.type !== "comment" && c.type !== "{" && c.type !== "}" && c.text.trim() !== "" && c.text.trim() !== ";");
+	const terminators = nonTrivial.filter((c) => c.type === "return_statement" || c.type === "throw_statement");
+	return nonTrivial.length > 0 && nonTrivial.length === terminators.length;
+}
+/** Get subsequent sibling statements after a terminator in the same block */
+function getSiblingsAfter(node) {
+	const parent = node.parent;
+	if (!parent) return [];
+	const siblings = parent.children;
+	const idx = siblings.indexOf(node);
+	if (idx < 0) return [];
+	return siblings.slice(idx + 1).filter((s) => s.type !== "comment" && s.type !== "{" && s.type !== "}" && s.text.trim() !== "" && s.text.trim() !== ";");
+}
+/** Evaluate whether an if condition is statically always truthy/falsy */
+function evaluateCondition(conditionNode) {
+	const text = conditionNode.text.trim();
+	if (text.startsWith("(") && text.endsWith(")")) {
+		const inner = conditionNode.children.find((c) => c.type !== "(" && c.type !== ")");
+		if (inner) return evaluateCondition(inner);
+	}
+	if (conditionNode.type === "unary_expression" && text.startsWith("!")) {
+		const operand = conditionNode.children.find((c) => c.type !== "!");
+		if (operand) {
+			const inner = evaluateCondition(operand);
+			if (inner === "always-truthy") return "always-falsy";
+			if (inner === "always-falsy") return "always-truthy";
+		}
+	}
+	if (conditionNode.type === "true") return "always-truthy";
+	if (conditionNode.type === "false") return "always-falsy";
+	if (conditionNode.type === "number") return parseFloat(text) === 0 ? "always-falsy" : "always-truthy";
+	if (conditionNode.type === "string" || conditionNode.type === "template_string") return text.replace(/^['"`]|['"`]$/g, "").length === 0 ? "always-falsy" : "unknown";
+	if (conditionNode.type === "null" || text === "undefined") return "always-falsy";
+	return "unknown";
+}
+async function parseWithTreeSitter(content, filePath) {
+	return parseFile(content, filePath.endsWith(".tsx"));
+}
+function detectDeadAfterThrow(ast, filePath) {
+	const diagnostics = [];
+	const throws = findNodesOfType(ast, "throw_statement");
+	for (const throwNode of throws) {
+		if (isInCatchOrFinally(throwNode)) continue;
+		if (isGuardReturn$1(throwNode)) continue;
+		const after = getSiblingsAfter(throwNode);
+		for (const dead of after) {
+			diagnostics.push(makeDiagnostic$1({
+				filePath,
+				rule: "dead-flow/dead-after-throw",
+				message: `Unreachable code after throw on line ${nodeLine(throwNode)}`,
+				line: nodeLine(dead),
+				severity: "error",
+				help: `Remove the unreachable code after the throw statement on line ${nodeLine(throwNode)}`,
+				suggestion: {
+					type: "delete",
+					text: "",
+					confidence: .95,
+					reason: "Code after throw in same block can never execute",
+					range: {
+						startLine: nodeLine(dead),
+						startCol: dead.startCol + 1,
+						endLine: dead.endRow + 1,
+						endCol: dead.endCol + 1
+					}
+				},
+				detail: {
+					terminatorKind: "throw",
+					terminatorLine: nodeLine(throwNode)
+				}
+			}));
+			break;
+		}
+	}
+	return diagnostics;
+}
+function detectDeadAfterReturn(ast, filePath) {
+	const diagnostics = [];
+	const returns = findNodesOfType(ast, "return_statement");
+	for (const returnNode of returns) {
+		if (isInCatchOrFinally(returnNode)) continue;
+		if (isInArrowFunction(returnNode)) {
+			const arrowAncestor = findAncestorOfType(returnNode, "arrow_function");
+			if (arrowAncestor) {
+				const body = arrowAncestor.children.find((c) => c.type === "statement_block");
+				if (body && body.children.includes(returnNode)) {
+					if (returnNode.parent === body) {
+						const after = getSiblingsAfter(returnNode);
+						for (const dead of after) {
+							diagnostics.push(makeDiagnostic$1({
+								filePath,
+								rule: "dead-flow/dead-after-return",
+								message: `Unreachable code after return on line ${nodeLine(returnNode)}`,
+								line: nodeLine(dead),
+								severity: "warning",
+								help: `Remove the unreachable code after the return statement on line ${nodeLine(returnNode)}`,
+								suggestion: {
+									type: "delete",
+									text: "",
+									confidence: .9,
+									reason: "Code after return in same block can never execute"
+								},
+								detail: {
+									terminatorKind: "return",
+									terminatorLine: nodeLine(returnNode)
+								}
+							}));
+							break;
+						}
+					}
+				}
+			}
+			continue;
+		}
+		if (isGuardReturn$1(returnNode)) continue;
+		const after = getSiblingsAfter(returnNode);
+		for (const dead of after) {
+			diagnostics.push(makeDiagnostic$1({
+				filePath,
+				rule: "dead-flow/dead-after-return",
+				message: `Unreachable code after return on line ${nodeLine(returnNode)}`,
+				line: nodeLine(dead),
+				severity: "warning",
+				help: `Remove the unreachable code after the return statement on line ${nodeLine(returnNode)}`,
+				suggestion: {
+					type: "delete",
+					text: "",
+					confidence: .9,
+					reason: "Code after return in same block can never execute"
+				},
+				detail: {
+					terminatorKind: "return",
+					terminatorLine: nodeLine(returnNode)
+				}
+			}));
+			break;
+		}
+	}
+	return diagnostics;
+}
+function detectDeadAfterBreak(ast, filePath) {
+	const diagnostics = [];
+	const breaks = findNodesOfTypes(ast, ["break_statement", "continue_statement"]);
+	for (const breakNode of breaks) {
+		const after = getSiblingsAfter(breakNode);
+		for (const dead of after) {
+			const kind = breakNode.type === "break_statement" ? "break" : "continue";
+			diagnostics.push(makeDiagnostic$1({
+				filePath,
+				rule: "dead-flow/dead-after-break",
+				message: `Unreachable code after ${kind} on line ${nodeLine(breakNode)}`,
+				line: nodeLine(dead),
+				severity: "error",
+				help: `Remove the unreachable code after the ${kind} statement on line ${nodeLine(breakNode)}`,
+				suggestion: {
+					type: "delete",
+					text: "",
+					confidence: .95,
+					reason: `Code after ${kind} in same block can never execute`
+				},
+				detail: {
+					terminatorKind: kind,
+					terminatorLine: nodeLine(breakNode)
+				}
+			}));
+			break;
+		}
+	}
+	return diagnostics;
+}
+function detectUnreachableAfterTerminatorAST(ast, filePath) {
+	const diagnostics = [];
+	const terminators = findNodesOfTypes(ast, [
+		"return_statement",
+		"throw_statement",
+		"break_statement",
+		"continue_statement"
+	]);
+	for (const term of terminators) {
+		if (isInCatchOrFinally(term)) continue;
+		if ((term.type === "return_statement" || term.type === "throw_statement") && isGuardReturn$1(term)) continue;
+		const after = getSiblingsAfter(term);
+		if (after.length === 0) continue;
+		const kind = term.type === "return_statement" ? "return" : term.type === "throw_statement" ? "throw" : term.type === "break_statement" ? "break" : "continue";
+		const severity = kind === "return" ? "warning" : "error";
+		diagnostics.push(makeDiagnostic$1({
+			filePath,
+			rule: "dead-flow/unreachable-after-terminator",
+			message: `Unreachable code after ${kind} on line ${nodeLine(term)}`,
+			line: nodeLine(after[0]),
+			severity,
+			help: `Remove or move the unreachable code after the ${kind} statement on line ${nodeLine(term)}`,
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .9,
+				reason: `Code after ${kind} can never execute`,
+				range: {
+					startLine: nodeLine(after[0]),
+					startCol: after[0].startCol + 1,
+					endLine: after[0].endRow + 1,
+					endCol: after[0].endCol + 1
+				}
+			},
+			detail: {
+				terminatorKind: kind,
+				terminatorLine: nodeLine(term)
+			}
+		}));
+	}
+	return diagnostics;
+}
+function detectUnusedVariablesAST(ast, filePath) {
+	const diagnostics = [];
+	const declarations = /* @__PURE__ */ new Map();
+	const lexicalDecls = findNodesOfTypes(ast, ["lexical_declaration", "variable_declaration"]);
+	for (const decl of lexicalDecls) {
+		const isExported = findAncestor(decl, (n) => n.type === "export_statement") !== null;
+		for (const child of decl.children) {
+			if (child.type !== "variable_declarator") continue;
+			const nameNode = child.children.find((c) => c.type === "identifier" && c.fieldName === "name") || child.children.find((c) => c.type === "identifier");
+			if (!nameNode) continue;
+			const name = nameNode.text;
+			if (name.includes(",") || name.includes("{") || name.includes("[")) continue;
+			declarations.set(name, {
+				node: child,
+				line: nodeLine(nameNode),
+				isExported,
+				isParameter: false,
+				isType: false,
+				isFunction: false
+			});
+		}
+	}
+	const funcDecls = findNodesOfTypes(ast, [
+		"function_declaration",
+		"generator_function_declaration",
+		"method_definition"
+	]);
+	for (const fn of funcDecls) {
+		const nameNode = fn.children.find((c) => c.type === "identifier" || c.type === "property_identifier");
+		if (!nameNode) continue;
+		const isExported = findAncestor(fn, (n) => n.type === "export_statement") !== null;
+		declarations.set(nameNode.text, {
+			node: fn,
+			line: nodeLine(nameNode),
+			isExported,
+			isParameter: false,
+			isType: false,
+			isFunction: true
+		});
+	}
+	const typeDecls = findNodesOfTypes(ast, ["type_alias_declaration", "interface_declaration"]);
+	for (const td of typeDecls) {
+		const nameNode = td.children.find((c) => c.type === "type_identifier");
+		if (!nameNode) continue;
+		const isExported = findAncestor(td, (n) => n.type === "export_statement") !== null;
+		declarations.set(nameNode.text, {
+			node: td,
+			line: nodeLine(nameNode),
+			isExported,
+			isParameter: false,
+			isType: true,
+			isFunction: false
+		});
+	}
+	const params = findNodesOfTypes(ast, [
+		"required_parameter",
+		"optional_parameter",
+		"rest_parameter"
+	]);
+	for (const param of params) {
+		const nameNode = param.children.find((c) => c.type === "identifier" && c.fieldName === "name") || param.children.find((c) => c.type === "identifier");
+		if (!nameNode) continue;
+		declarations.set(nameNode.text, {
+			node: param,
+			line: nodeLine(nameNode),
+			isExported: false,
+			isParameter: true,
+			isType: false,
+			isFunction: false
+		});
+	}
+	const references = /* @__PURE__ */ new Set();
+	walkAST(ast, (node) => {
+		if (node.type !== "identifier") return;
+		if (!(node.fieldName === "name" && node.parent && (node.parent.type === "variable_declarator" || node.parent.type === "function_declaration" || node.parent.type === "generator_function_declaration" || node.parent.type === "method_definition" || node.parent.type === "required_parameter" || node.parent.type === "optional_parameter" || node.parent.type === "rest_parameter" || node.parent.type === "type_alias_declaration" || node.parent.type === "interface_declaration" || node.parent.type === "class_declaration" || node.parent.type === "import_specifier" || node.parent.type === "export_specifier"))) references.add(node.text);
+	});
+	for (const [name, info] of declarations) {
+		if (name.startsWith("_")) continue;
+		if (info.isExported) continue;
+		if (info.isType) continue;
+		if (info.isParameter) continue;
+		if (/^[A-Z]/.test(name) && info.isFunction) continue;
+		if (!references.has(name)) diagnostics.push(makeDiagnostic$1({
+			filePath,
+			rule: "dead-flow/unused-variable",
+			message: `Variable \`${name}\` is declared but never used`,
+			line: info.line,
+			severity: "suggestion",
+			fixable: true,
+			help: `Remove the unused variable \`${name}\` or prefix with _ if intentionally unused`,
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .8,
+				reason: `Variable \`${name}\` is never referenced after its declaration (AST-verified)`
+			},
+			detail: {
+				variableName: name,
+				source: "ast"
+			}
+		}));
+	}
+	return diagnostics;
+}
+function detectUnusedExportsAST(astMap, rootDir) {
+	const diagnostics = [];
+	const exportMap = /* @__PURE__ */ new Map();
+	const importedSymbols = /* @__PURE__ */ new Set();
+	for (const [filePath, ast] of astMap) {
+		const exportStmts = findNodesOfType(ast, "export_statement");
+		for (const exp of exportStmts) {
+			const declChildren = exp.children.filter((c) => c.type === "lexical_declaration" || c.type === "variable_declaration" || c.type === "function_declaration" || c.type === "class_declaration" || c.type === "generator_function_declaration" || c.type === "type_alias_declaration" || c.type === "interface_declaration");
+			for (const decl of declChildren) {
+				const nameNode = decl.children.find((c) => c.type === "identifier" || c.type === "type_identifier");
+				if (!nameNode) continue;
+				const name = nameNode.text;
+				if (exp.text.includes("export default")) continue;
+				if (decl.type === "type_alias_declaration" || decl.type === "interface_declaration") continue;
+				if (!exportMap.has(name)) exportMap.set(name, []);
+				exportMap.get(name).push({
+					filePath,
+					line: nodeLine(nameNode)
+				});
+			}
+			const exportSpecifiers = findNodesOfType(exp, "export_specifier");
+			for (const spec of exportSpecifiers) {
+				const nameNode = spec.children.find((c) => c.type === "identifier");
+				if (!nameNode) continue;
+				const name = nameNode.text;
+				if (!exportMap.has(name)) exportMap.set(name, []);
+				exportMap.get(name).push({
+					filePath,
+					line: nodeLine(spec)
+				});
+			}
+		}
+		const importStmts = findNodesOfTypes(ast, ["import_statement", "import_declaration"]);
+		for (const imp of importStmts) {
+			const info = extractImportFromNode(imp);
+			if (info) for (const sym of info.symbols) importedSymbols.add(sym);
+		}
+		const callExprs = findNodesOfType(ast, "call_expression");
+		for (const call of callExprs) {
+			const func = call.children[0];
+			if (func && func.type === "import") {
+				const thenMatch = call.text.match(/\.then\s*\(\s*\((\w+)\)\s*=>\s*\1\.(\w+)/);
+				if (thenMatch) importedSymbols.add(thenMatch[2]);
+				const thenMatch2 = call.text.match(/\.then\s*\(\s*(\w+)\s*=>\s*\1\.(\w+)/);
+				if (thenMatch2) importedSymbols.add(thenMatch2[2]);
+			}
+		}
+	}
+	for (const [name, entries] of exportMap) {
+		if (/^[A-Z]/.test(name)) continue;
+		if (/Engine$/.test(name)) continue;
+		if (!importedSymbols.has(name)) for (const entry of entries) diagnostics.push(makeDiagnostic$1({
+			filePath: entry.filePath,
+			rule: "dead-flow/unused-export",
+			message: `Exported \`${name}\` is never imported by any other file`,
+			line: entry.line,
+			severity: "info",
+			fixable: true,
+			help: `Consider removing the unused export \`${name}\` or adding it to the public API explicitly`,
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .7,
+				reason: "This symbol is exported but never imported elsewhere (AST-verified)"
+			},
+			detail: {
+				symbolName: name,
+				source: "ast"
+			}
+		}));
+	}
+	return diagnostics;
+}
+function detectDeadBranchesAST(ast, filePath) {
+	const diagnostics = [];
+	const ifStmts = findNodesOfType(ast, "if_statement");
+	for (const ifStmt of ifStmts) {
+		const conditionNode = ifStmt.children.find((c) => c.type === "parenthesized_expression");
+		if (!conditionNode) continue;
+		const innerExpr = conditionNode.children.find((c) => c.type !== "(" && c.type !== ")");
+		if (!innerExpr) continue;
+		const eval_ = evaluateCondition(innerExpr);
+		if (eval_ === "unknown") continue;
+		const deadBranch = eval_ === "always-falsy" ? "then" : "else";
+		const branchDesc = deadBranch === "then" ? "if-block" : "else-block";
+		const conditionText = conditionNode.text.replace(/^\(|\)$/g, "").trim();
+		diagnostics.push(makeDiagnostic$1({
+			filePath,
+			rule: "dead-flow/dead-conditional",
+			message: `Condition \`${conditionText}\` is always ${eval_ === "always-falsy" ? "falsy" : "truthy"}, making the ${branchDesc} unreachable`,
+			line: nodeLine(ifStmt),
+			severity: "warning",
+			help: `Simplify the conditional — the ${branchDesc} can never execute`,
+			suggestion: {
+				type: "refactor",
+				text: deadBranch === "else" ? "// remove else branch, keep if-body" : "// remove if block, keep else body as direct code",
+				confidence: .85,
+				reason: `Condition is statically determined to always be ${eval_ === "always-falsy" ? "falsy" : "truthy"} (AST-verified)`
+			},
+			detail: {
+				condition: conditionText,
+				deadBranch,
+				source: "ast"
+			}
+		}));
+	}
+	return diagnostics;
+}
+/**
+* Run all AST-enhanced detections on a single file.
+* Returns null if tree-sitter is unavailable.
+*/
+async function detectAllAST(content, filePath) {
+	const ast = await parseWithTreeSitter(content, filePath);
+	if (!ast) return null;
+	const diagnostics = [];
+	const astRules = /* @__PURE__ */ new Set();
+	const deadThrow = detectDeadAfterThrow(ast, filePath);
+	diagnostics.push(...deadThrow);
+	if (deadThrow.length > 0) astRules.add("dead-after-throw");
+	const deadReturn = detectDeadAfterReturn(ast, filePath);
+	diagnostics.push(...deadReturn);
+	if (deadReturn.length > 0) astRules.add("dead-after-return");
+	const deadBreak = detectDeadAfterBreak(ast, filePath);
+	diagnostics.push(...deadBreak);
+	if (deadBreak.length > 0) astRules.add("dead-after-break");
+	const unreachable = detectUnreachableAfterTerminatorAST(ast, filePath);
+	diagnostics.push(...unreachable);
+	astRules.add("unreachable-after-terminator");
+	const unusedVars = detectUnusedVariablesAST(ast, filePath);
+	diagnostics.push(...unusedVars);
+	astRules.add("unused-variable");
+	const deadBranches = detectDeadBranchesAST(ast, filePath);
+	diagnostics.push(...deadBranches);
+	astRules.add("dead-conditional");
+	return {
+		diagnostics,
+		astRules,
+		astAvailable: true
+	};
+}
+/**
+* Run AST cross-file detections (unused exports).
+* Returns null if tree-sitter is unavailable.
+*/
+async function detectUnusedExportsASTWrapper(astMap, rootDir) {
+	if (astMap.size === 0) return null;
+	return detectUnusedExportsAST(astMap, rootDir);
+}
+
+//#endregion
+//#region src/engines/dead-flow/index.ts
+const TS_JS_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+function isRelevantFile(filePath) {
+	const ext = extname(filePath);
+	return TS_JS_EXTENSIONS.has(ext);
+}
+/** Recursively collect file paths under root, respecting exclude list */
+async function collectFiles(root, exclude) {
+	const results = [];
+	async function walk(dir) {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(dir, entry.name);
+			if (exclude.some((pat) => full.includes(pat))) continue;
+			if (entry.isDirectory()) await walk(full);
+			else if (entry.isFile() && isRelevantFile(full)) results.push(full);
+		}
+	}
+	await walk(root);
+	return results;
+}
+/** Make a diagnostic with sensible defaults */
+function makeDiagnostic(overrides) {
+	return {
+		engine: "dead-flow",
+		severity: "warning",
+		column: 1,
+		category: "dead-code",
+		fixable: true,
+		help: "",
+		...overrides
+	};
+}
+/** Check if a trimmed line is just a closing brace (with optional trailing punctuation) */
+function isClosingBraceLine(trimmed) {
+	return /^\}[;,)\s]*$/.test(trimmed);
+}
+function detectUnreachableAfterTerminator(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const terminatorRe = /^\s*(return\b|throw\b|break\b|continue\b)/;
+	const startDepths = [];
+	let depth = 0;
+	for (let i = 0; i < lines.length; i++) {
+		startDepths.push(depth);
+		for (const ch of lines[i].text) {
+			if (ch === "{") depth++;
+			if (ch === "}") depth--;
+		}
+	}
+	const inCallback = /* @__PURE__ */ new Set();
+	const callbackMethodRe = /\.(forEach|map|filter|reduce|find|findIndex|some|every|flatMap|sort)\s*\(/;
+	for (let i = 0; i < lines.length; i++) {
+		if (!callbackMethodRe.test(lines[i].text)) continue;
+		for (let s = i; s < Math.min(lines.length, i + 6); s++) {
+			const lineText = lines[s].text;
+			if ((lineText.includes("=>") || /function\s*\(/.test(lineText)) && lineText.includes("{")) {
+				let depthAfterLine = startDepths[s];
+				for (const ch of lineText) {
+					if (ch === "{") depthAfterLine++;
+					if (ch === "}") depthAfterLine--;
+				}
+				if (depthAfterLine > startDepths[s]) for (let mark = s + 1; mark < lines.length; mark++) {
+					if (startDepths[mark] <= startDepths[s]) break;
+					inCallback.add(mark);
+				}
+				break;
+			}
+		}
+	}
+	for (let i = 0; i < lines.length; i++) {
+		if (!lines[i].text.includes("=>")) continue;
+		if (!/=>\s*\{/.test(lines[i].text)) continue;
+		let depthAfterLine = startDepths[i];
+		for (const ch of lines[i].text) {
+			if (ch === "{") depthAfterLine++;
+			if (ch === "}") depthAfterLine--;
+		}
+		if (depthAfterLine > startDepths[i]) for (let mark = i + 1; mark < lines.length; mark++) {
+			if (startDepths[mark] <= startDepths[i]) break;
+			inCallback.add(mark);
+		}
+	}
+	const inCatchFinally = /* @__PURE__ */ new Set();
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		if (!(/(?:^|})\s*catch\b/.test(trimmed) || /(?:^|})\s*finally\b/.test(trimmed))) continue;
+		let braceLineIdx = -1;
+		if (lines[i].text.includes("{")) braceLineIdx = i;
+		else for (let s = i + 1; s < Math.min(lines.length, i + 3); s++) if (lines[s].text.includes("{")) {
+			braceLineIdx = s;
+			break;
+		}
+		if (braceLineIdx === -1) continue;
+		let depthAfterLine = startDepths[braceLineIdx];
+		for (const ch of lines[braceLineIdx].text) {
+			if (ch === "{") depthAfterLine++;
+			if (ch === "}") depthAfterLine--;
+		}
+		if (depthAfterLine > startDepths[braceLineIdx]) for (let mark = braceLineIdx + 1; mark < lines.length; mark++) {
+			if (startDepths[mark] <= startDepths[braceLineIdx]) break;
+			inCatchFinally.add(mark);
+		}
+	}
+	const guardReturnLines = /* @__PURE__ */ new Set();
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		if (!/^if\s*\(/.test(trimmed)) continue;
+		let braceLineIdx = -1;
+		if (lines[i].text.includes("{")) braceLineIdx = i;
+		else for (let s = i + 1; s < Math.min(lines.length, i + 3); s++) if (lines[s].text.includes("{")) {
+			braceLineIdx = s;
+			break;
+		}
+		if (braceLineIdx === -1) continue;
+		const ifBodyStart = braceLineIdx + 1;
+		let ifBlockEnd = -1;
+		let onlyTerminators = true;
+		for (let j = ifBodyStart; j < lines.length; j++) {
+			if (startDepths[j] <= startDepths[braceLineIdx]) {
+				ifBlockEnd = j;
+				break;
+			}
+			const bodyTrimmed = lines[j].text.trim();
+			if (bodyTrimmed === "" || bodyTrimmed.startsWith("//") || bodyTrimmed.startsWith("/*") || bodyTrimmed.startsWith("*")) continue;
+			if (isClosingBraceLine(bodyTrimmed)) continue;
+			if (/^return\b|^throw\b/.test(bodyTrimmed)) continue;
+			onlyTerminators = false;
+		}
+		if (!onlyTerminators || ifBlockEnd === -1) continue;
+		let nextNonEmpty = ifBlockEnd;
+		while (nextNonEmpty < lines.length) {
+			const t = lines[nextNonEmpty].text.trim();
+			if (t === "" || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) {
+				nextNonEmpty++;
+				continue;
+			}
+			break;
+		}
+		if (nextNonEmpty < lines.length) {
+			const nextTrimmed = lines[nextNonEmpty].text.trim();
+			if (/^}\s*else\b|^else\b/.test(nextTrimmed)) continue;
+		}
+		for (let j = ifBodyStart; j < ifBlockEnd; j++) {
+			const bodyTrimmed = lines[j].text.trim();
+			if (/^return\b|^throw\b/.test(bodyTrimmed)) guardReturnLines.add(j);
+		}
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].text.match(terminatorRe);
+		if (!match) continue;
+		if (guardReturnLines.has(i)) continue;
+		const terminatorKind = match[1];
+		if (terminatorKind !== "return" && terminatorKind !== "throw") continue;
+		if (isGuardReturn(lines, startDepths, i)) guardReturnLines.add(i);
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].text.match(terminatorRe);
+		if (!match) continue;
+		const terminatorKind = match[1];
+		const terminatorStartDepth = startDepths[i];
+		if (inCatchFinally.has(i)) continue;
+		if (inCallback.has(i)) continue;
+		if (callbackMethodRe.test(lines[i].text)) continue;
+		if (/=>\s*\{/.test(lines[i].text)) continue;
+		if (guardReturnLines.has(i)) continue;
+		let endLine = i;
+		if (!lines[i].text.trimEnd().endsWith(";") && !lines[i].text.trimEnd().endsWith("}")) for (let j = i + 1; j < lines.length && j <= i + 5; j++) {
+			endLine = j;
+			if (lines[j].text.includes(";") || lines[j].text.trimEnd().endsWith("}")) break;
+		}
+		for (let j = endLine + 1; j < lines.length; j++) {
+			const text = lines[j].text.trim();
+			if (text.startsWith("} catch") || text.startsWith("} else") || text.startsWith("} finally")) break;
+			if (isClosingBraceLine(text)) continue;
+			if (text === "" || text.startsWith("//") || text.startsWith("/*") || text.startsWith("*")) continue;
+			if (startDepths[j] !== terminatorStartDepth) break;
+			const severity = terminatorKind === "return" ? "warning" : "error";
+			diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "dead-flow/unreachable-after-terminator",
+				message: `Unreachable code after ${terminatorKind} on line ${lines[i].num}`,
+				line: lines[j].num,
+				severity,
+				help: `Remove or move the unreachable code after the ${terminatorKind} statement on line ${lines[i].num}`,
+				suggestion: {
+					type: "delete",
+					text: "",
+					confidence: .9,
+					reason: `Code after ${terminatorKind} can never execute`,
+					range: {
+						startLine: lines[j].num,
+						startCol: 1,
+						endLine: lines[j].num,
+						endCol: lines[j].text.length + 1
+					}
+				},
+				detail: {
+					terminatorKind,
+					terminatorLine: lines[i].num
+				}
+			}));
+			break;
+		}
+	}
+	return diagnostics;
+}
+/** Check if the terminator at line index `idx` is a braceless guard return
+*  (inside a braceless `if` without `else`). A guard return like
+*  `if (!x) return;` makes subsequent code the normal path, not unreachable. */
+function isGuardReturn(lines, startDepths, idx) {
+	let prevIdx = idx - 1;
+	while (prevIdx >= 0) {
+		const prevTrimmed = lines[prevIdx].text.trim();
+		if (prevTrimmed === "" || prevTrimmed.startsWith("//") || prevTrimmed.startsWith("/*") || prevTrimmed.startsWith("*")) {
+			prevIdx--;
+			continue;
+		}
+		break;
+	}
+	if (prevIdx < 0) return false;
+	const prevTrimmed = lines[prevIdx].text.trim();
+	if (/^if\s*\(/.test(prevTrimmed) && !prevTrimmed.includes("{")) {
+		let nextIdx = idx + 1;
+		while (nextIdx < lines.length) {
+			const nextTrimmed = lines[nextIdx].text.trim();
+			if (nextTrimmed === "" || nextTrimmed.startsWith("//") || nextTrimmed.startsWith("/*") || nextTrimmed.startsWith("*")) {
+				nextIdx++;
+				continue;
+			}
+			if (nextTrimmed.startsWith("else")) return false;
+			break;
+		}
+		return true;
+	}
+	return false;
+}
+function detectUnreachableAfterIfElseReturn(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const startDepths = [];
+	let depth = 0;
+	for (let i = 0; i < lines.length; i++) {
+		startDepths.push(depth);
+		for (const ch of lines[i].text) {
+			if (ch === "{") depth++;
+			if (ch === "}") depth--;
+		}
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const text = lines[i].text.trim();
+		if (!text.startsWith("if") && !text.startsWith("} else if")) continue;
+		const ifStartLine = i;
+		let braceDepth = 0;
+		let ifBlockEnd = -1;
+		let hasIfTerminator = false;
+		let j = i;
+		while (j < lines.length && !lines[j].text.includes("{")) j++;
+		if (j >= lines.length) continue;
+		braceDepth = 1;
+		j++;
+		while (j < lines.length && braceDepth > 0) {
+			lines[j].text.trim();
+			for (const ch of lines[j].text) {
+				if (ch === "{") braceDepth++;
+				if (ch === "}") braceDepth--;
+			}
+			if (braceDepth === 0) {
+				ifBlockEnd = j;
+				break;
+			}
+			if (/^\s*(return\b|throw\b)/.test(lines[j].text)) hasIfTerminator = true;
+			j++;
+		}
+		if (!hasIfTerminator || ifBlockEnd === -1) continue;
+		let elseStart = ifBlockEnd + 1;
+		while (elseStart < lines.length) {
+			const t = lines[elseStart].text.trim();
+			if (t === "" || t.startsWith("//")) {
+				elseStart++;
+				continue;
+			}
+			break;
+		}
+		if (elseStart >= lines.length) continue;
+		if (!lines[elseStart].text.trim().startsWith("else")) continue;
+		braceDepth = 0;
+		let elseBlockEnd = -1;
+		let hasElseTerminator = false;
+		let k = elseStart;
+		while (k < lines.length && !lines[k].text.includes("{")) k++;
+		if (k >= lines.length) continue;
+		braceDepth = 1;
+		k++;
+		while (k < lines.length && braceDepth > 0) {
+			for (const ch of lines[k].text) {
+				if (ch === "{") braceDepth++;
+				if (ch === "}") braceDepth--;
+			}
+			if (braceDepth === 0) {
+				elseBlockEnd = k;
+				break;
+			}
+			if (/^\s*(return\b|throw\b)/.test(lines[k].text)) hasElseTerminator = true;
+			k++;
+		}
+		if (!hasElseTerminator || elseBlockEnd === -1) continue;
+		const constructDepth = startDepths[ifStartLine];
+		for (let m = elseBlockEnd + 1; m < lines.length; m++) {
+			const t = lines[m].text.trim();
+			if (isClosingBraceLine(t)) break;
+			if (t === "" || t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
+			if (startDepths[m] < constructDepth) break;
+			if (startDepths[m] > constructDepth) continue;
+			diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "dead-flow/unreachable-after-if-else-return",
+				message: `Unreachable code: both if/else branches terminate (lines ${ifStartLine + 1}-${elseBlockEnd + 1})`,
+				line: lines[m].num,
+				severity: "warning",
+				help: "Remove the unreachable code after the if/else that both return/throw",
+				suggestion: {
+					type: "delete",
+					text: "",
+					confidence: .85,
+					reason: "Code after if/else where both branches terminate is unreachable",
+					range: {
+						startLine: lines[m].num,
+						startCol: 1,
+						endLine: lines[m].num,
+						endCol: lines[m].text.length + 1
+					}
+				}
+			}));
+			break;
+		}
+	}
+	return diagnostics;
+}
+function detectDeadConditionals(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const alwaysTruthy = /^(true|!false|[1-9]\d*|![0]+)$/;
+	const alwaysFalsy = /^(false|!true|0+|null|undefined|!1)$/;
+	for (const { num, text } of lines) {
+		const ifMatch = text.trim().match(/^if\s*\(\s*(.+?)\s*\)\s*\{?$/);
+		if (!ifMatch) continue;
+		const condition = ifMatch[1].trim();
+		if (condition.includes("&&") || condition.includes("||") || condition.includes("==") || condition.includes("!=") || condition.includes(">") || condition.includes("<")) continue;
+		let deadBranch = null;
+		if (alwaysTruthy.test(condition)) deadBranch = "else";
+		else if (alwaysFalsy.test(condition)) deadBranch = "then";
+		if (deadBranch) {
+			const branchDesc = deadBranch === "then" ? "if-block" : "else-block";
+			diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "dead-flow/dead-conditional",
+				message: `Condition \`${condition}\` is always ${deadBranch === "then" ? "falsy" : "truthy"}, making the ${branchDesc} unreachable`,
+				line: num,
+				severity: "warning",
+				help: `Simplify the conditional — the ${branchDesc} can never execute`,
+				suggestion: {
+					type: "refactor",
+					text: deadBranch === "else" ? "// remove else branch, keep if-body" : "// remove if block, keep else body as direct code",
+					confidence: .8,
+					reason: `Condition is statically determined to always be ${deadBranch === "then" ? "falsy" : "truthy"}`
+				},
+				detail: {
+					condition,
+					deadBranch
+				}
+			}));
+		}
+	}
+	return diagnostics;
+}
+function extractExports(content) {
+	const exports = [];
+	const lines = toLines(content);
+	for (const { num, text } of lines) {
+		const trimmed = text.trim();
+		const namedExport = trimmed.match(/^export\s+(?:default\s+)?(?:function|const|let|var|class|enum|interface|type)\s+(\w+)/);
+		if (namedExport) {
+			exports.push({
+				name: namedExport[1],
+				line: num,
+				isTypeExport: trimmed.includes("export type ") || trimmed.includes("export interface "),
+				isDefault: trimmed.includes("export default")
+			});
+			continue;
+		}
+		const braceExport = trimmed.match(/^export\s+(?:type\s+)?\{([^}]+)\}/);
+		if (braceExport) {
+			const names = braceExport[1].split(",").map((s) => {
+				const parts = s.trim().split(/\s+as\s+/);
+				return parts[parts.length - 1].trim();
+			}).filter(Boolean);
+			for (const name of names) exports.push({
+				name,
+				line: num,
+				isTypeExport: trimmed.includes("export type {"),
+				isDefault: false
+			});
+			continue;
+		}
+		if (trimmed.match(/^export\s+default\s+/)) exports.push({
+			name: "default",
+			line: num,
+			isTypeExport: false,
+			isDefault: true
+		});
+	}
+	return exports;
+}
+function detectUnusedExports(files, rootDir) {
+	const diagnostics = [];
+	const exportMap = /* @__PURE__ */ new Map();
+	const importedSymbols = /* @__PURE__ */ new Set();
+	for (const [filePath, content] of files) {
+		const relPath = relative(rootDir, filePath);
+		const exports = extractExports(content);
+		for (const exp of exports) {
+			const key = `${relPath}::${exp.name}`;
+			if (!exportMap.has(key)) exportMap.set(key, []);
+			exportMap.get(key).push({
+				filePath: relPath,
+				line: exp.line,
+				isType: exp.isTypeExport,
+				isDefault: exp.isDefault
+			});
+		}
+		const lines = toLines(content);
+		for (let li = 0; li < lines.length; li++) {
+			const trimmed = lines[li].text.trim();
+			const braceImport = trimmed.match(/^import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"][^'"]+['"]/);
+			if (braceImport) {
+				const names = braceImport[1].split(",").map((s) => {
+					return s.trim().split(/\s+as\s+/)[0].trim();
+				}).filter(Boolean);
+				for (const name of names) importedSymbols.add(name);
+			}
+			if (trimmed.match(/^import\s+(?:type\s+)?\{\s*$/)) for (let next = li + 1; next < lines.length; next++) {
+				const nextTrimmed = lines[next].text.trim();
+				if (nextTrimmed.startsWith("}")) break;
+				const nameParts = nextTrimmed.split(",").map((s) => {
+					return s.trim().split(/\s+as\s+/)[0].trim();
+				}).filter(Boolean);
+				for (const name of nameParts) importedSymbols.add(name);
+			}
+			const defaultImport = trimmed.match(/^import\s+(\w+)\s+from\s+['"][^'"]+['"]/);
+			if (defaultImport && !trimmed.includes("{")) importedSymbols.add(defaultImport[1]);
+			const nsImport = trimmed.match(/^import\s+\*\s+as\s+(\w+)\s+from/);
+			if (nsImport) importedSymbols.add(nsImport[1]);
+			const dynamicImport = trimmed.match(/import\s*\([^)]*\)\s*\.then\s*\(\s*(?:\((\w+)\)|(\w+))\s*=>\s*\2?\.?(\w+)/);
+			if (dynamicImport) {
+				const symbolName = dynamicImport[3];
+				if (symbolName) importedSymbols.add(symbolName);
+			}
+			const dynamicThenAccess = trimmed.match(/\.then\s*\(\s*\((\w+)\)\s*=>\s*\1\.(\w+)/);
+			if (dynamicThenAccess) importedSymbols.add(dynamicThenAccess[2]);
+			const dynamicThenAccessNoParens = trimmed.match(/\.then\s*\(\s*(\w+)\s*=>\s*\1\.(\w+)/);
+			if (dynamicThenAccessNoParens) importedSymbols.add(dynamicThenAccessNoParens[2]);
+		}
+	}
+	for (const [key, entries] of exportMap) for (const entry of entries) {
+		const symbolName = key.split("::").pop();
+		if (entry.isType) continue;
+		if (entry.isDefault) continue;
+		if (/^[A-Z]/.test(symbolName)) continue;
+		if (/Engine$/.test(symbolName)) continue;
+		if (!importedSymbols.has(symbolName)) diagnostics.push(makeDiagnostic({
+			filePath: entry.filePath,
+			rule: "dead-flow/unused-export",
+			message: `Exported \`${symbolName}\` is never imported by any other file`,
+			line: entry.line,
+			severity: "info",
+			fixable: true,
+			help: `Consider removing the unused export \`${symbolName}\` or adding it to the public API explicitly`,
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .6,
+				reason: "This symbol is exported but never imported elsewhere in the project"
+			},
+			detail: { symbolName }
+		}));
+	}
+	return diagnostics;
+}
+function detectUnusedVariables(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const declarations = /* @__PURE__ */ new Map();
+	for (const { num, text } of lines) {
+		const trimmed = text.trim();
+		const varMatch = trimmed.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)/);
+		if (varMatch) {
+			const name = varMatch[1];
+			declarations.set(name, {
+				line: num,
+				isExported: trimmed.startsWith("export"),
+				isReactComponent: /^[A-Z]/.test(name) && (trimmed.includes("=>") || trimmed.includes("function")),
+				isType: false,
+				isParameter: false
+			});
+			continue;
+		}
+		const fnMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+		if (fnMatch) {
+			const name = fnMatch[1];
+			declarations.set(name, {
+				line: num,
+				isExported: trimmed.startsWith("export"),
+				isReactComponent: /^[A-Z]/.test(name),
+				isType: false,
+				isParameter: false
+			});
+			continue;
+		}
+		const typeMatch = trimmed.match(/^(?:export\s+)?(?:type|interface)\s+(\w+)/);
+		if (typeMatch) {
+			declarations.set(typeMatch[1], {
+				line: num,
+				isExported: trimmed.startsWith("export"),
+				isReactComponent: false,
+				isType: true,
+				isParameter: false
+			});
+			continue;
+		}
+		const arrowParamMatch = trimmed.match(/^(?:export\s+)?(?:const|let)\s+\w+\s*=\s*\(\s*([^)]+)\)\s*=>/);
+		if (arrowParamMatch) {
+			const params = arrowParamMatch[1].split(",").map((p) => {
+				return p.trim().split(":")[0].trim().replace(/^\.\.\./, "").trim();
+			});
+			for (const param of params) if (param && /^\w+$/.test(param)) declarations.set(param, {
+				line: num,
+				isExported: false,
+				isReactComponent: false,
+				isType: false,
+				isParameter: true
+			});
+		}
+	}
+	const allContent = content;
+	for (const [name, info] of declarations) {
+		if (name.startsWith("_")) continue;
+		if (info.isExported) continue;
+		if (info.isReactComponent) continue;
+		if (info.isType) continue;
+		if (info.isParameter) continue;
+		const re = new RegExp(`\\b${escapeRegExp(name)}\\b`, "g");
+		const occurrences = (allContent.match(re) ?? []).length;
+		if (occurrences <= 1) diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "dead-flow/unused-variable",
+			message: `Variable \`${name}\` is declared but never used`,
+			line: info.line,
+			severity: "suggestion",
+			fixable: true,
+			help: `Remove the unused variable \`${name}\` or prefix with _ if intentionally unused`,
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .7,
+				reason: `Variable \`${name}\` is never referenced after its declaration`
+			},
+			detail: {
+				variableName: name,
+				referenceCount: occurrences
+			}
+		}));
+	}
+	return diagnostics;
+}
+/** Escape string for use in RegExp */
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function detectEmptyBlocks(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		const sameLineEmpty = trimmed.match(/^(?:if|else|for|while|do|try|catch|finally|switch)\s*\([^)]*\)\s*\{(.*)\}\s*$/);
+		if (sameLineEmpty) {
+			const innerContent = sameLineEmpty[1].trim();
+			const construct = trimmed.split("{")[0].trim();
+			if (/catch\b/.test(construct) || /finally\b/.test(construct)) {
+				const catchMatch = construct.match(/catch\s*\(\s*(\w+)\s*\)/);
+				const errorVar = catchMatch ? catchMatch[1] : "error";
+				if (/catch\b/.test(construct) && innerContent === "") diagnostics.push(makeDiagnostic({
+					filePath,
+					rule: "dead-flow/empty-block",
+					message: `Empty catch block — error is silently swallowed`,
+					line: lines[i].num,
+					severity: "warning",
+					fixable: true,
+					help: "Empty catch blocks silently swallow errors. Add console.error() or a TODO comment to handle the error.",
+					suggestion: {
+						type: "replace",
+						text: `${construct} { console.error(${errorVar}) }`,
+						range: {
+							startLine: lines[i].num,
+							startCol: 1,
+							endLine: lines[i].num,
+							endCol: lines[i].text.length + 1
+						},
+						confidence: .75,
+						reason: "Empty catch blocks hide errors. Adding console.error() ensures errors are at least logged."
+					}
+				}));
+				continue;
+			}
+			if (innerContent !== "") continue;
+			diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "dead-flow/empty-block",
+				message: `Empty block after \`${construct}\``,
+				line: lines[i].num,
+				severity: "info",
+				fixable: false,
+				help: "Empty blocks may indicate swallowed logic or placeholder code. Add implementation or a comment explaining intent.",
+				suggestion: {
+					type: "refactor",
+					text: "// TODO: implement",
+					confidence: .5,
+					reason: "Empty block likely indicates missing implementation"
+				}
+			}));
+			continue;
+		}
+		const elseEmpty = trimmed.match(/^else\s*\{(.*)\}\s*$/);
+		if (elseEmpty) {
+			if (elseEmpty[1].trim() === "") diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "dead-flow/empty-block",
+				message: "Empty else block",
+				line: lines[i].num,
+				severity: "info",
+				fixable: false,
+				help: "Empty else block may indicate swallowed logic. Add implementation or remove the else clause.",
+				suggestion: {
+					type: "refactor",
+					text: "// TODO: implement",
+					confidence: .5,
+					reason: "Empty else block likely indicates missing implementation"
+				}
+			}));
+			continue;
+		}
+		if (trimmed.endsWith("{") && !trimmed.includes("}")) {
+			if (!(/^(?:if|else|for|while|do|try|catch|finally|switch)/.test(trimmed) || trimmed === "{")) continue;
+			let nextLine = i + 1;
+			let isEmpty = true;
+			let hasComment = false;
+			while (nextLine < lines.length) {
+				const nextTrimmed = lines[nextLine].text.trim();
+				if (nextTrimmed.startsWith("}") || nextTrimmed.startsWith("});")) break;
+				if (nextTrimmed !== "") if (nextTrimmed.startsWith("//") || nextTrimmed.startsWith("/*") || nextTrimmed.startsWith("*")) hasComment = true;
+				else {
+					isEmpty = false;
+					break;
+				}
+				nextLine++;
+			}
+			if (isEmpty) {
+				const construct = trimmed.split("{")[0].trim() || "block";
+				const isCatchOrFinallyBlock = construct.startsWith("catch") || construct.startsWith("finally") || trimmed === "{" && i > 0 && (/^\s*}\s*catch\b/.test(lines[i - 1].text) || /^\s*}\s*finally\b/.test(lines[i - 1].text));
+				if (isCatchOrFinallyBlock && hasComment) continue;
+				if (isCatchOrFinallyBlock && construct.startsWith("catch") && !hasComment) {
+					const catchMatch = construct.match(/catch\s*\(\s*(\w+)\s*\)/);
+					const errorVar = catchMatch ? catchMatch[1] : "error";
+					diagnostics.push(makeDiagnostic({
+						filePath,
+						rule: "dead-flow/empty-block",
+						message: `Empty catch block — error is silently swallowed`,
+						line: lines[i].num,
+						severity: "warning",
+						fixable: true,
+						help: "Empty catch blocks silently swallow errors. Add console.error() or a TODO comment to handle the error.",
+						suggestion: {
+							type: "replace",
+							text: `${construct} {\n  console.error(${errorVar})\n}`,
+							range: {
+								startLine: lines[i].num,
+								startCol: 1,
+								endLine: nextLine + 1,
+								endCol: 1
+							},
+							confidence: .7,
+							reason: "Empty catch blocks hide errors. Adding console.error() ensures errors are at least logged."
+						}
+					}));
+					continue;
+				}
+				diagnostics.push(makeDiagnostic({
+					filePath,
+					rule: "dead-flow/empty-block",
+					message: `Empty ${construct} block`,
+					line: lines[i].num,
+					severity: "info",
+					fixable: false,
+					help: "Empty blocks may indicate swallowed logic or placeholder code. Add implementation or a comment.",
+					suggestion: {
+						type: "refactor",
+						text: "// TODO: implement",
+						confidence: .5,
+						reason: "Empty block likely indicates missing implementation"
+					}
+				}));
+			}
+		}
+	}
+	return diagnostics;
+}
+function detectDeadSwitchCases(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	for (let i = 0; i < lines.length; i++) {
+		if (!lines[i].text.trim().startsWith("switch")) continue;
+		let braceDepth = 0;
+		let j = i;
+		while (j < lines.length && !lines[j].text.includes("{")) j++;
+		if (j >= lines.length) continue;
+		braceDepth = 1;
+		j++;
+		const cases = [];
+		while (j < lines.length && braceDepth > 0) {
+			const lineText = lines[j].text;
+			for (const ch of lineText) {
+				if (ch === "{") braceDepth++;
+				if (ch === "}") braceDepth--;
+			}
+			const t = lineText.trim();
+			if (t.startsWith("case ") || t.startsWith("default:")) cases.push({
+				keyword: t.startsWith("default") ? "default" : "case",
+				line: lines[j].num
+			});
+			if (/^\s*(break;|return\b|throw\b|continue;)/.test(lineText) && braceDepth > 0) {
+				let nextLineIdx = j + 1;
+				while (nextLineIdx < lines.length && braceDepth > 0) {
+					const nextTrimmed = lines[nextLineIdx].text.trim();
+					for (const ch of lines[nextLineIdx].text) {
+						if (ch === "{") braceDepth++;
+						if (ch === "}") braceDepth--;
+					}
+					if (braceDepth <= 0) break;
+					if (nextTrimmed.startsWith("case ") || nextTrimmed.startsWith("default:")) break;
+					if (nextTrimmed === "" || nextTrimmed.startsWith("//") || nextTrimmed.startsWith("/*") || nextTrimmed.startsWith("*") || nextTrimmed.startsWith("break;")) {
+						nextLineIdx++;
+						continue;
+					}
+					diagnostics.push(makeDiagnostic({
+						filePath,
+						rule: "dead-flow/dead-switch-code",
+						message: `Unreachable code in switch after break/return on line ${lines[j].num}`,
+						line: lines[nextLineIdx].num,
+						severity: "warning",
+						help: "Remove the unreachable code in this switch case after the terminator statement",
+						suggestion: {
+							type: "delete",
+							text: "",
+							confidence: .9,
+							reason: "Code after break/return/throw in a switch case is unreachable",
+							range: {
+								startLine: lines[nextLineIdx].num,
+								startCol: 1,
+								endLine: lines[nextLineIdx].num,
+								endCol: lines[nextLineIdx].text.length + 1
+							}
+						}
+					}));
+					break;
+				}
+			}
+			j++;
+		}
+		const defaultIdx = cases.findIndex((c) => c.keyword === "default");
+		if (defaultIdx !== -1 && defaultIdx < cases.length - 1) for (let k = defaultIdx + 1; k < cases.length; k++) diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "dead-flow/dead-switch-case-after-default",
+			message: `Case on line ${cases[k].line} is unreachable: it appears after the default case`,
+			line: cases[k].line,
+			severity: "warning",
+			help: "Move the default case to the end of the switch, or remove the unreachable case",
+			suggestion: {
+				type: "refactor",
+				text: "// move default to end of switch",
+				confidence: .85,
+				reason: "Cases after default can never be reached"
+			}
+		}));
+	}
+	return diagnostics;
+}
+/** Build a dedup key for a diagnostic */
+function dedupKey(d) {
+	return `${d.filePath}:${d.line}:${d.rule}`;
+}
+/** Merge AST and regex diagnostics, preferring AST when both match.
+*  AST-only rules always pass through.
+*  For rules that both AST and regex can produce, AST wins on same file+line. */
+function mergeASTAndRegex(astDiags, regexDiags, astRulesRun) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const d of astDiags) {
+		const key = dedupKey(d);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(d);
+		}
+	}
+	for (const d of regexDiags) {
+		const key = dedupKey(d);
+		if (seen.has(key)) continue;
+		const ruleBase = d.rule.replace("dead-flow/", "");
+		if (astRulesRun.has(ruleBase)) continue;
+		seen.add(key);
+		result.push(d);
+	}
+	return result;
+}
+const deadFlowEngine = {
+	name: "dead-flow",
+	description: "Detects dead/unreachable code using AST (tree-sitter) with regex fallback: unreachable code after terminators, dead conditionals, unused exports/variables, empty blocks, and dead switch cases",
+	supportedLanguages: ["typescript", "javascript"],
+	async run(context) {
+		const start = Date.now();
+		const { rootDirectory, config, files: specifiedFiles } = context;
+		const filePaths = specifiedFiles ? specifiedFiles.filter(isRelevantFile) : await collectFiles(rootDirectory, config.exclude);
+		if (filePaths.length === 0) return {
+			engine: "dead-flow",
+			diagnostics: [],
+			elapsed: Date.now() - start,
+			skipped: true,
+			skipReason: "No TypeScript/JavaScript files found to analyze"
+		};
+		const fileContents = /* @__PURE__ */ new Map();
+		for (const fp of filePaths) try {
+			const content = await readFileContent(fp);
+			fileContents.set(fp, content);
+		} catch {}
+		const astDiagnostics = [];
+		const astMap = /* @__PURE__ */ new Map();
+		const perFileASTRules = /* @__PURE__ */ new Map();
+		let astAvailable = false;
+		for (const [fp, content] of fileContents) {
+			const relPath = relative(rootDirectory, fp);
+			try {
+				const astResult = await detectAllAST(content, relPath);
+				if (astResult) {
+					astAvailable = true;
+					astDiagnostics.push(...astResult.diagnostics);
+					perFileASTRules.set(relPath, astResult.astRules);
+					const ast = await parseWithTreeSitter(content, relPath);
+					if (ast) astMap.set(relPath, ast);
+				}
+			} catch {}
+		}
+		let astExportDiags = [];
+		let astExportRulesRun = false;
+		if (config.deadCode.unusedExports && astMap.size > 0) try {
+			const exportResult = await detectUnusedExportsASTWrapper(astMap, rootDirectory);
+			if (exportResult) {
+				astExportDiags = exportResult;
+				astExportRulesRun = true;
+			}
+		} catch {}
+		const regexDiagnostics = [];
+		for (const [fp, content] of fileContents) {
+			const relPath = relative(rootDirectory, fp);
+			if (config.deadCode.unreachableBranches) regexDiagnostics.push(...detectUnreachableAfterTerminator(content, relPath));
+			if (config.deadCode.unreachableBranches) regexDiagnostics.push(...detectUnreachableAfterIfElseReturn(content, relPath));
+			if (config.deadCode.unreachableBranches) regexDiagnostics.push(...detectDeadConditionals(content, relPath));
+			if (config.deadCode.unusedVariables) regexDiagnostics.push(...detectUnusedVariables(content, relPath));
+			regexDiagnostics.push(...detectEmptyBlocks(content, relPath));
+			if (config.deadCode.unreachableBranches) regexDiagnostics.push(...detectDeadSwitchCases(content, relPath));
+		}
+		if (config.deadCode.unusedExports) regexDiagnostics.push(...detectUnusedExports(fileContents, rootDirectory));
+		const globalASTRules = /* @__PURE__ */ new Set();
+		if (astAvailable) {
+			globalASTRules.add("unreachable-after-terminator");
+			globalASTRules.add("unused-variable");
+			globalASTRules.add("dead-conditional");
+			globalASTRules.add("dead-after-throw");
+			globalASTRules.add("dead-after-return");
+			globalASTRules.add("dead-after-break");
+		}
+		if (astExportRulesRun) globalASTRules.add("unused-export");
+		let merged = mergeASTAndRegex([...astDiagnostics, ...astExportDiags], regexDiagnostics, globalASTRules);
+		const seen = /* @__PURE__ */ new Set();
+		return {
+			engine: "dead-flow",
+			diagnostics: merged.filter((d) => {
+				const key = `${d.filePath}:${d.line}:${d.rule}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			}),
+			elapsed: Date.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { deadFlowEngine };