codeblast 0.2.0

package/dist/bin.js

@@ -0,0 +1,2299 @@
+#!/usr/bin/env node
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/db.ts
+import { createRequire } from "node:module";
+function openDatabase(file, opts = {}) {
+  if (isBun) {
+    const mod = require2("bun:sqlite");
+    return new mod.Database(file, { readonly: !!opts.readonly, create: true });
+  }
+  const mod = require2("node:sqlite");
+  return new mod.DatabaseSync(file, { readOnly: !!opts.readonly });
+}
+function transaction(db, fn) {
+  return (...args) => {
+    db.exec("BEGIN");
+    try {
+      fn(...args);
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
+  };
+}
+var require2, isBun;
+var init_db = __esm(() => {
+  require2 = createRequire(import.meta.url);
+  isBun = "Bun" in globalThis;
+  if (!isBun) {
+    const emit = process.emitWarning;
+    const filtered = (warning, ...rest) => {
+      const text = typeof warning === "string" ? warning : warning.message;
+      if (text.includes("SQLite is an experimental feature"))
+        return;
+      Reflect.apply(emit, process, [warning, ...rest]);
+    };
+    process.emitWarning = filtered;
+  }
+});
+
+// src/schema.ts
+function openGraph(dbPath) {
+  const db = openDatabase(dbPath);
+  db.exec("PRAGMA journal_mode = WAL;");
+  db.exec(DDL);
+  try {
+    db.exec("ALTER TABLE nodes ADD COLUMN signature TEXT NOT NULL DEFAULT ''");
+  } catch {}
+  return db;
+}
+function invalidateFile(db, relPath) {
+  db.prepare("DELETE FROM nodes WHERE src_file = ?").run(relPath);
+  db.prepare("DELETE FROM edges WHERE src_file = ?").run(relPath);
+  db.prepare("DELETE FROM blind_spots WHERE src_file = ?").run(relPath);
+  db.prepare("DELETE FROM import_bindings WHERE src_file = ?").run(relPath);
+  db.prepare("DELETE FROM files WHERE path = ?").run(relPath);
+}
+var DDL = `
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS files (
+  path TEXT PRIMARY KEY,      -- 相对仓库根
+  hash TEXT NOT NULL          -- 内容 hash，增量判断
+);
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  name TEXT NOT NULL,
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  end_line INTEGER NOT NULL,
+  exported INTEGER NOT NULL DEFAULT 0,
+  signature TEXT NOT NULL DEFAULT '',
+  src_file TEXT NOT NULL,
+  PRIMARY KEY (id)
+);
+CREATE INDEX IF NOT EXISTS idx_nodes_src_file ON nodes(src_file);
+CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
+CREATE TABLE IF NOT EXISTS edges (
+  src TEXT NOT NULL,
+  dst TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  confidence TEXT NOT NULL DEFAULT 'exact',
+  src_file TEXT NOT NULL,
+  PRIMARY KEY (src, dst, kind, file, line)
+);
+CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src);
+CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst);
+CREATE INDEX IF NOT EXISTS idx_edges_src_file ON edges(src_file);
+CREATE TABLE IF NOT EXISTS blind_spots (
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  reason TEXT NOT NULL,
+  src_file TEXT NOT NULL,
+  PRIMARY KEY (file, line, reason)
+);
+CREATE INDEX IF NOT EXISTS idx_blind_src_file ON blind_spots(src_file);
+CREATE TABLE IF NOT EXISTS import_bindings (
+  importer TEXT NOT NULL,       -- 引入方文件
+  imported TEXT NOT NULL,       -- 被引入文件
+  names TEXT NOT NULL,          -- 逗号分隔的具名绑定;空串+star=0 表示仅副作用 import
+  star INTEGER NOT NULL DEFAULT 0, -- 1 = namespace/星号/default 等无法枚举 → 禁止剪枝
+  src_file TEXT NOT NULL,
+  PRIMARY KEY (importer, imported)
+);
+CREATE INDEX IF NOT EXISTS idx_bindings_imported ON import_bindings(imported);
+CREATE INDEX IF NOT EXISTS idx_bindings_src_file ON import_bindings(src_file);
+`;
+var init_schema = __esm(() => {
+  init_db();
+});
+
+// src/extract.ts
+import ts from "typescript";
+import path from "node:path";
+import fs from "node:fs";
+function injectWorkspacePaths(base, pkgs, rootDir) {
+  if (pkgs.size === 0)
+    return base;
+  const options = { ...base, baseUrl: base.baseUrl ?? rootDir, paths: { ...base.paths } };
+  for (const [name, dir] of pkgs) {
+    const rel = path.relative(options.baseUrl, dir) || ".";
+    options.paths[name] ??= [`${rel}/src/index.ts`, `${rel}/index.ts`];
+    options.paths[`${name}/*`] ??= [`${rel}/src/*`, `${rel}/*`];
+  }
+  return options;
+}
+function workspaceGlobs(repoRoot) {
+  try {
+    const pj = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"));
+    const ws = Array.isArray(pj.workspaces) ? pj.workspaces : pj.workspaces?.packages;
+    return Array.isArray(ws) ? ws.filter((w) => typeof w === "string" && !w.startsWith("!")) : [];
+  } catch {
+    return [];
+  }
+}
+function discoverWorkspacePackages(repoRoot) {
+  const out = new Map;
+  const tryAdd = (dir) => {
+    const pj = path.join(dir, "package.json");
+    if (!fs.existsSync(pj))
+      return;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(pj, "utf8"));
+      if (parsed && typeof parsed === "object" && "name" in parsed && typeof parsed.name === "string") {
+        out.set(parsed.name, dir);
+      }
+    } catch {}
+  };
+  for (const g of workspaceGlobs(repoRoot)) {
+    const star = g.endsWith("/*");
+    const base = path.join(repoRoot, star ? g.slice(0, -2) : g);
+    if (!fs.existsSync(base))
+      continue;
+    if (!star) {
+      tryAdd(base);
+      continue;
+    }
+    for (const sub of fs.readdirSync(base, { withFileTypes: true }))
+      if (sub.isDirectory())
+        tryAdd(path.join(base, sub.name));
+  }
+  for (const entry of fs.readdirSync(repoRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith("."))
+      continue;
+    const dir = path.join(repoRoot, entry.name);
+    tryAdd(dir);
+    for (const sub of ["packages", "apps", "libs"].includes(entry.name) ? fs.readdirSync(dir, { withFileTypes: true }) : []) {
+      if (sub.isDirectory())
+        tryAdd(path.join(dir, sub.name));
+    }
+  }
+  return out;
+}
+
+class Extractor {
+  program;
+  checker;
+  parsedConfig;
+  programBuilt = false;
+  rootDir;
+  workspacePkgs = new Map;
+  implementers = new Map;
+  pendingBindings = new Map;
+  constructor(tsconfigPath, repoRoot) {
+    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (configFile.error)
+      throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, `
+`));
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(tsconfigPath));
+    this.rootDir = repoRoot ?? path.dirname(path.resolve(tsconfigPath));
+    this.workspacePkgs = discoverWorkspacePackages(this.rootDir);
+    this.parsedConfig = parsed;
+  }
+  fileNames() {
+    return this.parsedConfig.fileNames.filter((f) => !f.includes("node_modules") && !f.endsWith(".d.ts"));
+  }
+  ensureProgram() {
+    if (this.programBuilt)
+      return;
+    const options = injectWorkspacePaths(this.parsedConfig.options, this.workspacePkgs, this.rootDir);
+    this.program = ts.createProgram({ rootNames: this.parsedConfig.fileNames, options });
+    this.checker = this.program.getTypeChecker();
+    this.programBuilt = true;
+  }
+  static forFiles(fileNames, baseTsconfigPath, repoRoot) {
+    const configFile = ts.readConfigFile(baseTsconfigPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(configFile.config ?? {}, ts.sys, path.dirname(baseTsconfigPath));
+    const ex = Object.create(Extractor.prototype);
+    ex.rootDir = repoRoot;
+    ex.workspacePkgs = discoverWorkspacePackages(repoRoot);
+    ex.implementers = new Map;
+    ex.pendingBindings = new Map;
+    ex.reentryCache = new Map;
+    ex.parsedConfig = { ...parsed, fileNames };
+    ex.programBuilt = false;
+    return ex;
+  }
+  sourceFiles() {
+    this.ensureProgram();
+    return this.program.getSourceFiles().filter((sf) => !sf.isDeclarationFile && !sf.fileName.includes("node_modules"));
+  }
+  rel(fileName) {
+    return path.relative(this.rootDir, fileName);
+  }
+  collectImplementers() {
+    for (const sf of this.sourceFiles()) {
+      const visit = (node) => {
+        if (ts.isClassDeclaration(node) && node.heritageClauses) {
+          for (const clause of node.heritageClauses) {
+            for (const typeNode of clause.types) {
+              let sym = this.checker.getSymbolAtLocation(typeNode.expression);
+              if (sym && sym.flags & ts.SymbolFlags.Alias)
+                sym = this.checker.getAliasedSymbol(sym);
+              const decl = sym?.declarations?.[0];
+              if (!decl)
+                continue;
+              const parentId = this.nodeIdOfDecl(decl);
+              const classId = this.nodeIdOfDecl(node);
+              if (parentId && classId) {
+                const list = this.implementers.get(parentId) ?? [];
+                list.push(classId);
+                this.implementers.set(parentId, list);
+              }
+            }
+          }
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(sf);
+    }
+  }
+  extractFile(sf) {
+    const relPath = this.rel(sf.fileName);
+    const isTest = TEST_FILE_RE.test(relPath);
+    const nodes = [];
+    const edges = [];
+    const blindSpots = [];
+    this.pendingBindings.clear();
+    const lineOf = (node) => sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    const endLineOf = (node) => sf.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+    nodes.push({
+      id: relPath,
+      kind: "file",
+      name: path.basename(relPath),
+      file: relPath,
+      line: 1,
+      end_line: endLineOf(sf),
+      exported: 0,
+      signature: "",
+      src_file: relPath
+    });
+    for (const stmt of sf.statements) {
+      if (ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt)) {
+        const spec = stmt.moduleSpecifier;
+        if (spec && ts.isStringLiteral(spec)) {
+          const resolved = this.resolveModule(spec.text, sf.fileName);
+          if (!resolved) {
+            for (const entry of this.externalReentry(spec.text, sf.fileName)) {
+              edges.push({
+                src: relPath,
+                dst: this.rel(entry),
+                kind: "imports",
+                file: relPath,
+                line: lineOf(stmt),
+                confidence: "conservative",
+                src_file: relPath
+              });
+            }
+          } else {
+            edges.push({
+              src: relPath,
+              dst: this.rel(resolved),
+              kind: "imports",
+              file: relPath,
+              line: lineOf(stmt),
+              confidence: "exact",
+              src_file: relPath
+            });
+            const dstRel = this.rel(resolved);
+            let names = [];
+            let star = false;
+            if (ts.isImportDeclaration(stmt)) {
+              const c = stmt.importClause;
+              if (!c)
+                star = true;
+              else {
+                if (c.name)
+                  star = true;
+                if (c.namedBindings) {
+                  if (ts.isNamespaceImport(c.namedBindings))
+                    star = true;
+                  else
+                    for (const el of c.namedBindings.elements) {
+                      const src = (el.propertyName ?? el.name).text;
+                      if (src === "default")
+                        star = true;
+                      else
+                        names.push(src);
+                    }
+                }
+              }
+            } else {
+              if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+                for (const el of stmt.exportClause.elements) {
+                  if (el.propertyName && el.propertyName.text !== el.name.text)
+                    star = true;
+                  else if (el.name.text === "default")
+                    star = true;
+                  else
+                    names.push(el.name.text);
+                }
+              } else
+                star = true;
+            }
+            const key = `${relPath}\x00${dstRel}`;
+            const prev = this.pendingBindings.get(key);
+            if (prev) {
+              prev.star = prev.star || star;
+              for (const n of names)
+                prev.names.add(n);
+            } else {
+              this.pendingBindings.set(key, { star, names: new Set(names) });
+            }
+          }
+        } else if (spec) {
+          blindSpots.push({ file: relPath, line: lineOf(stmt), reason: "non-literal module specifier", src_file: relPath });
+        }
+      }
+    }
+    const enclosing = [];
+    const declKindOf = (node) => {
+      if (ts.isFunctionDeclaration(node))
+        return isTest ? "test" : "function";
+      if (ts.isMethodDeclaration(node))
+        return "method";
+      if (ts.isClassDeclaration(node))
+        return "class";
+      if (ts.isInterfaceDeclaration(node))
+        return "interface";
+      if (ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node))
+        return "interface";
+      if (ts.isVariableDeclaration(node) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)))
+        return isTest ? "test" : "function";
+      if (ts.isVariableDeclaration(node) && ts.isVariableDeclarationList(node.parent) && ts.isVariableStatement(node.parent.parent) && ts.isSourceFile(node.parent.parent.parent) && this.isExported(node))
+        return "const";
+      return;
+    };
+    const norm = (s) => s.replace(/\s+/g, " ").trim().slice(0, 200);
+    const typeSignature = (node) => {
+      if (ts.isInterfaceDeclaration(node))
+        return norm(node.members.map((m) => m.getText(sf)).join(" "));
+      if (ts.isTypeAliasDeclaration(node))
+        return norm(node.type.getText(sf));
+      if (ts.isEnumDeclaration(node))
+        return norm(node.members.map((m) => m.getText(sf)).join(" "));
+      if (ts.isVariableDeclaration(node))
+        return norm(node.type ? node.type.getText(sf) : node.initializer?.getText(sf) ?? "");
+      return "";
+    };
+    const visit = (node) => {
+      const kind = declKindOf(node);
+      const id = kind ? this.nodeIdOfDecl(node) : undefined;
+      if (kind && id) {
+        const name = this.declName(node) ?? "<anonymous>";
+        let signature = "";
+        const fnLike = ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) ? node : ts.isVariableDeclaration(node) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) ? node.initializer : undefined;
+        if (fnLike)
+          signature = fnLike.parameters.map((p) => p.getText(sf)).join(", ").slice(0, 200);
+        else
+          signature = typeSignature(node);
+        const exported = ts.isMethodDeclaration(node) && ts.isClassDeclaration(node.parent) ? this.isExported(node.parent) && !(ts.getCombinedModifierFlags(node) & (ts.ModifierFlags.Private | ts.ModifierFlags.Protected)) : this.isExported(node);
+        nodes.push({
+          id,
+          kind,
+          name,
+          file: relPath,
+          line: lineOf(node),
+          end_line: endLineOf(node),
+          exported: exported ? 1 : 0,
+          signature,
+          src_file: relPath
+        });
+        edges.push({
+          src: relPath,
+          dst: id,
+          kind: "contains",
+          file: relPath,
+          line: lineOf(node),
+          confidence: "exact",
+          src_file: relPath
+        });
+        if (ts.isClassDeclaration(node) && node.heritageClauses) {
+          for (const clause of node.heritageClauses) {
+            const ek = clause.token === ts.SyntaxKind.ImplementsKeyword ? "implements" : "extends";
+            for (const t of clause.types) {
+              let sym = this.checker.getSymbolAtLocation(t.expression);
+              if (sym && sym.flags & ts.SymbolFlags.Alias)
+                sym = this.checker.getAliasedSymbol(sym);
+              const decl = sym?.declarations?.[0];
+              const dst = decl ? this.nodeIdOfDecl(decl) : undefined;
+              if (dst)
+                edges.push({ src: id, dst, kind: ek, file: relPath, line: lineOf(clause), confidence: "exact", src_file: relPath });
+            }
+          }
+        }
+      }
+      if (kind && id)
+        enclosing.push(id);
+      if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+        const caller = [...enclosing].reverse().find(Boolean) ?? relPath;
+        if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+          const arg = node.arguments[0];
+          if (arg && ts.isStringLiteral(arg)) {
+            const resolved = this.resolveModule(arg.text, sf.fileName);
+            if (resolved) {
+              edges.push({
+                src: relPath,
+                dst: this.rel(resolved),
+                kind: "imports",
+                file: relPath,
+                line: lineOf(node),
+                confidence: "exact",
+                src_file: relPath
+              });
+            }
+          } else {
+            blindSpots.push({ file: relPath, line: lineOf(node), reason: `dynamic import: ${(arg?.getText() ?? "").slice(0, 80)}`, src_file: relPath });
+          }
+        } else {
+          this.resolveCall(node, caller, relPath, lineOf(node), edges, blindSpots);
+        }
+      }
+      ts.forEachChild(node, visit);
+      if (kind && id)
+        enclosing.pop();
+    };
+    visit(sf);
+    if (isTest) {
+      for (const e of edges) {
+        if (e.kind !== "calls")
+          continue;
+        const dstFile = e.dst.split("#")[0];
+        if (dstFile === e.dst || TEST_FILE_RE.test(dstFile))
+          continue;
+        edges.push({ ...e, kind: "tests" });
+      }
+    }
+    const bindings = [...this.pendingBindings.entries()].map(([key, v]) => {
+      const [importer, imported] = key.split("\x00");
+      return { importer, imported, names: [...v.names].join(","), star: v.star ? 1 : 0, src_file: relPath };
+    });
+    return { nodes, edges, blindSpots, bindings };
+  }
+  resolveCall(call, caller, relPath, line, edges, blindSpots) {
+    const expr = call.expression;
+    let sym = this.checker.getSymbolAtLocation(expr);
+    if (sym && sym.flags & ts.SymbolFlags.Alias)
+      sym = this.checker.getAliasedSymbol(sym);
+    const decl = sym?.valueDeclaration ?? sym?.declarations?.[0];
+    if (!decl) {
+      const structural = ts.isElementAccessExpression(expr) || ts.isPropertyAccessExpression(expr) && ["call", "apply", "bind"].includes(expr.name.text);
+      let leftmost = expr;
+      while (ts.isPropertyAccessExpression(leftmost) || ts.isCallExpression(leftmost) || ts.isNonNullExpression(leftmost)) {
+        leftmost = leftmost.expression;
+      }
+      const rootName = ts.isIdentifier(leftmost) ? leftmost.text : undefined;
+      const TEST_GLOBALS = {
+        describe: true,
+        it: true,
+        test: true,
+        expect: true,
+        expectTypeOf: true,
+        vi: true,
+        jest: true,
+        beforeEach: true,
+        afterEach: true,
+        beforeAll: true,
+        afterAll: true,
+        suite: true
+      };
+      const reason = structural ? `dynamic call: ${expr.getText().slice(0, 80)}` : rootName && TEST_GLOBALS[rootName] ? `test-global: ${rootName}` : `unresolved call: ${expr.getText().slice(0, 80)}`;
+      blindSpots.push({ file: relPath, line, reason, src_file: relPath });
+      return;
+    }
+    const declFile = decl.getSourceFile();
+    if (declFile.isDeclarationFile || declFile.fileName.includes("node_modules")) {
+      const SUBPROCESS_APIS = {
+        exec: true,
+        execSync: true,
+        execFile: true,
+        execFileSync: true,
+        spawn: true,
+        spawnSync: true,
+        fork: true
+      };
+      const calleeName = sym?.name ?? "";
+      if (SUBPROCESS_APIS[calleeName] && declFile.fileName.includes("child_process")) {
+        blindSpots.push({ file: relPath, line, reason: `subprocess spawn: ${calleeName}`, src_file: relPath });
+      }
+      return;
+    }
+    const dst = this.nodeIdOfDecl(decl);
+    if (!dst)
+      return;
+    if (ts.isVariableDeclaration(decl) && !(decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) && !(ts.isVariableDeclarationList(decl.parent) && ts.isVariableStatement(decl.parent.parent) && ts.isSourceFile(decl.parent.parent.parent) && this.isExported(decl)))
+      return;
+    const push = (target, confidence) => edges.push({ src: caller, dst: target, kind: "calls", file: relPath, line, confidence, src_file: relPath });
+    const isAbstractTarget = ts.isMethodSignature(decl) || ts.isMethodDeclaration(decl) && !!(ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Abstract) || ts.isInterfaceDeclaration(decl.parent ?? decl);
+    if (isAbstractTarget && ts.isMethodSignature(decl) && ts.isInterfaceDeclaration(decl.parent)) {
+      const ifaceId = this.nodeIdOfDecl(decl.parent);
+      const impls = ifaceId ? this.implementers.get(ifaceId) ?? [] : [];
+      push(dst, "exact");
+      const methodName = decl.name.getText();
+      for (const implClassId of impls) {
+        push(`${implClassId}.${methodName}`, "conservative");
+      }
+      if (impls.length === 0)
+        return;
+      return;
+    }
+    push(dst, "exact");
+  }
+  reentryCache = new Map;
+  externalReentry(specifier, fromFile) {
+    if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:"))
+      return [];
+    const pkgName = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+    if (this.workspacePkgs.has(pkgName))
+      return [];
+    const hit = this.reentryCache.get(pkgName);
+    if (hit)
+      return hit;
+    const out = [];
+    const r = ts.resolveModuleName(`${pkgName}/package.json`, fromFile, { ...this.program.getCompilerOptions(), resolveJsonModule: true, moduleResolution: ts.ModuleResolutionKind.Bundler }, ts.sys);
+    const pjPath = r.resolvedModule?.resolvedFileName;
+    if (pjPath && pjPath.includes("node_modules")) {
+      try {
+        const pj = JSON.parse(fs.readFileSync(pjPath, "utf8"));
+        for (const dep of new Set([...Object.keys(pj.dependencies ?? {}), ...Object.keys(pj.peerDependencies ?? {})])) {
+          const dir = this.workspacePkgs.get(dep);
+          if (!dir)
+            continue;
+          const entry = [path.join(dir, "src", "index.ts"), path.join(dir, "index.ts"), path.join(dir, "src", "index.tsx")].find((f) => fs.existsSync(f));
+          if (entry)
+            out.push(entry);
+        }
+      } catch {}
+    }
+    this.reentryCache.set(pkgName, out);
+    return out;
+  }
+  resolveModule(specifier, fromFile) {
+    const r = ts.resolveModuleName(specifier, fromFile, this.program.getCompilerOptions(), ts.sys);
+    let resolved = r.resolvedModule?.resolvedFileName;
+    if (!resolved) {
+      const pkgName = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+      const pkgDir = this.workspacePkgs.get(pkgName);
+      if (!pkgDir)
+        return;
+      const sub = specifier.slice(pkgName.length).replace(/^\//, "");
+      for (const cand of [
+        path.join(pkgDir, sub || "index.ts"),
+        path.join(pkgDir, sub, "index.ts"),
+        path.join(pkgDir, "src", sub || "index.ts"),
+        path.join(pkgDir, "src", sub, "index.ts"),
+        path.join(pkgDir, sub + ".ts")
+      ]) {
+        if (fs.existsSync(cand))
+          return cand;
+      }
+      return;
+    }
+    if (resolved.includes("node_modules")) {
+      try {
+        resolved = fs.realpathSync(resolved);
+      } catch {
+        return;
+      }
+      if (resolved.includes("node_modules"))
+        return;
+    }
+    return path.relative(this.rootDir, resolved).startsWith("..") ? undefined : resolved;
+  }
+  nodeIdOfDecl(decl) {
+    const sf = decl.getSourceFile();
+    const relPath = this.rel(sf.fileName);
+    const name = this.declName(decl);
+    if (!name)
+      return;
+    if ((ts.isMethodDeclaration(decl) || ts.isMethodSignature(decl)) && decl.parent && (ts.isClassDeclaration(decl.parent) || ts.isInterfaceDeclaration(decl.parent))) {
+      const parentName = this.declName(decl.parent);
+      return `${relPath}#${parentName}.${name}`;
+    }
+    return `${relPath}#${name}`;
+  }
+  declName(decl) {
+    if ((ts.isFunctionDeclaration(decl) || ts.isClassDeclaration(decl) || ts.isInterfaceDeclaration(decl) || ts.isMethodDeclaration(decl) || ts.isMethodSignature(decl) || ts.isVariableDeclaration(decl) || ts.isTypeAliasDeclaration(decl) || ts.isEnumDeclaration(decl)) && decl.name && (ts.isIdentifier(decl.name) || ts.isStringLiteral(decl.name)))
+      return decl.name.text;
+    return;
+  }
+  isExported(node) {
+    return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0;
+  }
+}
+var TEST_FILE_RE;
+var init_extract = __esm(() => {
+  TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\//;
+});
+
+// src/proc.ts
+import { spawnSync as nodeSpawnSync } from "node:child_process";
+function spawnSync(cmd, opts = {}) {
+  const p = nodeSpawnSync(cmd[0], cmd.slice(1), {
+    cwd: opts.cwd,
+    input: opts.input,
+    maxBuffer: opts.maxBuffer ?? 64 * 1024 * 1024,
+    encoding: "utf8"
+  });
+  if (p.error)
+    return { exitCode: 127, stdout: p.stdout ?? "", stderr: p.error.message };
+  return { exitCode: p.status ?? 1, stdout: p.stdout ?? "", stderr: p.stderr ?? "" };
+}
+function selfCommand(cmd, ...args) {
+  return [process.execPath, process.argv[1], cmd, ...args];
+}
+var init_proc = () => {};
+
+// src/cli.ts
+var exports_cli = {};
+import path2 from "node:path";
+import fs2 from "node:fs";
+import { createHash } from "node:crypto";
+function discoverTsconfigs(repoRoot) {
+  const found = [];
+  const rootConfig = path2.join(repoRoot, "tsconfig.json");
+  const SKIP = { node_modules: true, ".git": true, dist: true, build: true, coverage: true };
+  const walk = (dir, depth) => {
+    if (depth > 3)
+      return;
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+      const p = path2.join(dir, entry.name);
+      if (entry.isDirectory() && !SKIP[entry.name] && !entry.name.startsWith("."))
+        walk(p, depth + 1);
+      else if (entry.name === "tsconfig.json" && p !== rootConfig)
+        found.push(p);
+    }
+  };
+  walk(repoRoot, 1);
+  if (found.length === 0 && fs2.existsSync(rootConfig))
+    found.push(rootConfig);
+  return found;
+}
+function indexProgram(extractor) {
+  extractor.collectImplementers();
+  for (const sf of extractor.sourceFiles()) {
+    const relPath = extractor.rel(sf.fileName);
+    if (relPath.startsWith("..") || seenFiles.has(relPath))
+      continue;
+    seenFiles.add(relPath);
+    const hash = createHash("sha1").update(sf.text).digest("hex");
+    const existing = getHash.get(relPath);
+    if (existing?.hash === hash) {
+      skipped++;
+      continue;
+    }
+    try {
+      const { nodes, edges, blindSpots, bindings } = extractor.extractFile(sf);
+      writeBatch(relPath, hash, nodes, edges, blindSpots, bindings);
+      indexed++;
+      nodeCount += nodes.length;
+      edgeCount += edges.length;
+      blindCount += blindSpots.length;
+    } catch (err) {
+      failures++;
+      seenFiles.delete(relPath);
+      console.error(`EXTRACT FAILED ${relPath}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+}
+function sweep(dir) {
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS[entry.name])
+        sweep(path2.join(dir, entry.name));
+    } else if (/\.[cm]?tsx?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      const abs = path2.join(dir, entry.name);
+      const rel = path2.relative(repoRoot, abs);
+      if (!seenFiles.has(rel))
+        orphans.push(abs);
+    }
+  }
+}
+var args, target, dbFlag, dbPath, repoRoot, tsconfigs, t0, db, insertNode, insertEdge, insertBlind, insertBinding, upsertFile, getHash, writeBatch, indexed = 0, skipped = 0, nodeCount = 0, edgeCount = 0, blindCount = 0, seenFiles, failures = 0, orphans, SKIP_DIRS, pyProbe, dt;
+var init_cli = __esm(() => {
+  init_schema();
+  init_extract();
+  init_db();
+  init_proc();
+  args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("usage: codeblast index <repo-root-or-tsconfig> [--db graph.db]");
+    process.exit(1);
+  }
+  target = path2.resolve(args[0]);
+  dbFlag = args.indexOf("--db");
+  dbPath = dbFlag >= 0 ? args[dbFlag + 1] : path2.join(process.cwd(), "graph.db");
+  if (target.endsWith(".json")) {
+    repoRoot = path2.dirname(target);
+    tsconfigs = [target];
+  } else {
+    repoRoot = target;
+    tsconfigs = discoverTsconfigs(target);
+  }
+  if (tsconfigs.length === 0) {
+    console.error(`no tsconfig.json found under: ${target}`);
+    console.error("proceeding: python-only ingestion");
+  }
+  console.error(`repo root: ${repoRoot}`);
+  console.error(`tsconfigs: ${tsconfigs.length}`);
+  t0 = performance.now();
+  db = openGraph(dbPath);
+  insertNode = db.prepare("INSERT OR REPLACE INTO nodes (id, kind, name, file, line, end_line, exported, signature, src_file) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+  insertEdge = db.prepare("INSERT OR REPLACE INTO edges (src, dst, kind, file, line, confidence, src_file) VALUES (?, ?, ?, ?, ?, ?, ?)");
+  insertBlind = db.prepare("INSERT OR REPLACE INTO blind_spots (file, line, reason, src_file) VALUES (?, ?, ?, ?)");
+  insertBinding = db.prepare("INSERT OR REPLACE INTO import_bindings (importer, imported, names, star, src_file) VALUES (?, ?, ?, ?, ?)");
+  upsertFile = db.prepare("INSERT OR REPLACE INTO files (path, hash) VALUES (?, ?)");
+  getHash = db.prepare("SELECT hash FROM files WHERE path = ?");
+  writeBatch = transaction(db, (relPath, hash, nodes, edges, blind, bindings = []) => {
+    invalidateFile(db, relPath);
+    for (const n of nodes)
+      insertNode.run(n.id, n.kind, n.name, n.file, n.line, n.end_line, n.exported, n.signature ?? "", n.src_file);
+    for (const e of edges)
+      insertEdge.run(e.src, e.dst, e.kind, e.file, e.line, e.confidence, e.src_file);
+    for (const b of blind)
+      insertBlind.run(b.file, b.line, b.reason, b.src_file);
+    for (const ib of bindings)
+      insertBinding.run(ib.importer, ib.imported, ib.names, ib.star, ib.src_file);
+    upsertFile.run(relPath, hash);
+  });
+  seenFiles = new Set;
+  for (const tsconfigPath of tsconfigs) {
+    let extractor;
+    try {
+      extractor = new Extractor(tsconfigPath, repoRoot);
+    } catch (err) {
+      console.error(`skip ${path2.relative(repoRoot, tsconfigPath)}: ${err instanceof Error ? err.message.split(`
+`)[0] : err}`);
+      continue;
+    }
+    const names = extractor.fileNames();
+    let anyChanged = names.length === 0;
+    for (const abs of names) {
+      const rel = path2.relative(repoRoot, abs);
+      if (rel.startsWith("..") || seenFiles.has(rel))
+        continue;
+      let text;
+      try {
+        text = fs2.readFileSync(abs, "utf8");
+      } catch {
+        anyChanged = true;
+        break;
+      }
+      const hash = createHash("sha1").update(text).digest("hex");
+      const existing = getHash.get(rel);
+      if (existing?.hash !== hash) {
+        anyChanged = true;
+        break;
+      }
+    }
+    if (!anyChanged) {
+      for (const abs of names) {
+        const rel = path2.relative(repoRoot, abs);
+        if (!rel.startsWith("..") && !seenFiles.has(rel)) {
+          seenFiles.add(rel);
+          skipped++;
+        }
+      }
+      continue;
+    }
+    indexProgram(extractor);
+  }
+  orphans = [];
+  SKIP_DIRS = { node_modules: true, ".git": true, dist: true, build: true, coverage: true, ".next": true };
+  sweep(repoRoot);
+  if (tsconfigs.length > 0 && orphans.length > 0) {
+    console.error(`orphan files (outside all tsconfigs): ${orphans.length}`);
+    let orphanChanged = false;
+    for (const abs of orphans) {
+      const rel = path2.relative(repoRoot, abs);
+      let text;
+      try {
+        text = fs2.readFileSync(abs, "utf8");
+      } catch {
+        orphanChanged = true;
+        break;
+      }
+      const hash = createHash("sha1").update(text).digest("hex");
+      const existing = getHash.get(rel);
+      if (existing?.hash !== hash) {
+        orphanChanged = true;
+        break;
+      }
+    }
+    if (orphanChanged) {
+      try {
+        indexProgram(Extractor.forFiles(orphans, tsconfigs[0], repoRoot));
+      } catch (err) {
+        failures++;
+        console.error(`ORPHAN PROGRAM FAILED (${orphans.length} files unindexed): ${err instanceof Error ? err.message : err}`);
+      }
+    } else {
+      for (const abs of orphans) {
+        seenFiles.add(path2.relative(repoRoot, abs));
+        skipped++;
+      }
+    }
+  }
+  pyProbe = spawnSync(["python3", path2.join(import.meta.dirname, "py_extract.py"), repoRoot]);
+  if (pyProbe.exitCode === 0) {
+    const payload = JSON.parse(pyProbe.stdout);
+    for (const f of payload.files) {
+      if (seenFiles.has(f.path))
+        continue;
+      seenFiles.add(f.path);
+      const existing = getHash.get(f.path);
+      if (existing?.hash === f.hash && f.hash !== "") {
+        skipped++;
+        continue;
+      }
+      writeBatch(f.path, f.hash, f.nodes, f.edges, f.blind_spots);
+      indexed++;
+      nodeCount += f.nodes.length;
+      edgeCount += f.edges.length;
+      blindCount += f.blind_spots.length;
+    }
+    const pyFiles = payload.files.length;
+    if (pyFiles > 0)
+      console.error(`python files ingested: ${pyFiles}`);
+  }
+  dt = ((performance.now() - t0) / 1000).toFixed(1);
+  console.log(JSON.stringify({
+    db: dbPath,
+    seconds: Number(dt),
+    tsconfigs: tsconfigs.length,
+    files_indexed: indexed,
+    files_skipped: skipped,
+    nodes: nodeCount,
+    edges: edgeCount,
+    blind_spots: blindCount,
+    failures
+  }, null, 2));
+  if (failures > 0) {
+    console.error(`
+${failures} extraction failure(s) — graph is INCOMPLETE. Exiting non-zero.`);
+    process.exit(2);
+  }
+});
+
+// src/impact.ts
+function impact(db, targetId, maxNodes = 500) {
+  const targetRow = db.prepare("SELECT id, file FROM nodes WHERE id = ?").get(targetId);
+  if (!targetRow)
+    throw new Error(`node not found: ${targetId}`);
+  const targetName = targetId.includes("#") ? targetId.split("#").pop().split(".")[0] : null;
+  const bindingRows = (() => {
+    try {
+      return db.prepare("SELECT importer, imported, names, star FROM import_bindings").all();
+    } catch {
+      return [];
+    }
+  })();
+  const bindings = new Map;
+  for (const b of bindingRows) {
+    bindings.set(`${b.importer}\x00${b.imported}`, { star: b.star === 1, names: new Set(b.names ? b.names.split(",") : []) });
+  }
+  const incoming = db.prepare(`SELECT src, dst, kind, confidence, file, line FROM edges
+     WHERE kind IN (${IMPACT_EDGE_KINDS.map(() => "?").join(",")})`).all(...IMPACT_EDGE_KINDS);
+  const byDst = new Map;
+  for (const e of incoming) {
+    const list = byDst.get(e.dst) ?? [];
+    list.push(e);
+    byDst.set(e.dst, list);
+  }
+  const visited = new Map;
+  let frontier = [targetId];
+  visited.set(targetId, { hops: 0, confidence: "exact", via_file: targetRow.file, via_line: 0, fileLevel: false, namedMiss: false });
+  let truncated = false;
+  while (frontier.length > 0 && !truncated) {
+    const next = [];
+    for (const cur of frontier) {
+      const curInfo = visited.get(cur);
+      for (const e of byDst.get(cur) ?? []) {
+        if (visited.has(e.src))
+          continue;
+        let namedMiss = false;
+        if (e.kind === "imports" && targetName) {
+          const b = bindings.get(`${e.src}\x00${e.dst}`);
+          if (b && !b.star && !b.names.has(targetName))
+            namedMiss = true;
+        }
+        const conf = e.confidence === "conservative" || curInfo.confidence === "conservative" ? "conservative" : "exact";
+        const fileLevel = curInfo.fileLevel || e.kind === "imports" || e.kind === "contains";
+        const nm = curInfo.namedMiss || namedMiss;
+        visited.set(e.src, { hops: curInfo.hops + 1, confidence: conf, via_file: e.file, via_line: e.line, fileLevel, namedMiss: nm });
+        next.push(e.src);
+        if (visited.size > maxNodes) {
+          truncated = true;
+          break;
+        }
+      }
+      if (truncated)
+        break;
+    }
+    frontier = next;
+  }
+  visited.delete(targetId);
+  const getNode = db.prepare("SELECT id, name, kind, file, line FROM nodes WHERE id = ?");
+  const testEdges = db.prepare("SELECT DISTINCT src FROM edges WHERE kind = 'tests' AND dst = ?");
+  const items = [];
+  const affectedTests = new Set;
+  for (const [id, info] of visited) {
+    const n = getNode.get(id);
+    if (!n)
+      continue;
+    if (n.kind === "file" && n.file === targetRow.file)
+      continue;
+    const level = n.kind === "test" || TEST_FILE_RE2.test(n.file) ? "tests" : info.hops === 1 ? "direct" : "indirect";
+    if (level === "tests")
+      affectedTests.add(id);
+    items.push({
+      id: n.id,
+      name: n.name,
+      kind: n.kind,
+      file: n.file,
+      line: n.line,
+      level,
+      hops: info.hops,
+      confidence: info.confidence,
+      via_file: info.via_file,
+      via_line: info.via_line,
+      channel: info.fileLevel ? "file" : "call",
+      named_miss: info.namedMiss
+    });
+  }
+  for (const it of items) {
+    if (it.level === "tests")
+      continue;
+    for (const t of testEdges.all(it.id)) {
+      if (visited.has(t.src) || affectedTests.has(t.src))
+        continue;
+      const n = getNode.get(t.src);
+      if (!n)
+        continue;
+      affectedTests.add(t.src);
+      items.push({
+        id: n.id,
+        name: n.name,
+        kind: n.kind,
+        file: n.file,
+        line: n.line,
+        level: "tests",
+        hops: it.hops + 1,
+        confidence: it.confidence,
+        via_file: n.file,
+        via_line: n.line,
+        channel: it.channel
+      });
+    }
+  }
+  for (const t of testEdges.all(targetId)) {
+    if (affectedTests.has(t.src) || visited.has(t.src))
+      continue;
+    const n = getNode.get(t.src);
+    if (!n)
+      continue;
+    items.push({
+      id: n.id,
+      name: n.name,
+      kind: n.kind,
+      file: n.file,
+      line: n.line,
+      level: "tests",
+      hops: 1,
+      confidence: "exact",
+      via_file: n.file,
+      via_line: n.line,
+      channel: "call"
+    });
+  }
+  const blindReachTests = db.prepare(`SELECT DISTINCT file FROM blind_spots
+     WHERE (reason LIKE 'subprocess spawn%' OR reason LIKE 'dynamic import%')`).all();
+  const includedFiles = new Set(items.filter((it) => it.level === "tests").map((it) => it.file));
+  for (const { file } of blindReachTests) {
+    if (!TEST_FILE_RE2.test(file) || includedFiles.has(file))
+      continue;
+    const bs = db.prepare("SELECT line, reason FROM blind_spots WHERE file = ? AND (reason LIKE 'subprocess spawn%' OR reason LIKE 'dynamic import%') LIMIT 1").get(file);
+    includedFiles.add(file);
+    items.push({
+      id: file,
+      name: `${file} (${bs.reason})`,
+      kind: "file",
+      file,
+      line: bs.line,
+      level: "tests",
+      hops: 99,
+      confidence: "conservative",
+      via_file: file,
+      via_line: bs.line,
+      channel: "file"
+    });
+  }
+  const blindCount = db.prepare("SELECT COUNT(*) c FROM blind_spots WHERE file = ? AND reason NOT LIKE 'test-global%'").get(targetRow.file).c;
+  const coChange = db.prepare("SELECT dst, line, src_file FROM edges WHERE kind = 'co_change' AND src = ? ORDER BY line DESC LIMIT 10").all(targetRow.file).map((r) => ({ file: r.dst, co_commits: r.line, evidence: r.src_file }));
+  items.sort((a, b) => a.hops - b.hops || a.id.localeCompare(b.id));
+  return { target: targetId, items, truncated, blind_spot_count: blindCount, co_change_hints: coChange };
+}
+var IMPACT_EDGE_KINDS, TEST_FILE_RE2;
+var init_impact = __esm(() => {
+  IMPACT_EDGE_KINDS = ["calls", "implements", "extends", "imports", "contains"];
+  TEST_FILE_RE2 = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\/|(^|\/)tests?\/|(^|\/)test_[^/]*\.py$|_test\.py$|conftest\.py$/;
+});
+
+// src/impact-cli.ts
+var exports_impact_cli = {};
+var dbPath2, query, maxFlag, maxNodes, db2, targetId, exact, t02, result, ms, byLevel, callItems, fileNamed, fileUnnamed, ordered;
+var init_impact_cli = __esm(() => {
+  init_db();
+  init_impact();
+  [dbPath2, query] = process.argv.slice(2);
+  if (!dbPath2 || !query) {
+    console.error("usage: codeblast impact <graph.db> <node-id-or-name> [--max 500]");
+    process.exit(1);
+  }
+  maxFlag = process.argv.indexOf("--max");
+  maxNodes = maxFlag >= 0 ? Number(process.argv[maxFlag + 1]) : 500;
+  db2 = openDatabase(dbPath2, { readonly: true });
+  targetId = query;
+  exact = db2.prepare("SELECT id FROM nodes WHERE id = ?").get(query);
+  if (!exact) {
+    const candidates = db2.prepare("SELECT id, kind, file, line FROM nodes WHERE name = ? AND kind != 'file' LIMIT 20").all(query);
+    if (candidates.length === 0) {
+      console.error(`no node matches: ${query}`);
+      process.exit(1);
+    }
+    if (candidates.length > 1) {
+      console.error(`ambiguous name, ${candidates.length} candidates:`);
+      for (const c of candidates)
+        console.error(`  ${c.id}  (${c.kind} @ ${c.file}:${c.line})`);
+      process.exit(1);
+    }
+    targetId = candidates[0].id;
+  }
+  t02 = performance.now();
+  result = impact(db2, targetId, maxNodes);
+  ms = (performance.now() - t02).toFixed(0);
+  if (process.argv.includes("--json")) {
+    console.log(JSON.stringify(result));
+    process.exit(0);
+  }
+  byLevel = { direct: 0, indirect: 0, tests: 0 };
+  for (const it of result.items)
+    byLevel[it.level]++;
+  callItems = result.items.filter((it) => it.channel === "call");
+  fileNamed = result.items.filter((it) => it.channel === "file" && !it.named_miss);
+  fileUnnamed = result.items.filter((it) => it.channel === "file" && it.named_miss);
+  console.log(`target: ${result.target}`);
+  console.log(`impact: ${result.items.length} nodes (direct=${byLevel.direct} indirect=${byLevel.indirect} tests=${byLevel.tests})${result.truncated ? " [TRUNCATED — wide impact, run the full suite]" : ""}`);
+  console.log(`  ├─ call-graph reachable (high confidence): ${callItems.length}`);
+  console.log(`  ├─ reachable via named import: ${fileNamed.length}`);
+  console.log(`  └─ reachable via unnamed import (execution closure, conservative — do not skip): ${fileUnnamed.length}`);
+  if (result.blind_spot_count > 0)
+    console.log(`blind spots in target file: ${result.blind_spot_count} (impact may be underestimated)`);
+  if (result.co_change_hints.length > 0) {
+    console.log(`co-change hints (no static edge, but historically changed together):`);
+    for (const h of result.co_change_hints)
+      console.log(`  ~ ${h.file} (${h.co_commits}  co-commits, ${h.evidence})`);
+  }
+  console.log(`query: ${ms}ms
+`);
+  ordered = [...callItems, ...fileNamed, ...fileUnnamed];
+  for (const it of ordered.slice(0, 40)) {
+    const conf = it.confidence === "conservative" ? " ~" : "";
+    const ch = it.channel === "file" ? it.named_miss ? " ·closure" : " ·import" : "";
+    console.log(`  [${it.level}${conf}${ch}] ${it.id}  (${it.kind}, ${it.hops} hop, via ${it.via_file}:${it.via_line})`);
+  }
+  if (ordered.length > 40)
+    console.log(`  ... and ${ordered.length - 40} more`);
+});
+
+// src/graph-diff.ts
+function graphDiff(dbA, dbB) {
+  const q = "SELECT id, kind, name, file, line, exported, COALESCE(signature,'') signature FROM nodes WHERE kind NOT IN ('file')";
+  const nodesA = new Map(dbA.prepare(q).all().map((n) => [n.id, n]));
+  const nodesB = new Map(dbB.prepare(q).all().map((n) => [n.id, n]));
+  const rawAdded = [];
+  const rawRemoved = [];
+  for (const [id, n] of nodesB)
+    if (!nodesA.has(id))
+      rawAdded.push(n);
+  for (const [id, n] of nodesA)
+    if (!nodesB.has(id))
+      rawRemoved.push(n);
+  const visibilityChanged = [];
+  for (const [id, b] of nodesB) {
+    const a = nodesA.get(id);
+    if (a && a.exported !== b.exported) {
+      visibilityChanged.push({ id, name: b.name, kind: b.kind, file: b.file, line: b.line, nowExported: b.exported === 1 });
+    }
+  }
+  const signatureChanged = [];
+  for (const [id, b] of nodesB) {
+    const a = nodesA.get(id);
+    if (a && b.exported === 1 && a.signature !== b.signature && (a.signature || b.signature)) {
+      signatureChanged.push({ id, name: b.name, kind: b.kind, file: b.file, line: b.line, from: a.signature, to: b.signature });
+    }
+  }
+  const renamed = [];
+  const usedAdded = new Set;
+  const usedRemoved = new Set;
+  for (const r of rawRemoved) {
+    const candidate = rawAdded.find((a) => !usedAdded.has(a.id) && a.file === r.file && a.kind === r.kind && Math.abs(a.line - r.line) <= 30);
+    if (candidate) {
+      renamed.push({ from: r.name, to: candidate.name, file: r.file, kind: r.kind });
+      usedAdded.add(candidate.id);
+      usedRemoved.add(r.id);
+    }
+  }
+  for (const r of rawRemoved) {
+    if (usedRemoved.has(r.id))
+      continue;
+    const candidate = rawAdded.find((a) => !usedAdded.has(a.id) && a.name === r.name && a.kind === r.kind && Math.abs(a.line - r.line) <= 5);
+    if (candidate) {
+      renamed.push({ from: `${r.file}#${r.name}`, to: `${candidate.file}#${candidate.name}`, file: candidate.file, kind: r.kind });
+      usedAdded.add(candidate.id);
+      usedRemoved.add(r.id);
+    }
+  }
+  const eq = `SELECT src, dst, kind, file, line FROM edges WHERE kind IN ${STRUCTURAL_EDGE_KINDS}`;
+  const edgeKey = (e) => `${e.src}\x00${e.dst}\x00${e.kind}`;
+  const edgesA = new Map(dbA.prepare(eq).all().map((e) => [edgeKey(e), e]));
+  const edgesB = new Map(dbB.prepare(eq).all().map((e) => [edgeKey(e), e]));
+  const edgesAdded = [];
+  const edgesRemoved = [];
+  for (const [k, e] of edgesB)
+    if (!edgesA.has(k))
+      edgesAdded.push(e);
+  for (const [k, e] of edgesA)
+    if (!edgesB.has(k))
+      edgesRemoved.push(e);
+  return {
+    nodesAdded: rawAdded.filter((n) => !usedAdded.has(n.id)),
+    nodesRemoved: rawRemoved.filter((n) => !usedRemoved.has(n.id)),
+    renamed,
+    edgesAdded,
+    edgesRemoved,
+    visibilityChanged,
+    signatureChanged
+  };
+}
+function foldToModules(diff) {
+  const TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\/|(^|\/)tests?\/|(^|\/)test_[^/]*\.py$|_test\.py$|conftest\.py$/;
+  const moduleOf = (file) => {
+    if (TEST_RE.test(file))
+      return "tests";
+    const wsMatch = file.match(/^(?:packages|apps|libs)\/([^/]+)\//);
+    if (wsMatch)
+      return wsMatch[1];
+    const ix = file.indexOf("/");
+    return ix < 0 ? "(root)" : file.slice(0, ix);
+  };
+  const out = new Map;
+  const bump = (m, key) => {
+    const v = out.get(m) ?? { added: 0, removed: 0, renamed: 0, edgesIn: 0, edgesOut: 0 };
+    v[key]++;
+    out.set(m, v);
+  };
+  for (const n of diff.nodesAdded)
+    bump(moduleOf(n.file), "added");
+  for (const n of diff.nodesRemoved)
+    bump(moduleOf(n.file), "removed");
+  for (const r of diff.renamed)
+    bump(moduleOf(r.file), "renamed");
+  for (const e of diff.edgesAdded)
+    bump(moduleOf(e.file), "edgesIn");
+  for (const e of diff.edgesRemoved)
+    bump(moduleOf(e.file), "edgesOut");
+  return out;
+}
+var STRUCTURAL_EDGE_KINDS = "('calls','imports','implements','extends')";
+
+// src/change-cli.ts
+var exports_change_cli = {};
+import fs3 from "node:fs";
+async function buildGraphAt(repo, ref, db) {
+  const wt = `/tmp/codeblast-wt-${ref.replace(/[^\w]/g, "_")}`;
+  const sh = (cmd) => {
+    const p = spawnSync(cmd, { cwd: repo });
+    if (p.exitCode !== 0)
+      throw new Error(`${cmd.join(" ")}: ${p.stderr.slice(0, 300)}`);
+  };
+  spawnSync(["git", "worktree", "remove", "--force", wt], { cwd: repo });
+  sh(["git", "worktree", "add", "--detach", wt, ref]);
+  try {
+    const p = spawnSync(selfCommand("index", wt, "--db", db));
+    if (p.exitCode !== 0)
+      throw new Error(p.stderr.slice(0, 500));
+  } finally {
+    spawnSync(["git", "worktree", "remove", "--force", wt], { cwd: repo });
+  }
+}
+var args2, outFlag, outPath, jsonMode, dbA, dbB, header, diff, total, impactDetails, impactSummary, topChanged, folded, lines, doc;
+var init_change_cli = __esm(async () => {
+  init_db();
+  init_proc();
+  init_impact();
+  args2 = process.argv.slice(2);
+  outFlag = args2.indexOf("--out");
+  outPath = outFlag >= 0 ? args2[outFlag + 1] : undefined;
+  jsonMode = args2.includes("--json");
+  if (args2[0] === "--dbs") {
+    dbA = openDatabase(args2[1], { readonly: true });
+    dbB = openDatabase(args2[2], { readonly: true });
+    header = `${args2[1]} → ${args2[2]}`;
+  } else {
+    const [repo, refA, refB] = args2;
+    if (!repo || !refA || !refB) {
+      console.error("usage: codeblast change <repo> <ref-a> <ref-b> [--out report.md] | --dbs <a.db> <b.db>");
+      process.exit(1);
+    }
+    const pa = `/tmp/codeblast-diff-a.db`, pb = `/tmp/codeblast-diff-b.db`;
+    for (const f of [pa, pb])
+      for (const s of ["", "-wal", "-shm"])
+        fs3.rmSync(f + s, { force: true });
+    console.error(`building graph @ ${refA} ...`);
+    await buildGraphAt(repo, refA, pa);
+    console.error(`building graph @ ${refB} ...`);
+    await buildGraphAt(repo, refB, pb);
+    dbA = openDatabase(pa, { readonly: true });
+    dbB = openDatabase(pb, { readonly: true });
+    header = `${refA} → ${refB}`;
+  }
+  diff = graphDiff(dbA, dbB);
+  total = diff.nodesAdded.length + diff.nodesRemoved.length + diff.renamed.length + diff.edgesAdded.length + diff.edgesRemoved.length;
+  if (total === 0) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ range: header, structural_changes: 0 }));
+      process.exit(0);
+    }
+    console.log("无结构变化。");
+    process.exit(0);
+  }
+  impactDetails = [];
+  impactSummary = [];
+  topChanged = [...diff.nodesAdded, ...diff.renamed.map((r) => ({ id: `${r.file}#${r.to}`, kind: r.kind, name: r.to, file: r.file, line: 0 }))].slice(0, 10);
+  for (const n of topChanged) {
+    try {
+      const r = impact(dbB, n.id, 2000);
+      const tests = r.items.filter((i) => i.level === "tests").length;
+      impactSummary.push(`| ${n.name} | ${n.kind} | ${r.items.length}${r.truncated ? "+" : ""} | ${tests} |`);
+      impactDetails.push({ symbol: n.name, kind: n.kind, impact_nodes: r.items.length, affected_tests: tests, truncated: r.truncated });
+    } catch {}
+  }
+  folded = foldToModules(diff);
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      range: header,
+      structural_changes: total,
+      modules: Object.fromEntries(folded),
+      nodes_added: diff.nodesAdded,
+      nodes_removed: diff.nodesRemoved,
+      renamed: diff.renamed,
+      edges_added: diff.edgesAdded,
+      edges_removed: diff.edgesRemoved,
+      impact: impactDetails
+    }));
+    process.exit(0);
+  }
+  lines = [
+    `# Change Map`,
+    ``,
+    `> ${header} · 结构变更 ${total} 项`,
+    ``,
+    `## 模块级变化`,
+    ``,
+    `| 模块 | +符号 | -符号 | 重命名 | +依赖 | -依赖 |`,
+    `|---|---|---|---|---|---|`
+  ];
+  for (const [m, v] of [...folded.entries()].sort((a, b) => b[1].added + b[1].removed - (a[1].added + a[1].removed))) {
+    lines.push(`| ${m} | ${v.added} | ${v.removed} | ${v.renamed} | ${v.edgesIn} | ${v.edgesOut} |`);
+  }
+  if (diff.renamed.length > 0) {
+    lines.push(``, `## 重命名`, ``);
+    for (const r of diff.renamed.slice(0, 20))
+      lines.push(`- \`${r.from}\` → \`${r.to}\` (${r.kind}, ${r.file})`);
+  }
+  if (diff.nodesAdded.length > 0) {
+    lines.push(``, `## 新增符号（前 20）`, ``);
+    for (const n of diff.nodesAdded.slice(0, 20))
+      lines.push(`- \`${n.name}\` (${n.kind}) ${n.file}:${n.line}`);
+  }
+  if (diff.nodesRemoved.length > 0) {
+    lines.push(``, `## 删除符号（前 20）`, ``);
+    for (const n of diff.nodesRemoved.slice(0, 20))
+      lines.push(`- \`${n.name}\` (${n.kind}) ${n.file}`);
+  }
+  if (diff.edgesAdded.length > 0) {
+    lines.push(``, `## 新增依赖（前 15）`, ``);
+    for (const e of diff.edgesAdded.slice(0, 15))
+      lines.push(`- ${e.kind}: \`${e.src}\` → \`${e.dst}\` (${e.file}:${e.line})`);
+  }
+  if (diff.edgesRemoved.length > 0) {
+    lines.push(``, `## 删除依赖（前 15）`, ``);
+    for (const e of diff.edgesRemoved.slice(0, 15))
+      lines.push(`- ${e.kind}: \`${e.src}\` → \`${e.dst}\``);
+  }
+  if (impactSummary.length > 0) {
+    lines.push(``, `## 变更符号的影响半径`, ``, `| 符号 | 类型 | 影响节点 | 受影响测试 |`, `|---|---|---|---|`, ...impactSummary);
+  }
+  doc = lines.join(`
+`) + `
+`;
+  if (outPath) {
+    fs3.writeFileSync(outPath, doc);
+    console.error(`written: ${outPath}`);
+  } else {
+    console.log(doc);
+  }
+});
+
+// src/overlay.ts
+import fs4 from "node:fs";
+async function loadOverlay(path) {
+  if (!fs4.existsSync(path))
+    return { modules: {} };
+  return JSON.parse(fs4.readFileSync(path, "utf8"));
+}
+function applyOverlay(rawModules, overlay) {
+  const out = new Map;
+  for (const m of rawModules) {
+    const o = overlay.modules[m] ?? {};
+    let effective = m;
+    for (let i = 0;i < 5; i++) {
+      const next = overlay.modules[effective]?.mergeInto;
+      if (!next || next === effective)
+        break;
+      effective = next;
+    }
+    const display = overlay.modules[effective]?.name ?? effective;
+    out.set(m, { display, effective, hidden: o.hidden ?? overlay.modules[effective]?.hidden ?? false });
+  }
+  return out;
+}
+var init_overlay = () => {};
+
+// src/archmap-html.ts
+var exports_archmap_html = {};
+import fs5 from "node:fs";
+import dagre from "@dagrejs/dagre";
+async function layoutGraph(nodes, edges) {
+  const g = new dagre.graphlib.Graph;
+  g.setGraph({ rankdir: "TB", nodesep: 36, ranksep: 70, marginx: 24, marginy: 24 });
+  g.setDefaultEdgeLabel(() => ({}));
+  for (const n of nodes) {
+    g.setNode(n.id, { width: Math.max(150, n.label.length * 8.5 + 56, (n.meta ?? "").length * 6.8 + 40), height: 58 });
+  }
+  for (const e of edges) {
+    if (e.src !== e.dst)
+      g.setEdge(e.src, e.dst);
+  }
+  dagre.layout(g);
+  const gd = g.graph();
+  return {
+    width: gd.width ?? 900,
+    height: gd.height ?? 600,
+    nodes: g.nodes().map((id) => {
+      const n = g.node(id);
+      return { id, x: n.x - n.width / 2, y: n.y - n.height / 2, w: n.width, h: n.height };
+    }),
+    edges: edges.filter((e) => e.src !== e.dst).map((e) => ({
+      src: e.src,
+      dst: e.dst,
+      points: g.edge(e.src, e.dst)?.points ?? []
+    }))
+  };
+}
+var CLIENT_JS, dbPath3, outFlag2, outPath2, overlayFlag, overlayPath, repoFlag, repoUrl, impactFlag, impactTarget, diffFlag, diffBase, db3, overlay, TEST_RE, moduleOf = (file) => {
+  if (TEST_RE.test(file))
+    return "tests";
+  const ix = file.indexOf("/");
+  return ix < 0 ? "(root)" : file.slice(0, ix);
+}, files, blindRows, blindMap, symRows, symsByFile, fileInfos, importRows, rawModuleNames, ovMap, effModule = (m) => ovMap.get(m)?.effective ?? m, hiddenModules, modules, modEdges, cycles, layouts, impactOverlay = null, diffOverlay = null, data, html;
+var init_archmap_html = __esm(async () => {
+  init_db();
+  init_overlay();
+  init_impact();
+  CLIENT_JS = fs5.readFileSync(new URL("./archmap-client.js", import.meta.url), "utf8");
+  if (CLIENT_JS.includes("</script>"))
+    throw new Error("archmap-client.js must not contain </script>");
+  [dbPath3] = process.argv.slice(2);
+  outFlag2 = process.argv.indexOf("--out");
+  outPath2 = outFlag2 >= 0 ? process.argv[outFlag2 + 1] : "arch.html";
+  overlayFlag = process.argv.indexOf("--overlay");
+  overlayPath = overlayFlag >= 0 ? process.argv[overlayFlag + 1] : undefined;
+  repoFlag = process.argv.indexOf("--repo-url");
+  repoUrl = repoFlag >= 0 ? process.argv[repoFlag + 1] : undefined;
+  impactFlag = process.argv.indexOf("--impact");
+  impactTarget = impactFlag >= 0 ? process.argv[impactFlag + 1] : undefined;
+  diffFlag = process.argv.indexOf("--diff");
+  diffBase = diffFlag >= 0 ? process.argv[diffFlag + 1] : undefined;
+  if (!dbPath3) {
+    console.error("usage: codeblast archmap <graph.db> --out arch.html");
+    process.exit(1);
+  }
+  db3 = openDatabase(dbPath3, { readonly: true });
+  overlay = overlayPath ? await loadOverlay(overlayPath) : { modules: {} };
+  TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\/|(^|\/)tests?\/|(^|\/)test_[^/]*\.py$|_test\.py$|conftest\.py$/;
+  files = db3.prepare("SELECT file FROM nodes WHERE kind = 'file'").all();
+  blindRows = db3.prepare(`SELECT file,
+     SUM(CASE WHEN reason LIKE 'unresolved call%' THEN 0 ELSE 1 END) dyn,
+     SUM(CASE WHEN reason LIKE 'unresolved call%' THEN 1 ELSE 0 END) unres
+   FROM blind_spots WHERE reason NOT LIKE 'test-global%' GROUP BY file`).all();
+  blindMap = new Map(blindRows.map((b) => [b.file, { dyn: b.dyn, unres: b.unres }]));
+  symRows = db3.prepare("SELECT file, name, kind, line FROM nodes WHERE kind NOT IN ('file','module') ORDER BY file, line").all();
+  symsByFile = new Map;
+  for (const s of symRows) {
+    const list = symsByFile.get(s.file) ?? [];
+    list.push({ name: s.name, kind: s.kind, line: s.line });
+    symsByFile.set(s.file, list);
+  }
+  fileInfos = files.map((f) => ({
+    path: f.file,
+    module: moduleOf(f.file),
+    blind: blindMap.get(f.file) ?? { dyn: 0, unres: 0 },
+    symbols: symsByFile.get(f.file) ?? []
+  }));
+  importRows = db3.prepare("SELECT src, dst, line FROM edges WHERE kind = 'imports'").all();
+  rawModuleNames = [...new Set(fileInfos.map((f) => f.module))];
+  ovMap = applyOverlay(rawModuleNames, overlay);
+  for (const fi of fileInfos)
+    fi.module = effModule(fi.module);
+  hiddenModules = new Set([...ovMap.values()].filter((v) => v.hidden).map((v) => v.effective));
+  fileInfos = fileInfos.filter((f) => !hiddenModules.has(f.module));
+  modules = new Map;
+  for (const fi of fileInfos) {
+    const m = modules.get(fi.module) ?? { files: 0, blind: { dyn: 0, unres: 0 } };
+    m.files++;
+    m.blind.dyn += fi.blind.dyn;
+    m.blind.unres += fi.blind.unres;
+    modules.set(fi.module, m);
+  }
+  modEdges = new Map;
+  for (const e of importRows) {
+    const ms = moduleOf(e.src);
+    const md = moduleOf(e.dst);
+    if (ms !== md)
+      modEdges.set(`${ms}→${md}`, (modEdges.get(`${ms}→${md}`) ?? 0) + 1);
+  }
+  cycles = new Set;
+  for (const key of modEdges.keys()) {
+    const [a, b] = key.split("→");
+    if (modEdges.has(`${b}→${a}`)) {
+      cycles.add(key);
+      cycles.add(`${b}→${a}`);
+    }
+  }
+  layouts = {};
+  layouts["__modules__"] = await layoutGraph([...modules.keys()].map((m) => {
+    const o = overlay.modules[m];
+    const b = modules.get(m).blind;
+    const metaParts = [`${modules.get(m).files} files`];
+    if (b.dyn > 0)
+      metaParts.push(`${b.dyn} dyn`);
+    if (b.unres > 0)
+      metaParts.push(`${b.unres} unres`);
+    return { id: m, label: o?.name ?? m, meta: metaParts.join(" · ") };
+  }), [...modEdges.keys()].map((key) => {
+    const [src, dst] = key.split("→");
+    return { src, dst };
+  }));
+  for (const [mod] of modules) {
+    const fs = fileInfos.filter((f) => f.module === mod);
+    if (fs.length === 0 || fs.length > 80)
+      continue;
+    const inSet = new Set(fs.map((f) => f.path));
+    const agg = new Map;
+    for (const e of importRows) {
+      if (inSet.has(e.src) && inSet.has(e.dst) && e.src !== e.dst) {
+        agg.set(`${e.src}→${e.dst}`, { src: e.src, dst: e.dst });
+      }
+    }
+    layouts[mod] = await layoutGraph(fs.map((f) => ({
+      id: f.path,
+      label: f.path.split("/").pop() ?? f.path,
+      meta: `${f.symbols.length} symbols`
+    })), [...agg.values()]);
+  }
+  if (diffBase) {
+    const dbBase = openDatabase(diffBase, { readonly: true });
+    const d = graphDiff(dbBase, db3);
+    const fileStates = {};
+    const moduleCounts = {};
+    const bump = (file, key) => {
+      const m = moduleOf(file);
+      const mc = moduleCounts[m] ?? { added: 0, removed: 0, changed: 0, renamed: 0 };
+      mc[key]++;
+      moduleCounts[m] = mc;
+    };
+    for (const n of d.nodesAdded) {
+      fileStates[n.file] ??= "added";
+      bump(n.file, "added");
+    }
+    for (const n of d.nodesRemoved) {
+      fileStates[n.file] = fileStates[n.file] === "added" ? "changed" : fileStates[n.file] ?? "removed";
+      bump(n.file, "removed");
+    }
+    for (const r of d.renamed) {
+      fileStates[r.file] = "changed";
+      bump(r.file, "renamed");
+    }
+    for (const s of d.signatureChanged) {
+      fileStates[s.file] = "changed";
+      bump(s.file, "changed");
+    }
+    for (const v of d.visibilityChanged) {
+      fileStates[v.file] = "changed";
+      bump(v.file, "changed");
+    }
+    const total = d.nodesAdded.length + d.nodesRemoved.length + d.renamed.length + d.signatureChanged.length + d.visibilityChanged.length;
+    diffOverlay = { fileStates, moduleCounts, summary: `符号 +${d.nodesAdded.length} −${d.nodesRemoved.length} ↻${d.renamed.length} · 签名/可见性 ${d.signatureChanged.length + d.visibilityChanged.length} · 共 ${total} 项` };
+    dbBase.close();
+  }
+  if (impactTarget) {
+    let targetId = impactTarget;
+    const exact = db3.prepare("SELECT id, file FROM nodes WHERE id = ?").get(impactTarget);
+    let targetFile = exact?.file ?? "";
+    if (!exact) {
+      const cands = db3.prepare("SELECT id, file FROM nodes WHERE name = ? AND kind != 'file' LIMIT 2").all(impactTarget);
+      if (cands.length !== 1) {
+        console.error(`--impact: ${cands.length === 0 ? "no match" : "ambiguous"}: ${impactTarget}`);
+        process.exit(1);
+      }
+      targetId = cands[0].id;
+      targetFile = cands[0].file;
+    }
+    const r = impact(db3, targetId, 1e5);
+    const fileLevels = {};
+    const moduleCounts = {};
+    const RANK = { direct: 3, tests: 2, indirect: 1 };
+    for (const it of r.items) {
+      const prev = fileLevels[it.file];
+      if (!prev || RANK[it.level] > RANK[prev])
+        fileLevels[it.file] = it.level;
+      const m = moduleOf(it.file);
+      const mc = moduleCounts[m] ?? { direct: 0, indirect: 0, tests: 0 };
+      mc[it.level]++;
+      moduleCounts[m] = mc;
+    }
+    impactOverlay = { target: targetId, targetFile, fileLevels, moduleCounts };
+  }
+  data = {
+    generated: new Date().toISOString().slice(0, 16).replace("T", " "),
+    layouts,
+    impact: impactOverlay,
+    diff: diffOverlay,
+    repoUrl: repoUrl ?? null,
+    modules: [...modules.entries()].map(([name, v]) => ({ name, ...v })).sort((a, b) => b.files - a.files),
+    moduleMeta: Object.fromEntries([...modules.keys()].map((m) => {
+      const o = overlay.modules[m];
+      return [m, { display: o?.name ?? m, desc: o?.desc ?? "" }];
+    })),
+    modEdges: [...modEdges.entries()].map(([key, w]) => {
+      const [src, dst] = key.split("→");
+      return { src, dst, w, cyclic: cycles.has(key) };
+    }),
+    files: fileInfos,
+    fileEdges: importRows
+  };
+  html = `<!DOCTYPE html>
+<html lang="zh">
+<head>
+<meta charset="utf-8">
+<title>codeblast · Architecture Map</title>
+<style>
+  :root { --bg:#0d1117; --panel:#161b22; --border:#30363d; --fg:#e6edf3; --dim:#8b949e;
+          --accent:#58a6ff; --warn:#f85149; --ok:#3fb950; }
+  * { box-sizing: border-box; margin: 0; }
+  body { background: var(--bg); color: var(--fg); font: 14px/1.5 -apple-system, "Segoe UI", sans-serif; display: flex; height: 100vh; }
+  #graph { background:
+    radial-gradient(ellipse 80% 60% at 50% -10%, #1f6feb14, transparent),
+    radial-gradient(#30363d55 1px, transparent 1px);
+    background-size: auto, 26px 26px; }
+  #graph { flex: 1; position: relative; overflow: hidden; }
+  svg { width: 100%; height: 100%; cursor: grab; }
+  #side { width: 380px; border-left: 1px solid var(--border); background: var(--panel); overflow-y: auto; padding: 16px; }
+  h1 { font-size: 15px; padding: 12px 16px; border-bottom: 1px solid var(--border); background: var(--panel); }
+  h1 small { color: var(--dim); font-weight: normal; margin-left: 8px; }
+  .node rect { fill: url(#nodeFill); stroke: var(--c, var(--accent)); stroke-width: 1.4; rx: 10;
+    cursor: pointer; filter: drop-shadow(0 2px 6px #010409aa); transition: filter .15s; }
+  .node:hover rect { filter: drop-shadow(0 0 8px var(--c, var(--accent))) drop-shadow(0 2px 6px #010409aa); }
+  .node .accentbar { fill: var(--c, var(--accent)); rx: 2; pointer-events: none; }
+  .node.test { --c: var(--ok); }
+  .node.cyc { --c: var(--warn); }
+  .node.imp-direct { --c: #f85149; } .node.imp-direct rect { stroke-width: 2.2; }
+  .node.imp-tests { --c: #d29922; }
+  .node.imp-indirect { --c: #8957e5; }
+  .node.imp-target rect { stroke: #f85149; stroke-width: 3; filter: drop-shadow(0 0 12px #f8514988); }
+  .node.chg-added { --c: var(--ok); } .node.chg-added rect { stroke-width: 2.2; }
+  .node.chg-removed { --c: #6e40c9; opacity: 0.65; }
+  .node.chg-changed { --c: #d29922; } .node.chg-changed rect { stroke-width: 2.2; }
+  #impactbar { padding: 8px 16px; background: #f8514915; border-bottom: 1px solid #f8514944;
+    font-size: 13px; display: flex; gap: 18px; align-items: center; }
+  #impactbar .sw { display: inline-block; width: 10px; height: 10px; border-radius: 3px; margin-right: 5px; vertical-align: -1px; }
+  .node text { fill: var(--fg); font-size: 13.5px; font-weight: 600; pointer-events: none; }
+  .node .meta { fill: var(--dim); font-size: 11px; font-weight: 400; font-family: ui-monospace, Menlo, monospace; }
+  .edge { stroke: #58a6ff55; fill: none; marker-end: url(#arrow); }
+  .edge.mid { stroke-width: 1.8; stroke: #58a6ff77; }
+  .edge.heavy { stroke-width: 2.6; stroke: #58a6ffaa; }
+  .edge.cyclic { stroke: var(--warn); stroke-dasharray: 5 3; stroke-width: 2;
+    animation: cycflow 1.2s linear infinite; }
+  @keyframes cycflow { to { stroke-dashoffset: -16; } }
+  .edge.hi { stroke: #d29922 !important; stroke-width: 2.6; stroke-opacity: 1; }
+  .edge.dim { stroke-opacity: 0.1; }
+  .edge.faint { stroke-opacity: 0.06; }
+  .node.dimn { opacity: 0.3; }
+  #graph { position: relative; }
+  #toolbar { position: absolute; top: 12px; right: 12px; }
+  #toolbar button { background: var(--panel); color: var(--fg); border: 1px solid var(--border);
+    border-radius: 8px; padding: 6px 14px; cursor: pointer; font-size: 13px; }
+  #toolbar button:hover { border-color: var(--accent); }
+  #toolbar button.on { border-color: var(--accent); background: #1f6feb33; }
+  body.editing .node rect { cursor: text; }
+  body.editing .node.sel rect { stroke: #d29922; stroke-width: 3; }
+  .node.hidden-mod { opacity: 0.35; }
+  .node.hidden-mod rect { stroke-dasharray: 4 3; }
+  #editpanel { border-top: 1px solid var(--border); padding: 12px 0; margin-top: 12px; }
+  #editpanel input { width: 100%; background: #0d1117; color: var(--fg); border: 1px solid var(--border);
+    border-radius: 6px; padding: 6px 8px; font-size: 13px; margin: 4px 0 8px; }
+  #editpanel .row { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 8px; }
+  #editpanel button { flex: 1; background: var(--panel); color: var(--fg); border: 1px solid var(--border);
+    border-radius: 6px; padding: 6px 8px; cursor: pointer; font-size: 12.5px; }
+  #editpanel button:hover { border-color: var(--accent); }
+  #editpanel button.primary { background: #1f6feb33; border-color: var(--accent); }
+  #editpanel pre { background: #0d1117; border: 1px solid var(--border); border-radius: 6px;
+    padding: 8px; font-size: 11px; max-height: 180px; overflow: auto; white-space: pre-wrap; }
+  #editpanel .tip { color: var(--dim); font-size: 12px; }
+  .edge-label { fill: var(--dim); font-size: 10px; }
+  .crumb { color: var(--accent); cursor: pointer; }
+  #side h2 { font-size: 14px; margin: 8px 0; }
+  #side .item { padding: 6px 8px; border-radius: 6px; cursor: pointer; display: flex; justify-content: space-between; }
+  #side .item:hover { background: #21262d; }
+  #side .kind { color: var(--dim); font-size: 12px; }
+  #side .blind { color: var(--warn); font-size: 12px; }
+  .hint { color: var(--dim); font-size: 12px; margin-top: 12px; }
+  .cyclic-banner { background: #f8514922; border: 1px solid var(--warn); border-radius: 6px; padding: 8px 10px; margin-bottom: 10px; font-size: 13px; }
+</style>
+</head>
+<body>
+<div style="display:flex;flex-direction:column;flex:1">
+  <h1 id="title">Architecture Map <small id="crumbs"></small></h1>
+  ${data.impact ? `<div id="impactbar"><strong>Impact: ${data.impact.target.split("#").pop()}</strong>
+    <span><span class="sw" style="background:#f85149"></span>直接影响</span>
+    <span><span class="sw" style="background:#d29922"></span>受影响测试</span>
+    <span><span class="sw" style="background:#8957e5"></span>传递影响</span>
+    <span style="color:var(--dim)">未着色 = 不受影响</span></div>` : ""}
+  ${data.diff ? `<div id="impactbar" style="background:#3fb95012;border-color:#3fb95044"><strong>Change Map</strong>
+    <span>${data.diff.summary}</span>
+    <span><span class="sw" style="background:#3fb950"></span>新增</span>
+    <span><span class="sw" style="background:#d29922"></span>修改</span>
+    <span><span class="sw" style="background:#6e40c9"></span>删除</span></div>` : ""}
+  <div id="graph"><svg id="svg"><defs>
+    <marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse">
+      <path d="M 0 0 L 10 5 L 0 10 z" fill="#58a6ff88"/></marker>
+    <linearGradient id="nodeFill" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0" stop-color="#1c2430"/><stop offset="1" stop-color="#151b23"/>
+    </linearGradient>
+  </defs><g id="viewport"></g></svg>
+  <div id="toolbar"><button id="editbtn" onclick="toggleEdit()">✎ 编辑模块</button> <button onclick="toggleFit()">适配 / 100%</button> <button onclick="exportPNG()">导出 PNG</button></div></div>
+</div>
+<div id="side"><h2>概览</h2><div id="detail"></div>
+  <p class="hint">点击模块下钻到文件层;点击文件查看符号。红色虚线 = 循环依赖。滚轮缩放,拖拽平移。</p>
+</div>
+<script>
+const DATA = ${JSON.stringify(data)};
+${CLIENT_JS}</script>
+</body>
+</html>`;
+  fs5.writeFileSync(outPath2, html);
+  console.error(`written: ${outPath2} (${(html.length / 1024).toFixed(0)}KB)`);
+});
+
+// src/archmap.ts
+var exports_archmap = {};
+import fs6 from "node:fs";
+var dbPath4, outFlag3, outPath3, db4, TEST_RE2, moduleOf2 = (file) => {
+  if (TEST_RE2.test(file))
+    return "tests";
+  const ix = file.indexOf("/");
+  return ix < 0 ? "(root)" : file.slice(0, ix);
+}, files2, fileCount, imports, weight, blinds, blindByModule, alias, seq = 0, idOf = (m) => {
+  let a = alias.get(m);
+  if (!a) {
+    a = `M${seq++}`;
+    alias.set(m, a);
+  }
+  return a;
+}, lines2, sorted, sortedEdges, summaryTable, outDeg, inDeg, doc2;
+var init_archmap = __esm(() => {
+  init_db();
+  [dbPath4] = process.argv.slice(2);
+  if (!dbPath4) {
+    console.error("usage: codeblast mermaid <graph.db> [--out file.md]");
+    process.exit(1);
+  }
+  outFlag3 = process.argv.indexOf("--out");
+  outPath3 = outFlag3 >= 0 ? process.argv[outFlag3 + 1] : undefined;
+  db4 = openDatabase(dbPath4, { readonly: true });
+  TEST_RE2 = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\/|(^|\/)tests?\/|(^|\/)test_[^/]*\.py$|_test\.py$|conftest\.py$/;
+  files2 = db4.prepare("SELECT id, file FROM nodes WHERE kind = 'file'").all();
+  fileCount = new Map;
+  for (const f of files2) {
+    const m = moduleOf2(f.file);
+    fileCount.set(m, (fileCount.get(m) ?? 0) + 1);
+  }
+  imports = db4.prepare("SELECT src, dst FROM edges WHERE kind = 'imports'").all();
+  weight = new Map;
+  for (const e of imports) {
+    const ms = moduleOf2(e.src);
+    const md = moduleOf2(e.dst);
+    if (ms === md)
+      continue;
+    const key = `${ms}\x00${md}`;
+    weight.set(key, (weight.get(key) ?? 0) + 1);
+  }
+  blinds = db4.prepare(`SELECT file,
+     SUM(CASE WHEN reason LIKE 'dynamic%' OR reason LIKE 'subprocess%' OR reason LIKE 'star import%' OR reason LIKE 'unresolved self%' OR reason LIKE 'attribute call%' THEN 1 ELSE 0 END) dyn,
+     SUM(CASE WHEN reason LIKE 'unresolved call%' THEN 1 ELSE 0 END) unres
+   FROM blind_spots WHERE reason NOT LIKE 'test-global%' GROUP BY file`).all();
+  blindByModule = new Map;
+  for (const b of blinds) {
+    const m = moduleOf2(b.file);
+    const cur = blindByModule.get(m) ?? { dyn: 0, unres: 0 };
+    cur.dyn += b.dyn;
+    cur.unres += b.unres;
+    blindByModule.set(m, cur);
+  }
+  alias = new Map;
+  lines2 = ["```mermaid", "flowchart TD"];
+  sorted = [...fileCount.entries()].sort((a, b) => b[1] - a[1]);
+  for (const [m, count] of sorted) {
+    const blind = blindByModule.get(m) ?? { dyn: 0, unres: 0 };
+    const parts = [`${count} files`];
+    if (blind.dyn > 0)
+      parts.push(`${blind.dyn} dyn`);
+    if (blind.unres > 0)
+      parts.push(`${blind.unres} unres`);
+    const label = `${m}<br/>${parts.join(" · ")}`;
+    const shape = m === "tests" ? `${idOf(m)}[/"${label}"/]` : `${idOf(m)}["${label}"]`;
+    lines2.push(`    ${shape}`);
+  }
+  sortedEdges = [...weight.entries()].sort((a, b) => b[1] - a[1]);
+  for (const [key, w] of sortedEdges) {
+    const [ms, md] = key.split("\x00");
+    lines2.push(`    ${idOf(ms)} -->|${w}| ${idOf(md)}`);
+  }
+  lines2.push("```");
+  summaryTable = [
+    "",
+    "| 模块 | 文件数 | 动态调用盲区 | 未解析调用 | 出边依赖 | 入边被依赖 |",
+    "|---|---|---|---|---|"
+  ];
+  outDeg = new Map;
+  inDeg = new Map;
+  for (const [key, w] of weight) {
+    const [ms, md] = key.split("\x00");
+    outDeg.set(ms, (outDeg.get(ms) ?? 0) + w);
+    inDeg.set(md, (inDeg.get(md) ?? 0) + w);
+  }
+  for (const [m, count] of sorted) {
+    summaryTable.push(`| ${m} | ${count} | ${blindByModule.get(m)?.dyn ?? 0} | ${blindByModule.get(m)?.unres ?? 0} | ${outDeg.get(m) ?? 0} | ${inDeg.get(m) ?? 0} |`);
+  }
+  doc2 = [
+    `# Architecture Map`,
+    "",
+    `> codeblast M3-v0（目录级折叠）· 节点=模块（含文件数/盲区数），边=import 依赖（数字=强度）`,
+    `> 口径: **dyn** = 结构性动态调用（eval/动态import/子进程/属性链）,静态原理性不可达;`,
+    `> **unres** = 调用目标解析失败（多为缺依赖或复杂表达式）,可能因环境不全而虚高。`,
+    "",
+    ...lines2,
+    ...summaryTable,
+    ""
+  ].join(`
+`);
+  if (outPath3) {
+    fs6.writeFileSync(outPath3, doc2);
+    console.error(`written: ${outPath3}`);
+  } else {
+    console.log(doc2);
+  }
+});
+
+// src/cochange.ts
+var exports_cochange = {};
+var repo, dbPath5, cFlag, N_COMMITS, MIN_CO = 3, MIN_RATIO = 0.5, MAX_FILES_PER_COMMIT = 20, db5, known, log, commits, fileFreq, pairFreq, staticPairs, insert, emitted = 0, samples, writeAll;
+var init_cochange = __esm(() => {
+  init_db();
+  init_proc();
+  [repo, dbPath5] = process.argv.slice(2);
+  if (!repo || !dbPath5) {
+    console.error("usage: codeblast cochange <repo> <graph.db> [--commits 500]");
+    process.exit(1);
+  }
+  cFlag = process.argv.indexOf("--commits");
+  N_COMMITS = cFlag >= 0 ? Number(process.argv[cFlag + 1]) : 500;
+  db5 = openDatabase(dbPath5);
+  known = new Set(db5.prepare("SELECT path FROM files").all().map((r) => r.path));
+  log = spawnSync(["git", "log", "--no-merges", `-${N_COMMITS}`, "--name-only", "--format=%x01%h"], { cwd: repo, maxBuffer: 64 * 1024 * 1024 });
+  if (log.exitCode !== 0) {
+    console.error(log.stderr.slice(0, 300));
+    process.exit(1);
+  }
+  commits = [];
+  for (const block of log.stdout.split("\x01")) {
+    if (!block.trim())
+      continue;
+    const lines = block.trim().split(`
+`);
+    const sha = lines[0].trim();
+    const files = lines.slice(1).map((l) => l.trim()).filter((f) => f && known.has(f));
+    if (files.length >= 2 && files.length <= MAX_FILES_PER_COMMIT)
+      commits.push({ sha, files });
+  }
+  fileFreq = new Map;
+  pairFreq = new Map;
+  for (const c of commits) {
+    for (const f of c.files)
+      fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
+    const sorted = [...c.files].sort();
+    for (let i = 0;i < sorted.length; i++) {
+      for (let j = i + 1;j < sorted.length; j++) {
+        const key = `${sorted[i]}\x00${sorted[j]}`;
+        const e = pairFreq.get(key) ?? { count: 0, lastSha: c.sha };
+        e.count++;
+        e.lastSha = c.sha;
+        pairFreq.set(key, e);
+      }
+    }
+  }
+  staticPairs = new Set;
+  for (const r of db5.prepare("SELECT DISTINCT src, dst FROM edges WHERE kind != 'co_change'").all()) {
+    const fa = r.src.split("#")[0];
+    const fb = r.dst.split("#")[0];
+    if (fa === fb)
+      continue;
+    staticPairs.add([fa, fb].sort().join("\x00"));
+  }
+  db5.prepare("DELETE FROM edges WHERE kind = 'co_change'").run();
+  insert = db5.prepare("INSERT OR REPLACE INTO edges (src, dst, kind, file, line, confidence, src_file) VALUES (?, ?, 'co_change', ?, ?, 'conservative', ?)");
+  samples = [];
+  writeAll = transaction(db5, () => {
+    for (const [key, e] of pairFreq) {
+      if (e.count < MIN_CO)
+        continue;
+      const [a, b] = key.split("\x00");
+      if (staticPairs.has(key))
+        continue;
+      const ratio = Math.max(e.count / fileFreq.get(a), e.count / fileFreq.get(b));
+      if (ratio < MIN_RATIO)
+        continue;
+      insert.run(a, b, a, e.count, `git:${e.lastSha}`);
+      insert.run(b, a, b, e.count, `git:${e.lastSha}`);
+      emitted += 2;
+      if (samples.length < 10)
+        samples.push(`${a} <-> ${b} (${e.count}x, ${(ratio * 100).toFixed(0)}%, ${e.lastSha})`);
+    }
+  });
+  writeAll();
+  console.log(JSON.stringify({ commits_scanned: commits.length, pairs_considered: pairFreq.size, edges_emitted: emitted }, null, 2));
+  for (const s of samples)
+    console.error("  " + s);
+});
+
+// src/pr-silence.ts
+function structuralTotal(diff) {
+  return diff.nodesAdded.length + diff.nodesRemoved.length + diff.renamed.length + diff.edgesAdded.length + diff.edgesRemoved.length + diff.visibilityChanged.length + diff.signatureChanged.length;
+}
+function bodySignalCount(bodyChanged, diffLineCount, hasCallImpact) {
+  let n = 0;
+  for (const fn of bodyChanged) {
+    if (hasCallImpact(fn))
+      n++;
+    else if (!AUX_RE.test(fn.file) && diffLineCount >= BIG_DIFF_LINES)
+      n++;
+  }
+  return n;
+}
+function coreNamedCount(diff, prodNodesAdded) {
+  return diff.edgesAdded.filter((e) => !AUX_RE.test(e.file)).length + prodNodesAdded.filter((n) => !AUX_RE.test(n.file)).length + diff.renamed.filter((r) => !AUX_RE.test(r.file)).length + diff.visibilityChanged.filter((v) => !AUX_RE.test(v.file)).length + diff.signatureChanged.filter((s) => !AUX_RE.test(s.file)).length;
+}
+var TEST_RE3, AUX_RE, BIG_DIFF_LINES = 40;
+var init_pr_silence = __esm(() => {
+  TEST_RE3 = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\/|(^|\/)tests?\//;
+  AUX_RE = /^(www|docs|examples)\//;
+});
+
+// src/pr-comment.ts
+var exports_pr_comment = {};
+import fs7 from "node:fs";
+async function buildGraphAt2(ref, db) {
+  const shaProc = spawnSync(["git", "rev-parse", ref], { cwd: repo2 });
+  const sha = shaProc.exitCode === 0 ? shaProc.stdout.trim() : null;
+  const cache = sha ? `/tmp/codeblast-cache-${sha}.db` : null;
+  if (cache && fs7.existsSync(cache)) {
+    fs7.copyFileSync(cache, db);
+    return;
+  }
+  const wt = `/tmp/codeblast-pr-${ref.slice(0, 12)}`;
+  spawnSync(["git", "worktree", "remove", "--force", wt], { cwd: repo2 });
+  const add = spawnSync(["git", "worktree", "add", "--detach", wt, ref], { cwd: repo2 });
+  if (add.exitCode !== 0)
+    throw new Error(add.stderr.slice(0, 300));
+  try {
+    const p = spawnSync(selfCommand("index", wt, "--db", db));
+    if (p.exitCode !== 0)
+      throw new Error(p.stderr.slice(0, 500));
+    const ck = openDatabase(db);
+    ck.exec("PRAGMA wal_checkpoint(TRUNCATE);");
+    ck.close();
+    if (cache)
+      fs7.copyFileSync(db, cache);
+  } finally {
+    spawnSync(["git", "worktree", "remove", "--force", wt], { cwd: repo2 });
+  }
+}
+var args3, repo2, baseSha, headSha, urlFlag, repoUrl2, dbPathA = "/tmp/codeblast-pr-base.db", dbPathB = "/tmp/codeblast-pr-head.db", dbA2, dbB2, diff2, total2, structuralIds, bodyChanged, link = (file, line) => repoUrl2 ? `[${file}:${line}](${repoUrl2}/blob/${headSha}/${file}#L${line})` : `${file}:${line}`, lines3, folded2, sigView = (s) => {
+  let d = 0;
+  while (d < s.from.length && d < s.to.length && s.from[d] === s.to[d])
+    d++;
+  const ctx = Math.max(0, d - 15);
+  const clip = (t) => (ctx > 0 ? "…" : "") + t.slice(ctx, ctx + 70).replace(/`/g, "'") + (t.length > ctx + 70 ? "…" : "");
+  const wrap = s.kind === "interface" || s.kind === "const" ? (t) => t : (t) => `(${t})`;
+  const what = s.kind === "interface" ? "成员变化" : s.kind === "const" ? "类型变化" : "";
+  return `- \`${s.name}\`${what ? ` ${what}` : ""}: \`${wrap(clip(s.from))}\` → \`${wrap(clip(s.to))}\` （${link(s.file, s.line)}）`;
+}, apiSig, testSig, uncovered, impactRows, prodNodesAdded, diffLineCount, bodySignal, coreNamed;
+var init_pr_comment = __esm(async () => {
+  init_db();
+  init_proc();
+  init_impact();
+  init_pr_silence();
+  args3 = process.argv.slice(2);
+  [repo2, baseSha, headSha] = args3;
+  if (!repo2 || !baseSha || !headSha) {
+    console.error("usage: codeblast pr-comment <repo> <base-sha> <head-sha> [--repo-url <url>]");
+    process.exit(1);
+  }
+  urlFlag = args3.indexOf("--repo-url");
+  repoUrl2 = urlFlag >= 0 ? args3[urlFlag + 1] : undefined;
+  for (const f of [dbPathA, dbPathB])
+    for (const s of ["", "-wal", "-shm"])
+      fs7.rmSync(f + s, { force: true });
+  await buildGraphAt2(baseSha, dbPathA);
+  await buildGraphAt2(headSha, dbPathB);
+  dbA2 = openDatabase(dbPathA, { readonly: true });
+  dbB2 = openDatabase(dbPathB, { readonly: true });
+  diff2 = graphDiff(dbA2, dbB2);
+  total2 = structuralTotal(diff2);
+  structuralIds = new Set([...diff2.nodesAdded.map((n) => n.id), ...diff2.renamed.map((r) => `${r.file}#${r.to}`)]);
+  bodyChanged = [];
+  {
+    const diffOut = spawnSync(["git", "diff", "--unified=0", baseSha, headSha, "--", "*.ts", "*.tsx"], { cwd: repo2, maxBuffer: 64 * 1024 * 1024 }).stdout;
+    const findFn = dbB2.prepare("SELECT id, name, kind, file, line FROM nodes WHERE file = ? AND kind IN ('function','method') AND line <= ? AND end_line >= ? ORDER BY (end_line - line) ASC LIMIT 1");
+    let curFile = "";
+    const seen = new Set;
+    for (const ln of diffOut.split(`
+`)) {
+      const fm = ln.match(/^\+\+\+ b\/(.+)$/);
+      if (fm) {
+        curFile = fm[1];
+        continue;
+      }
+      const hm = ln.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+      if (!hm || !curFile || TEST_RE3.test(curFile))
+        continue;
+      const start = Number(hm[1]);
+      const count = hm[2] === undefined ? 1 : Number(hm[2]);
+      for (const probe of [start, start + Math.max(0, count - 1)]) {
+        const fn = findFn.get(curFile, probe, probe);
+        if (fn && !structuralIds.has(fn.id) && !seen.has(fn.id)) {
+          seen.add(fn.id);
+          bodyChanged.push(fn);
+        }
+      }
+    }
+  }
+  if (total2 === 0 && bodyChanged.length === 0)
+    process.exit(0);
+  lines3 = [
+    `## \uD83E\uDDED codeblast · 结构变更分析`,
+    ``,
+    `**${total2} 项结构变更**（符号 +${diff2.nodesAdded.length} −${diff2.nodesRemoved.length} ↻${diff2.renamed.length}，依赖边 +${diff2.edgesAdded.length} −${diff2.edgesRemoved.length}）`,
+    ``
+  ];
+  folded2 = foldToModules(diff2);
+  if (folded2.size > 1) {
+    lines3.push(`| 模块 | 符号变化 | 依赖变化 |`, `|---|---|---|`);
+    for (const [m, v] of folded2) {
+      lines3.push(`| ${m} | +${v.added} −${v.removed} ↻${v.renamed} | +${v.edgesIn} −${v.edgesOut} |`);
+    }
+    lines3.push(``);
+  }
+  if (diff2.renamed.length > 0) {
+    lines3.push(`### 重命名`, ``);
+    for (const r of diff2.renamed.slice(0, 10)) {
+      lines3.push(`- \`${r.from}\` → \`${r.to}\` (${r.kind})`);
+    }
+    if (diff2.renamed.length > 10)
+      lines3.push(`- …及另外 ${diff2.renamed.length - 10} 项`);
+    lines3.push(``);
+  }
+  if (diff2.visibilityChanged.length > 0) {
+    lines3.push(`### 可见性变化（公共 API 面）`, ``);
+    for (const v of diff2.visibilityChanged.slice(0, 10)) {
+      lines3.push(`- \`${v.name}\` (${v.kind}) ${v.nowExported ? "转为导出" : "**不再导出**"} （${link(v.file, v.line)}）`);
+    }
+    lines3.push(``);
+  }
+  apiSig = diff2.signatureChanged.filter((s) => !TEST_RE3.test(s.file));
+  testSig = diff2.signatureChanged.filter((s) => TEST_RE3.test(s.file));
+  if (apiSig.length > 0) {
+    lines3.push(`### 签名变更（公共 API 面）`, ``, ...apiSig.slice(0, 10).map(sigView));
+    if (apiSig.length > 10)
+      lines3.push(`- …及另外 ${apiSig.length - 10} 项`);
+    lines3.push(``);
+  }
+  if (testSig.length > 0) {
+    lines3.push(`### 测试助手签名变更`, ``, ...testSig.slice(0, 5).map(sigView), ``);
+  }
+  if (diff2.edgesAdded.length > 0) {
+    lines3.push(`### 新增依赖`, ``);
+    for (const e of diff2.edgesAdded.slice(0, 10)) {
+      const srcName = e.src.split("#").pop();
+      const dstName = e.dst.split("#").pop();
+      lines3.push(`- \`${srcName}\` → \`${dstName}\` （${link(e.file, e.line)}）`);
+    }
+    if (diff2.edgesAdded.length > 10)
+      lines3.push(`- …及另外 ${diff2.edgesAdded.length - 10} 条`);
+    lines3.push(``);
+  }
+  uncovered = [];
+  impactRows = [];
+  prodNodesAdded = diff2.nodesAdded.filter((n) => !TEST_RE3.test(n.file));
+  for (const n of prodNodesAdded.slice(0, 15)) {
+    try {
+      const r = impact(dbB2, n.id, 2000);
+      const callItems = r.items.filter((i) => i.channel === "call");
+      const tests = callItems.filter((i) => i.level === "tests").length;
+      impactRows.push(`| \`${n.name}\` | ${n.kind} | ${callItems.length} | ${tests} | ${link(n.file, n.line)} |`);
+      const blind = r.blind_spot_count > 0;
+      if (tests === 0 && n.kind !== "interface" && n.kind !== "const") {
+        uncovered.push(`- \`${n.name}\` （${link(n.file, n.line)}）${blind ? " — 所在文件含动态调用,覆盖可能未被静态识别" : ""}`);
+      }
+    } catch {}
+  }
+  if (impactRows.length > 0) {
+    lines3.push(`### 新增符号的影响半径（仅调用链可达,不含 import 粗粒度）`, ``, `| 符号 | 类型 | 调用链影响 | 受影响测试 | 位置 |`, `|---|---|---|---|---|`, ...impactRows, ``);
+  }
+  if (uncovered.length > 0) {
+    lines3.push(`### ⚠️ 无测试覆盖的新增符号`, ``, ...uncovered, ``);
+  }
+  diffLineCount = spawnSync(["git", "diff", "--numstat", baseSha, headSha], { cwd: repo2, maxBuffer: 16 * 1024 * 1024 }).stdout.split(`
+`).reduce((sum, l) => {
+    const m = l.match(/^(\d+)\t(\d+)\t/);
+    return sum + (m ? Number(m[1]) + Number(m[2]) : 0);
+  }, 0);
+  bodySignal = bodySignalCount(bodyChanged, diffLineCount, (fn) => {
+    try {
+      return impact(dbB2, fn.id, 2000).items.some((i) => i.channel === "call");
+    } catch {
+      return false;
+    }
+  });
+  coreNamed = coreNamedCount(diff2, prodNodesAdded);
+  if (coreNamed + bodySignal === 0)
+    process.exit(0);
+  if (bodyChanged.length > 0) {
+    const rows = [];
+    for (const fn of bodyChanged.slice(0, 12)) {
+      try {
+        const r = impact(dbB2, fn.id, 2000);
+        const callItems = r.items.filter((i) => i.channel === "call");
+        const tests = callItems.filter((i) => i.level === "tests").length;
+        rows.push(`| \`${fn.name}\` | ${callItems.length} | ${tests} | ${link(fn.file, fn.line)} |`);
+      } catch {}
+    }
+    if (rows.length > 0) {
+      lines3.push(`### 函数体内改动（结构未变,行为可能变）`, ``, `| 函数 | 调用链影响 | 受影响测试 | 位置 |`, `|---|---|---|---|`, ...rows, ``);
+    }
+    if (bodyChanged.length > 12)
+      lines3.push(`…及另外 ${bodyChanged.length - 12} 个函数`, ``);
+  }
+  if (total2 === 0 && bodyChanged.length > 0) {
+    lines3[2] = `**无结构变更**,但有 ${bodyChanged.length} 个函数体内改动（见下）`;
+  }
+  lines3.push(`<sub>由 [codeblast](https://github.com/alloevil/codeblast) 生成 · 每条结论基于静态分析,含证据链接 · 动态调用盲区不在本报告内 · 评论不准?[30 秒反馈](https://github.com/alloevil/codeblast/issues/new?template=bot-feedback.yml&title=${encodeURIComponent(`[feedback] ${baseSha.slice(0, 7)}..${headSha.slice(0, 7)}`)})</sub>`);
+  console.log(lines3.join(`
+`));
+});
+
+// src/demo.ts
+var exports_demo = {};
+import fs8 from "node:fs";
+import path3 from "node:path";
+var repo3, db6 = "/tmp/codeblast-demo.db", out = "/tmp/codeblast-demo-arch.html", run = (label, args) => {
+  console.log(`
+\x1B[36m▸ ${label}\x1B[0m`);
+  console.log(`  $ codeblast ${args.slice(2).join(" ")}`);
+  const p = spawnSync(args);
+  if (p.exitCode !== 0) {
+    console.error(p.stderr.slice(-800) || p.stdout.slice(-800));
+    console.error(`
+\x1B[31m✗ step failed: ${label}\x1B[0m`);
+    process.exit(p.exitCode);
+  }
+  process.stdout.write(p.stdout.split(`
+`).slice(0, 14).map((l) => "  " + l).join(`
+`) + `
+`);
+  return p.stdout;
+}, conn, pick;
+var init_demo = __esm(() => {
+  init_db();
+  init_proc();
+  repo3 = path3.resolve(process.argv[2] ?? path3.join(import.meta.dirname, ".."));
+  console.log(`codeblast demo — target: ${repo3}`);
+  for (const s of ["", "-wal", "-shm"])
+    fs8.rmSync(db6 + s, { force: true });
+  run("1/4 build graph", selfCommand("index", repo3, "--db", db6));
+  run("2/4 incremental rerun (should skip everything)", selfCommand("index", repo3, "--db", db6));
+  conn = openDatabase(db6, { readonly: true });
+  pick = conn.prepare(`SELECT n.id, COUNT(DISTINCT e.src) c FROM nodes n
+   JOIN edges e ON e.dst = n.id AND e.kind = 'calls'
+   WHERE n.kind IN ('function','method','class') AND n.exported = 1
+   GROUP BY n.id ORDER BY c DESC LIMIT 1`).get();
+  conn.close();
+  if (pick) {
+    run(`3/4 impact of the most-called export (${pick.id.split("#").pop()}, ${pick.c} callers)`, selfCommand("impact", db6, pick.id));
+  } else {
+    console.log(`
+▸ 3/4 impact — skipped: no exported symbol with callers in this repo`);
+  }
+  run("4/4 interactive architecture map", selfCommand("archmap", db6, "--out", out));
+  console.log(`
+\x1B[32m✓ demo complete\x1B[0m
+  graph:  ${db6}
+  map:    ${out}   ← open this in a browser
+  next:   codeblast impact ${db6} "<symbol>"
+          codeblast change <repo> HEAD~1 HEAD
+  live demos: https://alloevil.github.io/codeblast/`);
+});
+
+// src/name-modules.ts
+var exports_name_modules = {};
+import fs9 from "node:fs";
+var dbPath6, overlayFlag2, overlayPath2, db7, TEST_RE4, files3, byModule, symStmt, evidence, prompt, cmd;
+var init_name_modules = __esm(async () => {
+  init_db();
+  init_proc();
+  init_overlay();
+  [dbPath6] = process.argv.slice(2);
+  overlayFlag2 = process.argv.indexOf("--overlay");
+  overlayPath2 = overlayFlag2 >= 0 ? process.argv[overlayFlag2 + 1] : "codeblast.overlay.json";
+  if (!dbPath6) {
+    console.error("usage: codeblast name-modules <graph.db> --overlay codeblast.overlay.json");
+    process.exit(1);
+  }
+  db7 = openDatabase(dbPath6, { readonly: true });
+  TEST_RE4 = /\.(test|spec)\.[cm]?[jt]sx?$|__tests__\/|(^|\/)tests?\/|(^|\/)test_[^/]*\.py$|_test\.py$|conftest\.py$/;
+  files3 = db7.prepare("SELECT file FROM nodes WHERE kind='file'").all();
+  byModule = new Map;
+  for (const { file } of files3) {
+    const m = TEST_RE4.test(file) ? "tests" : file.includes("/") ? file.slice(0, file.indexOf("/")) : "(root)";
+    const list = byModule.get(m) ?? [];
+    list.push(file);
+    byModule.set(m, list);
+  }
+  symStmt = db7.prepare("SELECT DISTINCT name FROM nodes WHERE exported=1 AND kind IN ('function','class','method') AND file LIKE ? LIMIT 15");
+  evidence = {};
+  for (const [mod, fs] of byModule) {
+    const prefix = mod === "(root)" ? "" : mod + "/";
+    const exports = mod === "(root)" ? [] : symStmt.all(prefix + "%").map((r) => r.name);
+    evidence[mod] = { files: fs.slice(0, 15).map((f) => f.replace(prefix, "")), exports };
+  }
+  prompt = `你是代码架构分析器。基于每个模块的文件清单和导出符号，给出中文人话名（≤8字）和一句话职责（≤25字）。
+只输出 JSON，格式：{"<模块目录名>": {"name": "<人话名>", "desc": "<职责>"}}
+不要编造证据里看不到的功能。证据：
+${JSON.stringify(evidence, null, 1)}`;
+  cmd = process.env.LLM_CMD;
+  if (!cmd) {
+    const applyFlag = process.argv.indexOf("--apply");
+    if (applyFlag >= 0) {
+      const namesJson = JSON.parse(fs9.readFileSync(process.argv[applyFlag + 1], "utf8"));
+      const overlay = await loadOverlay(overlayPath2);
+      for (const [mod, v] of Object.entries(namesJson)) {
+        const existing = overlay.modules[mod];
+        if (existing?.name)
+          continue;
+        overlay.modules[mod] = { ...existing, name: `${v.name}`, ...v.desc ? {} : {} };
+        overlay.modules[mod].desc = v.desc;
+      }
+      fs9.writeFileSync(overlayPath2, JSON.stringify(overlay, null, 2));
+      console.error(`overlay written: ${overlayPath2}`);
+    } else {
+      console.log(prompt);
+    }
+  } else {
+    const proc = spawnSync(["sh", "-c", cmd], { input: prompt });
+    const raw = proc.stdout.trim();
+    const jsonStart = raw.indexOf("{");
+    const namesJson = JSON.parse(raw.slice(jsonStart));
+    const overlay = await loadOverlay(overlayPath2);
+    for (const [mod, v] of Object.entries(namesJson)) {
+      if (overlay.modules[mod]?.name)
+        continue;
+      overlay.modules[mod] = { ...overlay.modules[mod], name: v.name };
+      overlay.modules[mod].desc = v.desc;
+    }
+    fs9.writeFileSync(overlayPath2, JSON.stringify(overlay, null, 2));
+    console.error(`overlay written: ${overlayPath2}`);
+  }
+});
+
+// src/bin.ts
+var ROUTES = {
+  index: () => Promise.resolve().then(() => (init_cli(), exports_cli)),
+  impact: () => Promise.resolve().then(() => (init_impact_cli(), exports_impact_cli)),
+  change: () => init_change_cli().then(() => exports_change_cli),
+  archmap: () => init_archmap_html().then(() => exports_archmap_html),
+  mermaid: () => Promise.resolve().then(() => (init_archmap(), exports_archmap)),
+  cochange: () => Promise.resolve().then(() => (init_cochange(), exports_cochange)),
+  "pr-comment": () => init_pr_comment().then(() => exports_pr_comment),
+  demo: () => Promise.resolve().then(() => (init_demo(), exports_demo)),
+  "name-modules": () => init_name_modules().then(() => exports_name_modules)
+};
+var [cmd2, ...rest] = process.argv.slice(2);
+if (!cmd2 || cmd2 === "--help" || cmd2 === "-h" || !ROUTES[cmd2]) {
+  console.log(`codeblast — deterministic code graph: architecture, change & impact maps
+
+usage: codeblast <command> [args]
+
+  index     <repo> [--db graph.db]              build/update the graph (incremental)
+  impact    <graph.db> <symbol> [--json]        blast radius of a change
+  change    <repo> <ref-a> <ref-b> [--json]     structural diff between two refs
+  archmap   <graph.db> --out arch.html          interactive architecture map
+            [--impact <sym>] [--diff <base.db>]   ...with impact / change overlay
+  mermaid   <graph.db>                          module map as mermaid
+  cochange  <repo> <graph.db>                   mine git history coupling
+  pr-comment <repo> <base-sha> <head-sha>       PR review comment (silent if no change)
+  demo      [repo]                              build + query + map in one shot
+
+docs: https://github.com/alloevil/codeblast · demos: https://alloevil.github.io/codeblast/`);
+  process.exit(cmd2 && !ROUTES[cmd2] ? 1 : 0);
+}
+process.argv.splice(2, 1);
+await ROUTES[cmd2]();