@wrongstack/tools 0.296.2 → 0.296.3

package/dist/codebase-index/index.js

@@ -255,11 +255,18 @@ async function parseSymbols(opts) {
     } else if (ts.isHeritageClause(node)) {
       for (const t of node.types) {
         const name = getTypeName(t.expression);
-        if (name) refs.push({ fromId: 0, toName: name, callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement", line: lineNum });
+        if (name)
+          refs.push({
+            fromId: 0,
+            toName: name,
+            callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement",
+            line: lineNum
+          });
       }
     } else if (ts.isImportDeclaration(node)) {
-      const moduleName = getModuleName(node);
-      if (moduleName) refs.push({ fromId: 0, toName: moduleName, callType: "import", line: lineNum });
+      emitImportSpecifierRefs(node, refs, lineNum);
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+      emitExportSpecifierRefs(node, refs, lineNum);
     }
     const scopeIdx = scopeParts.length;
     pushScopeName(node, scopeParts);
@@ -275,11 +282,6 @@ function getTypeName(name) {
   if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
   return "";
 }
-function getModuleName(node) {
-  const moduleSpecifier = node.moduleSpecifier;
-  if (ts.isStringLiteral(moduleSpecifier)) return moduleSpecifier.text;
-  return "";
-}
 function deduplicateRefs(refs) {
   const seen = /* @__PURE__ */ new Set();
   return refs.filter((r) => {
@@ -289,6 +291,44 @@ function deduplicateRefs(refs) {
     return true;
   });
 }
+function getImportSpecifierName(spec) {
+  return spec.propertyName?.text ?? spec.name.text;
+}
+function emitImportSpecifierRefs(node, refs, lineNum) {
+  const clause = node.importClause;
+  if (!clause) return;
+  if (clause.name) {
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum });
+  }
+  const bindings = clause.namedBindings;
+  if (!bindings) return;
+  if (ts.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      refs.push({
+        fromId: 0,
+        toName: getImportSpecifierName(element),
+        callType: "import",
+        line: lineNum
+      });
+    }
+  } else if (ts.isNamespaceImport(bindings)) {
+    refs.push({ fromId: 0, toName: bindings.name.text, callType: "import", line: lineNum });
+  }
+}
+function emitExportSpecifierRefs(node, refs, lineNum) {
+  const clause = node.exportClause;
+  if (clause && ts.isNamespaceExport(clause)) {
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum });
+    return;
+  }
+  if (clause && ts.isNamedExports(clause)) {
+    for (const element of clause.elements) {
+      const originalName = element.propertyName?.text ?? element.name.text;
+      refs.push({ fromId: 0, toName: originalName, callType: "import", line: lineNum });
+    }
+    return;
+  }
+}
 var ts, tsLoad, kindMapCache;
 var init_ts_parser = __esm({
   "src/codebase-index/ts-parser.ts"() {
@@ -2130,71 +2170,6 @@ import { expectDefined as expectDefined4 } from "@wrongstack/core/utils";
 import * as fs7 from "node:fs";
 import * as path10 from "node:path";
 
-// src/codebase-index/schema.ts
-var SCHEMA_VERSION = 3;
-
-// src/codebase-index/lsp-kind.ts
-function lspKindToInternalKind(k) {
-  switch (k) {
-    case 5 /* Class */:
-      return "class";
-    case 6 /* Method */:
-      return "method";
-    case 7 /* Property */:
-    case 8 /* Field */:
-      return "property";
-    case 9 /* Constructor */:
-      return "class";
-    case 10 /* Enum */:
-      return "enum";
-    case 11 /* Interface */:
-      return "interface";
-    case 12 /* Function */:
-      return "function";
-    case 13 /* Variable */:
-      return "var";
-    case 14 /* Constant */:
-      return "const";
-    case 22 /* EnumMember */:
-      return "enum";
-    case 26 /* TypeParameter */:
-      return "type";
-    case 3 /* Namespace */:
-      return "namespace";
-    default:
-      return null;
-  }
-}
-function internalKindToLspKind(k) {
-  switch (k) {
-    case "class":
-      return 5 /* Class */;
-    case "method":
-      return 6 /* Method */;
-    case "property":
-      return 7 /* Property */;
-    case "function":
-      return 12 /* Function */;
-    case "var":
-      return 13 /* Variable */;
-    case "const":
-      return 14 /* Constant */;
-    case "let":
-      return 13 /* Variable */;
-    case "enum":
-      return 10 /* Enum */;
-    case "interface":
-      return 11 /* Interface */;
-    case "namespace":
-      return 3 /* Namespace */;
-    case "type":
-      return 26 /* TypeParameter */;
-    // parameter and other internal-only kinds have no LSP equivalent
-    default:
-      return null;
-  }
-}
-
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
 var B = 0.75;
@@ -2284,6 +2259,71 @@ var Bm25Index = class {
   }
 };
 
+// src/codebase-index/lsp-kind.ts
+function lspKindToInternalKind(k) {
+  switch (k) {
+    case 5 /* Class */:
+      return "class";
+    case 6 /* Method */:
+      return "method";
+    case 7 /* Property */:
+    case 8 /* Field */:
+      return "property";
+    case 9 /* Constructor */:
+      return "class";
+    case 10 /* Enum */:
+      return "enum";
+    case 11 /* Interface */:
+      return "interface";
+    case 12 /* Function */:
+      return "function";
+    case 13 /* Variable */:
+      return "var";
+    case 14 /* Constant */:
+      return "const";
+    case 22 /* EnumMember */:
+      return "enum";
+    case 26 /* TypeParameter */:
+      return "type";
+    case 3 /* Namespace */:
+      return "namespace";
+    default:
+      return null;
+  }
+}
+function internalKindToLspKind(k) {
+  switch (k) {
+    case "class":
+      return 5 /* Class */;
+    case "method":
+      return 6 /* Method */;
+    case "property":
+      return 7 /* Property */;
+    case "function":
+      return 12 /* Function */;
+    case "var":
+      return 13 /* Variable */;
+    case "const":
+      return 14 /* Constant */;
+    case "let":
+      return 13 /* Variable */;
+    case "enum":
+      return 10 /* Enum */;
+    case "interface":
+      return 11 /* Interface */;
+    case "namespace":
+      return 3 /* Namespace */;
+    case "type":
+      return 26 /* TypeParameter */;
+    // parameter and other internal-only kinds have no LSP equivalent
+    default:
+      return null;
+  }
+}
+
+// src/codebase-index/schema.ts
+var SCHEMA_VERSION = 3;
+
 // src/codebase-index/sqlite-runtime.ts
 import { createRequire } from "node:module";
 import { toErrorMessage } from "@wrongstack/core/utils";
@@ -2351,96 +2391,6 @@ function runSqliteWithRetry(fn) {
   throw lastError;
 }
 
-// src/codebase-index/writer-helpers.ts
-import { resolveWstackPaths } from "@wrongstack/core/utils";
-function escapeLike(value) {
-  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
-}
-function assignRefsToSymbols(refs, symbols) {
-  if (refs.length === 0 || symbols.length === 0) return [];
-  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
-  const seen = /* @__PURE__ */ new Set();
-  const assigned = [];
-  for (const ref of refs) {
-    let owner;
-    for (const symbol of ordered) {
-      if (symbol.line > ref.line) break;
-      owner = symbol;
-    }
-    if (!owner && ref.callType === "import") owner = ordered[0];
-    if (!owner || owner.id <= 0) continue;
-    const key = `${owner.id}:${ref.toName}:${ref.callType}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    assigned.push({ ...ref, fromId: owner.id });
-  }
-  return assigned;
-}
-function resolveIndexDir(projectRoot, override) {
-  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
-}
-function codebaseIndexDirOverride(ctx) {
-  const v = ctx.meta?.["codebaseIndexDir"];
-  return typeof v === "string" ? v : void 0;
-}
-
-// src/codebase-index/writer-schema.ts
-var METADATA_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS metadata (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-`;
-var CORE_TABLES_SQL = `
-  CREATE TABLE IF NOT EXISTS files (
-    file TEXT PRIMARY KEY,
-    lang TEXT NOT NULL,
-    mtime_ms INTEGER NOT NULL,
-    symbol_count INTEGER NOT NULL DEFAULT 0,
-    last_indexed INTEGER NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS symbols (
-    id INTEGER PRIMARY KEY,
-    lang TEXT NOT NULL,
-    kind TEXT NOT NULL,
-    name TEXT NOT NULL,
-    file TEXT NOT NULL,
-    line INTEGER NOT NULL,
-    col INTEGER NOT NULL,
-    signature TEXT NOT NULL DEFAULT '',
-    doc_comment TEXT NOT NULL DEFAULT '',
-    scope TEXT NOT NULL DEFAULT '',
-    text TEXT NOT NULL DEFAULT '',
-    file_fk TEXT NOT NULL
-  );
-`;
-var SYMBOL_INDEX_SQL = [
-  "CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)",
-  "CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)",
-  "CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)",
-  "CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)",
-  "CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)",
-  "CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)",
-  "CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)"
-];
-var REFS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS refs (
-    id INTEGER PRIMARY KEY,
-    from_id INTEGER NOT NULL,
-    to_name TEXT NOT NULL,
-    to_id INTEGER,
-    call_type TEXT NOT NULL,
-    line INTEGER NOT NULL
-  );
-`;
-var REFS_INDEX_SQL = [
-  "CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)",
-  "CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)",
-  "CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)",
-  "CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)"
-];
-var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
-
 // src/codebase-index/writer-admin.ts
 import * as fs6 from "node:fs";
 import * as path8 from "node:path";
@@ -2913,6 +2863,39 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
   return { nodes, edges };
 }
 
+// src/codebase-index/writer-helpers.ts
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function assignRefsToSymbols(refs, symbols) {
+  if (refs.length === 0 || symbols.length === 0) return [];
+  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
+  const seen = /* @__PURE__ */ new Set();
+  const assigned = [];
+  for (const ref of refs) {
+    let owner;
+    for (const symbol of ordered) {
+      if (symbol.line > ref.line) break;
+      owner = symbol;
+    }
+    if (!owner && ref.callType === "import") owner = ordered[0];
+    if (!owner || owner.id <= 0) continue;
+    const key = `${owner.id}:${ref.toName}:${ref.callType}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    assigned.push({ ...ref, fromId: owner.id });
+  }
+  return assigned;
+}
+function resolveIndexDir(projectRoot, override) {
+  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+}
+function codebaseIndexDirOverride(ctx) {
+  const v = ctx.meta?.["codebaseIndexDir"];
+  return typeof v === "string" ? v : void 0;
+}
+
 // src/codebase-index/writer-pragmas.ts
 import { sqliteCachePragmas } from "@wrongstack/core/utils";
 function applyIndexStorePragmas(db) {
@@ -2931,6 +2914,63 @@ function applyIndexStorePragmas(db) {
   }
 }
 
+// src/codebase-index/writer-schema.ts
+var METADATA_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+var CORE_TABLES_SQL = `
+  CREATE TABLE IF NOT EXISTS files (
+    file TEXT PRIMARY KEY,
+    lang TEXT NOT NULL,
+    mtime_ms INTEGER NOT NULL,
+    symbol_count INTEGER NOT NULL DEFAULT 0,
+    last_indexed INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS symbols (
+    id INTEGER PRIMARY KEY,
+    lang TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    name TEXT NOT NULL,
+    file TEXT NOT NULL,
+    line INTEGER NOT NULL,
+    col INTEGER NOT NULL,
+    signature TEXT NOT NULL DEFAULT '',
+    doc_comment TEXT NOT NULL DEFAULT '',
+    scope TEXT NOT NULL DEFAULT '',
+    text TEXT NOT NULL DEFAULT '',
+    file_fk TEXT NOT NULL
+  );
+`;
+var SYMBOL_INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)",
+  "CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)",
+  "CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)",
+  "CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)",
+  "CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)",
+  "CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)",
+  "CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)"
+];
+var REFS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS refs (
+    id INTEGER PRIMARY KEY,
+    from_id INTEGER NOT NULL,
+    to_name TEXT NOT NULL,
+    to_id INTEGER,
+    call_type TEXT NOT NULL,
+    line INTEGER NOT NULL
+  );
+`;
+var REFS_INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)",
+  "CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)",
+  "CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)",
+  "CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)"
+];
+var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
+
 // src/codebase-index/writer-search-helpers.ts
 function normalizeSearchLimit(limit) {
   return typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : void 0;
@@ -3139,9 +3179,15 @@ var IndexStore = class _IndexStore {
         DROP TABLE IF EXISTS refs;
       `);
       this.db.exec("DROP TABLE IF EXISTS symbols_fts");
-      this.stmt("UPDATE metadata SET value = ? WHERE key = ?").run(String(SCHEMA_VERSION), "version");
+      this.stmt("UPDATE metadata SET value = ? WHERE key = ?").run(
+        String(SCHEMA_VERSION),
+        "version"
+      );
     } else if (storedVersion === null) {
-      this.stmt("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+      this.stmt("INSERT INTO metadata(key, value) VALUES (?, ?)").run(
+        "version",
+        String(SCHEMA_VERSION)
+      );
     }
     this.db.exec(CORE_TABLES_SQL);
     for (const sql of SYMBOL_INDEX_SQL) this.db.exec(sql);
@@ -3158,7 +3204,9 @@ var IndexStore = class _IndexStore {
       );
       if (symbolCount !== ftsCount) {
         this.db.exec("DELETE FROM symbols_fts");
-        const rows = this.stmt("SELECT id, name, signature, doc_comment FROM symbols ORDER BY id").all();
+        const rows = this.stmt(
+          "SELECT id, name, signature, doc_comment FROM symbols ORDER BY id"
+        ).all();
         bulkInsertFtsWithStatement(
           (sql) => this.stmt(sql),
           _IndexStore.MAX_SQL_VARS,
@@ -3380,7 +3428,9 @@ var IndexStore = class _IndexStore {
     const limitSql = limit !== void 0 ? " LIMIT ?" : "";
     const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment, text FROM symbols ${where}${limitSql}`;
     const binds = limit !== void 0 ? [...values, limit] : values;
-    const rows = this.stmt(sql).all(...binds);
+    const rows = this.stmt(sql).all(
+      ...binds
+    );
     return rows.map((row) => mapWriterSearchRow(row, filter?.lspKind));
   }
   /** Shared WHERE builder for {@link search} / empty-query ranked totals. */
@@ -3556,7 +3606,9 @@ var IndexStore = class _IndexStore {
   }
   setLastIndexed(ts2) {
     this.runWithRetry(() => {
-      this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(String(ts2));
+      this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(
+        String(ts2)
+      );
     });
   }
   getMetadata(key) {
@@ -3667,7 +3719,9 @@ var IndexStore = class _IndexStore {
           this.stmt(
             `DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
           ).run(...options.deleteForFiles);
-          this.stmt(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(...options.deleteForFiles);
+          this.stmt(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(
+            ...options.deleteForFiles
+          );
         }
         const totalSymbols = entries.reduce((n, e) => n + e.symbols.length, 0);
         let nextId = this.allocateSymbolIds(totalSymbols);
@@ -3711,11 +3765,7 @@ var IndexStore = class _IndexStore {
           this.ftsAvailable,
           ftsRows
         );
-        bulkInsertRefsWithStatement(
-          (sql) => this.stmt(sql),
-          _IndexStore.MAX_SQL_VARS,
-          refsToInsert
-        );
+        bulkInsertRefsWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, refsToInsert);
         const upsertStmt = this.stmt(
           `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
            VALUES (?, ?, ?, ?, ?)
@@ -3744,7 +3794,9 @@ var IndexStore = class _IndexStore {
    */
   deleteRefsForFile(file) {
     this.runWithRetry(() => {
-      this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(file);
+      this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(
+        file
+      );
     });
   }
   /**
@@ -3899,9 +3951,7 @@ var IndexStore = class _IndexStore {
    * build the full symbol universe for the reachability scan.
    */
   getAllSymbols() {
-    return this.stmt(
-      "SELECT id, name, file, kind, line FROM symbols ORDER BY id"
-    ).all().map((r) => ({ ...r, kind: r.kind }));
+    return this.stmt("SELECT id, name, file, kind, line FROM symbols ORDER BY id").all().map((r) => ({ ...r, kind: r.kind }));
   }
   /**
    * Returns every resolved reference (to_id IS NOT NULL). Used by
@@ -3913,6 +3963,25 @@ var IndexStore = class _IndexStore {
       "SELECT from_id AS fromId, to_id AS toId, call_type AS callType FROM refs WHERE to_id IS NOT NULL"
     ).all();
   }
+  /**
+   * Returns ALL import refs (including unresolved) with their source-file
+   * path and resolved target id.  Used by the dead-code scan's file-level
+   * graph traversal to handle barrel-only entry points where no symbol
+   * carries the ref.
+   *
+   * Refs whose `from_id` doesn't match a known symbol (e.g. pure-barrel
+   * files with no declarations) will have `sourceFile === null`.
+   */
+  getAllImportRefs() {
+    return this.stmt(
+      `SELECT s.file AS sourceFile, r.to_name AS toName, r.to_id AS toId,
+              r.call_type AS callType, r.line
+       FROM refs r
+       LEFT JOIN symbols s ON r.from_id = s.id
+       WHERE r.call_type = 'import'
+       ORDER BY r.line`
+    ).all();
+  }
   close() {
     this.stmtCache.clear();
     this.bm25Dirty = true;
@@ -5808,6 +5877,7 @@ var codebaseStatsTool = {
 };
 
 // src/codebase-index/dead-code-scan.ts
+init_languages();
 import * as fs12 from "node:fs";
 import * as path13 from "node:path";
 var deadCodeScanTool = {
@@ -5876,7 +5946,15 @@ function discoverEntryPoints(projectRoot, userEntryPoints) {
   if (rootPkg) {
     addPkgJsonEntryPoints(projectRoot, rootPkg, entries);
   }
-  const workspaces = rootPkg ? extractWorkspaceGlobs(rootPkg, projectRoot) : [];
+  let workspaces;
+  if (rootPkg) {
+    workspaces = extractWorkspaceGlobs(rootPkg, projectRoot);
+    if (workspaces.length === 0) {
+      workspaces = extractPnpmWorkspaceDirs(projectRoot);
+    }
+  } else {
+    workspaces = [];
+  }
   for (const wsDir of workspaces) {
     const pkgJsonPath = path13.join(wsDir, "package.json");
     const pkg = tryReadJson(pkgJsonPath);
@@ -5898,77 +5976,189 @@ function discoverEntryPoints(projectRoot, userEntryPoints) {
   }
   return [...entries];
 }
+var BUILD_OUTPUT_DIRS = ["dist", "out", "build", "release"];
+var BUILD_OUTPUT_DIR_NAMES = BUILD_OUTPUT_DIRS.map((d) => `${path13.sep}${d}${path13.sep}`);
+function trySourceEquivalent(resolved) {
+  resolved = resolved.replace(/[/\\]/g, path13.sep);
+  for (const marker of BUILD_OUTPUT_DIR_NAMES) {
+    const idx = resolved.indexOf(marker);
+    if (idx === -1) continue;
+    const base = resolved.replace(marker, `${path13.sep}src${path13.sep}`);
+    const candidate = base.replace(/\.(js|mjs|cjs)$/, ".ts");
+    if (candidate !== base && fs12.existsSync(candidate)) {
+      return candidate;
+    }
+    const dtsStripped = base.replace(/\.d\.ts$/, "");
+    const candidateDts = dtsStripped + ".ts";
+    if (candidateDts !== base && candidateDts !== candidate && fs12.existsSync(candidateDts)) {
+      return candidateDts;
+    }
+    const candidateNoExt = base + ".ts";
+    if (candidate !== candidateNoExt && candidateNoExt !== candidateDts && fs12.existsSync(candidateNoExt)) {
+      return candidateNoExt;
+    }
+  }
+  return null;
+}
+function tryAddEntryPath(pkgDir, rawPath, entries) {
+  const resolved = resolveAgainst(pkgDir, rawPath);
+  if (fs12.existsSync(resolved)) entries.add(resolved);
+  const tsResolved = resolved.replace(/\.(js|mjs|cjs)$/, ".ts");
+  if (tsResolved !== resolved && fs12.existsSync(tsResolved)) {
+    entries.add(tsResolved);
+  }
+  const srcAlt = trySourceEquivalent(resolved);
+  if (srcAlt) entries.add(srcAlt);
+}
 function addPkgJsonEntryPoints(pkgDir, pkg, entries) {
   if (typeof pkg.main === "string") {
-    const resolved = resolveAgainst(pkgDir, pkg.main);
-    if (fs12.existsSync(resolved)) entries.add(resolved);
-    const tsResolved = resolved.replace(/\.(js|mjs|cjs)$/, ".ts");
-    if (tsResolved !== resolved && fs12.existsSync(tsResolved)) {
-      entries.add(tsResolved);
-    }
+    tryAddEntryPath(pkgDir, pkg.main, entries);
   }
   const bin = pkg.bin;
   if (typeof bin === "string") {
-    const resolved = resolveAgainst(pkgDir, bin);
-    if (fs12.existsSync(resolved)) entries.add(resolved);
+    tryAddEntryPath(pkgDir, bin, entries);
   } else if (bin && typeof bin === "object") {
     for (const value of Object.values(bin)) {
       if (typeof value === "string") {
-        const resolved = resolveAgainst(pkgDir, value);
-        if (fs12.existsSync(resolved)) entries.add(resolved);
+        tryAddEntryPath(pkgDir, value, entries);
       }
     }
   }
   for (const key of ["types", "typings"]) {
     if (typeof pkg[key] === "string") {
-      const resolved = resolveAgainst(pkgDir, pkg[key]);
-      if (fs12.existsSync(resolved)) entries.add(resolved);
+      tryAddEntryPath(pkgDir, pkg[key], entries);
     }
   }
   const exports_ = pkg.exports;
   if (exports_ && typeof exports_ === "object") {
     for (const value of Object.values(exports_)) {
       if (typeof value === "string") {
-        const resolved = resolveAgainst(pkgDir, value);
-        if (fs12.existsSync(resolved)) entries.add(resolved);
+        tryAddEntryPath(pkgDir, value, entries);
       } else if (value && typeof value === "object") {
-        for (const nested of Object.values(
-          value
-        )) {
+        for (const nested of Object.values(value)) {
           if (typeof nested === "string") {
-            const resolved = resolveAgainst(pkgDir, nested);
-            if (fs12.existsSync(resolved)) entries.add(resolved);
+            tryAddEntryPath(pkgDir, nested, entries);
           }
         }
       }
     }
   }
 }
+function expandGlobPattern(entry, projectRoot) {
+  const dirs = [];
+  if (entry.includes("*")) {
+    const base = entry.replace(/\/\*+$/, "");
+    const baseDir = path13.resolve(projectRoot, base);
+    try {
+      const children = fs12.readdirSync(baseDir, { withFileTypes: true });
+      for (const child of children) {
+        if (child.isDirectory()) {
+          dirs.push(path13.join(baseDir, child.name));
+        }
+      }
+    } catch {
+    }
+  } else {
+    dirs.push(path13.resolve(projectRoot, entry));
+  }
+  return dirs;
+}
 function extractWorkspaceGlobs(pkg, projectRoot) {
   const dirs = [];
   const workspaces = pkg.workspaces;
   if (Array.isArray(workspaces)) {
     for (const entry of workspaces) {
       if (typeof entry === "string") {
-        if (entry.includes("*")) {
-          const base = entry.replace(/\/\*+$/, "");
-          const baseDir = path13.resolve(projectRoot, base);
-          try {
-            const children = fs12.readdirSync(baseDir, { withFileTypes: true });
-            for (const child of children) {
-              if (child.isDirectory()) {
-                dirs.push(path13.join(baseDir, child.name));
-              }
-            }
-          } catch {
+        dirs.push(...expandGlobPattern(entry, projectRoot));
+      }
+    }
+  }
+  return dirs;
+}
+function extractPnpmWorkspaceDirs(projectRoot) {
+  const yamlPath = path13.join(projectRoot, "pnpm-workspace.yaml");
+  if (!fs12.existsSync(yamlPath)) return [];
+  try {
+    const content = fs12.readFileSync(yamlPath, "utf8");
+    const dirs = [];
+    let inPackages = false;
+    const lines = content.split("\n");
+    const itemRe = /^\s+-\s+"([^"]+)"|^\s+-\s+'([^']+)'|^\s+-\s+(\S+)/;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (/^packages\s*:\s*$/.test(trimmed)) {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages && trimmed.length > 0 && !line.startsWith(" ") && !line.startsWith("	")) {
+        if (!trimmed.startsWith("-")) {
+          inPackages = false;
+          continue;
+        }
+      }
+      if (inPackages) {
+        const m = itemRe.exec(line);
+        if (m) {
+          const entry = m[1] ?? m[2] ?? m[3];
+          if (entry) {
+            dirs.push(...expandGlobPattern(entry, projectRoot));
           }
-        } else {
-          dirs.push(path13.resolve(projectRoot, entry));
         }
       }
     }
+    return dirs;
+  } catch {
+    return [];
   }
-  return dirs;
+}
+function resolveModulePath(importerPath, moduleSpecifier, indexedFiles) {
+  if (!moduleSpecifier.startsWith(".")) return [];
+  const dir = path13.dirname(importerPath);
+  const base = path13.resolve(dir, moduleSpecifier);
+  const results = [];
+  const stripped = base.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+  const skipBase = stripped !== base && /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(base);
+  const candidates = skipBase ? [stripped] : [base];
+  for (const candidate of candidates) {
+    if (indexedFiles.has(candidate + ".ts")) results.push(candidate + ".ts");
+    if (indexedFiles.has(candidate + ".tsx")) results.push(candidate + ".tsx");
+    if (indexedFiles.has(candidate + ".js")) results.push(candidate + ".js");
+    if (indexedFiles.has(candidate + ".jsx")) results.push(candidate + ".jsx");
+    if (indexedFiles.has(candidate + ".mjs")) results.push(candidate + ".mjs");
+    if (indexedFiles.has(candidate + ".cjs")) results.push(candidate + ".cjs");
+    if (indexedFiles.has(path13.join(candidate, "index.ts")))
+      results.push(path13.join(candidate, "index.ts"));
+    if (indexedFiles.has(path13.join(candidate, "index.tsx")))
+      results.push(path13.join(candidate, "index.tsx"));
+    if (indexedFiles.has(path13.join(candidate, "index.js")))
+      results.push(path13.join(candidate, "index.js"));
+    if (indexedFiles.has(path13.join(candidate, "index.jsx")))
+      results.push(path13.join(candidate, "index.jsx"));
+    if (indexedFiles.has(path13.join(candidate, "index.mjs")))
+      results.push(path13.join(candidate, "index.mjs"));
+    if (indexedFiles.has(path13.join(candidate, "index.cjs")))
+      results.push(path13.join(candidate, "index.cjs"));
+  }
+  return [...new Set(results)];
+}
+function parseNamedExportSymbols(matchText) {
+  const braceStart = matchText.indexOf("{");
+  if (braceStart === -1) return null;
+  const braceEnd = matchText.indexOf("}", braceStart);
+  if (braceEnd === -1) return null;
+  const inner = matchText.slice(braceStart + 1, braceEnd);
+  const symbols = [];
+  for (const part of inner.split(",")) {
+    let s = part.trim();
+    if (!s) continue;
+    s = s.replace(/^type\s+/, "");
+    const asIdx = s.search(/\s+as\s+/);
+    if (asIdx !== -1) {
+      s = s.slice(0, asIdx).trim();
+    }
+    if (s) symbols.push(s);
+  }
+  return symbols;
 }
 function runDeadCodeScan(projectRoot, opts = {}) {
   const store = opts.store ?? indexStorePool.acquire(projectRoot, { indexDir: opts.indexDir });
@@ -5990,12 +6180,71 @@ function runDeadCodeScan(projectRoot, opts = {}) {
     }
     const discoveredFiles = discoverEntryPoints(projectRoot, opts.userEntryPoints);
     const entryFileSet = new Set(discoveredFiles.map((f) => path13.resolve(f)));
+    const indexedFiles = /* @__PURE__ */ new Set();
+    for (const s of allSymbols) indexedFiles.add(s.file);
+    for (const fm of store.getAllFileMetas()) indexedFiles.add(fm.file);
     const seedIds = /* @__PURE__ */ new Set();
     for (const s of allSymbols) {
       if (entryFileSet.has(s.file)) {
         seedIds.add(s.id);
       }
     }
+    const fileToSymbolIds = /* @__PURE__ */ new Map();
+    for (const s of allSymbols) {
+      let byFile = fileToSymbolIds.get(s.file);
+      if (!byFile) {
+        byFile = [];
+        fileToSymbolIds.set(s.file, byFile);
+      }
+      byFile.push(s.id);
+    }
+    const scannedBarrels = /* @__PURE__ */ new Set();
+    const barrelWorkList = [...entryFileSet];
+    while (barrelWorkList.length > 0) {
+      const epFile = barrelWorkList.pop();
+      if (scannedBarrels.has(epFile)) continue;
+      scannedBarrels.add(epFile);
+      try {
+        const content = fs12.readFileSync(epFile, "utf8");
+        const strippedContent = content.replace(/\/\*[\s\S]*?\*\//g, (m) => " ".repeat(m.length)).replace(/\/\/[^\n]*/g, (m) => " ".repeat(m.length));
+        const reExportRe = /export\s+(?:(?:type\s+)?\{[\s\S]*?\}\s+from|\*\s+as\s+\w+\s+from|\*\s+from)\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = reExportRe.exec(strippedContent)) !== null) {
+          const moduleSpec = match[1];
+          const resolvedFiles = resolveModulePath(epFile, moduleSpec, indexedFiles);
+          for (const rf of resolvedFiles) {
+            const fileSyms = fileToSymbolIds.get(rf);
+            if (fileSyms) {
+              const namedSymbols = parseNamedExportSymbols(match[0]);
+              if (namedSymbols) {
+                const nameSet = new Set(namedSymbols);
+                for (const sid of fileSyms) {
+                  const sym = symbolById.get(sid);
+                  if (sym && nameSet.has(sym.name)) seedIds.add(sid);
+                }
+              } else {
+                for (const sid of fileSyms) seedIds.add(sid);
+              }
+            }
+            if (!scannedBarrels.has(rf)) {
+              barrelWorkList.push(rf);
+            }
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.code !== "ENOENT") {
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "dead_code_scan_barrel_read_failed",
+              message: err.message,
+              file: epFile,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      }
+    }
     const alive = new Set(seedIds);
     const frontier = [...seedIds];
     const visitedEdges = /* @__PURE__ */ new Set();
@@ -6029,8 +6278,7 @@ function runDeadCodeScan(projectRoot, opts = {}) {
       dead.push({
         name: s.name,
         kind: s.kind,
-        lang: "ts",
-        // populated from symbol file metadata
+        lang: detectLang(s.file) ?? "ts",
         file: s.file,
         line: s.line,
         reason
@@ -6055,16 +6303,14 @@ function runDeadCodeScan(projectRoot, opts = {}) {
         deadFiles.push({
           file,
           symbolCount: syms.length,
-          lang: syms[0]?.kind ?? "ts"
+          lang: detectLang(file) ?? "ts"
         });
       }
     }
     const deadPackages = [];
     const pkgEntries = findPackageEntries(projectRoot);
     for (const [pkgName, pkgDir] of pkgEntries) {
-      const pkgFiles = allSymbols.filter(
-        (s) => s.file.startsWith(pkgDir + path13.sep)
-      );
+      const pkgFiles = allSymbols.filter((s) => s.file.startsWith(pkgDir + path13.sep));
       if (pkgFiles.length === 0) continue;
       const pkgUsed = pkgFiles.filter((s) => alive.has(s.id));
       if (pkgUsed.length === 0) {
@@ -6105,7 +6351,10 @@ function findPackageEntries(projectRoot) {
     pkgMap.set(rootPkg.name, projectRoot);
   }
   if (rootPkg) {
-    const wsDirs = extractWorkspaceGlobs(rootPkg, projectRoot);
+    let wsDirs = extractWorkspaceGlobs(rootPkg, projectRoot);
+    if (wsDirs.length === 0) {
+      wsDirs = extractPnpmWorkspaceDirs(projectRoot);
+    }
     for (const wsDir of wsDirs) {
       const wsPkg = tryReadJson(path13.join(wsDir, "package.json"));
       if (wsPkg && typeof wsPkg.name === "string") {