deadwood-scan 0.2.0

package/dist/index.js

@@ -0,0 +1,2597 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+import process from "process";
+import { Command, Option } from "commander";
+import ora from "ora";
+import pc2 from "picocolors";
+
+// ../core/src/index.ts
+import fs8 from "fs";
+import path11 from "path";
+import { glob as glob2 } from "tinyglobby";
+
+// ../core/src/errors.ts
+var ScanError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ScanError";
+  }
+  code;
+};
+
+// ../core/src/graph/parser.ts
+import ts from "typescript";
+var DEPRECATED_RE = /@deprecated\b/;
+var REMOVAL_RE = /\b(?:TODO:?\s*(?:remove|delete|kill)|dead\s*code|FIXME:?\s*remove)\b/i;
+function scriptKindFor(file) {
+  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (/\.(ts|mts|cts)$/.test(file)) return ts.ScriptKind.TS;
+  return ts.ScriptKind.JS;
+}
+function parseFile(filePosix, text) {
+  const ast = ts.createSourceFile(
+    filePosix,
+    text,
+    ts.ScriptTarget.Latest,
+    true,
+    scriptKindFor(filePosix)
+  );
+  const result = {
+    file: filePosix,
+    ast,
+    imports: [],
+    exports: [],
+    dynamicPatterns: [],
+    commentMarkers: collectCommentMarkers(text),
+    pathLiterals: [],
+    hasCjsDynamicExport: false
+  };
+  const lineOf = (node) => ast.getLineAndCharacterOfPosition(node.getStart(ast)).line + 1;
+  const hasDeprecatedJsDoc = (node) => {
+    const ranges = ts.getLeadingCommentRanges(text, node.getFullStart()) ?? [];
+    return ranges.some((r) => DEPRECATED_RE.test(text.slice(r.pos, r.end)));
+  };
+  for (const stmt of ast.statements) {
+    if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
+      const record = {
+        specifier: stmt.moduleSpecifier.text,
+        kind: "static",
+        names: [],
+        line: lineOf(stmt)
+      };
+      const clause = stmt.importClause;
+      if (clause) {
+        if (clause.name) record.names.push({ imported: "default", local: clause.name.text });
+        if (clause.namedBindings) {
+          if (ts.isNamespaceImport(clause.namedBindings)) {
+            record.namespaceLocal = clause.namedBindings.name.text;
+          } else {
+            for (const el of clause.namedBindings.elements) {
+              record.names.push({
+                imported: el.propertyName?.text ?? el.name.text,
+                local: el.name.text
+              });
+            }
+          }
+        }
+      }
+      result.imports.push(record);
+      continue;
+    }
+    if (ts.isExportDeclaration(stmt)) {
+      const spec = stmt.moduleSpecifier;
+      if (spec && ts.isStringLiteral(spec)) {
+        if (!stmt.exportClause) {
+          result.imports.push({
+            specifier: spec.text,
+            kind: "reexport-star",
+            names: [],
+            line: lineOf(stmt)
+          });
+        } else if (ts.isNamedExports(stmt.exportClause)) {
+          const reexported = stmt.exportClause.elements.map((el) => ({
+            exported: el.name.text,
+            original: el.propertyName?.text ?? el.name.text
+          }));
+          result.imports.push({
+            specifier: spec.text,
+            kind: "reexport-named",
+            names: [],
+            reexported,
+            line: lineOf(stmt)
+          });
+          for (const r of reexported) {
+            result.exports.push({ name: r.exported, kind: "value", line: lineOf(stmt) });
+          }
+        } else if (ts.isNamespaceExport(stmt.exportClause)) {
+          result.imports.push({
+            specifier: spec.text,
+            kind: "reexport-star",
+            names: [],
+            line: lineOf(stmt)
+          });
+          result.exports.push({
+            name: stmt.exportClause.name.text,
+            kind: "value",
+            line: lineOf(stmt)
+          });
+        }
+      } else if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) {
+          result.exports.push({
+            name: el.name.text,
+            kind: "value",
+            line: lineOf(el),
+            ...hasDeprecatedJsDoc(stmt) ? { deprecated: true } : {}
+          });
+        }
+      }
+      continue;
+    }
+    if (ts.isExportAssignment(stmt)) {
+      result.exports.push({ name: "default", kind: "value", line: lineOf(stmt) });
+      continue;
+    }
+    collectModifierExports(stmt, result, lineOf, hasDeprecatedJsDoc);
+  }
+  const visit = (node) => {
+    if (ts.isCallExpression(node)) {
+      handleCall(node, result, lineOf);
+    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      handleCjsExportAssignment(node, result, lineOf);
+    } else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      const v = node.text;
+      if (v.length < 200 && v.startsWith("/") && !/\s/.test(v)) {
+        result.pathLiterals.push({ value: v, line: lineOf(node) });
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(ast, visit);
+  const namespaceLocals = /* @__PURE__ */ new Map();
+  for (const imp of result.imports) {
+    if (imp.namespaceLocal) {
+      const usage = { members: /* @__PURE__ */ new Set(), escapes: false };
+      imp.namespaceUsage = usage;
+      namespaceLocals.set(imp.namespaceLocal, usage);
+    }
+  }
+  if (namespaceLocals.size > 0) {
+    trackNamespaceUsage(ast, namespaceLocals);
+  }
+  return result;
+}
+function collectModifierExports(stmt, result, lineOf, hasDeprecatedJsDoc) {
+  const mods = ts.canHaveModifiers(stmt) ? ts.getModifiers(stmt) : void 0;
+  if (!mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+  const isDefault = mods.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+  const deprecated = hasDeprecatedJsDoc(stmt) ? true : void 0;
+  const push = (name, kind, node) => result.exports.push({ name, kind, line: lineOf(node), ...deprecated ? { deprecated } : {} });
+  if (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt)) {
+    push(isDefault ? "default" : stmt.name?.text ?? "default", "value", stmt);
+  } else if (ts.isVariableStatement(stmt)) {
+    for (const decl of stmt.declarationList.declarations) {
+      collectBindingNames(decl.name, (name) => push(name, "value", decl));
+    }
+  } else if (ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) {
+    push(stmt.name.text, "type", stmt);
+  } else if (ts.isEnumDeclaration(stmt) || ts.isModuleDeclaration(stmt)) {
+    if (stmt.name && ts.isIdentifier(stmt.name)) push(stmt.name.text, "value", stmt);
+  }
+}
+function collectBindingNames(name, cb) {
+  if (ts.isIdentifier(name)) {
+    cb(name.text);
+  } else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+    for (const el of name.elements) {
+      if (ts.isBindingElement(el)) collectBindingNames(el.name, cb);
+    }
+  }
+}
+function literalPrefixOf(arg) {
+  if (ts.isTemplateExpression(arg) && arg.head.text.length > 0) return arg.head.text;
+  if (ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.PlusToken && (ts.isStringLiteral(arg.left) || ts.isNoSubstitutionTemplateLiteral(arg.left))) {
+    return arg.left.text;
+  }
+  return void 0;
+}
+function handleCall(node, result, lineOf) {
+  const line = lineOf(node);
+  if (ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1) {
+    const arg = node.arguments[0];
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+      const record = { specifier: arg.text, kind: "require", names: [], line };
+      bindRequireResult(node, record);
+      result.imports.push(record);
+    } else {
+      const prefix = literalPrefixOf(arg);
+      result.dynamicPatterns.push({ kind: "require", line, ...prefix ? { prefix } : {} });
+    }
+    return;
+  }
+  if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length >= 1) {
+    const arg = node.arguments[0];
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+      result.imports.push({ specifier: arg.text, kind: "dynamic", names: [], line });
+    } else {
+      const prefix = literalPrefixOf(arg);
+      result.dynamicPatterns.push({ kind: "import", line, ...prefix ? { prefix } : {} });
+    }
+    return;
+  }
+  if (ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "require" && node.expression.name.text === "context" && node.arguments.length >= 1) {
+    const arg = node.arguments[0];
+    const prefix = ts.isStringLiteral(arg) ? arg.text : literalPrefixOf(arg);
+    result.dynamicPatterns.push({ kind: "require", line, ...prefix ? { prefix } : {} });
+  }
+}
+function bindRequireResult(call, record) {
+  const parent = call.parent;
+  if (parent && ts.isVariableDeclaration(parent) && parent.initializer === call) {
+    if (ts.isIdentifier(parent.name)) {
+      record.namespaceLocal = parent.name.text;
+    } else if (ts.isObjectBindingPattern(parent.name)) {
+      for (const el of parent.name.elements) {
+        if (ts.isBindingElement(el) && ts.isIdentifier(el.name)) {
+          const imported = el.propertyName && ts.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+          record.names.push({ imported, local: el.name.text });
+        }
+      }
+    }
+  }
+}
+function handleCjsExportAssignment(node, result, lineOf) {
+  const left = node.left;
+  const line = lineOf(node);
+  const isModuleExports = (e) => ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression) && e.expression.text === "module" && e.name.text === "exports";
+  if (isModuleExports(left)) {
+    if (ts.isObjectLiteralExpression(node.right)) {
+      for (const prop of node.right.properties) {
+        const name = prop.name;
+        if (name && (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
+          result.exports.push({ name: name.text, kind: "cjs", line });
+        }
+      }
+    } else {
+      result.exports.push({ name: "default", kind: "cjs", line });
+    }
+    return;
+  }
+  if (ts.isPropertyAccessExpression(left)) {
+    const base = left.expression;
+    const isExportsBase = ts.isIdentifier(base) && base.text === "exports" || isModuleExports(base);
+    if (isExportsBase && left.name.text !== "__esModule") {
+      result.exports.push({ name: left.name.text, kind: "cjs", line });
+    }
+    return;
+  }
+  if (ts.isElementAccessExpression(left)) {
+    const base = left.expression;
+    if (ts.isIdentifier(base) && base.text === "exports" || isModuleExports(base)) {
+      result.hasCjsDynamicExport = true;
+    }
+  }
+}
+function trackNamespaceUsage(ast, locals) {
+  const visit = (node) => {
+    if (ts.isIdentifier(node) && locals.has(node.text)) {
+      const usage = locals.get(node.text);
+      const parent = node.parent;
+      const isDeclarationSite = parent && (ts.isNamespaceImport(parent) && parent.name === node || ts.isVariableDeclaration(parent) && parent.name === node || ts.isImportSpecifier(parent) && parent.name === node);
+      if (!isDeclarationSite) {
+        if (parent && ts.isPropertyAccessExpression(parent) && parent.expression === node) {
+          usage.members.add(parent.name.text);
+        } else {
+          usage.escapes = true;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(ast, visit);
+}
+function collectCommentMarkers(text) {
+  const markers = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!/\/\/|\/\*|^\s*\*/.test(line)) continue;
+    if (DEPRECATED_RE.test(line)) {
+      markers.push({ line: i + 1, type: "deprecated", text: line.trim() });
+    } else if (REMOVAL_RE.test(line)) {
+      markers.push({ line: i + 1, type: "removal", text: line.trim() });
+    }
+  }
+  return markers;
+}
+
+// ../core/src/graph/moduleGraph.ts
+var ModuleGraph = class {
+  files = /* @__PURE__ */ new Map();
+  reverse = /* @__PURE__ */ new Map();
+  addFile(pf) {
+    this.files.set(pf.file, pf);
+  }
+  /** Resolve every import record and build the reverse index. Call once after all addFile(). */
+  link(resolver) {
+    for (const pf of this.files.values()) {
+      for (const record of pf.imports) {
+        const res = resolver.resolve(record.specifier, pf.file);
+        if (res.file && this.files.has(res.file)) {
+          record.resolvedFile = res.file;
+          let edges = this.reverse.get(res.file);
+          if (!edges) this.reverse.set(res.file, edges = []);
+          edges.push({ importer: pf.file, record });
+        } else if (res.pkg) {
+          record.resolvedPackage = res.pkg;
+        }
+      }
+    }
+  }
+  importersOf(file) {
+    return this.reverse.get(file) ?? [];
+  }
+  /** BFS over resolved edges (all kinds — static, require, dynamic-literal, reexports). */
+  reachable(entries) {
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const e of entries) {
+      if (this.files.has(e) && !seen.has(e)) {
+        seen.add(e);
+        queue.push(e);
+      }
+    }
+    while (queue.length > 0) {
+      const file = queue.shift();
+      const pf = this.files.get(file);
+      for (const record of pf.imports) {
+        const next = record.resolvedFile;
+        if (next && !seen.has(next)) {
+          seen.add(next);
+          queue.push(next);
+        }
+      }
+    }
+    return seen;
+  }
+  /**
+   * Is `name` (exported by `file`) forwarded by re-export chains into any of
+   * the `targets` files? Used to detect public-API exposure through entry
+   * barrels — external consumers of those are invisible to static analysis.
+   */
+  isReexportedThrough(file, name, targets, visited = /* @__PURE__ */ new Set()) {
+    const key = `${file}#${name}`;
+    if (visited.has(key)) return false;
+    visited.add(key);
+    for (const { importer, record } of this.importersOf(file)) {
+      let forwardedAs;
+      if (record.kind === "reexport-star" && name !== "default") {
+        forwardedAs = name;
+      } else if (record.kind === "reexport-named") {
+        forwardedAs = record.reexported?.find((r) => r.original === name)?.exported;
+      }
+      if (!forwardedAs) continue;
+      if (targets.has(importer)) return true;
+      if (this.isReexportedThrough(importer, forwardedAs, targets, visited)) return true;
+    }
+    return false;
+  }
+  /**
+   * Is `name` exported by `file` consumed anywhere, following re-export chains
+   * through barrels? Conservative by construction: namespace imports whose
+   * usage can't be fully traced count as usage.
+   */
+  isExportUsed(file, name, visited = /* @__PURE__ */ new Set()) {
+    const key = `${file}#${name}`;
+    if (visited.has(key)) return false;
+    visited.add(key);
+    for (const { importer, record } of this.importersOf(file)) {
+      switch (record.kind) {
+        case "static":
+        case "require": {
+          if (record.names.some((n) => n.imported === name)) return true;
+          const ns = record.namespaceUsage;
+          if (ns && (ns.escapes || ns.members.has(name))) return true;
+          break;
+        }
+        case "dynamic":
+          return true;
+        case "reexport-named": {
+          const match = record.reexported?.find((r) => r.original === name);
+          if (match && this.isExportUsed(importer, match.exported, visited)) return true;
+          break;
+        }
+        case "reexport-star":
+          if (name !== "default" && this.isExportUsed(importer, name, visited)) return true;
+          break;
+      }
+    }
+    return false;
+  }
+};
+
+// ../core/src/graph/resolver.ts
+import fs from "fs";
+import path2 from "path";
+import { builtinModules } from "module";
+import ts2 from "typescript";
+
+// ../core/src/util/paths.ts
+import path from "path";
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function absPosix(p) {
+  return toPosix(path.resolve(p));
+}
+function relPosix(from, to) {
+  return toPosix(path.relative(from, to));
+}
+function dirnamePosix(p) {
+  return toPosix(path.dirname(p));
+}
+function isUnder(dir, file) {
+  return file === dir || file.startsWith(dir.endsWith("/") ? dir : dir + "/");
+}
+
+// ../core/src/graph/resolver.ts
+var BUILTINS = new Set(builtinModules);
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var DEFAULT_OPTIONS = {
+  moduleResolution: ts2.ModuleResolutionKind.Bundler,
+  module: ts2.ModuleKind.ESNext,
+  target: ts2.ScriptTarget.Latest,
+  allowJs: true,
+  resolveJsonModule: true
+};
+var Resolver = class {
+  constructor(rootDir, workspacePackages, scannedFiles, warnings) {
+    this.rootDir = rootDir;
+    this.workspacePackages = workspacePackages;
+    this.scannedFiles = scannedFiles;
+    this.warnings = warnings;
+  }
+  rootDir;
+  workspacePackages;
+  scannedFiles;
+  warnings;
+  /** dir → compiler options of the nearest tsconfig (or defaults). */
+  optionsByDir = /* @__PURE__ */ new Map();
+  /** tsconfig path → parsed options. */
+  parsedConfigs = /* @__PURE__ */ new Map();
+  warnedConfigs = /* @__PURE__ */ new Set();
+  resolve(specifier, containingFile) {
+    if (specifier.startsWith("node:")) return {};
+    if (BUILTINS.has(specifier) || BUILTINS.has(specifier.split("/")[0])) return {};
+    const wsFirst = this.resolveWorkspace(specifier);
+    if (wsFirst?.file && this.scannedFiles.has(wsFirst.file)) return wsFirst;
+    const options = this.optionsFor(dirnamePosix(containingFile));
+    const r = ts2.resolveModuleName(specifier, containingFile, options, ts2.sys);
+    const resolved = r.resolvedModule;
+    if (resolved) {
+      const file = toPosix(resolved.resolvedFileName);
+      if (!resolved.isExternalLibraryImport && !file.includes("/node_modules/")) {
+        if (this.scannedFiles.has(file)) return { file };
+        const ws2 = this.resolveWorkspace(specifier);
+        if (ws2?.file && this.scannedFiles.has(ws2.file)) return ws2;
+        if (specifier.startsWith(".")) {
+          const manual = tryFile(path2.resolve(path2.dirname(containingFile), specifier));
+          if (manual && this.scannedFiles.has(toPosix(manual))) return { file: toPosix(manual) };
+          return {};
+        }
+        return { pkg: packageNameOf(specifier) };
+      }
+      return { pkg: resolved.packageId?.name ?? packageNameOf(specifier) };
+    }
+    const ws = this.resolveWorkspace(specifier);
+    if (ws) return ws;
+    if (specifier.startsWith(".") || specifier.startsWith("/")) {
+      const manual = tryFile(path2.resolve(path2.dirname(containingFile), specifier));
+      if (manual) return { file: toPosix(manual) };
+      return {};
+    }
+    return { pkg: packageNameOf(specifier) };
+  }
+  resolveWorkspace(specifier) {
+    for (const ws of this.workspacePackages) {
+      if (specifier === ws.name) {
+        return ws.entryFile ? { file: ws.entryFile } : { pkg: ws.name };
+      }
+      if (specifier.startsWith(ws.name + "/")) {
+        const sub = specifier.slice(ws.name.length + 1);
+        const hit = tryFile(path2.join(ws.dir, sub)) ?? tryFile(path2.join(ws.dir, "src", sub));
+        return hit ? { file: toPosix(hit) } : { pkg: ws.name };
+      }
+    }
+    return void 0;
+  }
+  optionsFor(dirPosix) {
+    const cached = this.optionsByDir.get(dirPosix);
+    if (cached) return cached;
+    let options = DEFAULT_OPTIONS;
+    let dir = dirPosix;
+    while (true) {
+      const candidate = dir + "/tsconfig.json";
+      if (fs.existsSync(candidate)) {
+        options = this.parseConfig(candidate);
+        break;
+      }
+      if (dir === this.rootDir || !dir.startsWith(this.rootDir)) break;
+      const parent = dirnamePosix(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    this.optionsByDir.set(dirPosix, options);
+    return options;
+  }
+  parseConfig(tsconfigPath) {
+    const cached = this.parsedConfigs.get(tsconfigPath);
+    if (cached) return cached;
+    let options = DEFAULT_OPTIONS;
+    const read = ts2.readConfigFile(tsconfigPath, ts2.sys.readFile);
+    if (read.error) {
+      this.warnConfig(tsconfigPath);
+    } else {
+      const parsed = ts2.parseJsonConfigFileContent(read.config, ts2.sys, path2.dirname(tsconfigPath));
+      if (parsed.errors.some((e) => e.category === ts2.DiagnosticCategory.Error && e.code === 5083)) {
+        this.warnConfig(tsconfigPath);
+      }
+      options = {
+        ...parsed.options,
+        allowJs: true,
+        resolveJsonModule: true,
+        // Classic resolution predates node_modules conventions; never useful here.
+        moduleResolution: !parsed.options.moduleResolution || parsed.options.moduleResolution === ts2.ModuleResolutionKind.Classic ? ts2.ModuleResolutionKind.Bundler : parsed.options.moduleResolution
+      };
+    }
+    this.parsedConfigs.set(tsconfigPath, options);
+    return options;
+  }
+  warnConfig(tsconfigPath) {
+    if (this.warnedConfigs.has(tsconfigPath)) return;
+    this.warnedConfigs.add(tsconfigPath);
+    this.warnings.push(
+      `Could not parse ${toPosix(path2.relative(this.rootDir, tsconfigPath))}; path aliases from it are ignored.`
+    );
+  }
+};
+function packageNameOf(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") && parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0];
+}
+function tryFile(p) {
+  if (fs.existsSync(p) && fs.statSync(p).isFile()) return p;
+  for (const ext of RESOLVE_EXTENSIONS) {
+    if (fs.existsSync(p + ext)) return p + ext;
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const idx = path2.join(p, "index" + ext);
+    if (fs.existsSync(idx)) return idx;
+  }
+  return void 0;
+}
+
+// ../core/src/workspace/workspaces.ts
+import fs2 from "fs";
+import path3 from "path";
+import { glob } from "tinyglobby";
+import { parse as parseYaml } from "yaml";
+async function discoverWorkspaces(root) {
+  const warnings = [];
+  const units = [];
+  const rootPkg = readPackageJson(path3.join(root, "package.json"), warnings);
+  units.push({ name: rootPkg?.name ?? ".", dir: root, packageJson: rootPkg ?? {} });
+  if (!rootPkg) {
+    warnings.push("No package.json at the scan root; dependency analysis is limited.");
+  }
+  const globs = workspaceGlobs(root, rootPkg);
+  if (globs.length > 0) {
+    const pkgFiles = await glob(
+      globs.map((g) => `${g.replace(/\/$/, "")}/package.json`),
+      { cwd: root, ignore: ["**/node_modules/**"], absolute: true }
+    );
+    for (const pkgFile of pkgFiles.sort()) {
+      const pkg2 = readPackageJson(pkgFile, warnings);
+      if (!pkg2) continue;
+      const dir = toPosix(path3.dirname(pkgFile));
+      units.push({ name: pkg2.name ?? toPosix(path3.relative(root, dir)), dir, packageJson: pkg2 });
+    }
+  }
+  return { units, warnings };
+}
+function workspaceGlobs(root, rootPkg) {
+  const pnpmWs = path3.join(root, "pnpm-workspace.yaml");
+  if (fs2.existsSync(pnpmWs)) {
+    try {
+      const parsed = parseYaml(fs2.readFileSync(pnpmWs, "utf8"));
+      if (Array.isArray(parsed?.packages)) return parsed.packages.filter((p) => !p.startsWith("!"));
+    } catch {
+    }
+  }
+  const ws = rootPkg?.workspaces;
+  if (Array.isArray(ws)) return ws;
+  if (ws && Array.isArray(ws.packages)) return ws.packages;
+  return [];
+}
+function readPackageJson(file, warnings) {
+  if (!fs2.existsSync(file)) return void 0;
+  try {
+    return JSON.parse(fs2.readFileSync(file, "utf8"));
+  } catch {
+    warnings.push(`Could not parse ${toPosix(file)}; treating package as empty.`);
+    return void 0;
+  }
+}
+function unitForFile(units, file) {
+  let best = units[0];
+  for (const u of units) {
+    if ((file === u.dir || file.startsWith(u.dir + "/")) && u.dir.length > best.dir.length) {
+      best = u;
+    }
+  }
+  if (!(file === best.dir || file.startsWith(best.dir + "/"))) return units[0];
+  return best;
+}
+
+// ../core/src/workspace/entrypoints.ts
+import path4 from "path";
+
+// ../core/src/manifest/fileRefs.ts
+var RUNNER_RE = /(?:^|[\s;&|("'`])(?:node|tsx|ts-node(?:-esm)?|nodemon|vite-node|bun)\s+(?:-{1,2}[\w-]+(?:[= ][^\s;&|"'`]+)?\s+)*["']?([^\s;&|"'`)]+\.(?:m?[jt]s|[jt]sx|c[jt]s))["']?/g;
+function extractFileRefs(text) {
+  const refs = [];
+  for (const match of text.matchAll(RUNNER_RE)) {
+    refs.push(match[1]);
+  }
+  return refs;
+}
+
+// ../core/src/workspace/entrypoints.ts
+var BUILD_DIRS = ["dist", "build", "lib", "out", "output", ".next"];
+var TEST_FILE_RE = /(\.|\/)(test|spec)\.[mc]?[jt]sx?$|\/__tests__\/|^tests?\//;
+function isTestFile(relPath) {
+  return TEST_FILE_RE.test(relPath);
+}
+var CONFIG_FILE_RE = /(^|\/)[\w.-]+\.config\.[mc]?[jt]s$|(^|\/)\.\w+rc\.[mc]?js$/;
+function discoverEntryPoints(unit, scannedFiles, warnings) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pkg2 = unit.packageJson;
+  const add = (file, reason, detail, tag) => {
+    if (!seen.has(file) && scannedFiles.has(file)) {
+      seen.add(file);
+      entries.push({ file, reason, ...tag ? { tag } : {}, ...detail ? { detail } : {} });
+    }
+  };
+  const addRef = (ref, reason, detail) => {
+    const resolved = resolveEntryRef(unit.dir, ref, scannedFiles);
+    if (resolved) {
+      add(resolved, reason, detail);
+    } else if (["main", "module", "bin", "exports"].includes(reason)) {
+      warnings.push(
+        `Entry '${ref}' in ${unit.name}/package.json does not map to a scanned source file.`
+      );
+    }
+  };
+  if (typeof pkg2.main === "string") addRef(pkg2.main, "main");
+  if (typeof pkg2.module === "string") addRef(pkg2.module, "module");
+  if (typeof pkg2.browser === "string") addRef(pkg2.browser, "browser");
+  if (typeof pkg2.bin === "string") addRef(pkg2.bin, "bin");
+  else if (pkg2.bin && typeof pkg2.bin === "object") {
+    for (const target of Object.values(pkg2.bin)) addRef(target, "bin");
+  }
+  for (const target of exportsTargets(pkg2.exports)) addRef(target, "exports");
+  for (const [scriptName, command] of Object.entries(pkg2.scripts ?? {})) {
+    for (const ref of extractFileRefs(command)) {
+      addRef(ref, "script", `package.json script '${scriptName}'`);
+    }
+  }
+  const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
+  if (deps["next"]) {
+    for (const file of scannedFiles) {
+      const rel = relTo(unit.dir, file);
+      if (rel && /^(pages|app|src\/pages|src\/app)\//.test(rel))
+        add(file, "framework", "Next.js route convention");
+      if (rel && /^(src\/)?middleware\.[jt]s$/.test(rel))
+        add(file, "framework", "Next.js middleware");
+    }
+  }
+  if (deps["@nestjs/core"]) {
+    const main = tryFile(path4.join(unit.dir, "src/main"));
+    if (main) add(toPosix(main), "framework", "NestJS bootstrap");
+  }
+  for (const file of scannedFiles) {
+    const rel = relTo(unit.dir, file);
+    if (rel && !rel.includes("/") && CONFIG_FILE_RE.test(rel)) {
+      add(file, "config", "tool configuration file");
+    }
+  }
+  for (const file of scannedFiles) {
+    const rel = relTo(unit.dir, file);
+    if (rel && isTestFile(rel)) add(file, "test", void 0, "test");
+  }
+  return entries;
+}
+function resolveEntryRef(unitDir, ref, scannedFiles) {
+  const accept = (p) => {
+    if (!p) return void 0;
+    const posix = toPosix(p);
+    return !scannedFiles || scannedFiles.has(posix) ? posix : void 0;
+  };
+  const clean = ref.replace(/^\.\//, "");
+  const direct = accept(tryFile(path4.join(unitDir, clean)));
+  if (direct) return direct;
+  const parts = clean.split("/");
+  const first = parts[0];
+  if (BUILD_DIRS.includes(first)) {
+    const rest = parts.slice(1).join("/");
+    const stripped = rest.replace(/\.(js|mjs|cjs|d\.ts)$/, "");
+    for (const base of [`src/${stripped}`, stripped]) {
+      const hit = accept(tryFile(path4.join(unitDir, base)));
+      if (hit) return hit;
+    }
+  }
+  return void 0;
+}
+function exportsTargets(exp) {
+  const out = [];
+  const walk = (value) => {
+    if (typeof value === "string") {
+      if (!value.endsWith(".d.ts")) out.push(value);
+    } else if (value && typeof value === "object") {
+      for (const v of Object.values(value)) walk(v);
+    }
+  };
+  walk(exp);
+  return out;
+}
+function relTo(dir, file) {
+  return file.startsWith(dir + "/") ? file.slice(dir.length + 1) : void 0;
+}
+
+// ../core/src/manifest/crontab.ts
+import fs3 from "fs";
+import path5 from "path";
+function isCrontabFile(relPath) {
+  return /(^|\/)crontab$|\.cron$|(^|\/)cron\.d\//.test(relPath);
+}
+function parseCrontab(root, manifestRel) {
+  const callers = [];
+  const text = fs3.readFileSync(path5.join(root, manifestRel), "utf8");
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const fields = line.split(/\s+/);
+    const schedule = line.startsWith("@") ? fields[0] : fields.slice(0, 5).join(" ");
+    for (const ref of extractFileRefs(line)) {
+      const resolved = tryFile(path5.resolve(root, ref));
+      if (resolved) {
+        callers.push({
+          file: toPosix(resolved),
+          manifest: manifestRel,
+          kind: "crontab",
+          detail: `cron '${schedule}' runs ${ref}`
+        });
+      }
+    }
+  }
+  return callers;
+}
+
+// ../core/src/manifest/githubActions.ts
+import fs4 from "fs";
+import path6 from "path";
+import { parse as parseYaml2 } from "yaml";
+function parseGithubWorkflow(root, manifestRel, warnings) {
+  const callers = [];
+  let doc;
+  try {
+    doc = parseYaml2(fs4.readFileSync(path6.join(root, manifestRel), "utf8"));
+  } catch {
+    warnings.push(`Could not parse workflow ${manifestRel}; its callers are unknown.`);
+    return callers;
+  }
+  for (const [jobName, job] of Object.entries(doc?.jobs ?? {})) {
+    for (const step of job?.steps ?? []) {
+      if (typeof step?.run !== "string") continue;
+      for (const ref of extractFileRefs(step.run)) {
+        const resolved = tryFile(path6.resolve(root, ref));
+        if (resolved) {
+          callers.push({
+            file: toPosix(resolved),
+            manifest: manifestRel,
+            kind: "github-actions",
+            detail: `GitHub Actions job '${jobName}' runs ${ref}`
+          });
+        }
+      }
+    }
+  }
+  return callers;
+}
+
+// ../core/src/manifest/k8s.ts
+import fs5 from "fs";
+import path7 from "path";
+import { parseAllDocuments } from "yaml";
+function parseK8sManifest(root, manifestRel, warnings) {
+  const callers = [];
+  let docs;
+  try {
+    docs = parseAllDocuments(fs5.readFileSync(path7.join(root, manifestRel), "utf8"));
+  } catch {
+    warnings.push(`Could not parse yaml ${manifestRel}; its callers are unknown.`);
+    return callers;
+  }
+  for (const doc of docs) {
+    const obj = doc?.toJS?.();
+    if (!obj || typeof obj !== "object" || !obj["apiVersion"] || !obj["kind"]) continue;
+    const kind = String(obj["kind"]);
+    for (const container of containersOf(obj)) {
+      const cmd = [...container.command ?? [], ...container.args ?? []].filter((c) => typeof c === "string").join(" ");
+      for (const ref of extractFileRefs(cmd)) {
+        const resolved = tryFile(path7.resolve(root, ref));
+        if (resolved) {
+          callers.push({
+            file: toPosix(resolved),
+            manifest: manifestRel,
+            kind: "k8s",
+            detail: `k8s ${kind} container runs ${ref}`
+          });
+        }
+      }
+    }
+  }
+  return callers;
+}
+function containersOf(obj) {
+  const out = [];
+  const walk = (value) => {
+    if (Array.isArray(value)) {
+      for (const v of value) walk(v);
+    } else if (value && typeof value === "object") {
+      const rec = value;
+      if (Array.isArray(rec["containers"])) {
+        for (const c of rec["containers"]) {
+          if (c && typeof c === "object") out.push(c);
+        }
+      }
+      for (const v of Object.values(rec)) walk(v);
+    }
+  };
+  walk(obj);
+  return out;
+}
+
+// ../core/src/manifest/configRefs.ts
+import fs6 from "fs";
+import path8 from "path";
+import { parse as parseYaml3 } from "yaml";
+function parseDockerfile(root, manifestRel) {
+  const callers = [];
+  const text = fs6.readFileSync(path8.join(root, manifestRel), "utf8");
+  for (const line of text.split(/\r?\n/)) {
+    const m = /^\s*(CMD|ENTRYPOINT)\s+(.*)$/i.exec(line);
+    if (!m) continue;
+    let command = m[2].trim();
+    if (command.startsWith("[")) {
+      try {
+        const arr = JSON.parse(command);
+        command = arr.filter((a) => typeof a === "string").join(" ");
+      } catch {
+      }
+    }
+    for (const ref of extractFileRefs(command)) {
+      const resolved = tryFile(path8.resolve(root, ref));
+      if (resolved) {
+        callers.push({
+          file: toPosix(resolved),
+          manifest: manifestRel,
+          kind: "dockerfile",
+          detail: `Dockerfile ${m[1].toUpperCase()} runs ${ref}`
+        });
+      }
+    }
+  }
+  return callers;
+}
+function parseServerless(root, manifestRel, warnings) {
+  const callers = [];
+  let doc;
+  try {
+    doc = parseYaml3(fs6.readFileSync(path8.join(root, manifestRel), "utf8"));
+  } catch {
+    warnings.push(`Could not parse ${manifestRel}; its handlers are unknown.`);
+    return callers;
+  }
+  for (const [fnName, fn] of Object.entries(doc?.functions ?? {})) {
+    if (typeof fn?.handler !== "string") continue;
+    const fileBase = fn.handler.slice(0, fn.handler.lastIndexOf("."));
+    const resolved = tryFile(path8.resolve(root, fileBase));
+    if (resolved) {
+      callers.push({
+        file: toPosix(resolved),
+        manifest: manifestRel,
+        kind: "serverless",
+        detail: `serverless function '${fnName}' handler`
+      });
+    }
+  }
+  return callers;
+}
+function parseWebpackConfig(root, manifestRel) {
+  const callers = [];
+  const text = fs6.readFileSync(path8.join(root, manifestRel), "utf8");
+  const entryMatch = /\bentry\s*:\s*(\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"])/s.exec(text);
+  if (!entryMatch) return callers;
+  for (const str of entryMatch[1].matchAll(/['"]([^'"]+)['"]/g)) {
+    const resolved = tryFile(path8.resolve(root, str[1]));
+    if (resolved) {
+      callers.push({
+        file: toPosix(resolved),
+        manifest: manifestRel,
+        kind: "webpack",
+        detail: `webpack entry`
+      });
+    }
+  }
+  return callers;
+}
+
+// ../core/src/model/signals.ts
+function kill(id, weight, description) {
+  return { id, source: "static", direction: "kill", weight, description };
+}
+function spare(id, weight, description) {
+  return { id, source: "static", direction: "spare", weight: -Math.abs(weight), description };
+}
+var SIGNAL_LIST = [
+  // Base signals — one per category; they carry the category's base score so
+  // the JSON output is fully self-describing (score is just Σ evidence.weight).
+  kill("static:unreachable-file", 60, "File is not reachable from any entry point"),
+  kill("static:unreferenced-export", 65, "Exported symbol is never imported anywhere in the repo"),
+  kill("static:unused-dependency", 70, "Declared dependency is never imported"),
+  kill("static:route-registered", 35, "Route is registered; static analysis cannot observe calls"),
+  // Kill signals (raise confidence).
+  kill("static:deprecated-jsdoc", 15, "Marked @deprecated"),
+  kill("static:removal-comment", 10, "A nearby comment asks for removal"),
+  kill("static:test-only-reference", 10, "Only reachable from test files"),
+  kill("static:no-client-path-match", 10, "No string literal in the repo matches the route path"),
+  kill("static:controller-not-in-module", 45, "Controller is not registered in any @Module"),
+  kill(
+    "static:route-file-unreachable",
+    45,
+    "The file registering this route is itself unreachable, so the route is never mounted"
+  ),
+  // Spare signals (hidden callers — lower confidence, never silently drop).
+  spare(
+    "static:dynamic-import-in-dir",
+    25,
+    "A dynamic import/require may load files in this directory"
+  ),
+  spare(
+    "static:dynamic-import-exact-dir",
+    40,
+    "A dynamic import/require targets exactly this directory"
+  ),
+  spare("static:string-dispatch", 20, "Symbol appears in a string-keyed dispatch table"),
+  spare("static:script-reference", 60, "Referenced by a package.json script"),
+  spare("static:config-reference", 60, "Referenced by a build/deploy config"),
+  spare("static:manifest-reference", 60, "Referenced by a caller manifest (cron/CI/k8s)"),
+  spare("static:job-registration", 50, "File registers scheduled jobs or queue workers"),
+  spare(
+    "static:namespace-import-ambiguity",
+    15,
+    "Imported via namespace whose usage could not be fully traced"
+  ),
+  spare("static:cjs-dynamic-pattern", 20, "File assigns computed CommonJS exports"),
+  spare(
+    "static:client-path-match",
+    30,
+    "A string literal elsewhere in the repo matches the route path"
+  ),
+  spare("static:dynamic-route-prefix", 15, "Route prefix could not be resolved statically"),
+  spare(
+    "static:types-package-pairing",
+    60,
+    "@types package pairs with a runtime package that is in use"
+  ),
+  spare(
+    "static:public-api-reexport",
+    30,
+    "Re-exported by a package entry point; external consumers are invisible to static analysis"
+  ),
+  // Reserved for the paid evidence layer — registered now so the scorer and
+  // JSON contract already understand them.
+  {
+    id: "prod:zero-requests-90d",
+    source: "production",
+    direction: "kill",
+    weight: 35,
+    description: "No production requests observed in 90 days"
+  },
+  {
+    id: "prod:request-seen",
+    source: "production",
+    direction: "spare",
+    weight: -100,
+    description: "Production traffic observed"
+  }
+];
+var SIGNALS = new Map(SIGNAL_LIST.map((s) => [s.id, s]));
+var BASE_SIGNALS = {
+  "unreachable-file": "static:unreachable-file",
+  "unused-export": "static:unreferenced-export",
+  "unused-dependency": "static:unused-dependency",
+  "dead-route": "static:route-registered"
+};
+var STATIC_CAPS = {
+  "dead-route": 70,
+  "unused-export": 85,
+  "unused-dependency": 85,
+  "unreachable-file": 85
+};
+var STATIC_CAP_REASON = "no runtime evidence \u2014 connect telemetry to confirm";
+function evidenceFor(signalId, detail, location) {
+  const spec = SIGNALS.get(signalId);
+  if (!spec) {
+    throw new Error(`Unknown signal id: ${signalId}`);
+  }
+  return {
+    signal: spec.id,
+    source: spec.source,
+    direction: spec.direction,
+    weight: spec.weight,
+    detail,
+    ...location ? { location } : {}
+  };
+}
+
+// ../core/src/model/finding.ts
+function targetKey(target) {
+  switch (target.kind) {
+    case "route":
+      return `route:${target.framework}:${target.method} ${target.path}`;
+    case "export":
+      return `export:${target.file}#${target.symbol}`;
+    case "dependency":
+      return `dependency:${target.depType}:${target.name}`;
+    case "file":
+      return `file:${target.file}`;
+  }
+}
+function describeTarget(target) {
+  switch (target.kind) {
+    case "route":
+      return `${target.method} ${target.path}`;
+    case "export":
+      return `export '${target.symbol}' in ${target.file}`;
+    case "dependency":
+      return `${target.name} (${target.depType})`;
+    case "file":
+      return target.file;
+  }
+}
+
+// ../core/src/util/hash.ts
+import { createHash } from "crypto";
+function stableId(...parts) {
+  return createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12);
+}
+
+// ../core/src/detectors/types.ts
+function makeFinding(category, target, location, workspace, baseDetail) {
+  return {
+    id: stableId(targetKey(target), workspace),
+    category,
+    target,
+    location,
+    workspace,
+    evidence: [evidenceFor(BASE_SIGNALS[category], baseDetail)],
+    confidence: { score: 0, level: "low" }
+  };
+}
+
+// ../core/src/detectors/unreachableFiles.ts
+var unreachableFiles = {
+  name: "unreachable-files",
+  detect: () => true,
+  extract(ctx) {
+    const findings = [];
+    const entryFiles = new Set(ctx.entryPoints.map((e) => e.file));
+    const entryCount = ctx.entryPoints.filter((e) => e.tag !== "test").length;
+    for (const file of ctx.unitFiles()) {
+      if (entryFiles.has(file)) continue;
+      const rel = ctx.rel(file);
+      if (!ctx.reach.all.has(file)) {
+        findings.push(
+          makeFinding(
+            "unreachable-file",
+            { kind: "file", file: rel },
+            { file: rel, line: 1 },
+            ctx.unit.name,
+            `Not imported (directly or transitively) by any of ${entryCount} entry points`
+          )
+        );
+      } else if (!ctx.reach.prod.has(file)) {
+        const finding = makeFinding(
+          "unreachable-file",
+          { kind: "file", file: rel },
+          { file: rel, line: 1 },
+          ctx.unit.name,
+          "Only reachable through test files; no production entry point imports it"
+        );
+        finding.evidence.push(
+          evidenceFor("static:test-only-reference", "Reachable exclusively via test entry points")
+        );
+        findings.push(finding);
+      }
+    }
+    return { findings };
+  }
+};
+
+// ../core/src/detectors/unusedExports.ts
+var unusedExports = {
+  name: "unused-exports",
+  detect: () => true,
+  extract(ctx) {
+    const findings = [];
+    const entryFiles = new Set(ctx.entryPoints.map((e) => e.file));
+    const publicEntryFiles = new Set(
+      ctx.entryPoints.filter((e) => e.tag !== "test").map((e) => e.file)
+    );
+    for (const file of ctx.unitFiles()) {
+      if (entryFiles.has(file)) continue;
+      if (!ctx.reach.all.has(file)) continue;
+      const rel = ctx.rel(file);
+      if (isTestFile(rel)) continue;
+      const pf = ctx.graph.files.get(file);
+      const seenNames = /* @__PURE__ */ new Set();
+      for (const exp of pf.exports) {
+        if (seenNames.has(exp.name)) continue;
+        seenNames.add(exp.name);
+        if (ctx.graph.isExportUsed(file, exp.name)) continue;
+        const finding = makeFinding(
+          "unused-export",
+          { kind: "export", symbol: exp.name, file: rel },
+          { file: rel, line: exp.line },
+          ctx.unit.name,
+          exp.kind === "type" ? `Type export '${exp.name}' is never imported` : `'${exp.name}' is exported but never imported anywhere in the repo`
+        );
+        if (exp.deprecated) {
+          finding.evidence.push(
+            evidenceFor("static:deprecated-jsdoc", `'${exp.name}' is marked @deprecated`)
+          );
+        }
+        if (ctx.graph.isReexportedThrough(file, exp.name, publicEntryFiles)) {
+          finding.evidence.push(
+            evidenceFor(
+              "static:public-api-reexport",
+              `'${exp.name}' is part of the package's public API via an entry-point re-export`
+            )
+          );
+        }
+        if (pf.hasCjsDynamicExport) {
+          finding.evidence.push(
+            evidenceFor(
+              "static:cjs-dynamic-pattern",
+              "File assigns computed CommonJS exports; the export set is not fully static"
+            )
+          );
+        }
+        findings.push(finding);
+      }
+    }
+    return { findings };
+  }
+};
+
+// ../core/src/detectors/unusedDeps.ts
+import fs7 from "fs";
+import path9 from "path";
+var unusedDeps = {
+  name: "unused-dependencies",
+  detect: (unit) => Object.keys(unit.packageJson.dependencies ?? {}).length > 0 || Object.keys(unit.packageJson.devDependencies ?? {}).length > 0,
+  extract(ctx) {
+    const findings = [];
+    const used = usedPackages(ctx);
+    const pkgJsonRel = ctx.rel(`${ctx.unit.dir}/package.json`);
+    const lineIndex = packageJsonLines(ctx.unit.dir);
+    for (const depType of ["dependencies", "devDependencies"]) {
+      for (const name of Object.keys(ctx.unit.packageJson[depType] ?? {})) {
+        if (used.has(name)) continue;
+        const finding = makeFinding(
+          "unused-dependency",
+          { kind: "dependency", name, depType },
+          { file: pkgJsonRel, line: lineIndex.get(name) ?? 1 },
+          ctx.unit.name,
+          `'${name}' is declared in ${depType} but never imported`
+        );
+        if (name.startsWith("@types/")) {
+          const runtime = runtimePackageFor(name);
+          if (runtime === "node" || used.has(runtime)) {
+            finding.evidence.push(
+              evidenceFor(
+                "static:types-package-pairing",
+                `Type definitions for '${runtime}', which is in use`
+              )
+            );
+          }
+        }
+        findings.push(finding);
+      }
+    }
+    return { findings };
+  }
+};
+function usedPackages(ctx) {
+  const used = /* @__PURE__ */ new Set();
+  for (const file of ctx.graph.files.keys()) {
+    if (!isUnder(ctx.unit.dir, file)) continue;
+    const pf = ctx.graph.files.get(file);
+    for (const imp of pf.imports) {
+      if (imp.resolvedPackage) {
+        used.add(imp.resolvedPackage);
+      } else if (!imp.specifier.startsWith(".") && !imp.specifier.startsWith("node:")) {
+        used.add(packageNameOf(imp.specifier));
+      }
+    }
+  }
+  return used;
+}
+function runtimePackageFor(typesPackage) {
+  const base = typesPackage.slice("@types/".length);
+  return base.includes("__") ? `@${base.replace("__", "/")}` : base;
+}
+function packageJsonLines(unitDir) {
+  const lines = /* @__PURE__ */ new Map();
+  try {
+    const text = fs7.readFileSync(path9.join(unitDir, "package.json"), "utf8");
+    text.split(/\r?\n/).forEach((line, i) => {
+      const m = /^\s*"((?:@[\w.-]+\/)?[\w.-]+)"\s*:/.exec(line);
+      if (m && !lines.has(m[1])) lines.set(m[1], i + 1);
+    });
+  } catch {
+  }
+  return lines;
+}
+
+// ../core/src/detectors/routes/express.ts
+import ts3 from "typescript";
+var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "all", "head", "options"]);
+var CONVENTIONAL_RECEIVERS = /* @__PURE__ */ new Set(["app", "router", "server", "api", "fastify"]);
+var RECEIVER_FACTORIES = /* @__PURE__ */ new Set(["express", "fastify", "Fastify", "Router"]);
+var CLIENT_LITERAL_THRESHOLD = 3;
+var expressRoutes = {
+  name: "express-routes",
+  detect: (unit) => {
+    const deps = { ...unit.packageJson.dependencies, ...unit.packageJson.devDependencies };
+    return Boolean(deps["express"] || deps["fastify"]);
+  },
+  extract(ctx) {
+    const registrations = [];
+    const mounts = [];
+    for (const file of ctx.unitFiles()) {
+      if (isTestFile(ctx.rel(file))) continue;
+      const pf = ctx.graph.files.get(file);
+      collectFromFile(pf, registrations, mounts);
+    }
+    const prefixByFileReceiver = /* @__PURE__ */ new Map();
+    const prefixByFile = /* @__PURE__ */ new Map();
+    for (const mount of mounts) {
+      const pf = ctx.graph.files.get(mount.file);
+      const imported = pf.imports.find(
+        (i) => i.resolvedFile && (i.names.some((n) => n.local === mount.localName) || i.namespaceLocal === mount.localName)
+      );
+      if (imported?.resolvedFile) {
+        if (!prefixByFile.has(imported.resolvedFile)) {
+          prefixByFile.set(imported.resolvedFile, mount.prefix);
+        }
+      } else if (!prefixByFileReceiver.has(`${mount.file}#${mount.localName}`)) {
+        prefixByFileReceiver.set(`${mount.file}#${mount.localName}`, mount.prefix);
+      }
+    }
+    const routeFiles = new Set(registrations.map((r) => r.file));
+    const clientLiterals = [];
+    for (const [file, pf] of ctx.graph.files) {
+      if (routeFiles.has(file)) continue;
+      for (const lit of pf.pathLiterals) clientLiterals.push({ value: lit.value, file });
+    }
+    const literalsMeaningful = clientLiterals.length >= CLIENT_LITERAL_THRESHOLD;
+    const findings = [];
+    const seen = /* @__PURE__ */ new Set();
+    const framework = frameworkOf(ctx);
+    for (const reg of registrations) {
+      const prefix = prefixByFileReceiver.get(`${reg.file}#${reg.receiver}`) ?? prefixByFile.get(reg.file) ?? "";
+      const fullPath = joinRoutePath(prefix, reg.path);
+      const method = reg.method.toUpperCase();
+      const key = `${method} ${fullPath} ${reg.file}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const rel = ctx.rel(reg.file);
+      const finding = makeFinding(
+        "dead-route",
+        { kind: "route", method, path: fullPath, framework },
+        { file: rel, line: reg.line },
+        ctx.unit.name,
+        `${method} ${fullPath} is registered here; static analysis cannot observe whether it is called`
+      );
+      if (prefix === "<dynamic>") {
+        finding.evidence.push(
+          evidenceFor(
+            "static:dynamic-route-prefix",
+            "Mounted under a prefix that is not a string literal"
+          )
+        );
+      }
+      if (!ctx.reach.all.has(reg.file)) {
+        finding.evidence.push(
+          evidenceFor(
+            "static:route-file-unreachable",
+            `${rel} is not reachable from any entry point`
+          )
+        );
+      } else if (literalsMeaningful && !fullPath.startsWith("<dynamic>")) {
+        const match = findPathMatch(fullPath, clientLiterals);
+        if (match) {
+          finding.evidence.push(
+            evidenceFor(
+              "static:client-path-match",
+              `'${match.value}' in ${ctx.rel(match.file)} matches this route`
+            )
+          );
+        } else {
+          finding.evidence.push(
+            evidenceFor(
+              "static:no-client-path-match",
+              `None of ${clientLiterals.length} URL-like strings in the repo match this route`
+            )
+          );
+        }
+      }
+      findings.push(finding);
+    }
+    return { findings, counted: { routes: seen.size } };
+  }
+};
+function frameworkOf(ctx) {
+  const deps = { ...ctx.unit.packageJson.dependencies, ...ctx.unit.packageJson.devDependencies };
+  return deps["fastify"] && !deps["express"] ? "fastify" : "express";
+}
+function collectFromFile(pf, registrations, mounts) {
+  const receivers = new Set(CONVENTIONAL_RECEIVERS);
+  const seed = (node) => {
+    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer && ts3.isCallExpression(node.initializer)) {
+      const callee = node.initializer.expression;
+      const isFactory = ts3.isIdentifier(callee) && RECEIVER_FACTORIES.has(callee.text) || ts3.isPropertyAccessExpression(callee) && callee.name.text === "Router";
+      if (isFactory) receivers.add(node.name.text);
+    }
+    ts3.forEachChild(node, seed);
+  };
+  ts3.forEachChild(pf.ast, seed);
+  const lineOf = (node) => pf.ast.getLineAndCharacterOfPosition(node.getStart(pf.ast)).line + 1;
+  const visit = (node) => {
+    if (ts3.isCallExpression(node) && ts3.isPropertyAccessExpression(node.expression)) {
+      const methodName = node.expression.name.text;
+      const base = node.expression.expression;
+      if (HTTP_METHODS.has(methodName)) {
+        const viaRoute = routeCallPath(base);
+        if (viaRoute) {
+          if (viaRoute.receiver && receivers.has(viaRoute.receiver)) {
+            registrations.push({
+              method: methodName,
+              path: viaRoute.path,
+              receiver: viaRoute.receiver,
+              line: lineOf(node),
+              file: pf.file
+            });
+          }
+        } else if (ts3.isIdentifier(base) && receivers.has(base.text)) {
+          const arg0 = node.arguments[0];
+          if (arg0 && (ts3.isStringLiteral(arg0) || ts3.isNoSubstitutionTemplateLiteral(arg0)) && node.arguments.length >= 2 && node.arguments.slice(1).some(isHandlerish)) {
+            registrations.push({
+              method: methodName,
+              path: arg0.text,
+              receiver: base.text,
+              line: lineOf(node),
+              file: pf.file
+            });
+          }
+        }
+      }
+      if (methodName === "route" && ts3.isIdentifier(base) && receivers.has(base.text)) {
+        const arg0 = node.arguments[0];
+        if (arg0 && ts3.isObjectLiteralExpression(arg0)) {
+          const get = (prop) => {
+            for (const p of arg0.properties) {
+              if (ts3.isPropertyAssignment(p) && ts3.isIdentifier(p.name) && p.name.text === prop && (ts3.isStringLiteral(p.initializer) || ts3.isNoSubstitutionTemplateLiteral(p.initializer))) {
+                return p.initializer.text;
+              }
+            }
+            return void 0;
+          };
+          const url = get("url") ?? get("path");
+          const method = get("method");
+          if (url && method) {
+            registrations.push({
+              method: method.toLowerCase(),
+              path: url,
+              receiver: base.text,
+              line: lineOf(node),
+              file: pf.file
+            });
+          }
+        }
+      }
+      if ((methodName === "use" || methodName === "register") && ts3.isIdentifier(base) && receivers.has(base.text) && node.arguments.length >= 1) {
+        collectMount(node, methodName, pf.file, mounts);
+      }
+    }
+    ts3.forEachChild(node, visit);
+  };
+  ts3.forEachChild(pf.ast, visit);
+}
+function routeCallPath(base) {
+  if (ts3.isCallExpression(base) && ts3.isPropertyAccessExpression(base.expression) && base.expression.name.text === "route" && base.arguments.length >= 1) {
+    const arg = base.arguments[0];
+    if (ts3.isStringLiteral(arg) || ts3.isNoSubstitutionTemplateLiteral(arg)) {
+      const receiverExpr = base.expression.expression;
+      return {
+        path: arg.text,
+        ...ts3.isIdentifier(receiverExpr) ? { receiver: receiverExpr.text } : {}
+      };
+    }
+  }
+  return void 0;
+}
+function collectMount(node, methodName, file, mounts) {
+  const args = node.arguments;
+  if (methodName === "register") {
+    if (args[0] && ts3.isIdentifier(args[0])) {
+      let prefix = "";
+      const opts = args[1];
+      if (opts && ts3.isObjectLiteralExpression(opts)) {
+        for (const p of opts.properties) {
+          if (ts3.isPropertyAssignment(p) && ts3.isIdentifier(p.name) && p.name.text === "prefix") {
+            prefix = ts3.isStringLiteral(p.initializer) ? p.initializer.text : "<dynamic>";
+          }
+        }
+      }
+      mounts.push({ prefix, localName: args[0].text, file });
+    }
+    return;
+  }
+  const first = args[0];
+  if (ts3.isStringLiteral(first) || ts3.isNoSubstitutionTemplateLiteral(first)) {
+    for (const arg of args.slice(1)) {
+      if (ts3.isIdentifier(arg)) mounts.push({ prefix: first.text, localName: arg.text, file });
+    }
+  } else if (ts3.isIdentifier(first)) {
+    mounts.push({ prefix: "", localName: first.text, file });
+  } else if (args.length >= 2) {
+    for (const arg of args.slice(1)) {
+      if (ts3.isIdentifier(arg)) mounts.push({ prefix: "<dynamic>", localName: arg.text, file });
+    }
+  }
+}
+function isHandlerish(arg) {
+  return !(ts3.isObjectLiteralExpression(arg) || ts3.isStringLiteral(arg) || ts3.isNoSubstitutionTemplateLiteral(arg) || ts3.isNumericLiteral(arg) || arg.kind === ts3.SyntaxKind.TrueKeyword || arg.kind === ts3.SyntaxKind.FalseKeyword);
+}
+function joinRoutePath(prefix, p) {
+  if (!prefix) return p || "/";
+  const joined = `${prefix}/${p}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : joined;
+}
+function findPathMatch(routePath, literals) {
+  const paramIdx = routePath.search(/[:*]/);
+  if (paramIdx === -1) {
+    return literals.find((l) => l.value === routePath || l.value.startsWith(routePath + "?"));
+  }
+  const prefix = routePath.slice(0, paramIdx);
+  return literals.find((l) => l.value.startsWith(prefix) && l.value.length > prefix.length);
+}
+
+// ../core/src/detectors/routes/nest.ts
+import ts4 from "typescript";
+var FRAMEWORK = "nest";
+var METHOD_DECORATORS = {
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Patch: "PATCH",
+  Delete: "DELETE",
+  Options: "OPTIONS",
+  Head: "HEAD",
+  All: "ALL"
+};
+var nestRoutes = {
+  name: "nest-routes",
+  detect: (unit) => {
+    const deps = { ...unit.packageJson.dependencies, ...unit.packageJson.devDependencies };
+    return Boolean(deps["@nestjs/core"] || deps["@nestjs/common"]);
+  },
+  extract(ctx) {
+    const controllers = [];
+    const registeredIn = /* @__PURE__ */ new Map();
+    for (const file of ctx.unitFiles()) {
+      if (isTestFile(ctx.rel(file))) continue;
+      const pf = ctx.graph.files.get(file);
+      collectControllers(pf, controllers);
+      collectModuleControllers(pf, registeredIn);
+    }
+    const findings = [];
+    const seen = /* @__PURE__ */ new Set();
+    let routeCount = 0;
+    for (const ctrl of controllers) {
+      const registered = isRegistered(ctx, ctrl, registeredIn.get(ctrl.name));
+      for (const route of ctrl.routes) {
+        const fullPath = joinRoutePath2(ctrl.prefix, route.path);
+        routeCount++;
+        const key = `${route.method} ${fullPath} ${ctrl.file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const rel = ctx.rel(ctrl.file);
+        const finding = makeFinding(
+          "dead-route",
+          { kind: "route", method: route.method, path: fullPath, framework: FRAMEWORK },
+          { file: rel, line: route.line },
+          ctx.unit.name,
+          `${route.method} ${fullPath} is declared on @Controller ${ctrl.name}; static analysis cannot observe whether it is called`
+        );
+        if (!registered) {
+          finding.evidence.push(
+            evidenceFor(
+              "static:controller-not-in-module",
+              `@Controller ${ctrl.name} is not listed in any @Module({ controllers }), so Nest never mounts it`,
+              { file: rel, line: ctrl.line }
+            )
+          );
+        }
+        if (ctrl.prefix === "<dynamic>") {
+          finding.evidence.push(
+            evidenceFor(
+              "static:dynamic-route-prefix",
+              `@Controller ${ctrl.name} prefix is not a string literal`
+            )
+          );
+        }
+        findings.push(finding);
+      }
+    }
+    return { findings, counted: { routes: routeCount } };
+  }
+};
+function isRegistered(ctx, ctrl, moduleFiles) {
+  if (!moduleFiles || moduleFiles.size === 0) return false;
+  for (const moduleFile of moduleFiles) {
+    if (moduleFile === ctrl.file) return true;
+    const pf = ctx.graph.files.get(moduleFile);
+    if (pf?.imports.some((imp) => imp.resolvedFile === ctrl.file)) return true;
+  }
+  return false;
+}
+function collectControllers(pf, out) {
+  const lineOf = (node) => pf.ast.getLineAndCharacterOfPosition(node.getStart(pf.ast)).line + 1;
+  const visit = (node) => {
+    if (ts4.isClassDeclaration(node) && node.name) {
+      const decorators = ts4.getDecorators?.(node) ?? [];
+      const controllerDec = decorators.find((d) => decoratorName(d) === "Controller");
+      if (controllerDec) {
+        const prefix = controllerPrefix(controllerDec);
+        const routes = [];
+        for (const member of node.members) {
+          if (!ts4.isMethodDeclaration(member)) continue;
+          for (const dec of ts4.getDecorators?.(member) ?? []) {
+            const verb = METHOD_DECORATORS[decoratorName(dec) ?? ""];
+            if (verb) {
+              routes.push({
+                method: verb,
+                path: decoratorStringArg(dec) ?? "",
+                line: lineOf(member)
+              });
+            }
+          }
+        }
+        if (routes.length > 0) {
+          out.push({ name: node.name.text, prefix, routes, file: pf.file, line: lineOf(node) });
+        }
+      }
+    }
+    ts4.forEachChild(node, visit);
+  };
+  ts4.forEachChild(pf.ast, visit);
+}
+function collectModuleControllers(pf, out) {
+  const visit = (node) => {
+    if (ts4.isClassDeclaration(node)) {
+      const moduleDec = (ts4.getDecorators?.(node) ?? []).find((d) => decoratorName(d) === "Module");
+      if (moduleDec && ts4.isCallExpression(moduleDec.expression)) {
+        const arg = moduleDec.expression.arguments[0];
+        if (arg && ts4.isObjectLiteralExpression(arg)) {
+          for (const prop of arg.properties) {
+            if (ts4.isPropertyAssignment(prop) && ts4.isIdentifier(prop.name) && prop.name.text === "controllers" && ts4.isArrayLiteralExpression(prop.initializer)) {
+              for (const el of prop.initializer.elements) {
+                if (ts4.isIdentifier(el)) {
+                  let set = out.get(el.text);
+                  if (!set) out.set(el.text, set = /* @__PURE__ */ new Set());
+                  set.add(pf.file);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    ts4.forEachChild(node, visit);
+  };
+  ts4.forEachChild(pf.ast, visit);
+}
+function decoratorName(dec) {
+  const expr = ts4.isCallExpression(dec.expression) ? dec.expression.expression : dec.expression;
+  return ts4.isIdentifier(expr) ? expr.text : void 0;
+}
+function decoratorStringArg(dec) {
+  if (!ts4.isCallExpression(dec.expression)) return void 0;
+  const arg = dec.expression.arguments[0];
+  if (arg && (ts4.isStringLiteral(arg) || ts4.isNoSubstitutionTemplateLiteral(arg))) return arg.text;
+  return void 0;
+}
+function controllerPrefix(dec) {
+  if (!ts4.isCallExpression(dec.expression)) return "";
+  const arg = dec.expression.arguments[0];
+  if (!arg) return "";
+  if (ts4.isStringLiteral(arg) || ts4.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
+  if (ts4.isObjectLiteralExpression(arg)) {
+    for (const prop of arg.properties) {
+      if (ts4.isPropertyAssignment(prop) && ts4.isIdentifier(prop.name) && prop.name.text === "path") {
+        if (ts4.isStringLiteral(prop.initializer) || ts4.isNoSubstitutionTemplateLiteral(prop.initializer)) {
+          return prop.initializer.text;
+        }
+        return "<dynamic>";
+      }
+    }
+    return "";
+  }
+  return "<dynamic>";
+}
+function joinRoutePath2(prefix, p) {
+  const a = prefix.replace(/^\/|\/$/g, "");
+  const b = p.replace(/^\/|\/$/g, "");
+  const joined = [a, b].filter(Boolean).join("/");
+  return "/" + joined;
+}
+
+// ../core/src/detectors/routes/next.ts
+var FRAMEWORK2 = "next";
+var CLIENT_LITERAL_THRESHOLD2 = 3;
+var NON_ROUTE_BASENAMES = /* @__PURE__ */ new Set([
+  "_app",
+  "_document",
+  "_error",
+  "layout",
+  "loading",
+  "error",
+  "not-found",
+  "template",
+  "default",
+  "global-error",
+  "instrumentation",
+  "middleware"
+]);
+var nextRoutes = {
+  name: "next-routes",
+  detect: (unit) => {
+    const deps = { ...unit.packageJson.dependencies, ...unit.packageJson.devDependencies };
+    return Boolean(deps["next"]);
+  },
+  extract(ctx) {
+    const routes = [];
+    const routeFiles = /* @__PURE__ */ new Set();
+    for (const file of ctx.unitFiles()) {
+      const rel = relTo2(ctx.unit.dir, ctx.rel(file), ctx);
+      if (!rel) continue;
+      const parsed = routeFromFile(rel);
+      if (parsed) {
+        routes.push({ ...parsed, file });
+        routeFiles.add(file);
+      }
+    }
+    const clientLiterals = [];
+    for (const [file, pf] of ctx.graph.files) {
+      if (routeFiles.has(file)) continue;
+      for (const lit of pf.pathLiterals) clientLiterals.push({ value: lit.value, file });
+    }
+    const literalsMeaningful = clientLiterals.length >= CLIENT_LITERAL_THRESHOLD2;
+    const findings = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const route of routes) {
+      const key = `${route.method} ${route.routePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const rel = ctx.rel(route.file);
+      const finding = makeFinding(
+        "dead-route",
+        { kind: "route", method: route.method, path: route.routePath, framework: FRAMEWORK2 },
+        { file: rel, line: 1 },
+        ctx.unit.name,
+        `${route.method} ${route.routePath} is a Next.js route file; static analysis cannot observe whether it is visited`
+      );
+      if (literalsMeaningful && !route.routePath.includes("[")) {
+        const match = findPathMatch2(route.routePath, clientLiterals);
+        if (match) {
+          finding.evidence.push(
+            evidenceFor(
+              "static:client-path-match",
+              `'${match.value}' in ${ctx.rel(match.file)} links to this route`
+            )
+          );
+        } else {
+          finding.evidence.push(
+            evidenceFor(
+              "static:no-client-path-match",
+              `No <Link>/router/redirect literal among ${clientLiterals.length} in the repo matches this route`
+            )
+          );
+        }
+      } else if (route.routePath.includes("[")) {
+        finding.evidence.push(
+          evidenceFor(
+            "static:dynamic-route-prefix",
+            "Route has dynamic segments; client-link matching is unreliable"
+          )
+        );
+      }
+      findings.push(finding);
+    }
+    return { findings, counted: { routes: seen.size } };
+  }
+};
+function routeFromFile(rel) {
+  const m = /^(?:src\/)?(pages|app)\/(.+)\.(?:[jt]sx?)$/.exec(rel);
+  if (!m) return void 0;
+  const router = m[1];
+  let rest = m[2];
+  const segments = rest.split("/");
+  const basename = segments[segments.length - 1];
+  if (NON_ROUTE_BASENAMES.has(basename)) return void 0;
+  if (router === "app") {
+    if (basename !== "page" && basename !== "route") return void 0;
+    segments.pop();
+    const method = basename === "route" ? "ALL" : "GET";
+    return { routePath: toRoutePath(segments), method };
+  }
+  if (basename === "index") segments.pop();
+  const isApi = segments[0] === "api";
+  return { routePath: toRoutePath(segments), method: isApi ? "ALL" : "GET" };
+}
+function toRoutePath(segments) {
+  const kept = segments.filter((s) => !(s.startsWith("(") && s.endsWith(")")));
+  return "/" + kept.join("/");
+}
+function relTo2(unitDir, repoRel, ctx) {
+  const unitRel = ctx.rel(unitDir);
+  if (unitRel === "." || unitRel === "") return repoRel;
+  return repoRel.startsWith(unitRel + "/") ? repoRel.slice(unitRel.length + 1) : void 0;
+}
+function findPathMatch2(routePath, literals) {
+  return literals.find(
+    (l) => l.value === routePath || l.value.startsWith(routePath + "?") || l.value.startsWith(routePath + "#") || routePath !== "/" && l.value.startsWith(routePath + "/")
+  );
+}
+
+// ../core/src/evidence/dynamicImports.ts
+import path10 from "path";
+
+// ../core/src/evidence/types.ts
+function addOnce(finding, evidence) {
+  if (!finding.evidence.some((e) => e.signal === evidence.signal)) {
+    finding.evidence.push(evidence);
+  }
+}
+
+// ../core/src/evidence/dynamicImports.ts
+var dynamicImports = {
+  name: "dynamic-imports",
+  provide(ctx, findings) {
+    const targets = [];
+    for (const [file, pf] of ctx.graph.files) {
+      for (const pattern of pf.dynamicPatterns) {
+        targets.push({
+          dir: dynamicDir(file, pattern.prefix),
+          sourceFile: file,
+          line: pattern.line
+        });
+      }
+    }
+    if (targets.length === 0) return;
+    for (const finding of findings) {
+      if (finding.category === "unused-dependency") continue;
+      const findingFile = ctx.abs(finding.location.file);
+      const findingDir = dirnamePosix(findingFile);
+      const exact = targets.find((t) => t.dir === findingDir);
+      const under = exact ?? targets.find((t) => isUnder(t.dir, findingFile));
+      if (!under) continue;
+      addOnce(
+        finding,
+        evidenceFor(
+          exact ? "static:dynamic-import-exact-dir" : "static:dynamic-import-in-dir",
+          `Dynamic import/require at ${ctx.rel(under.sourceFile)}:${under.line} may load this file at runtime`,
+          { file: ctx.rel(under.sourceFile), line: under.line }
+        )
+      );
+    }
+  }
+};
+function dynamicDir(containingFile, prefix) {
+  const baseDir = dirnamePosix(containingFile);
+  if (!prefix || !prefix.startsWith(".")) return baseDir;
+  const resolved = toPosix(path10.resolve(baseDir, prefix));
+  return prefix.endsWith("/") ? resolved : dirnamePosix(resolved);
+}
+
+// ../core/src/evidence/stringDispatch.ts
+import ts5 from "typescript";
+var stringDispatch = {
+  name: "string-dispatch",
+  provide(ctx, findings) {
+    const bySymbol = indexExportFindings(ctx, findings);
+    if (bySymbol.size === 0) return;
+    for (const [file, pf] of ctx.graph.files) {
+      const importedLocals = /* @__PURE__ */ new Map();
+      for (const imp of pf.imports) {
+        if (!imp.resolvedFile) continue;
+        for (const n of imp.names) {
+          importedLocals.set(n.local, { file: imp.resolvedFile, imported: n.imported });
+        }
+      }
+      if (importedLocals.size === 0) continue;
+      const visit = (node) => {
+        if (ts5.isObjectLiteralExpression(node) && node.properties.length >= 2) {
+          for (const prop of node.properties) {
+            let local;
+            if (ts5.isShorthandPropertyAssignment(prop)) local = prop.name.text;
+            else if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.initializer)) {
+              local = prop.initializer.text;
+            }
+            const ref = local ? importedLocals.get(local) : void 0;
+            if (ref) {
+              const finding = bySymbol.get(`${ctx.rel(ref.file)}#${ref.imported}`);
+              if (finding) {
+                addOnce(
+                  finding,
+                  evidenceFor(
+                    "static:string-dispatch",
+                    `'${ref.imported}' appears in a dispatch table in ${ctx.rel(file)}`
+                  )
+                );
+              }
+            }
+          }
+        }
+        ts5.forEachChild(node, visit);
+      };
+      ts5.forEachChild(pf.ast, visit);
+    }
+  }
+};
+function indexExportFindings(ctx, findings) {
+  const index = /* @__PURE__ */ new Map();
+  for (const f of findings) {
+    if (f.category === "unused-export" && f.target.kind === "export") {
+      index.set(`${f.target.file}#${f.target.symbol}`, f);
+    }
+  }
+  return index;
+}
+
+// ../core/src/evidence/packageScripts.ts
+var packageScripts = {
+  name: "package-scripts",
+  provide(ctx, findings) {
+    for (const finding of findings) {
+      if (finding.category !== "unused-dependency" || finding.target.kind !== "dependency")
+        continue;
+      const depName = finding.target.name;
+      const unit = ctx.units.find((u) => u.name === finding.workspace) ?? ctx.units[0];
+      const hit = scriptReferencing(unit, depName) ?? scriptReferencing(ctx.units[0], depName);
+      if (hit) {
+        addOnce(
+          finding,
+          evidenceFor(
+            "static:script-reference",
+            `Referenced by package.json script '${hit.script}': ${truncate(hit.command)}`
+          )
+        );
+      }
+    }
+  }
+};
+function scriptReferencing(unit, depName) {
+  const binName = depName.includes("/") ? depName.split("/").pop() : depName;
+  const re = new RegExp(`(^|[\\s"'=/])${escapeRe(binName)}($|[\\s"'@])`);
+  for (const [script, command] of Object.entries(unit.packageJson.scripts ?? {})) {
+    if (command.includes(depName) || re.test(command)) return { script, command };
+  }
+  return void 0;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function truncate(s) {
+  return s.length > 60 ? s.slice(0, 57) + "\u2026" : s;
+}
+
+// ../core/src/evidence/jobRegistration.ts
+import ts6 from "typescript";
+var JOB_PACKAGES = /* @__PURE__ */ new Set([
+  "node-cron",
+  "cron",
+  "bull",
+  "bullmq",
+  "agenda",
+  "bree",
+  "node-schedule",
+  "toad-scheduler"
+]);
+var JOB_CALL_NAMES = /* @__PURE__ */ new Set(["schedule", "scheduleJob", "process", "add", "every"]);
+var JOB_CTOR_NAMES = /* @__PURE__ */ new Set(["Queue", "Worker", "CronJob", "Agenda", "Bree"]);
+var jobRegistration = {
+  name: "job-registration",
+  provide(ctx, findings) {
+    const jobFiles = /* @__PURE__ */ new Map();
+    for (const [file, pf] of ctx.graph.files) {
+      const jobPkg = pf.imports.map((i) => i.resolvedPackage ?? packageNameOf(i.specifier)).find((p) => JOB_PACKAGES.has(p));
+      if (jobPkg && registersJobs(pf.ast)) jobFiles.set(file, jobPkg);
+    }
+    if (jobFiles.size === 0) return;
+    for (const finding of findings) {
+      if (finding.category === "unused-dependency") continue;
+      const pkg2 = jobFiles.get(ctx.abs(finding.location.file));
+      if (pkg2) {
+        addOnce(
+          finding,
+          evidenceFor(
+            "static:job-registration",
+            `File registers scheduled work via '${pkg2}' \u2014 it may run without ever being imported`
+          )
+        );
+      }
+    }
+  }
+};
+function registersJobs(ast) {
+  let found = false;
+  const visit = (node) => {
+    if (found) return;
+    if (ts6.isCallExpression(node) && ts6.isPropertyAccessExpression(node.expression) && JOB_CALL_NAMES.has(node.expression.name.text)) {
+      found = true;
+      return;
+    }
+    if (ts6.isNewExpression(node)) {
+      const callee = node.expression;
+      const name = ts6.isIdentifier(callee) ? callee.text : ts6.isPropertyAccessExpression(callee) ? callee.name.text : void 0;
+      if (name && JOB_CTOR_NAMES.has(name)) {
+        found = true;
+        return;
+      }
+    }
+    ts6.forEachChild(node, visit);
+  };
+  ts6.forEachChild(ast, visit);
+  return found;
+}
+
+// ../core/src/evidence/comments.ts
+var PROXIMITY_LINES = 3;
+var comments = {
+  name: "comments",
+  provide(ctx, findings) {
+    for (const finding of findings) {
+      const pf = ctx.graph.files.get(ctx.abs(finding.location.file));
+      if (!pf || pf.commentMarkers.length === 0) continue;
+      for (const marker of pf.commentMarkers) {
+        const near = Math.abs(marker.line - finding.location.line) <= PROXIMITY_LINES || // Whole-file findings: a marker anywhere in the first lines of the file.
+        finding.category === "unreachable-file" && marker.line <= PROXIMITY_LINES + 1;
+        if (!near) continue;
+        addOnce(
+          finding,
+          evidenceFor(
+            marker.type === "deprecated" ? "static:deprecated-jsdoc" : "static:removal-comment",
+            `${marker.type === "deprecated" ? "Deprecation" : "Removal"} marker at line ${marker.line}: ${truncate2(marker.text)}`,
+            { file: finding.location.file, line: marker.line }
+          )
+        );
+      }
+    }
+  }
+};
+function truncate2(s) {
+  return s.length > 70 ? s.slice(0, 67) + "\u2026" : s;
+}
+
+// ../core/src/evidence/manifestReference.ts
+var manifestReference = {
+  name: "manifest-reference",
+  provide(ctx, findings) {
+    if (ctx.manifestCallers.length === 0) return;
+    const byFile = new Map(ctx.manifestCallers.map((c) => [c.file, c]));
+    for (const finding of findings) {
+      if (finding.category === "unused-dependency") continue;
+      const caller = byFile.get(ctx.abs(finding.location.file));
+      if (caller) {
+        addOnce(
+          finding,
+          evidenceFor("static:manifest-reference", `${caller.detail} (${caller.manifest})`)
+        );
+      }
+    }
+  }
+};
+
+// ../core/src/scoring/score.ts
+function levelFor(score) {
+  if (score >= 80) return "high";
+  if (score >= 50) return "medium";
+  return "low";
+}
+function scoreFinding(category, evidence) {
+  const raw = evidence.reduce((sum, e) => sum + e.weight, 0);
+  const allStatic = evidence.every((e) => e.source === "static");
+  const cap = allStatic ? STATIC_CAPS[category] : 100;
+  const score = Math.max(0, Math.min(cap, Math.round(raw)));
+  const result = { score, level: levelFor(score) };
+  if (allStatic && raw > cap) {
+    result.capped = { at: cap, reason: STATIC_CAP_REASON };
+  }
+  return result;
+}
+
+// ../core/src/index.ts
+var DEFAULT_INCLUDE = ["**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}"];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/out/**",
+  "**/coverage/**",
+  "**/.git/**",
+  "**/.next/**",
+  "**/vendor/**",
+  "**/*.d.ts",
+  "**/*.min.js"
+];
+var ALL_CATEGORIES = [
+  "dead-route",
+  "unused-export",
+  "unused-dependency",
+  "unreachable-file"
+];
+var DETECTORS = [
+  expressRoutes,
+  nestRoutes,
+  nextRoutes,
+  unreachableFiles,
+  unusedExports,
+  unusedDeps
+];
+var FRAMEWORK_DETECTORS = {
+  express: expressRoutes,
+  fastify: expressRoutes,
+  nest: nestRoutes,
+  next: nextRoutes
+};
+var PROVIDERS = [
+  dynamicImports,
+  stringDispatch,
+  packageScripts,
+  jobRegistration,
+  manifestReference,
+  comments
+];
+async function scan(options) {
+  const startedAt = Date.now();
+  const root = absPosix(options.path);
+  if (!fs8.existsSync(root) || !fs8.statSync(root).isDirectory()) {
+    throw new ScanError("INVALID_PATH", `Not a directory: ${options.path}`);
+  }
+  const warnings = [];
+  const { units: allUnits, warnings: wsWarnings } = await discoverWorkspaces(root);
+  warnings.push(...wsWarnings);
+  const units = options.workspaces && options.workspaces.length > 0 ? allUnits.filter((u, i) => i === 0 || options.workspaces.includes(u.name)) : allUnits;
+  const files = await glob2([...DEFAULT_INCLUDE, ...options.include ?? []], {
+    cwd: root,
+    ignore: [...DEFAULT_EXCLUDE, ...options.exclude ?? []],
+    absolute: true,
+    dot: true
+  });
+  if (files.length === 0) {
+    throw new ScanError("NO_SOURCE_FILES", `No JS/TS source files found under ${options.path}`);
+  }
+  const graph = new ModuleGraph();
+  for (const file of files.map(toPosix).sort()) {
+    try {
+      graph.addFile(parseFile(file, fs8.readFileSync(file, "utf8")));
+    } catch {
+      warnings.push(`Could not parse ${relPosix(root, file)}; it is excluded from analysis.`);
+    }
+  }
+  const scannedFiles = new Set(graph.files.keys());
+  const wsEntries = units.filter((u) => u.name !== ".").map((u) => ({ name: u.name, dir: u.dir, entryFile: guessUnitEntry(u, scannedFiles) }));
+  graph.link(new Resolver(root, wsEntries, scannedFiles, warnings));
+  const manifestCallers = await collectManifestCallers(root, scannedFiles, warnings);
+  const entriesByUnit = /* @__PURE__ */ new Map();
+  for (const unit of units) {
+    entriesByUnit.set(unit, discoverEntryPoints(unit, scannedFiles, warnings));
+  }
+  const rootUnit = units[0];
+  for (const caller of manifestCallers) {
+    pushEntry(entriesByUnit, unitForFile(units, caller.file), {
+      file: caller.file,
+      reason: "manifest",
+      detail: caller.detail
+    });
+  }
+  for (const ref of options.entries ?? []) {
+    const resolved = resolveEntryRef(root, ref, scannedFiles) ?? tryFile(path11.resolve(root, ref));
+    if (resolved) {
+      pushEntry(entriesByUnit, unitForFile(units, toPosix(resolved)), {
+        file: toPosix(resolved),
+        reason: "cli-flag",
+        detail: "--entry"
+      });
+    } else {
+      warnings.push(`--entry '${ref}' does not match a scanned file.`);
+    }
+  }
+  for (const unit of units) {
+    const eps = entriesByUnit.get(unit);
+    if (!eps.some((e) => e.tag !== "test" && e.reason !== "config")) {
+      const guess = guessUnitEntry(unit, scannedFiles);
+      if (guess)
+        pushEntry(entriesByUnit, unit, { file: guess, reason: "main", detail: "convention" });
+    }
+  }
+  const allEntryPoints = [...entriesByUnit.values()].flat();
+  const reach = {
+    all: graph.reachable(allEntryPoints.map((e) => e.file)),
+    prod: graph.reachable(allEntryPoints.filter((e) => e.tag !== "test").map((e) => e.file))
+  };
+  const resolvedOptions = {
+    categories: new Set(options.categories?.length ? options.categories : ALL_CATEGORIES),
+    frameworks: new Set(options.frameworks ?? [])
+  };
+  const fileOwner = /* @__PURE__ */ new Map();
+  for (const file of scannedFiles) fileOwner.set(file, unitForFile(units, file));
+  let findings = [];
+  let routesTotal = 0;
+  for (const unit of units) {
+    const ctx = {
+      root,
+      units,
+      unit,
+      graph,
+      entryPoints: allEntryPoints,
+      unitEntryPoints: entriesByUnit.get(unit) ?? [],
+      manifestCallers,
+      reach,
+      options: resolvedOptions,
+      warnings,
+      rel: (file) => relPosix(root, file),
+      unitFiles: () => [...scannedFiles].filter((f) => fileOwner.get(f) === unit)
+    };
+    const forcedDetectors = new Set(
+      [...resolvedOptions.frameworks].map((f) => FRAMEWORK_DETECTORS[f]).filter(Boolean)
+    );
+    for (const detector of DETECTORS) {
+      if (!forcedDetectors.has(detector) && !detector.detect(unit)) continue;
+      const result = detector.extract(ctx);
+      findings.push(...result.findings);
+      routesTotal += result.counted?.routes ?? 0;
+    }
+  }
+  const providerCtx = {
+    root,
+    units,
+    graph,
+    manifestCallers,
+    entryPoints: allEntryPoints,
+    warnings,
+    rel: (file) => relPosix(root, file),
+    abs: (relPath) => `${root}/${relPath}`
+  };
+  for (const provider of PROVIDERS) {
+    provider.provide(providerCtx, findings);
+  }
+  for (const finding of findings) {
+    finding.confidence = scoreFinding(finding.category, finding.evidence);
+  }
+  findings = findings.filter((f) => !(f.category === "dead-route" && f.evidence.length === 1));
+  findings = findings.filter((f) => resolvedOptions.categories.has(f.category));
+  const categoryOrder = new Map(ALL_CATEGORIES.map((c, i) => [c, i]));
+  findings.sort(
+    (a, b) => categoryOrder.get(a.category) - categoryOrder.get(b.category) || b.confidence.score - a.confidence.score || a.location.file.localeCompare(b.location.file) || a.location.line - b.location.line
+  );
+  return {
+    schemaVersion: 1,
+    tool: { name: "deadwood", version: options.toolVersion ?? "0.0.0" },
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    root,
+    workspaces: units.map((u) => u.name),
+    findings,
+    stats: computeStats(graph, units, findings, routesTotal, Date.now() - startedAt),
+    warnings: [...new Set(warnings)]
+  };
+}
+function pushEntry(map, unit, entry) {
+  const list = map.get(unit);
+  if (!list) {
+    map.set(unit, [entry]);
+  } else if (!list.some((e) => e.file === entry.file)) {
+    list.push(entry);
+  }
+}
+function guessUnitEntry(unit, scannedFiles) {
+  if (typeof unit.packageJson.main === "string") {
+    const mapped = resolveEntryRef(unit.dir, unit.packageJson.main, scannedFiles);
+    if (mapped) return mapped;
+  }
+  for (const candidate of ["src/index", "index", "src/main", "src/app", "app", "server", "main"]) {
+    const hit = tryFile(path11.join(unit.dir, candidate));
+    if (hit && scannedFiles.has(toPosix(hit))) return toPosix(hit);
+  }
+  return void 0;
+}
+async function collectManifestCallers(root, scannedFiles, warnings) {
+  const callers = [];
+  const manifestFiles = await glob2(
+    [
+      ".github/workflows/*.{yml,yaml}",
+      "**/*.{yml,yaml}",
+      "**/Dockerfile*",
+      "**/crontab",
+      "**/*.cron",
+      "**/cron.d/**",
+      "webpack.config.{js,cjs,mjs,ts}"
+    ],
+    { cwd: root, ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"], dot: true }
+  );
+  for (const rel of manifestFiles.map(toPosix).sort()) {
+    try {
+      if (rel.startsWith(".github/workflows/")) {
+        callers.push(...parseGithubWorkflow(root, rel, warnings));
+      } else if (/(^|\/)serverless\.(yml|yaml)$/.test(rel)) {
+        callers.push(...parseServerless(root, rel, warnings));
+      } else if (/\.(yml|yaml)$/.test(rel)) {
+        callers.push(...parseK8sManifest(root, rel, warnings));
+      } else if (/(^|\/)Dockerfile/.test(rel)) {
+        callers.push(...parseDockerfile(root, rel));
+      } else if (isCrontabFile(rel)) {
+        callers.push(...parseCrontab(root, rel));
+      } else if (/(^|\/)webpack\.config\./.test(rel)) {
+        callers.push(...parseWebpackConfig(root, rel));
+      }
+    } catch {
+      warnings.push(`Could not read manifest ${rel}; its callers are unknown.`);
+    }
+  }
+  return callers.filter((c) => scannedFiles.has(c.file));
+}
+function computeStats(graph, units, findings, routesTotal, durationMs) {
+  const flagged = (category) => findings.filter((f) => f.category === category && f.confidence.score >= 50).length;
+  let exportsTotal = 0;
+  for (const pf of graph.files.values()) {
+    exportsTotal += new Set(pf.exports.map((e) => e.name)).size;
+  }
+  let depsTotal = 0;
+  for (const u of units) {
+    depsTotal += Object.keys(u.packageJson.dependencies ?? {}).length + Object.keys(u.packageJson.devDependencies ?? {}).length;
+  }
+  return {
+    filesScanned: graph.files.size,
+    durationMs,
+    routes: { total: routesTotal, flagged: flagged("dead-route") },
+    exports: { total: exportsTotal, flagged: flagged("unused-export") },
+    dependencies: { total: depsTotal, flagged: flagged("unused-dependency") },
+    files: { total: graph.files.size, flagged: flagged("unreachable-file") }
+  };
+}
+
+// src/failOn.ts
+var LEVEL_RANK = { low: 0, medium: 1, high: 2 };
+function parseFailOn(spec) {
+  const m = /^(high|medium|low)(?::(\d+))?$/.exec(spec);
+  if (!m) {
+    throw new Error(`Invalid --fail-on '${spec}' (expected e.g. 'high', 'medium', 'high:5')`);
+  }
+  return { level: m[1], min: m[2] ? Number(m[2]) : 1 };
+}
+function evaluateFailOn(findings, spec) {
+  const count = findings.filter(
+    (f) => LEVEL_RANK[f.confidence.level] >= LEVEL_RANK[spec.level]
+  ).length;
+  return { count, tripped: count >= spec.min };
+}
+
+// src/reporters/json.ts
+function renderJson(result) {
+  return JSON.stringify(result, null, 2) + "\n";
+}
+
+// src/reporters/md.ts
+var CATEGORY_TITLES = {
+  "dead-route": "Routes that appear dead",
+  "unused-export": "Exports that appear unused",
+  "unused-dependency": "Dependencies that appear unused",
+  "unreachable-file": "Files that appear unreachable"
+};
+function renderMd(result) {
+  const lines = [];
+  const { stats } = result;
+  lines.push(`## \u2620 deadwood report`);
+  lines.push("");
+  if (stats.routes.total > 0) {
+    const pct = Math.round(stats.routes.flagged / stats.routes.total * 100);
+    lines.push(
+      `**${pct}% of routes appear dead** (${stats.routes.flagged} of ${stats.routes.total})`
+    );
+  }
+  const summary = [];
+  if (stats.exports.total > 0) summary.push(`${stats.exports.flagged} unused exports`);
+  if (stats.dependencies.total > 0)
+    summary.push(`${stats.dependencies.flagged} unused dependencies`);
+  if (stats.files.total > 0) summary.push(`${stats.files.flagged} unreachable files`);
+  if (summary.length > 0)
+    lines.push(`${summary.join(" \xB7 ")} \u2014 ${stats.filesScanned} files scanned`);
+  lines.push("");
+  for (const category of Object.keys(CATEGORY_TITLES)) {
+    const group = result.findings.filter((f) => f.category === category);
+    if (group.length === 0) continue;
+    lines.push(`### ${CATEGORY_TITLES[category]} (${group.length})`);
+    lines.push("");
+    lines.push("| Confidence | Target | Location | Top evidence |");
+    lines.push("|---|---|---|---|");
+    for (const f of group) {
+      const top = [...f.evidence].sort((a, b) => Math.abs(b.weight) - Math.abs(a.weight))[0];
+      lines.push(
+        `| ${f.confidence.score} ${f.confidence.level} | ${escapeMd(describeTarget(f.target))} | \`${f.location.file}:${f.location.line}\` | ${escapeMd(top?.detail ?? "")} |`
+      );
+    }
+    lines.push("");
+  }
+  if (result.findings.some((f) => f.confidence.capped)) {
+    lines.push(
+      `> \u26A0 Confidence is capped for static-only findings \u2014 no runtime evidence. Connect production telemetry to confirm.`
+    );
+    lines.push("");
+  }
+  for (const warning of result.warnings) {
+    lines.push(`> \u26A0 ${escapeMd(warning)}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function escapeMd(s) {
+  return s.replace(/\|/g, "\\|");
+}
+
+// src/reporters/pretty.ts
+import pc from "picocolors";
+var CATEGORY_TITLES2 = {
+  "dead-route": "ROUTES THAT APPEAR DEAD",
+  "unused-export": "EXPORTS THAT APPEAR UNUSED",
+  "unused-dependency": "DEPENDENCIES THAT APPEAR UNUSED",
+  "unreachable-file": "FILES THAT APPEAR UNREACHABLE"
+};
+var RULE_WIDTH = 72;
+function renderPretty(result, useColor) {
+  const c = pc.createColors(useColor);
+  const lines = [];
+  const { stats } = result;
+  lines.push("");
+  lines.push(`  ${c.bold("\u2620 deadwood")} ${c.dim(`v${result.tool.version}`)}`);
+  const meta = [
+    `${stats.filesScanned} files scanned`,
+    formatDuration(stats.durationMs),
+    result.workspaces.length > 1 ? `${result.workspaces.length} workspaces` : void 0
+  ].filter(Boolean);
+  lines.push(`  ${c.dim(meta.join("  \xB7  "))}`);
+  lines.push(`  ${c.dim("\u2500".repeat(RULE_WIDTH))}`);
+  lines.push("");
+  pushShock(lines, c, stats.routes, "of your routes appear dead", true);
+  pushShock(lines, c, stats.exports, "exports appear unused");
+  pushShock(lines, c, stats.dependencies, "dependencies appear unused");
+  pushShock(lines, c, stats.files, "files appear unreachable");
+  if (result.findings.length === 0) {
+    lines.push(
+      `  ${c.green("\u2713")} No dead code findings. Either pristine \u2014 or hiding from static analysis.`
+    );
+  }
+  for (const category of Object.keys(CATEGORY_TITLES2)) {
+    const group = result.findings.filter((f) => f.category === category);
+    if (group.length === 0) continue;
+    const actionable = group.filter((f) => f.confidence.score >= 50).length;
+    const counts = actionable === group.length ? `${group.length}` : `${group.length} \xB7 ${actionable} actionable`;
+    lines.push("");
+    lines.push(sectionRule(c, CATEGORY_TITLES2[category], counts));
+    lines.push("");
+    for (const finding of group) {
+      const lv = finding.confidence.level;
+      lines.push(
+        `  ${dot(c, lv)} ${scoreLabel(c, finding.confidence.score, lv)} ${c.dim("\u2502")} ${c.bold(
+          describeTarget(finding.target)
+        )}`
+      );
+      lines.push(
+        `               ${c.dim("\u2502")} ${c.dim(`${finding.location.file}:${finding.location.line}`)}`
+      );
+      const top = topEvidence(finding);
+      for (const ev of top) {
+        const mark = ev.direction === "kill" ? c.red("\u25AA") : c.yellow("\u25AB");
+        lines.push(`               ${c.dim("\u2502")} ${mark} ${c.dim(ev.detail)}`);
+      }
+      const more = finding.evidence.length - top.length;
+      if (more > 0) {
+        lines.push(
+          `               ${c.dim("\u2502")} ${c.dim(`\u2026 ${more} more signal${more > 1 ? "s" : ""} (see --json)`)}`
+        );
+      }
+      lines.push("");
+    }
+  }
+  lines.push(`  ${c.dim("\u2500".repeat(RULE_WIDTH))}`);
+  const anyStaticOnly = result.findings.some((f) => f.evidence.every((e) => e.source === "static"));
+  if (anyStaticOnly) {
+    lines.push(
+      `  ${c.yellow("\u26A0")} Confidence is capped for static-only findings ${c.dim("(routes 70, others 85)")} \u2014`
+    );
+    lines.push(`    no runtime evidence. Connect production telemetry to confirm.`);
+  }
+  if (result.findings.some((f) => f.confidence.score < 50)) {
+    lines.push(
+      `  ${c.dim("\u2139")} ${c.dim("actionable = medium confidence or higher; headline counts only these")}`
+    );
+  }
+  for (const warning of result.warnings) {
+    lines.push(`  ${c.yellow("\u26A0")} ${c.dim(warning)}`);
+  }
+  lines.push("");
+  lines.push(
+    `  ${c.dim("\u2192 --min-confidence medium  \xB7  --json for machines  \xB7  --fail-on high for CI")}`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function pushShock(lines, c, stat, label, withPercent = false) {
+  if (stat.total === 0) return;
+  const skull = stat.flagged > 0 ? c.red("\u2620") : c.green("\u2713");
+  if (withPercent) {
+    const pct = Math.round(stat.flagged / stat.total * 100);
+    lines.push(
+      `  ${skull} ${c.bold(`${pct}%`)} ${label} ${c.dim(`(${stat.flagged} of ${stat.total})`)}`
+    );
+  } else {
+    lines.push(`  ${skull} ${c.bold(String(stat.flagged))} ${c.dim("of")} ${stat.total} ${label}`);
+  }
+}
+function sectionRule(c, title, counts) {
+  const fill = Math.max(2, RULE_WIDTH - title.length - counts.length - 8);
+  return `  ${c.dim("\u2500\u2500")} ${c.bold(title)} ${c.dim("\u2500".repeat(fill))} ${c.dim(counts)}`;
+}
+function dot(c, level) {
+  if (level === "high") return c.red("\u25CF");
+  if (level === "medium") return c.yellow("\u25CF");
+  return c.dim("\u25CB");
+}
+function scoreLabel(c, score, level) {
+  const text = `${String(score).padStart(3)} ${level.padEnd(6)}`;
+  if (level === "high") return c.red(c.bold(text));
+  if (level === "medium") return c.yellow(text);
+  return c.dim(text);
+}
+function topEvidence(finding) {
+  return [...finding.evidence].sort((a, b) => Math.abs(b.weight) - Math.abs(a.weight)).slice(0, 2);
+}
+function formatDuration(ms) {
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+
+// src/index.ts
+var pkg = createRequire(import.meta.url)("../package.json");
+var CATEGORIES = [
+  "dead-route",
+  "unused-export",
+  "unused-dependency",
+  "unreachable-file"
+];
+var LEVEL_RANK2 = { low: 0, medium: 1, high: 2 };
+var program = new Command();
+program.name("deadwood").description("Find dead code and prove it \u2014 scans a JS/TS repo and prints a shock report").version(pkg.version).argument("[path]", "directory to scan", ".").option("--json", "machine-readable ScanResult on stdout").option("--md", "markdown report (PR comments / Slack)").option("--fail-on <spec>", "CI gate: 'high', 'medium', or 'high:5' (exit 1 when tripped)").option("--include <glob...>", "extra include globs").option("--exclude <glob...>", "extra exclude globs").addOption(new Option("--category <category...>", "limit findings").choices(CATEGORIES)).option("--workspace <name...>", "limit monorepo scan to these packages").addOption(
+  new Option("--framework <framework...>", "force route framework detection").choices([
+    "express",
+    "fastify",
+    "nest",
+    "next"
+  ])
+).option("--entry <file...>", "extra entry points (false-positive escape hatch)").addOption(
+  new Option("--min-confidence <level>", "hide findings below this level").choices(["low", "medium", "high"]).default("low")
+).option("--no-color", "disable colors").action(async (path12, opts) => {
+  await run(path12, opts);
+});
+async function run(path12, opts) {
+  if (opts.json && opts.md) {
+    process.stderr.write("error: --json and --md are mutually exclusive\n");
+    process.exitCode = 2;
+    return;
+  }
+  const failOnSpec = (() => {
+    try {
+      return opts.failOn ? parseFailOn(opts.failOn) : void 0;
+    } catch (err) {
+      process.stderr.write(`error: ${err.message}
+`);
+      process.exitCode = 2;
+      return null;
+    }
+  })();
+  if (failOnSpec === null) return;
+  const machineOutput = Boolean(opts.json || opts.md);
+  const spinner = ora({
+    text: "scanning\u2026",
+    stream: process.stderr,
+    isEnabled: !machineOutput && process.stderr.isTTY === true
+  });
+  try {
+    spinner.start();
+    const result = await scan({
+      path: path12,
+      include: opts.include,
+      exclude: opts.exclude,
+      categories: opts.category,
+      frameworks: opts.framework,
+      entries: opts.entry,
+      workspaces: opts.workspace,
+      toolVersion: pkg.version
+    });
+    spinner.stop();
+    const gate = failOnSpec ? evaluateFailOn(result.findings, failOnSpec) : void 0;
+    const displayed = filterForDisplay(result, opts.minConfidence);
+    const useColor = opts.color && pc2.isColorSupported && process.stdout.isTTY === true;
+    const output = opts.json ? renderJson(displayed) : opts.md ? renderMd(displayed) : renderPretty(displayed, useColor);
+    process.stdout.write(output);
+    if (opts.json) {
+      for (const warning of result.warnings) process.stderr.write(`warning: ${warning}
+`);
+    }
+    if (gate?.tripped) {
+      process.stderr.write(
+        `deadwood: --fail-on ${opts.failOn} tripped (${gate.count} finding${gate.count === 1 ? "" : "s"} at/above '${failOnSpec.level}')
+`
+      );
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    spinner.stop();
+    if (err instanceof ScanError) {
+      process.stderr.write(`error (${err.code}): ${err.message}
+`);
+    } else {
+      process.stderr.write(
+        `error: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`
+      );
+    }
+    process.exitCode = 2;
+  }
+}
+function filterForDisplay(result, minConfidence) {
+  if (minConfidence === "low") return result;
+  const min = LEVEL_RANK2[minConfidence];
+  const findings = result.findings.filter((f) => LEVEL_RANK2[f.confidence.level] >= min);
+  return { ...result, findings };
+}
+await program.parseAsync(process.argv);
+//# sourceMappingURL=index.js.map