@surething/cockpit 1.0.272 → 1.0.273

package/dist/wsServer.mjs

@@ -36,6 +36,10 @@ import {
   ValidationError,
   WSError
 } from "./chunk-4EU4KZIO.mjs";
+import {
+  registerWatcherSubscriber,
+  subscribeBuildProgress
+} from "./chunk-UG6WUXIQ.mjs";
 import "./chunk-7P6ASYW6.mjs";
 
 // src/lib/wsServer.ts
@@ -71,10 +75,10 @@ var fromWebSocket = (ws, proto) => Effect_exports.gen(function* () {
       ws.on("error", onError);
       return { onMessage, onClose, onError };
     }),
-    (handlers2) => Effect_exports.sync(() => {
-      ws.off("message", handlers2.onMessage);
-      ws.off("close", handlers2.onClose);
-      ws.off("error", handlers2.onError);
+    (handlers) => Effect_exports.sync(() => {
+      ws.off("message", handlers.onMessage);
+      ws.off("close", handlers.onClose);
+      ws.off("error", handlers.onError);
     })
   );
   const send = (msg) => Effect_exports.try({
@@ -423,33 +427,6 @@ var g_watch = globalThis;
 var fileWatcher = g_watch.__cockpitFileWatcher ?? (g_watch.__cockpitFileWatcher = new FileWatcherManager());
 var reviewWatcher = g_watch.__cockpitReviewWatcher ?? (g_watch.__cockpitReviewWatcher = new ReviewWatcher());
 
-// packages/feature/explorer/src/server/codeMap/projectGraph/buildProgress.ts
-var g = globalThis;
-var listeners = g.__cockpitGraphProgressListeners ?? (g.__cockpitGraphProgressListeners = /* @__PURE__ */ new Map());
-var lastFrame = g.__cockpitGraphProgressLastFrame ?? (g.__cockpitGraphProgressLastFrame = /* @__PURE__ */ new Map());
-var lastEmitAt = g.__cockpitGraphProgressLastEmitAt ?? (g.__cockpitGraphProgressLastEmitAt = /* @__PURE__ */ new Map());
-function subscribeBuildProgress(cwd, fn) {
-  let set = listeners.get(cwd);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    listeners.set(cwd, set);
-  }
-  set.add(fn);
-  const snapshot = lastFrame.get(cwd);
-  if (snapshot) {
-    try {
-      fn(snapshot);
-    } catch {
-    }
-  }
-  return () => {
-    const s = listeners.get(cwd);
-    if (!s) return;
-    s.delete(fn);
-    if (s.size === 0) listeners.delete(cwd);
-  };
-}
-
 // src/lib/effect/fileWatchHandler.ts
 var HEARTBEAT = Schedule_exports.spaced("30 seconds");
 var fileEvents = (cwd) => Stream_exports.unwrapScoped(
@@ -1412,2788 +1389,24 @@ var runSessionStreamHandler = (ws, sessionId) => {
   });
 };
 
-// packages/feature/explorer/src/server/codeMap/projectGraph/codeIndex.ts
-import { promises as fs4 } from "fs";
-import path6 from "path";
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-
-// packages/feature/explorer/src/server/codeMap/projectGraph/buildGraph.ts
-import { exec } from "child_process";
-import { promises as fs } from "fs";
-import path from "path";
-import { promisify } from "util";
-
-// packages/feature/explorer/src/server/codeMap/handlers/registry.ts
-var handlers = /* @__PURE__ */ new Map();
-function registerHandler(handler) {
-  handlers.set(handler.grammarId, handler);
-}
-
-// packages/feature/explorer/src/server/codeMap/projectGraph/buildGraph.ts
-var execAsync = promisify(exec);
-var RESOLUTION_EXT = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var STRIPPABLE_EXT = [".js", ".jsx", ".mjs", ".cjs"];
-function findFileForBase(baseAbs, cwd, fileSet) {
-  let baseRel = path.relative(cwd, baseAbs);
-  if (baseRel.startsWith("..")) return null;
-  for (const ext of STRIPPABLE_EXT) {
-    if (baseRel.endsWith(ext)) {
-      baseRel = baseRel.slice(0, -ext.length);
-      break;
-    }
-  }
-  if (fileSet.has(baseRel)) return baseRel;
-  for (const ext of RESOLUTION_EXT) {
-    const c = baseRel + ext;
-    if (fileSet.has(c)) return c;
-  }
-  for (const ext of RESOLUTION_EXT) {
-    const c = path.join(baseRel, "index" + ext);
-    if (fileSet.has(c)) return c;
-  }
-  return null;
-}
-function fileInScope(file, scope) {
-  return scope === "" || file === scope || file.startsWith(scope + "/");
-}
-async function loadWorkspaces(cwd, fileSet) {
-  const patterns = await readWorkspacePatterns(cwd);
-  if (patterns.length === 0) return /* @__PURE__ */ new Map();
-  let pkgJsonPaths = [];
-  try {
-    const { stdout } = await execAsync(
-      "git -c core.quotePath=false ls-files --cached --others --exclude-standard",
-      { cwd, maxBuffer: 50 * 1024 * 1024 }
-    );
-    pkgJsonPaths = stdout.split("\n").map((p) => p.trim()).filter((p) => p.endsWith("/package.json") && !p.includes("node_modules/"));
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-  const matched = pkgJsonPaths.filter((p) => {
-    const dir = p.slice(0, -"/package.json".length);
-    return patterns.some((pat) => globMatchesDir(dir, pat));
-  });
-  const result = /* @__PURE__ */ new Map();
-  for (const rel of matched) {
-    let pkg;
-    try {
-      pkg = JSON.parse(await fs.readFile(path.join(cwd, rel), "utf8"));
-    } catch {
-      continue;
-    }
-    if (typeof pkg.name !== "string") continue;
-    const dir = path.dirname(rel);
-    const entryFile = resolveWorkspaceEntry(dir, pkg, fileSet);
-    result.set(pkg.name, { name: pkg.name, dir, entryFile });
-  }
-  return result;
-}
-async function readWorkspacePatterns(cwd) {
-  try {
-    const yaml = await fs.readFile(path.join(cwd, "pnpm-workspace.yaml"), "utf8");
-    return parsePnpmWorkspaces(yaml);
-  } catch {
-  }
-  try {
-    const pkg = JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf8"));
-    const ws = pkg?.workspaces;
-    if (Array.isArray(ws)) return ws.filter((s) => typeof s === "string");
-    if (ws && Array.isArray(ws.packages)) {
-      return ws.packages.filter((s) => typeof s === "string");
-    }
-  } catch {
-  }
-  return [];
-}
-function parsePnpmWorkspaces(yaml) {
-  const out = [];
-  let inPackages = false;
-  for (const rawLine of yaml.split("\n")) {
-    const line = rawLine.replace(/#.*$/, "");
-    if (/^packages\s*:/.test(line)) {
-      inPackages = true;
-      continue;
-    }
-    if (!inPackages) continue;
-    const itemMatch = line.match(/^\s*-\s*['"]?([^'"#\s]+)['"]?\s*$/);
-    if (itemMatch) {
-      out.push(itemMatch[1]);
-    } else if (/^\S/.test(line)) {
-      inPackages = false;
-    }
-  }
-  return out;
-}
-function globMatchesDir(dir, pattern) {
-  const re = new RegExp(
-    "^" + pattern.replace(/\\/g, "/").replace(/[.+^${}()|[\]]/g, "\\$&").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLESTAR___/g, ".*") + "$"
-  );
-  return re.test(dir);
-}
-function resolveWorkspaceEntry(pkgDir, pkg, fileSet) {
-  const tryRelToPkg = (subpath) => {
-    const cleaned = subpath.replace(/^\.\//, "");
-    return findFileRelativeToProject(path.posix.join(pkgDir, cleaned), fileSet);
-  };
-  const exp = pkg.exports;
-  let exportEntry;
-  if (typeof exp === "string") {
-    exportEntry = exp;
-  } else if (exp && typeof exp === "object" && exp["."]) {
-    const dot = exp["."];
-    if (typeof dot === "string") exportEntry = dot;
-    else if (dot && typeof dot === "object") {
-      exportEntry = dot["types"] ?? dot["import"] ?? dot["default"] ?? dot["require"];
-    }
-  }
-  if (typeof exportEntry === "string") {
-    const r = tryRelToPkg(exportEntry);
-    if (r) return r;
-  }
-  if (typeof pkg.main === "string") {
-    const r = tryRelToPkg(pkg.main);
-    if (r) return r;
-  }
-  for (const conv of ["src/index.ts", "src/index.tsx", "index.ts", "index.tsx", "src/index.js", "index.js"]) {
-    if (fileSet.has(path.posix.join(pkgDir, conv))) {
-      return path.posix.join(pkgDir, conv);
-    }
-  }
-  return null;
-}
-function findFileRelativeToProject(baseRel, fileSet) {
-  if (baseRel.startsWith("..") || baseRel.startsWith("/")) return null;
-  for (const ext of STRIPPABLE_EXT) {
-    if (baseRel.endsWith(ext)) {
-      baseRel = baseRel.slice(0, -ext.length);
-      break;
-    }
-  }
-  if (fileSet.has(baseRel)) return baseRel;
-  for (const ext of RESOLUTION_EXT) {
-    const c = baseRel + ext;
-    if (fileSet.has(c)) return c;
-  }
-  for (const ext of RESOLUTION_EXT) {
-    const c = path.posix.join(baseRel, "index" + ext);
-    if (fileSet.has(c)) return c;
-  }
-  return null;
-}
-async function parseTsconfigAliases(filePath, cwd) {
-  const aliases = /* @__PURE__ */ new Map();
-  let json;
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    const stripped = raw.replace(/^\s*\/\/.*$/gm, "");
-    json = JSON.parse(stripped);
-  } catch {
-    return aliases;
-  }
-  const baseUrl = json?.compilerOptions?.baseUrl ?? ".";
-  const pathsMap = json?.compilerOptions?.paths ?? {};
-  const absBase = path.resolve(path.dirname(filePath), baseUrl);
-  const relBase = path.relative(cwd, absBase) || ".";
-  for (const [key, vals] of Object.entries(pathsMap)) {
-    if (!Array.isArray(vals) || vals.length === 0) continue;
-    const cleanKey = key.replace(/\/\*$/, "");
-    const cleanVal = vals[0].replace(/\/\*$/, "");
-    aliases.set(cleanKey, path.join(relBase, cleanVal));
-  }
-  return aliases;
-}
-async function loadTsconfigs(cwd) {
-  const scopes = [];
-  let tsconfigPaths = [];
-  try {
-    const { stdout } = await execAsync(
-      "git -c core.quotePath=false ls-files --cached --others --exclude-standard",
-      { cwd, maxBuffer: 50 * 1024 * 1024 }
-    );
-    tsconfigPaths = stdout.split("\n").map((p) => p.trim()).filter((p) => /(^|\/)tsconfig[^/]*\.json$/.test(p) && !p.includes("node_modules/"));
-  } catch {
-    try {
-      await fs.access(path.join(cwd, "tsconfig.json"));
-      tsconfigPaths = ["tsconfig.json"];
-    } catch {
-    }
-  }
-  for (const rel of tsconfigPaths) {
-    const aliases = await parseTsconfigAliases(path.join(cwd, rel), cwd);
-    if (aliases.size === 0) continue;
-    const scope = path.dirname(rel);
-    scopes.push({
-      scope: scope === "." ? "" : scope,
-      aliases,
-      sortedAliases: sortAliasesByLength(aliases)
-    });
-  }
-  let root = scopes.find((s) => s.scope === "");
-  if (!root) {
-    const aliases = /* @__PURE__ */ new Map();
-    root = { scope: "", aliases, sortedAliases: [] };
-    scopes.push(root);
-  }
-  if (!root.aliases.has("@")) {
-    root.aliases.set("@", "./src");
-    root.sortedAliases = sortAliasesByLength(root.aliases);
-  }
-  return scopes.sort((a, b) => b.scope.length - a.scope.length);
-}
-function sortAliasesByLength(aliases) {
-  return [...aliases.entries()].sort(([a], [b]) => b.length - a.length);
-}
-
-// packages/feature/explorer/src/server/codeMap/handlers/typescript.ts
-import path2 from "path";
-
-// packages/feature/explorer/src/server/codeMap/extractSymbols.ts
-function hashText(s) {
-  let h1 = 3735928559;
-  let h2 = 1103547991;
-  for (let i = 0; i < s.length; i++) {
-    const ch = s.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  return (4294967296 * (2097151 & h2) + (h1 >>> 0) >>> 0).toString(16);
-}
-function normalizeForHash(s) {
-  return s.replace(/\s+/g, " ").trim();
-}
-function qualify(parent, name) {
-  return parent ? `${parent}>${name}` : name;
-}
-function nameOf(node) {
-  const named = node.childForFieldName("name");
-  if (named) return named.text;
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (c && (c.type === "identifier" || c.type === "type_identifier" || c.type === "property_identifier")) {
-      return c.text;
-    }
-  }
-  return "<anonymous>";
-}
-function makeSymbol(node, name, kind, parentQname, children = [], params) {
-  return {
-    qualifiedName: qualify(parentQname, name),
-    name,
-    kind,
-    // tree-sitter rows are 0-based; we expose 1-based for UI alignment.
-    startLine: node.startPosition.row + 1,
-    endLine: node.endPosition.row + 1,
-    contentHash: hashText(normalizeForHash(node.text)),
-    children,
-    params
-  };
-}
-function paramText(p) {
-  switch (p.type) {
-    case "required_parameter":
-    case "optional_parameter": {
-      const pat = p.childForFieldName("pattern");
-      return pat ? paramText(pat) : p.text;
-    }
-    case "assignment_pattern": {
-      const left = p.childForFieldName("left");
-      return left ? paramText(left) : p.text;
-    }
-    case "default_parameter":
-    case "typed_default_parameter": {
-      const name = p.childForFieldName("name");
-      return name ? name.text : p.text;
-    }
-    case "typed_parameter": {
-      for (let i = 0; i < p.namedChildCount; i++) {
-        const c = p.namedChild(i);
-        if (c?.type === "identifier") return c.text;
-      }
-      return p.text;
-    }
-    // Identifiers, splat patterns, destructuring patterns — text as-is.
-    default:
-      return p.text;
-  }
-}
-function extractParams(fnNode) {
-  const single = fnNode.childForFieldName("parameter");
-  if (single) return [single.text];
-  const params = fnNode.childForFieldName("parameters");
-  if (!params) return void 0;
-  const out = [];
-  for (let i = 0; i < params.namedChildCount; i++) {
-    const p = params.namedChild(i);
-    if (!p) continue;
-    out.push(paramText(p));
-  }
-  return out;
-}
-function extractClassMembers(body, parentQname) {
-  if (!body) return [];
-  const out = [];
-  for (let i = 0; i < body.namedChildCount; i++) {
-    const m = body.namedChild(i);
-    if (!m) continue;
-    if (m.type === "method_definition") {
-      out.push(
-        makeSymbol(m, nameOf(m), "method", parentQname, [], extractParams(m))
-      );
-    } else if (m.type === "public_field_definition") {
-      const value = m.childForFieldName("value");
-      if (value && (value.type === "arrow_function" || value.type === "function_expression")) {
-        out.push(
-          makeSymbol(m, nameOf(m), "method", parentQname, [], extractParams(value))
-        );
-      }
-    }
-  }
-  return out;
-}
-function extractFromLexical(decl, parentQname, _isExported) {
-  const out = [];
-  for (let i = 0; i < decl.namedChildCount; i++) {
-    const declarator = decl.namedChild(i);
-    if (!declarator || declarator.type !== "variable_declarator") continue;
-    const nameNode = declarator.childForFieldName("name");
-    const valueNode = declarator.childForFieldName("value");
-    if (!nameNode) continue;
-    const name = nameNode.text;
-    const isFn = valueNode && (valueNode.type === "arrow_function" || valueNode.type === "function_expression");
-    const params = isFn && valueNode ? extractParams(valueNode) : void 0;
-    out.push(
-      makeSymbol(
-        decl,
-        name,
-        isFn ? "function" : "const",
-        parentQname,
-        [],
-        params
-      )
-    );
-    if (valueNode && valueNode.type === "object" && !isFn) {
-      const childParent = parentQname ? `${parentQname}>${name}` : name;
-      for (let j = 0; j < valueNode.namedChildCount; j++) {
-        const prop = valueNode.namedChild(j);
-        if (!prop) continue;
-        if (prop.type === "pair") {
-          const keyNode = prop.childForFieldName("key");
-          const valNode = prop.childForFieldName("value");
-          if (!keyNode || !valNode) continue;
-          if (keyNode.type !== "property_identifier" && keyNode.type !== "identifier") {
-            continue;
-          }
-          if (valNode.type !== "arrow_function" && valNode.type !== "function_expression") {
-            continue;
-          }
-          out.push(
-            makeSymbol(
-              prop,
-              keyNode.text,
-              "method",
-              childParent,
-              [],
-              extractParams(valNode)
-            )
-          );
-        } else if (prop.type === "method_definition") {
-          const propName = nameOf(prop);
-          if (propName) {
-            out.push(
-              makeSymbol(prop, propName, "method", childParent, [], extractParams(prop))
-            );
-          }
-        }
-      }
-    }
-  }
-  return out;
-}
-function extractFromNode(node, parentQname, isExported = false) {
-  switch (node.type) {
-    case "export_statement":
-    case "export_default_declaration": {
-      const out = [];
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const inner = node.namedChild(i);
-        if (inner) out.push(...extractFromNode(inner, parentQname, true));
-      }
-      return out;
-    }
-    case "function_declaration":
-    case "generator_function_declaration": {
-      return [
-        makeSymbol(node, nameOf(node), "function", parentQname, [], extractParams(node))
-      ];
-    }
-    case "class_declaration":
-    case "abstract_class_declaration": {
-      const className = nameOf(node);
-      const qname = qualify(parentQname, className);
-      const body = node.childForFieldName("body");
-      const members = extractClassMembers(body, qname);
-      return [makeSymbol(node, className, "class", parentQname, members)];
-    }
-    case "interface_declaration": {
-      return [makeSymbol(node, nameOf(node), "interface", parentQname)];
-    }
-    case "type_alias_declaration": {
-      return [makeSymbol(node, nameOf(node), "type", parentQname)];
-    }
-    case "enum_declaration": {
-      return [makeSymbol(node, nameOf(node), "enum", parentQname)];
-    }
-    case "lexical_declaration":
-    case "variable_declaration": {
-      return extractFromLexical(node, parentQname, isExported);
-    }
-    // ---- Python ------------------------------------------------------------
-    case "function_definition": {
-      return [
-        makeSymbol(node, nameOf(node), "function", parentQname, [], extractParams(node))
-      ];
-    }
-    case "class_definition": {
-      const className = nameOf(node);
-      const qname = qualify(parentQname, className);
-      const body = node.childForFieldName("body");
-      const members = extractPythonClassMembers(body, qname);
-      return [makeSymbol(node, className, "class", parentQname, members)];
-    }
-    case "decorated_definition": {
-      const inner = node.childForFieldName("definition");
-      if (!inner) return [];
-      const innerSymbols = extractFromNode(inner, parentQname, false);
-      return innerSymbols.map((s) => ({
-        ...s,
-        startLine: node.startPosition.row + 1,
-        // Re-hash from the decorated text so contentHash captures the
-        // decorator change too. The simplest form: hash the outer node.
-        contentHash: hashText(normalizeForHash(node.text))
-      }));
-    }
-    case "expression_statement": {
-      const out = [];
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c?.type === "assignment") {
-          const sym = extractPythonAssignment(node, c, parentQname);
-          if (sym) out.push(sym);
-        }
-      }
-      out.push(...extractFromCallStatement(node, parentQname));
-      return out;
-    }
-    default:
-      return [];
-  }
-}
-function extractFromCallStatement(node, parentQname) {
-  let call = null;
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (!c) continue;
-    if (c.type === "call_expression") {
-      call = c;
-      break;
-    }
-    if (c.type === "await_expression") {
-      for (let j = 0; j < c.namedChildCount; j++) {
-        const inner = c.namedChild(j);
-        if (inner?.type === "call_expression") {
-          call = inner;
-          break;
-        }
-      }
-      break;
-    }
-  }
-  if (!call) return [];
-  const callee = call.childForFieldName("function");
-  const args = call.childForFieldName("arguments");
-  if (!callee || !args) return [];
-  let label = null;
-  const fnArgs = [];
-  for (let i = 0; i < args.namedChildCount; i++) {
-    const arg = args.namedChild(i);
-    if (!arg) continue;
-    if (label === null && (arg.type === "string" || arg.type === "template_string")) {
-      const t = arg.text;
-      label = t.length >= 2 && /^["'`]/.test(t) ? t.slice(1, -1) : t;
-    }
-    if (arg.type === "arrow_function" || arg.type === "function_expression") {
-      fnArgs.push(arg);
-    }
-  }
-  if (fnArgs.length === 0 || !label) return [];
-  const calleeName = leafCalleeName(callee);
-  const baseName = calleeName ? `${calleeName} ${label}` : label;
-  return fnArgs.map(
-    (fnArg, i) => makeSymbol(
-      fnArg,
-      fnArgs.length > 1 ? `${baseName} #${i + 1}` : baseName,
-      "function",
-      parentQname,
-      [],
-      extractParams(fnArg)
-    )
-  );
-}
-function extractPythonClassMembers(body, parentQname) {
-  if (!body) return [];
-  const out = [];
-  for (let i = 0; i < body.namedChildCount; i++) {
-    const m = body.namedChild(i);
-    if (!m) continue;
-    if (m.type === "function_definition") {
-      out.push(
-        makeSymbol(m, nameOf(m), "method", parentQname, [], extractParams(m))
-      );
-    } else if (m.type === "decorated_definition") {
-      const inner = m.childForFieldName("definition");
-      if (inner?.type === "function_definition") {
-        out.push({
-          ...makeSymbol(inner, nameOf(inner), "method", parentQname, [], extractParams(inner)),
-          startLine: m.startPosition.row + 1,
-          contentHash: hashText(normalizeForHash(m.text))
-        });
-      } else if (inner?.type === "class_definition") {
-        const innerName = nameOf(inner);
-        const innerQname = qualify(parentQname, innerName);
-        const innerBody = inner.childForFieldName("body");
-        const nested = extractPythonClassMembers(innerBody, innerQname);
-        out.push({
-          ...makeSymbol(inner, innerName, "class", parentQname, nested),
-          startLine: m.startPosition.row + 1,
-          contentHash: hashText(normalizeForHash(m.text))
-        });
-      }
-    } else if (m.type === "class_definition") {
-      const innerName = nameOf(m);
-      const innerQname = qualify(parentQname, innerName);
-      const innerBody = m.childForFieldName("body");
-      const nested = extractPythonClassMembers(innerBody, innerQname);
-      out.push(makeSymbol(m, innerName, "class", parentQname, nested));
-    }
-  }
-  return out;
-}
-function extractPythonAssignment(outer, assignment, parentQname) {
-  const lhs = assignment.childForFieldName("left");
-  if (!lhs || lhs.type !== "identifier") return null;
-  const name = lhs.text;
-  return {
-    qualifiedName: qualify(parentQname, name),
-    name,
-    kind: "const",
-    startLine: outer.startPosition.row + 1,
-    endLine: outer.endPosition.row + 1,
-    contentHash: hashText(normalizeForHash(outer.text)),
-    children: []
-  };
-}
-function leafCalleeName(node) {
-  if (node.type === "identifier") return node.text;
-  if (node.type === "member_expression") {
-    const prop = node.childForFieldName("property");
-    return prop?.text ?? "";
-  }
-  if (node.type === "call_expression") {
-    const fn = node.childForFieldName("function");
-    return fn ? leafCalleeName(fn) : "";
-  }
-  return "";
-}
-function extractImportHeader(rootNode) {
-  const headerNodes = [];
-  let firstLine = -1;
-  let lastLine = -1;
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const c = rootNode.namedChild(i);
-    if (!c) continue;
-    const isHeader = (
-      // JS/TS: `import X from 'y'`, `import 'y'`
-      c.type === "import_statement" || // JS/TS: `export { x } from './y'` (re-export with `source` field)
-      c.type === "export_statement" && c.childForFieldName("source") !== null || // Python: `from x import y` / `from .x import y`
-      c.type === "import_from_statement" || // Python: `import x` / `import x.y as z`
-      c.type === "future_import_statement"
-    );
-    if (isHeader) {
-      headerNodes.push(c);
-      if (firstLine < 0) firstLine = c.startPosition.row + 1;
-      lastLine = c.endPosition.row + 1;
-    } else if (firstLine >= 0) {
-      break;
-    }
-  }
-  if (firstLine < 0) return null;
-  const text = headerNodes.map((n) => n.text).join("\n");
-  return {
-    qualifiedName: "__imports__",
-    name: "imports",
-    kind: "unknown",
-    startLine: firstLine,
-    endLine: lastLine,
-    contentHash: hashText(normalizeForHash(text)),
-    children: []
-  };
-}
-function absorbLeadingComments(rootNode, symbols) {
-  const commentByEndLine = /* @__PURE__ */ new Map();
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const c = rootNode.namedChild(i);
-    if (!c || !c.type.endsWith("comment")) continue;
-    commentByEndLine.set(c.endPosition.row + 1, c);
-  }
-  if (commentByEndLine.size === 0) return;
-  const covered = /* @__PURE__ */ new Set();
-  for (const s of symbols) {
-    for (let i = s.startLine; i <= s.endLine; i++) covered.add(i);
-  }
-  for (const s of symbols) {
-    if (s.kind === "unknown") continue;
-    let start = s.startLine;
-    for (; ; ) {
-      const c = commentByEndLine.get(start - 1);
-      if (!c) break;
-      const cStart = c.startPosition.row + 1;
-      let blocked = false;
-      for (let i = cStart; i <= start - 1; i++) {
-        if (covered.has(i)) {
-          blocked = true;
-          break;
-        }
-      }
-      if (blocked) break;
-      start = cStart;
-    }
-    if (start === s.startLine) continue;
-    for (let i = start; i < s.startLine; i++) covered.add(i);
-    s.startLine = start;
-  }
-}
-function computeFillerBlocks(rootNode, existing) {
-  const source = rootNode.text;
-  const lines = source.split("\n");
-  const fileLineCount = lines.length;
-  if (fileLineCount === 0) return [];
-  const covered = new Uint8Array(fileLineCount + 2);
-  for (const s of existing) {
-    const lo = Math.max(1, s.startLine);
-    const hi = Math.min(fileLineCount, s.endLine);
-    for (let i = lo; i <= hi; i++) covered[i] = 1;
-  }
-  const fillers = [];
-  const flush = (start, end) => {
-    let hasContent = false;
-    for (let i = start; i <= end; i++) {
-      const ln = lines[i - 1];
-      if (ln && ln.trim().length > 0) {
-        hasContent = true;
-        break;
+// src/lib/codeIndexSync.ts
+var wired = false;
+function wireCodeIndexToFileWatcher() {
+  if (wired) return;
+  wired = true;
+  registerWatcherSubscriber((cwd, onDirty) => {
+    fileWatcher.subscribe(cwd, (events) => {
+      if (events.some((e) => e.type === "file" || e.type === "git")) {
+        onDirty();
       }
-    }
-    if (!hasContent) return;
-    const text = lines.slice(start - 1, end).join("\n");
-    fillers.push({
-      qualifiedName: `__code_${start}_${end}__`,
-      name: "code",
-      kind: "unknown",
-      startLine: start,
-      endLine: end,
-      contentHash: hashText(normalizeForHash(text)),
-      children: []
     });
-  };
-  let runStart = -1;
-  for (let i = 1; i <= fileLineCount; i++) {
-    if (!covered[i]) {
-      if (runStart < 0) runStart = i;
-    } else if (runStart >= 0) {
-      flush(runStart, i - 1);
-      runStart = -1;
-    }
-  }
-  if (runStart >= 0) flush(runStart, fileLineCount);
-  return fillers;
-}
-function extractSymbolsFromTree(rootNode) {
-  const out = [];
-  const header = extractImportHeader(rootNode);
-  if (header) out.push(header);
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const child = rootNode.namedChild(i);
-    if (child) out.push(...extractFromNode(child, void 0, false));
-  }
-  absorbLeadingComments(rootNode, out);
-  out.push(...computeFillerBlocks(rootNode, out));
-  dedupeQualifiedNames(out);
-  return out;
-}
-function dedupeQualifiedNames(syms) {
-  const seen = /* @__PURE__ */ new Map();
-  const walk = (arr) => {
-    for (const s of arr) {
-      const n = (seen.get(s.qualifiedName) ?? 0) + 1;
-      seen.set(s.qualifiedName, n);
-      if (n > 1) s.qualifiedName = `${s.qualifiedName}#${n}`;
-      walk(s.children);
-    }
-  };
-  walk(syms);
-}
-
-// packages/feature/explorer/src/server/codeMap/extractCalls.ts
-function extractRawCalls(root) {
-  const out = [];
-  function visit(node) {
-    if (node.type === "call_expression" || node.type === "call") {
-      const fn = node.childForFieldName("function");
-      const name = calleeLeafName(fn);
-      if (name) {
-        const receiverName = receiverRootName(fn);
-        out.push({
-          calleeName: name,
-          line: node.startPosition.row + 1,
-          ...receiverName ? { receiverName } : {}
-        });
-      }
-    } else if (node.type === "jsx_opening_element" || node.type === "jsx_self_closing_element") {
-      const nameNode = node.childForFieldName("name");
-      const name = jsxComponentName(nameNode);
-      if (name) out.push({ calleeName: name, line: node.startPosition.row + 1 });
-    }
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i);
-      if (c) visit(c);
-    }
-  }
-  visit(root);
-  return out;
-}
-function receiverRootName(node) {
-  if (!node) return void 0;
-  if (node.type !== "member_expression" && node.type !== "attribute") {
-    return void 0;
-  }
-  let cur = node;
-  while (cur) {
-    if (cur.type === "identifier") return cur.text;
-    if (cur.type === "this" || cur.type === "super") return void 0;
-    if (cur.type === "member_expression" || cur.type === "attribute") {
-      cur = cur.childForFieldName("object");
-      continue;
-    }
-    return void 0;
-  }
-  return void 0;
-}
-function calleeLeafName(node) {
-  if (!node) return null;
-  if (node.type === "identifier" || node.type === "shorthand_property_identifier") {
-    return node.text;
-  }
-  if (node.type === "member_expression") {
-    const prop = node.childForFieldName("property");
-    return prop?.text ?? null;
-  }
-  if (node.type === "attribute") {
-    const prop = node.childForFieldName("attribute");
-    return prop?.text ?? null;
-  }
-  if (node.type === "call_expression" || node.type === "call") {
-    return calleeLeafName(node.childForFieldName("function"));
-  }
-  return null;
-}
-function jsxComponentName(node) {
-  if (!node) return null;
-  if (node.type === "identifier") {
-    return /^[A-Z]/.test(node.text) ? node.text : null;
-  }
-  if (node.type === "member_expression" || node.type === "jsx_member_expression") {
-    const obj = node.childForFieldName("object") ?? node.namedChild(0);
-    return jsxComponentName(obj);
-  }
-  return null;
-}
-function extractImportBindings(root) {
-  const out = [];
-  for (let i = 0; i < root.namedChildCount; i++) {
-    const n = root.namedChild(i);
-    if (!n) continue;
-    if (n.type === "import_statement") {
-      const src = n.childForFieldName("source");
-      if (src) {
-        extractJsTsBindings(n, src, out);
-      } else {
-        extractPythonImportBindings(n, out);
-      }
-    } else if (n.type === "import_from_statement") {
-      extractPythonFromBindings(n, out);
-    }
-  }
-  return out;
-}
-function extractJsTsBindings(n, src, out) {
-  const specifier = stripQuotes(src.text);
-  let clause = null;
-  for (let j = 0; j < n.namedChildCount; j++) {
-    const c = n.namedChild(j);
-    if (c?.type === "import_clause") {
-      clause = c;
-      break;
-    }
-  }
-  if (!clause) return;
-  for (let j = 0; j < clause.namedChildCount; j++) {
-    const c = clause.namedChild(j);
-    if (!c) continue;
-    if (c.type === "identifier") {
-      out.push({ specifier, importedName: "default", localName: c.text });
-    } else if (c.type === "namespace_import") {
-      const id = firstNamedChildOfType(c, "identifier");
-      if (id) out.push({ specifier, importedName: "*", localName: id.text });
-    } else if (c.type === "named_imports") {
-      for (let k = 0; k < c.namedChildCount; k++) {
-        const spec = c.namedChild(k);
-        if (!spec || spec.type !== "import_specifier") continue;
-        const nameNode = spec.childForFieldName("name");
-        const aliasNode = spec.childForFieldName("alias");
-        if (nameNode) {
-          out.push({
-            specifier,
-            importedName: nameNode.text,
-            localName: aliasNode?.text ?? nameNode.text
-          });
-        }
-      }
-    }
-  }
-}
-function extractPythonImportBindings(n, out) {
-  for (let i = 0; i < n.childCount; i++) {
-    const c = n.child(i);
-    if (!c || n.fieldNameForChild(i) !== "name") continue;
-    if (c.type === "dotted_name") {
-      const spec = c.text;
-      const local = spec.split(".")[0];
-      out.push({ specifier: spec, importedName: "*", localName: local });
-    } else if (c.type === "aliased_import") {
-      const name = c.childForFieldName("name");
-      const alias = c.childForFieldName("alias");
-      if (name?.type === "dotted_name" && alias) {
-        out.push({ specifier: name.text, importedName: "*", localName: alias.text });
-      }
-    }
-  }
-}
-function extractPythonFromBindings(n, out) {
-  const moduleNode = n.childForFieldName("module_name");
-  let specifier = "";
-  if (moduleNode) {
-    if (moduleNode.type === "dotted_name") {
-      specifier = moduleNode.text;
-    } else if (moduleNode.type === "relative_import") {
-      let dots = "";
-      let modulePath = "";
-      for (let i = 0; i < moduleNode.namedChildCount; i++) {
-        const c = moduleNode.namedChild(i);
-        if (!c) continue;
-        if (c.type === "import_prefix") dots = c.text;
-        else if (c.type === "dotted_name") modulePath = c.text;
-      }
-      specifier = dots + modulePath;
-    }
-  }
-  if (!specifier) return;
-  let sawWildcard = false;
-  for (let i = 0; i < n.childCount; i++) {
-    const c = n.child(i);
-    if (!c) continue;
-    const field = n.fieldNameForChild(i);
-    if (c.type === "wildcard_import") {
-      sawWildcard = true;
-      continue;
-    }
-    if (field !== "name") continue;
-    if (c.type === "dotted_name") {
-      const name = c.text;
-      out.push({ specifier, importedName: name, localName: name });
-    } else if (c.type === "aliased_import") {
-      const name = c.childForFieldName("name");
-      const alias = c.childForFieldName("alias");
-      if (name?.type === "dotted_name" && alias) {
-        out.push({
-          specifier,
-          importedName: name.text,
-          localName: alias.text
-        });
-      }
-    }
-  }
-  if (sawWildcard) {
-    out.push({ specifier, importedName: "*", localName: "*" });
-  }
-}
-function extractReexports(root) {
-  const out = [];
-  for (let i = 0; i < root.namedChildCount; i++) {
-    const n = root.namedChild(i);
-    if (!n || n.type !== "export_statement") continue;
-    const src = n.childForFieldName("source");
-    if (!src) continue;
-    const specifier = stripQuotes(src.text);
-    let clause = null;
-    for (let j = 0; j < n.namedChildCount; j++) {
-      const c = n.namedChild(j);
-      if (c?.type === "export_clause") {
-        clause = c;
-        break;
-      }
-    }
-    if (!clause) continue;
-    for (let k = 0; k < clause.namedChildCount; k++) {
-      const spec = clause.namedChild(k);
-      if (!spec || spec.type !== "export_specifier") continue;
-      const nameNode = spec.childForFieldName("name");
-      const aliasNode = spec.childForFieldName("alias");
-      if (!nameNode) continue;
-      const originalName = nameNode.text;
-      const exportedName = aliasNode?.text ?? originalName;
-      out.push({
-        localName: exportedName,
-        specifier,
-        importedName: originalName,
-        isReexport: true
-      });
-    }
-  }
-  return out;
-}
-function stripQuotes(s) {
-  if (s.length >= 2 && (s[0] === '"' || s[0] === "'") && s[s.length - 1] === s[0]) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-function firstNamedChildOfType(node, type) {
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (c?.type === type) return c;
-  }
-  return null;
-}
-
-// packages/feature/explorer/src/server/codeMap/projectGraph/extractImports.ts
-function walkForJsTsImports(root) {
-  const out = [];
-  function readStringNode(stringNode) {
-    if (!stringNode || stringNode.type !== "string") return null;
-    for (let i = 0; i < stringNode.namedChildCount; i++) {
-      const c = stringNode.namedChild(i);
-      if (c && c.type === "string_fragment") return c.text;
-    }
-    return "";
-  }
-  function visit(node) {
-    switch (node.type) {
-      case "import_statement":
-      case "export_statement": {
-        const source = node.childForFieldName("source");
-        const spec = readStringNode(source);
-        if (spec) out.push(spec);
-        return;
-      }
-      case "call_expression": {
-        const fn = node.childForFieldName("function");
-        if (fn) {
-          const isDynamicImport = fn.type === "import";
-          const isRequire = fn.type === "identifier" && fn.text === "require";
-          if (isDynamicImport || isRequire) {
-            const args = node.childForFieldName("arguments");
-            if (args && args.namedChildCount > 0) {
-              const firstArg = args.namedChild(0);
-              const spec = readStringNode(firstArg);
-              if (spec) out.push(spec);
-            }
-          }
-        }
-        break;
-      }
-    }
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child) visit(child);
-    }
-  }
-  visit(root);
-  return out;
-}
-function walkForPythonImports(root) {
-  const out = [];
-  function visit(node) {
-    switch (node.type) {
-      case "import_statement": {
-        for (let i = 0; i < node.childCount; i++) {
-          const c = node.child(i);
-          if (!c || node.fieldNameForChild(i) !== "name") continue;
-          if (c.type === "dotted_name") {
-            out.push(c.text);
-          } else if (c.type === "aliased_import") {
-            const name = c.childForFieldName("name");
-            if (name?.type === "dotted_name") out.push(name.text);
-          }
-        }
-        return;
-      }
-      case "import_from_statement": {
-        const spec = readPythonModuleSpec(node);
-        if (spec) out.push(spec);
-        return;
-      }
-    }
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child) visit(child);
-    }
-  }
-  visit(root);
-  return out;
-}
-function readPythonModuleSpec(node) {
-  const moduleNode = node.childForFieldName("module_name");
-  if (!moduleNode) return "";
-  if (moduleNode.type === "dotted_name") return moduleNode.text;
-  if (moduleNode.type === "relative_import") {
-    let dots = "";
-    let modulePath = "";
-    for (let i = 0; i < moduleNode.namedChildCount; i++) {
-      const c = moduleNode.namedChild(i);
-      if (!c) continue;
-      if (c.type === "import_prefix") dots = c.text;
-      else if (c.type === "dotted_name") modulePath = c.text;
-    }
-    return dots + modulePath;
-  }
-  return "";
-}
-var WALKERS = {
-  typescript: walkForJsTsImports,
-  tsx: walkForJsTsImports,
-  javascript: walkForJsTsImports,
-  python: walkForPythonImports
-};
-function extractImportsFromTree(root, grammar) {
-  const walker = WALKERS[grammar];
-  if (!walker) return [];
-  return walker(root);
-}
-
-// packages/feature/explorer/src/server/codeMap/handlers/typescript.ts
-function isFunctionLikeKind(k) {
-  return k === "function" || k === "class" || k === "method";
-}
-var REEXPORT_MAX_DEPTH = 5;
-function findExportedSymbol(file, name, depth, visited, allFiles) {
-  if (depth > REEXPORT_MAX_DEPTH) return null;
-  if (visited.has(file.path)) return null;
-  visited.add(file.path);
-  const candidates = file.symbolsByName.get(name);
-  if (candidates) {
-    let best = null;
-    for (const s of candidates) {
-      if (!isFunctionLikeKind(s.kind)) continue;
-      if (!best || s.endLine - s.startLine > best.endLine - best.startLine) {
-        best = s;
-      }
-    }
-    if (best) return best;
-  }
-  const reexp = file.reexportsByLocalName.get(name);
-  if (reexp) {
-    const nextPath = file.resolvedImports.get(reexp.specifier);
-    if (nextPath) {
-      const nextFile = allFiles.get(nextPath);
-      if (nextFile) {
-        const found = findExportedSymbol(
-          nextFile,
-          reexp.importedName,
-          depth + 1,
-          visited,
-          allFiles
-        );
-        if (found) return found;
-      }
-    }
-  }
-  return null;
-}
-function findReceiverMethod(file, receiverImportedName, methodName, depth, visited, allFiles) {
-  if (depth > REEXPORT_MAX_DEPTH) return null;
-  if (visited.has(file.path)) return null;
-  visited.add(file.path);
-  if (receiverImportedName !== "*") {
-    const nestedQname = `${receiverImportedName}>${methodName}`;
-    const nested = file.symbolsByQname.get(nestedQname);
-    if (nested && isFunctionLikeKind(nested.kind)) return nested;
-  }
-  if (receiverImportedName === "*") {
-    const top = file.symbolsByName.get(methodName);
-    if (top) {
-      let best = null;
-      for (const s of top) {
-        if (s.qualifiedName.includes(">")) continue;
-        if (!isFunctionLikeKind(s.kind)) continue;
-        if (!best || s.endLine - s.startLine > best.endLine - best.startLine) {
-          best = s;
-        }
-      }
-      if (best) return best;
-    }
-  }
-  const reexp = file.reexportsByLocalName.get(receiverImportedName);
-  if (reexp) {
-    const nextPath = file.resolvedImports.get(reexp.specifier);
-    if (nextPath) {
-      const nextFile = allFiles.get(nextPath);
-      if (nextFile) {
-        const found = findReceiverMethod(
-          nextFile,
-          reexp.importedName,
-          methodName,
-          depth + 1,
-          visited,
-          allFiles
-        );
-        if (found) return found;
-      }
-    }
-  }
-  return null;
-}
-function makeTsFamilyHandler(grammarId, extensions) {
-  return {
-    grammarId,
-    extensions,
-    extractSymbols(root, _source) {
-      return extractSymbolsFromTree(root);
-    },
-    extractImports(root) {
-      const specs = extractImportsFromTree(root, grammarId);
-      const baseBindings = extractImportBindings(root);
-      const reexportBindings = extractReexports(root);
-      return {
-        specs,
-        bindings: [...baseBindings, ...reexportBindings]
-      };
-    },
-    extractCallSites(root, _symbols) {
-      return extractRawCalls(root);
-    },
-    // ----------------------------------------------------------------
-    // Project context — loads tsconfig path aliases + workspace
-    // packages so resolveSpecifier can match aliased imports
-    // (`@/foo`, `@org/auth`) without re-reading filesystem on every
-    // resolve. Async because both loaders read JSON files.
-    // ----------------------------------------------------------------
-    async buildProjectContext(cwd, fileSet) {
-      const mutableFileSet = new Set(fileSet);
-      const tsconfigs = await loadTsconfigs(cwd);
-      const workspaces = await loadWorkspaces(cwd, mutableFileSet);
-      const sortedWsNames = [...workspaces.keys()].sort(
-        (a, b) => b.length - a.length
-      );
-      const ctx = {
-        cwd,
-        tsconfigs,
-        workspaces,
-        sortedWsNames,
-        owningScopesCache: /* @__PURE__ */ new Map()
-      };
-      return ctx;
-    },
-    resolveSpecifier(spec, fromFilePath, ctx, fileSet) {
-      const c = ctx;
-      const mutableFileSet = fileSet;
-      let owningScopes = c.owningScopesCache.get(fromFilePath);
-      if (!owningScopes) {
-        owningScopes = c.tsconfigs.filter(
-          (t) => fileInScope(fromFilePath, t.scope)
-        );
-        c.owningScopesCache.set(fromFilePath, owningScopes);
-      }
-      if (spec.startsWith("./") || spec.startsWith("../")) {
-        return findFileForBase(
-          path2.resolve(c.cwd, path2.dirname(fromFilePath), spec),
-          c.cwd,
-          mutableFileSet
-        );
-      }
-      if (spec.startsWith("/")) {
-        return findFileForBase(
-          path2.resolve(c.cwd, spec.slice(1)),
-          c.cwd,
-          mutableFileSet
-        );
-      }
-      for (const ts of owningScopes) {
-        const hit = ts.sortedAliases.find(
-          ([prefix2]) => spec === prefix2 || spec.startsWith(prefix2 + "/")
-        );
-        if (!hit) continue;
-        const [prefix, target] = hit;
-        const remainder = spec === prefix ? "" : spec.slice(prefix.length + 1);
-        const r = findFileForBase(
-          path2.resolve(c.cwd, target, remainder),
-          c.cwd,
-          mutableFileSet
-        );
-        if (r) return r;
-      }
-      for (const pkgName of c.sortedWsNames) {
-        if (spec !== pkgName && !spec.startsWith(pkgName + "/")) continue;
-        const ws = c.workspaces.get(pkgName);
-        if (spec === pkgName) return ws.entryFile;
-        const subpath = spec.slice(pkgName.length + 1);
-        return findFileRelativeToProject(
-          path2.posix.join(ws.dir, subpath),
-          mutableFileSet
-        ) ?? findFileRelativeToProject(
-          path2.posix.join(ws.dir, "src", subpath),
-          mutableFileSet
-        );
-      }
-      return null;
-    },
-    resolveCall(call, from, fromFile, allFiles, _ctx) {
-      if (call.receiverName) {
-        const recvBinding = fromFile.bindingsByLocalName.get(call.receiverName);
-        if (!recvBinding) return [];
-        const recvFilePath = fromFile.resolvedImports.get(recvBinding.specifier);
-        if (!recvFilePath) return [];
-        const recvTarget = allFiles.get(recvFilePath);
-        if (!recvTarget) return [];
-        const sym2 = findReceiverMethod(
-          recvTarget,
-          recvBinding.importedName,
-          call.calleeName,
-          0,
-          /* @__PURE__ */ new Set(),
-          allFiles
-        );
-        if (sym2) {
-          return [
-            {
-              kind: "symbol",
-              addr: { filePath: sym2.filePath, qualifiedName: sym2.qualifiedName }
-            }
-          ];
-        }
-        return [
-          {
-            kind: "method-unresolved",
-            receiverName: call.receiverName,
-            methodName: call.calleeName
-          }
-        ];
-      }
-      const localMatches = fromFile.symbolsByName.get(call.calleeName);
-      if (localMatches && localMatches.length > 0) {
-        const out = [];
-        for (const callee of localMatches) {
-          if (callee.qualifiedName === from.qualifiedName) continue;
-          if (!isFunctionLikeKind(callee.kind)) continue;
-          out.push({
-            kind: "symbol",
-            addr: {
-              filePath: callee.filePath,
-              qualifiedName: callee.qualifiedName
-            }
-          });
-        }
-        return out;
-      }
-      const binding = fromFile.bindingsByLocalName.get(call.calleeName);
-      if (!binding) return [];
-      const targetFile = fromFile.resolvedImports.get(binding.specifier);
-      if (!targetFile) {
-        return [
-          {
-            kind: "external",
-            name: binding.importedName,
-            packageSpec: binding.specifier
-          }
-        ];
-      }
-      const target = allFiles.get(targetFile);
-      if (!target) return [];
-      const sym = findExportedSymbol(
-        target,
-        binding.importedName,
-        0,
-        /* @__PURE__ */ new Set(),
-        allFiles
-      );
-      if (!sym) return [];
-      return [
-        {
-          kind: "symbol",
-          addr: { filePath: sym.filePath, qualifiedName: sym.qualifiedName }
-        }
-      ];
-    },
-    moduleForFile(filePath, _ctx) {
-      return filePath;
-    }
-  };
-}
-var typescriptHandler = makeTsFamilyHandler("typescript", [".ts"]);
-var tsxHandler = makeTsFamilyHandler("tsx", [".tsx", ".jsx"]);
-var javascriptHandler = makeTsFamilyHandler("javascript", [
-  ".js",
-  ".mjs",
-  ".cjs"
-]);
-
-// packages/feature/explorer/src/server/codeMap/handlers/python.ts
-import path3 from "path";
-function isFunctionLikeKind2(k) {
-  return k === "function" || k === "class" || k === "method";
-}
-function findExportedSymbolPy(file, name) {
-  const candidates = file.symbolsByName.get(name);
-  if (!candidates) return null;
-  let best = null;
-  for (const s of candidates) {
-    if (!isFunctionLikeKind2(s.kind)) continue;
-    if (!best || s.endLine - s.startLine > best.endLine - best.startLine) {
-      best = s;
-    }
-  }
-  return best;
-}
-function findReceiverMethodPy(file, receiverImportedName, methodName) {
-  if (receiverImportedName !== "*") {
-    const nestedQname = `${receiverImportedName}>${methodName}`;
-    const nested = file.symbolsByQname.get(nestedQname);
-    if (nested && isFunctionLikeKind2(nested.kind)) return nested;
-  }
-  if (receiverImportedName === "*") {
-    const top = file.symbolsByName.get(methodName);
-    if (top) {
-      let best = null;
-      for (const s of top) {
-        if (s.qualifiedName.includes(">")) continue;
-        if (!isFunctionLikeKind2(s.kind)) continue;
-        if (!best || s.endLine - s.startLine > best.endLine - best.startLine) {
-          best = s;
-        }
-      }
-      if (best) return best;
-    }
-  }
-  return null;
-}
-function tryPythonPaths(baseDir, modulePath, fileSet) {
-  const sub = modulePath.replace(/\./g, "/");
-  const join2 = (...segs) => segs.filter((s) => s !== "" && s !== ".").join("/");
-  if (!sub) {
-    const init = join2(baseDir, "__init__.py");
-    if (fileSet.has(init)) return init;
-    return null;
-  }
-  const direct = join2(baseDir, sub + ".py");
-  if (fileSet.has(direct)) return direct;
-  const initFile = join2(baseDir, sub, "__init__.py");
-  if (fileSet.has(initFile)) return initFile;
-  return null;
-}
-var pythonHandler = {
-  grammarId: "python",
-  extensions: [".py", ".pyi"],
-  extractSymbols(root, _source) {
-    return extractSymbolsFromTree(root);
-  },
-  extractImports(root) {
-    const specs = extractImportsFromTree(root, "python");
-    const bindings = extractImportBindings(root);
-    return { specs, bindings };
-  },
-  extractCallSites(root, _symbols) {
-    return extractRawCalls(root);
-  },
-  buildProjectContext(cwd, fileSet) {
-    const pythonRoots = [cwd];
-    let hasSrcLayout = false;
-    if (fileSet.has("src/__init__.py")) {
-      hasSrcLayout = true;
-    } else {
-      for (const p of fileSet) {
-        if (p.startsWith("src/") && p.endsWith(".py")) {
-          hasSrcLayout = true;
-          break;
-        }
-      }
-    }
-    if (hasSrcLayout) pythonRoots.push(path3.join(cwd, "src"));
-    const ctx = { cwd, pythonRoots };
-    return ctx;
-  },
-  resolveSpecifier(spec, fromFilePath, ctx, fileSet) {
-    const c = ctx;
-    const dotMatch = /^(\.+)/.exec(spec);
-    if (dotMatch) {
-      const dots = dotMatch[1].length;
-      const rest = spec.slice(dots);
-      let baseDir = path3.dirname(fromFilePath);
-      for (let i = 1; i < dots; i++) baseDir = path3.dirname(baseDir);
-      return tryPythonPaths(baseDir || ".", rest, fileSet);
-    }
-    for (const root of c.pythonRoots) {
-      const rootRel = path3.relative(c.cwd, root) || ".";
-      const r = tryPythonPaths(rootRel, spec, fileSet);
-      if (r) return r;
-    }
-    return null;
-  },
-  resolveCall(call, from, fromFile, allFiles, _ctx) {
-    if (call.receiverName) {
-      const recvBinding = fromFile.bindingsByLocalName.get(call.receiverName);
-      if (!recvBinding) return [];
-      const recvFilePath = fromFile.resolvedImports.get(recvBinding.specifier);
-      if (!recvFilePath) return [];
-      const recvTarget = allFiles.get(recvFilePath);
-      if (!recvTarget) return [];
-      const sym2 = findReceiverMethodPy(
-        recvTarget,
-        recvBinding.importedName,
-        call.calleeName
-      );
-      if (sym2) {
-        return [
-          {
-            kind: "symbol",
-            addr: { filePath: sym2.filePath, qualifiedName: sym2.qualifiedName }
-          }
-        ];
-      }
-      return [
-        {
-          kind: "method-unresolved",
-          receiverName: call.receiverName,
-          methodName: call.calleeName
-        }
-      ];
-    }
-    const localMatches = fromFile.symbolsByName.get(call.calleeName);
-    if (localMatches && localMatches.length > 0) {
-      const out = [];
-      for (const callee of localMatches) {
-        if (callee.qualifiedName === from.qualifiedName) continue;
-        if (!isFunctionLikeKind2(callee.kind)) continue;
-        out.push({
-          kind: "symbol",
-          addr: {
-            filePath: callee.filePath,
-            qualifiedName: callee.qualifiedName
-          }
-        });
-      }
-      return out;
-    }
-    const binding = fromFile.bindingsByLocalName.get(call.calleeName);
-    if (!binding) return [];
-    const targetFile = fromFile.resolvedImports.get(binding.specifier);
-    if (!targetFile) {
-      return [
-        {
-          kind: "external",
-          name: binding.importedName,
-          packageSpec: binding.specifier
-        }
-      ];
-    }
-    const target = allFiles.get(targetFile);
-    if (!target) return [];
-    const sym = findExportedSymbolPy(target, binding.importedName);
-    if (!sym) return [];
-    return [
-      {
-        kind: "symbol",
-        addr: { filePath: sym.filePath, qualifiedName: sym.qualifiedName }
-      }
-    ];
-  },
-  moduleForFile(filePath, _ctx) {
-    return filePath;
-  }
-};
-
-// packages/feature/explorer/src/server/codeMap/handlers/go.ts
-import { promises as fs2 } from "fs";
-import path4 from "path";
-function qualify2(parent, name) {
-  return parent ? `${parent}>${name}` : name;
-}
-function makeSymbol2(node, name, kind, parentQname, children = [], params) {
-  return {
-    qualifiedName: qualify2(parentQname, name),
-    name,
-    kind,
-    startLine: node.startPosition.row + 1,
-    endLine: node.endPosition.row + 1,
-    contentHash: hashText(normalizeForHash(node.text)),
-    children,
-    params
-  };
-}
-function extractGoParams(fnNode) {
-  const params = fnNode.childForFieldName("parameters");
-  if (!params) return void 0;
-  const out = [];
-  for (let i = 0; i < params.namedChildCount; i++) {
-    const p = params.namedChild(i);
-    if (!p) continue;
-    if (p.type === "parameter_declaration") {
-      const nameNode = p.childForFieldName("name");
-      if (!nameNode) {
-        out.push("_");
-        continue;
-      }
-      if (nameNode.type === "identifier") {
-        out.push(nameNode.text);
-      } else if (nameNode.type === "identifier_list") {
-        for (let j = 0; j < nameNode.namedChildCount; j++) {
-          const id = nameNode.namedChild(j);
-          if (id?.type === "identifier") out.push(id.text);
-        }
-      } else {
-        out.push(nameNode.text);
-      }
-    } else if (p.type === "variadic_parameter_declaration") {
-      const nameNode = p.childForFieldName("name");
-      if (nameNode?.type === "identifier") {
-        out.push(`...${nameNode.text}`);
-      } else {
-        out.push("...");
-      }
-    }
-  }
-  return out;
-}
-function extractReceiverTypeName(method) {
-  const receiver = method.childForFieldName("receiver");
-  if (!receiver) return null;
-  for (let i = 0; i < receiver.namedChildCount; i++) {
-    const p = receiver.namedChild(i);
-    if (p?.type !== "parameter_declaration") continue;
-    const t = p.childForFieldName("type");
-    if (!t) return null;
-    return readReceiverTypeIdentifier(t);
-  }
-  return null;
-}
-function readReceiverTypeIdentifier(t) {
-  if (t.type === "type_identifier") return t.text;
-  if (t.type === "pointer_type") {
-    for (let i = 0; i < t.namedChildCount; i++) {
-      const inner = t.namedChild(i);
-      if (inner) {
-        const r = readReceiverTypeIdentifier(inner);
-        if (r) return r;
-      }
-    }
-    return null;
-  }
-  if (t.type === "generic_type") {
-    const base = t.childForFieldName("type");
-    if (base) return readReceiverTypeIdentifier(base);
-  }
-  return null;
-}
-function extractTypeDeclaration(decl, parentQname) {
-  const out = [];
-  for (let i = 0; i < decl.namedChildCount; i++) {
-    const spec = decl.namedChild(i);
-    if (!spec) continue;
-    if (spec.type === "type_spec" || spec.type === "type_alias") {
-      const nameNode = spec.childForFieldName("name");
-      const typeNode = spec.childForFieldName("type");
-      if (!nameNode) continue;
-      const name = nameNode.text;
-      const kind = typeNode?.type === "interface_type" ? "interface" : "class";
-      out.push(makeSymbol2(spec, name, kind, parentQname));
-    }
-  }
-  return out;
-}
-function extractValueDeclaration(decl, parentQname) {
-  const out = [];
-  for (let i = 0; i < decl.namedChildCount; i++) {
-    const spec = decl.namedChild(i);
-    if (!spec) continue;
-    if (spec.type === "var_spec" || spec.type === "const_spec") {
-      const nameNode = spec.childForFieldName("name");
-      if (!nameNode) continue;
-      if (nameNode.type === "identifier_list") {
-        for (let j = 0; j < nameNode.namedChildCount; j++) {
-          const id = nameNode.namedChild(j);
-          if (id?.type === "identifier") {
-            out.push(makeSymbol2(spec, id.text, "const", parentQname));
-          }
-        }
-      } else if (nameNode.type === "identifier") {
-        out.push(makeSymbol2(spec, nameNode.text, "const", parentQname));
-      }
-    }
-  }
-  return out;
-}
-function extractGoImportHeader(rootNode) {
-  const headerNodes = [];
-  let firstLine = -1;
-  let lastLine = -1;
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const c = rootNode.namedChild(i);
-    if (!c) continue;
-    if (c.type === "import_declaration") {
-      headerNodes.push(c);
-      if (firstLine < 0) firstLine = c.startPosition.row + 1;
-      lastLine = c.endPosition.row + 1;
-    } else if (c.type === "package_clause") {
-      continue;
-    } else if (firstLine >= 0) {
-      break;
-    }
-  }
-  if (firstLine < 0) return null;
-  const text = headerNodes.map((n) => n.text).join("\n");
-  return {
-    qualifiedName: "__imports__",
-    name: "imports",
-    kind: "unknown",
-    startLine: firstLine,
-    endLine: lastLine,
-    contentHash: hashText(normalizeForHash(text)),
-    children: []
-  };
-}
-function extractTopLevel(rootNode) {
-  const symbols = [];
-  const pendingMethods = [];
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const node = rootNode.namedChild(i);
-    if (!node) continue;
-    switch (node.type) {
-      case "function_declaration": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        symbols.push(
-          makeSymbol2(
-            node,
-            nameNode.text,
-            "function",
-            void 0,
-            [],
-            extractGoParams(node)
-          )
-        );
-        break;
-      }
-      case "method_declaration": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        const recvType = extractReceiverTypeName(node);
-        const sym = makeSymbol2(
-          node,
-          nameNode.text,
-          "method",
-          recvType ?? void 0,
-          [],
-          extractGoParams(node)
-        );
-        if (recvType) {
-          pendingMethods.push({ receiverType: recvType, symbol: sym });
-        } else {
-          symbols.push(sym);
-        }
-        break;
-      }
-      case "type_declaration":
-        symbols.push(...extractTypeDeclaration(node, void 0));
-        break;
-      case "var_declaration":
-      case "const_declaration":
-        symbols.push(...extractValueDeclaration(node, void 0));
-        break;
-    }
-  }
-  return { symbols, pendingMethods };
-}
-function attachMethods(symbols, pending) {
-  if (pending.length === 0) return symbols;
-  const byName = /* @__PURE__ */ new Map();
-  for (const s of symbols) {
-    if (s.kind === "class" || s.kind === "interface") byName.set(s.name, s);
-  }
-  const orphans = [];
-  for (const m of pending) {
-    const host = byName.get(m.receiverType);
-    if (host) {
-      host.children = [...host.children, m.symbol];
-    } else {
-      orphans.push(m.symbol);
-    }
-  }
-  return [...symbols, ...orphans];
-}
-function stripQuotes2(s) {
-  if (s.length >= 2 && (s[0] === '"' || s[0] === "'" || s[0] === "`") && s[s.length - 1] === s[0]) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-function extractGoImports(rootNode) {
-  const specs = [];
-  const bindings = [];
-  function visit(node) {
-    if (node.type === "import_declaration") {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (!c) continue;
-        if (c.type === "import_spec") {
-          processSpec(c);
-        } else if (c.type === "import_spec_list") {
-          for (let j = 0; j < c.namedChildCount; j++) {
-            const sp = c.namedChild(j);
-            if (sp?.type === "import_spec") processSpec(sp);
-          }
-        }
-      }
-      return;
-    }
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const child = node.namedChild(i);
-      if (child) visit(child);
-    }
-  }
-  function processSpec(spec) {
-    const pathNode = spec.childForFieldName("path");
-    if (!pathNode) return;
-    const specifier = stripQuotes2(pathNode.text);
-    if (!specifier) return;
-    specs.push(specifier);
-    const nameNode = spec.childForFieldName("name");
-    let localName;
-    if (nameNode) {
-      localName = nameNode.text;
-    } else {
-      const segs = specifier.split("/");
-      localName = segs[segs.length - 1] || specifier;
-    }
-    bindings.push({
-      specifier,
-      importedName: "*",
-      // Go imports a whole package, not specific names
-      localName
-    });
-  }
-  visit(rootNode);
-  return { specs, bindings };
-}
-function extractGoCallSites(rootNode) {
-  const out = [];
-  function visit(node) {
-    if (node.type === "call_expression") {
-      const fn = node.childForFieldName("function");
-      const name = calleeLeafName2(fn);
-      if (name) {
-        const receiverName = receiverRootName2(fn);
-        out.push({
-          calleeName: name,
-          line: node.startPosition.row + 1,
-          ...receiverName ? { receiverName } : {}
-        });
-      }
-    }
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i);
-      if (c) visit(c);
-    }
-  }
-  visit(rootNode);
-  return out;
-}
-function calleeLeafName2(node) {
-  if (!node) return null;
-  if (node.type === "identifier") return node.text;
-  if (node.type === "selector_expression") {
-    const field = node.childForFieldName("field");
-    return field?.text ?? null;
-  }
-  if (node.type === "call_expression") {
-    return calleeLeafName2(node.childForFieldName("function"));
-  }
-  return null;
-}
-function receiverRootName2(node) {
-  if (!node || node.type !== "selector_expression") return void 0;
-  let cur = node;
-  while (cur) {
-    if (cur.type === "identifier") return cur.text;
-    if (cur.type === "selector_expression") {
-      cur = cur.childForFieldName("operand");
-      continue;
-    }
-    return void 0;
-  }
-  return void 0;
-}
-async function readModulePath(cwd) {
-  try {
-    const text = await fs2.readFile(path4.join(cwd, "go.mod"), "utf8");
-    const m = /^\s*module\s+(\S+)/m.exec(text);
-    return m ? m[1].trim() : null;
-  } catch {
-    return null;
-  }
-}
-function bucketGoFilesByDir(fileSet) {
-  const out = /* @__PURE__ */ new Map();
-  for (const f of fileSet) {
-    if (!f.endsWith(".go")) continue;
-    const dir = path4.dirname(f);
-    const list = out.get(dir);
-    if (list) list.push(f);
-    else out.set(dir, [f]);
-  }
-  return out;
-}
-var goHandler = {
-  grammarId: "go",
-  extensions: [".go"],
-  extractSymbols(rootNode, _source) {
-    const out = [];
-    const header = extractGoImportHeader(rootNode);
-    if (header) out.push(header);
-    const { symbols, pendingMethods } = extractTopLevel(rootNode);
-    out.push(...attachMethods(symbols, pendingMethods));
-    absorbLeadingComments(rootNode, out);
-    out.push(...computeFillerBlocks(rootNode, out));
-    return out;
-  },
-  extractImports(rootNode) {
-    return extractGoImports(rootNode);
-  },
-  extractCallSites(rootNode, _symbols) {
-    return extractGoCallSites(rootNode);
-  },
-  // -------- T3: call graph --------
-  async buildProjectContext(cwd, fileSet) {
-    const modulePath = await readModulePath(cwd);
-    const dirToGoFiles = bucketGoFilesByDir(fileSet);
-    const ctx = { cwd, modulePath, dirToGoFiles };
-    return ctx;
-  },
-  resolveSpecifier(spec, _fromFilePath, ctx, _fileSet) {
-    const c = ctx;
-    if (!c.modulePath) return null;
-    if (spec === c.modulePath) {
-      const files = c.dirToGoFiles.get(".");
-      return files?.[0] ?? null;
-    }
-    if (spec.startsWith(c.modulePath + "/")) {
-      const relDir = spec.slice(c.modulePath.length + 1);
-      const files = c.dirToGoFiles.get(relDir);
-      return files?.[0] ?? null;
-    }
-    return null;
-  },
-  resolveCall(call, from, fromFile, allFiles, ctx) {
-    const c = ctx;
-    const fromDir = path4.dirname(fromFile.path);
-    const samePackageFiles = c.dirToGoFiles.get(fromDir) ?? [fromFile.path];
-    if (call.receiverName) {
-      const recvBinding = fromFile.bindingsByLocalName.get(call.receiverName);
-      if (recvBinding) {
-        const recvFilePath = fromFile.resolvedImports.get(recvBinding.specifier);
-        if (!recvFilePath) {
-          return [
-            {
-              kind: "external",
-              name: call.calleeName,
-              packageSpec: recvBinding.specifier
-            }
-          ];
-        }
-        const targetDir = path4.dirname(recvFilePath);
-        const dirFiles = c.dirToGoFiles.get(targetDir) ?? [];
-        for (const fp of dirFiles) {
-          const tf = allFiles.get(fp);
-          if (!tf) continue;
-          const candidates = tf.symbolsByName.get(call.calleeName);
-          if (!candidates) continue;
-          let sym;
-          for (const s of candidates) {
-            if (s.qualifiedName.includes(">")) continue;
-            if (!isCallableKind(s.kind)) continue;
-            sym = s;
-            break;
-          }
-          if (sym) {
-            return [
-              {
-                kind: "symbol",
-                addr: {
-                  filePath: sym.filePath,
-                  qualifiedName: sym.qualifiedName
-                }
-              }
-            ];
-          }
-        }
-        return [
-          {
-            kind: "external",
-            name: call.calleeName,
-            packageSpec: recvBinding.specifier
-          }
-        ];
-      }
-      const methodQname = `${call.receiverName}>${call.calleeName}`;
-      for (const fp of samePackageFiles) {
-        const tf = allFiles.get(fp);
-        if (!tf) continue;
-        const sym = tf.symbolsByQname.get(methodQname);
-        if (sym && isCallableKind(sym.kind)) {
-          return [
-            {
-              kind: "symbol",
-              addr: {
-                filePath: sym.filePath,
-                qualifiedName: sym.qualifiedName
-              }
-            }
-          ];
-        }
-      }
-      return [
-        {
-          kind: "method-unresolved",
-          receiverName: call.receiverName,
-          methodName: call.calleeName
-        }
-      ];
-    }
-    const out = [];
-    for (const fp of samePackageFiles) {
-      const tf = allFiles.get(fp);
-      if (!tf) continue;
-      const candidates = tf.symbolsByName.get(call.calleeName);
-      if (!candidates) continue;
-      for (const s of candidates) {
-        if (s.qualifiedName === from.qualifiedName) continue;
-        if (s.qualifiedName.includes(">")) continue;
-        if (!isCallableKind(s.kind)) continue;
-        out.push({
-          kind: "symbol",
-          addr: { filePath: s.filePath, qualifiedName: s.qualifiedName }
-        });
-      }
-    }
-    return out;
-  },
-  moduleForFile(filePath, ctx) {
-    const c = ctx;
-    const dir = path4.dirname(filePath);
-    if (!c?.modulePath) return dir;
-    return dir === "." ? c.modulePath : `${c.modulePath}/${dir}`;
-  }
-};
-function isCallableKind(k) {
-  return k === "function" || k === "class" || k === "method";
-}
-
-// packages/feature/explorer/src/server/codeMap/handlers/rust.ts
-import { promises as fs3 } from "fs";
-import path5 from "path";
-function qualify3(parent, name) {
-  return parent ? `${parent}>${name}` : name;
-}
-function makeSymbol3(node, name, kind, parentQname, children = [], params) {
-  return {
-    qualifiedName: qualify3(parentQname, name),
-    name,
-    kind,
-    startLine: node.startPosition.row + 1,
-    endLine: node.endPosition.row + 1,
-    contentHash: hashText(normalizeForHash(node.text)),
-    children,
-    params
-  };
-}
-function extractRustParams(fnNode) {
-  const params = fnNode.childForFieldName("parameters");
-  if (!params) return void 0;
-  const out = [];
-  for (let i = 0; i < params.namedChildCount; i++) {
-    const p = params.namedChild(i);
-    if (!p) continue;
-    if (p.type === "self_parameter") {
-      out.push(p.text);
-    } else if (p.type === "parameter") {
-      const pat = p.childForFieldName("pattern");
-      if (pat) {
-        out.push(pat.text);
-      } else {
-        out.push("_");
-      }
-    } else if (p.type === "variadic_parameter") {
-      out.push("...");
-    }
-  }
-  return out;
-}
-function readImplTargetType(implNode) {
-  const t = implNode.childForFieldName("type");
-  if (!t) return null;
-  return readRustTypeName(t);
-}
-function readRustTypeName(t) {
-  if (t.type === "type_identifier") return t.text;
-  if (t.type === "generic_type") {
-    const base = t.childForFieldName("type");
-    if (base) return readRustTypeName(base);
-  }
-  if (t.type === "reference_type") {
-    for (let i = 0; i < t.namedChildCount; i++) {
-      const inner = t.namedChild(i);
-      if (inner) {
-        const r = readRustTypeName(inner);
-        if (r) return r;
-      }
-    }
-  }
-  if (t.type === "scoped_type_identifier") {
-    const name = t.childForFieldName("name");
-    if (name?.type === "type_identifier") return name.text;
-  }
-  return null;
-}
-function extractImplMembers(impl, parentQname) {
-  const body = impl.childForFieldName("body");
-  if (!body) return [];
-  const out = [];
-  for (let i = 0; i < body.namedChildCount; i++) {
-    const m = body.namedChild(i);
-    if (!m) continue;
-    if (m.type === "function_item") {
-      const nameNode = m.childForFieldName("name");
-      if (!nameNode) continue;
-      out.push(
-        makeSymbol3(
-          m,
-          nameNode.text,
-          "method",
-          parentQname,
-          [],
-          extractRustParams(m)
-        )
-      );
-    } else if (m.type === "function_signature_item") {
-      const nameNode = m.childForFieldName("name");
-      if (!nameNode) continue;
-      out.push(
-        makeSymbol3(
-          m,
-          nameNode.text,
-          "method",
-          parentQname,
-          [],
-          extractRustParams(m)
-        )
-      );
-    }
-  }
-  return out;
-}
-function extractTraitMembers(trait, parentQname) {
-  const body = trait.childForFieldName("body");
-  if (!body) return [];
-  const out = [];
-  for (let i = 0; i < body.namedChildCount; i++) {
-    const m = body.namedChild(i);
-    if (!m) continue;
-    if (m.type === "function_item" || m.type === "function_signature_item") {
-      const nameNode = m.childForFieldName("name");
-      if (!nameNode) continue;
-      out.push(
-        makeSymbol3(
-          m,
-          nameNode.text,
-          "method",
-          parentQname,
-          [],
-          extractRustParams(m)
-        )
-      );
-    }
-  }
-  return out;
-}
-function extractRustImportHeader(rootNode) {
-  const headerNodes = [];
-  let firstLine = -1;
-  let lastLine = -1;
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const c = rootNode.namedChild(i);
-    if (!c) continue;
-    if (c.type === "use_declaration" || c.type === "extern_crate_declaration") {
-      headerNodes.push(c);
-      if (firstLine < 0) firstLine = c.startPosition.row + 1;
-      lastLine = c.endPosition.row + 1;
-    } else if (firstLine >= 0) {
-      break;
-    }
-  }
-  if (firstLine < 0) return null;
-  const text = headerNodes.map((n) => n.text).join("\n");
-  return {
-    qualifiedName: "__imports__",
-    name: "imports",
-    kind: "unknown",
-    startLine: firstLine,
-    endLine: lastLine,
-    contentHash: hashText(normalizeForHash(text)),
-    children: []
-  };
-}
-function extractTopLevel2(rootNode) {
-  const symbols = [];
-  const pendingImpls = [];
-  for (let i = 0; i < rootNode.namedChildCount; i++) {
-    const node = rootNode.namedChild(i);
-    if (!node) continue;
-    switch (node.type) {
-      case "function_item": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        symbols.push(
-          makeSymbol3(
-            node,
-            nameNode.text,
-            "function",
-            void 0,
-            [],
-            extractRustParams(node)
-          )
-        );
-        break;
-      }
-      case "struct_item":
-      case "union_item": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        symbols.push(makeSymbol3(node, nameNode.text, "class", void 0));
-        break;
-      }
-      case "enum_item": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        symbols.push(makeSymbol3(node, nameNode.text, "enum", void 0));
-        break;
-      }
-      case "trait_item": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        const qname = nameNode.text;
-        const members = extractTraitMembers(node, qname);
-        symbols.push(
-          makeSymbol3(node, nameNode.text, "interface", void 0, members)
-        );
-        break;
-      }
-      case "impl_item": {
-        const target = readImplTargetType(node);
-        if (!target) break;
-        const methods = extractImplMembers(node, target);
-        if (methods.length > 0) {
-          pendingImpls.push({ targetType: target, methods });
-        }
-        break;
-      }
-      case "const_item":
-      case "static_item": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        symbols.push(makeSymbol3(node, nameNode.text, "const", void 0));
-        break;
-      }
-      case "type_item": {
-        const nameNode = node.childForFieldName("name");
-        if (!nameNode) break;
-        symbols.push(makeSymbol3(node, nameNode.text, "type", void 0));
-        break;
-      }
-      case "mod_item": {
-        const nameNode = node.childForFieldName("name");
-        const body = node.childForFieldName("body");
-        if (!nameNode || !body) {
-          break;
-        }
-        symbols.push(makeSymbol3(node, nameNode.text, "class", void 0));
-        break;
-      }
-    }
-  }
-  return { symbols, pendingImpls };
-}
-function attachImplMethods(symbols, pending) {
-  if (pending.length === 0) return symbols;
-  const byName = /* @__PURE__ */ new Map();
-  for (const s of symbols) {
-    if (s.kind === "class" || s.kind === "enum" || s.kind === "interface") {
-      byName.set(s.name, s);
-    }
-  }
-  const orphans = [];
-  for (const impl of pending) {
-    const host = byName.get(impl.targetType);
-    if (host) {
-      host.children = [...host.children, ...impl.methods];
-    } else {
-      orphans.push(...impl.methods);
-    }
-  }
-  return [...symbols, ...orphans];
-}
-function extractRustImports(rootNode) {
-  const specs = [];
-  const bindings = [];
-  function walkUse(useNode) {
-    for (let i = 0; i < useNode.namedChildCount; i++) {
-      const c = useNode.namedChild(i);
-      if (c) processUseTree(c, "");
-    }
-  }
-  function processUseTree(node, prefix) {
-    switch (node.type) {
-      case "use_as_clause": {
-        const pathNode = node.childForFieldName("path");
-        const aliasNode = node.childForFieldName("alias");
-        if (pathNode && aliasNode) {
-          const fullPath = joinPath(prefix, pathToString(pathNode));
-          specs.push(fullPath);
-          bindings.push({
-            specifier: fullPath,
-            importedName: leafOf(fullPath),
-            localName: aliasNode.text
-          });
-        }
-        break;
-      }
-      case "use_list": {
-        for (let i = 0; i < node.namedChildCount; i++) {
-          const inner = node.namedChild(i);
-          if (inner) processUseTree(inner, prefix);
-        }
-        break;
-      }
-      case "scoped_use_list": {
-        const pathNode = node.childForFieldName("path");
-        const listNode = node.childForFieldName("list");
-        const newPrefix = pathNode ? joinPath(prefix, pathToString(pathNode)) : prefix;
-        if (listNode) {
-          for (let i = 0; i < listNode.namedChildCount; i++) {
-            const inner = listNode.namedChild(i);
-            if (inner) processUseTree(inner, newPrefix);
-          }
-        }
-        break;
-      }
-      case "use_wildcard": {
-        const pathNode = node.childForFieldName("path");
-        const fullPath = pathNode ? joinPath(prefix, pathToString(pathNode)) : prefix;
-        if (fullPath) {
-          specs.push(fullPath);
-          bindings.push({
-            specifier: fullPath,
-            importedName: "*",
-            localName: "*"
-          });
-        }
-        break;
-      }
-      case "identifier":
-      case "self":
-      case "super":
-      case "crate":
-      case "scoped_identifier": {
-        const leaf = pathToString(node);
-        const fullPath = joinPath(prefix, leaf);
-        if (fullPath) {
-          specs.push(fullPath);
-          bindings.push({
-            specifier: fullPath,
-            importedName: leafOf(fullPath),
-            localName: leafOf(fullPath)
-          });
-        }
-        break;
-      }
-    }
-  }
-  function pathToString(node) {
-    if (node.type === "identifier" || node.type === "crate" || node.type === "self" || node.type === "super") {
-      return node.text;
-    }
-    if (node.type === "scoped_identifier") {
-      const path7 = node.childForFieldName("path");
-      const name = node.childForFieldName("name");
-      const left = path7 ? pathToString(path7) : "";
-      const right = name?.text ?? "";
-      return left ? `${left}::${right}` : right;
-    }
-    return node.text;
-  }
-  function joinPath(prefix, suffix) {
-    if (!prefix) return suffix;
-    if (!suffix) return prefix;
-    return `${prefix}::${suffix}`;
-  }
-  function leafOf(p) {
-    const parts = p.split("::");
-    return parts[parts.length - 1] ?? p;
-  }
-  function visit(node) {
-    if (node.type === "use_declaration") {
-      walkUse(node);
-      return;
-    }
-    if (node.type === "extern_crate_declaration") {
-      const nameNode = node.childForFieldName("name");
-      if (nameNode) {
-        specs.push(nameNode.text);
-        bindings.push({
-          specifier: nameNode.text,
-          importedName: "*",
-          localName: nameNode.text
-        });
-      }
-      return;
-    }
-    if (node.type === "mod_item") {
-      const body = node.childForFieldName("body");
-      const nameNode = node.childForFieldName("name");
-      if (!body && nameNode) {
-        specs.push(nameNode.text);
-      }
-      return;
-    }
-    for (let i = 0; i < node.namedChildCount; i++) {
-      const c = node.namedChild(i);
-      if (c) visit(c);
-    }
-  }
-  visit(rootNode);
-  return { specs, bindings };
-}
-function extractRustCallSites(rootNode) {
-  const out = [];
-  function visit(node) {
-    if (node.type === "call_expression") {
-      const fn = node.childForFieldName("function");
-      const name = calleeLeafName3(fn);
-      if (name) {
-        const receiverName = receiverRootName3(fn);
-        out.push({
-          calleeName: name,
-          line: node.startPosition.row + 1,
-          ...receiverName ? { receiverName } : {}
-        });
-      }
-    } else if (node.type === "method_call_expression") {
-      const methodNode = node.childForFieldName("method");
-      const receiverNode = node.childForFieldName("value");
-      if (methodNode) {
-        const receiverName = receiverNode?.type === "identifier" ? receiverNode.text : void 0;
-        out.push({
-          calleeName: methodNode.text,
-          line: node.startPosition.row + 1,
-          ...receiverName ? { receiverName } : {}
-        });
-      }
-    }
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i);
-      if (c) visit(c);
-    }
-  }
-  visit(rootNode);
-  return out;
-}
-function calleeLeafName3(node) {
-  if (!node) return null;
-  if (node.type === "identifier") return node.text;
-  if (node.type === "scoped_identifier") {
-    const name = node.childForFieldName("name");
-    return name?.text ?? null;
-  }
-  if (node.type === "field_expression") {
-    const field = node.childForFieldName("field");
-    return field?.text ?? null;
-  }
-  return null;
-}
-function receiverRootName3(node) {
-  if (!node) return void 0;
-  if (node.type === "scoped_identifier") {
-    let cur = node;
-    while (cur) {
-      if (cur.type === "identifier") return cur.text;
-      if (cur.type === "scoped_identifier") {
-        cur = cur.childForFieldName("path");
-        continue;
-      }
-      break;
-    }
-  }
-  if (node.type === "field_expression") {
-    const value = node.childForFieldName("value");
-    if (value?.type === "identifier") return value.text;
-  }
-  return void 0;
-}
-function findRustEntryFiles(fileSet) {
-  const out = [];
-  for (const f of fileSet) {
-    if (f === "src/lib.rs" || f === "src/main.rs" || f.endsWith("/src/lib.rs") || f.endsWith("/src/main.rs") || /^src\/bin\/[^/]+\.rs$/.test(f) || /\/src\/bin\/[^/]+\.rs$/.test(f)) {
-      out.push(f);
-    }
-  }
-  return out;
-}
-function stripRustCommentsAndStrings(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/"(?:\\.|[^"\\\n])*"/g, '""');
-}
-function findFileModDeclarations(source) {
-  const cleaned = stripRustCommentsAndStrings(source);
-  const out = [];
-  const re = /\b(?:pub(?:\s*\([^)]*\))?\s+)?mod\s+(\w+)\s*;/g;
-  let m;
-  while ((m = re.exec(cleaned)) !== null) {
-    out.push(m[1]);
-  }
-  return out;
-}
-async function buildModTree(cwd, fileSet) {
-  const modTree = /* @__PURE__ */ new Map();
-  const fileToMod = /* @__PURE__ */ new Map();
-  const visited = /* @__PURE__ */ new Set();
-  async function walk(modPath, filePath) {
-    if (visited.has(filePath)) return;
-    visited.add(filePath);
-    modTree.set(modPath, filePath);
-    fileToMod.set(filePath, modPath);
-    let source;
-    try {
-      source = await fs3.readFile(path5.join(cwd, filePath), "utf8");
-    } catch {
-      return;
-    }
-    const childMods = findFileModDeclarations(source);
-    if (childMods.length === 0) return;
-    const dir = path5.dirname(filePath);
-    const baseName = path5.basename(filePath, ".rs");
-    const possibleSubdirs = baseName === "mod" || baseName === "lib" || baseName === "main" ? [dir] : [dir, path5.join(dir, baseName)];
-    for (const childMod of childMods) {
-      const childModPath = `${modPath}::${childMod}`;
-      let childFile = null;
-      for (const subdir of possibleSubdirs) {
-        const candidates = [
-          path5.join(subdir, `${childMod}.rs`),
-          path5.join(subdir, childMod, "mod.rs")
-        ];
-        for (const c of candidates) {
-          const normalised = c.startsWith("./") ? c.slice(2) : c;
-          if (fileSet.has(normalised)) {
-            childFile = normalised;
-            break;
-          }
-        }
-        if (childFile) break;
-      }
-      if (childFile) {
-        await walk(childModPath, childFile);
-      }
-    }
-  }
-  for (const entry of findRustEntryFiles(fileSet)) {
-    if (entry === "src/lib.rs" || entry === "src/main.rs") {
-      await walk("crate", entry);
-    } else if (entry.startsWith("src/bin/")) {
-      await walk("crate", entry);
-    } else {
-      const parts = entry.split("/");
-      const memberIdx = parts.indexOf("src");
-      if (memberIdx > 0) {
-        const memberName = parts[memberIdx - 1];
-        await walk(memberName, entry);
-      }
-    }
-  }
-  return { modTree, fileToMod };
-}
-function resolveModPath(spec, fromModPath) {
-  if (spec.startsWith("crate::")) return spec;
-  if (spec === "crate") return "crate";
-  if (spec.startsWith("self::")) {
-    return `${fromModPath}::${spec.slice("self::".length)}`;
-  }
-  if (spec === "self") return fromModPath;
-  if (spec.startsWith("super::")) {
-    let parent = fromModPath;
-    let rest = spec;
-    while (rest.startsWith("super::")) {
-      const lastSep = parent.lastIndexOf("::");
-      if (lastSep < 0) return null;
-      parent = parent.slice(0, lastSep);
-      rest = rest.slice("super::".length);
-    }
-    if (rest === "super") {
-      const lastSep = parent.lastIndexOf("::");
-      return lastSep < 0 ? null : parent.slice(0, lastSep);
-    }
-    return rest ? `${parent}::${rest}` : parent;
-  }
-  return null;
-}
-var rustHandler = {
-  grammarId: "rust",
-  extensions: [".rs"],
-  extractSymbols(rootNode, _source) {
-    const out = [];
-    const header = extractRustImportHeader(rootNode);
-    if (header) out.push(header);
-    const { symbols, pendingImpls } = extractTopLevel2(rootNode);
-    out.push(...attachImplMethods(symbols, pendingImpls));
-    absorbLeadingComments(rootNode, out);
-    out.push(...computeFillerBlocks(rootNode, out));
-    return out;
-  },
-  extractImports(rootNode) {
-    return extractRustImports(rootNode);
-  },
-  extractCallSites(rootNode, _symbols) {
-    return extractRustCallSites(rootNode);
-  },
-  // -------- T3: call graph --------
-  async buildProjectContext(cwd, fileSet) {
-    const { modTree, fileToMod } = await buildModTree(cwd, fileSet);
-    const ctx = { cwd, modTree, fileToMod };
-    return ctx;
-  },
-  resolveSpecifier(spec, fromFilePath, ctx, _fileSet) {
-    const c = ctx;
-    const fromMod = c.fileToMod.get(fromFilePath);
-    if (!fromMod) return null;
-    const resolved = resolveModPath(spec, fromMod);
-    if (!resolved) return null;
-    if (c.modTree.has(resolved)) return c.modTree.get(resolved);
-    const segs = resolved.split("::");
-    while (segs.length > 1) {
-      segs.pop();
-      const candidate = segs.join("::");
-      const file = c.modTree.get(candidate);
-      if (file) return file;
-    }
-    return null;
-  },
-  resolveCall(call, from, fromFile, allFiles, _ctx) {
-    if (call.receiverName) {
-      const recvBinding = fromFile.bindingsByLocalName.get(call.receiverName);
-      if (recvBinding) {
-        const recvFilePath = fromFile.resolvedImports.get(recvBinding.specifier);
-        if (!recvFilePath) {
-          return [
-            {
-              kind: "external",
-              name: call.calleeName,
-              packageSpec: recvBinding.specifier
-            }
-          ];
-        }
-        const targetFile2 = allFiles.get(recvFilePath);
-        if (!targetFile2) return [];
-        const candidates = targetFile2.symbolsByName.get(call.calleeName);
-        if (candidates) {
-          for (const s of candidates) {
-            if (s.qualifiedName.includes(">")) continue;
-            if (!isCallableKind2(s.kind)) continue;
-            return [
-              {
-                kind: "symbol",
-                addr: {
-                  filePath: s.filePath,
-                  qualifiedName: s.qualifiedName
-                }
-              }
-            ];
-          }
-        }
-        const nestedQname = `${recvBinding.importedName}>${call.calleeName}`;
-        const nested = targetFile2.symbolsByQname.get(nestedQname);
-        if (nested && isCallableKind2(nested.kind)) {
-          return [
-            {
-              kind: "symbol",
-              addr: {
-                filePath: nested.filePath,
-                qualifiedName: nested.qualifiedName
-              }
-            }
-          ];
-        }
-        return [
-          {
-            kind: "method-unresolved",
-            receiverName: call.receiverName,
-            methodName: call.calleeName
-          }
-        ];
-      }
-      const directMethod = `${call.receiverName}>${call.calleeName}`;
-      const directHit = fromFile.symbolsByQname.get(directMethod);
-      if (directHit) {
-        return [
-          {
-            kind: "symbol",
-            addr: {
-              filePath: directHit.filePath,
-              qualifiedName: directHit.qualifiedName
-            }
-          }
-        ];
-      }
-      const out = [];
-      const allSameName = fromFile.symbolsByName.get(call.calleeName);
-      if (allSameName) {
-        for (const s of allSameName) {
-          if (s.kind !== "method") continue;
-          out.push({
-            kind: "symbol",
-            addr: { filePath: s.filePath, qualifiedName: s.qualifiedName }
-          });
-        }
-      }
-      if (out.length > 0) return out;
-      return [
-        {
-          kind: "method-unresolved",
-          receiverName: call.receiverName,
-          methodName: call.calleeName
-        }
-      ];
-    }
-    const local = [];
-    const localCandidates = fromFile.symbolsByName.get(call.calleeName);
-    if (localCandidates) {
-      for (const s of localCandidates) {
-        if (s.qualifiedName === from.qualifiedName) continue;
-        if (s.qualifiedName.includes(">")) continue;
-        if (!isCallableKind2(s.kind)) continue;
-        local.push({
-          kind: "symbol",
-          addr: { filePath: s.filePath, qualifiedName: s.qualifiedName }
-        });
-      }
-    }
-    if (local.length > 0) return local;
-    const binding = fromFile.bindingsByLocalName.get(call.calleeName);
-    if (!binding) return [];
-    const targetFile = fromFile.resolvedImports.get(binding.specifier);
-    if (!targetFile) {
-      return [
-        {
-          kind: "external",
-          name: binding.importedName,
-          packageSpec: binding.specifier
-        }
-      ];
-    }
-    const target = allFiles.get(targetFile);
-    if (!target) return [];
-    const targetCandidates = target.symbolsByName.get(binding.importedName);
-    let sym;
-    if (targetCandidates) {
-      for (const s of targetCandidates) {
-        if (s.qualifiedName.includes(">")) continue;
-        if (!isCallableKind2(s.kind)) continue;
-        sym = s;
-        break;
-      }
-    }
-    if (!sym) return [];
-    return [
-      {
-        kind: "symbol",
-        addr: { filePath: sym.filePath, qualifiedName: sym.qualifiedName }
-      }
-    ];
-  },
-  moduleForFile(filePath, ctx) {
-    const c = ctx;
-    return c?.fileToMod.get(filePath) ?? path5.dirname(filePath);
-  }
-};
-function isCallableKind2(k) {
-  return k === "function" || k === "class" || k === "method";
-}
-
-// packages/feature/explorer/src/server/codeMap/handlers/index.ts
-registerHandler(typescriptHandler);
-registerHandler(tsxHandler);
-registerHandler(javascriptHandler);
-registerHandler(pythonHandler);
-registerHandler(goHandler);
-registerHandler(rustHandler);
-
-// packages/feature/explorer/src/server/codeMap/projectGraph/codeIndex.ts
-var dirtyCwds = /* @__PURE__ */ new Set();
-var subscribedCwds = /* @__PURE__ */ new Set();
-var watcherSubscriber = null;
-function registerWatcherSubscriber(fn) {
-  watcherSubscriber = fn;
-  if (fn) {
-    for (const cwd of subscribedCwds) {
-      fn(cwd, () => dirtyCwds.add(cwd));
-    }
-  }
-}
-var execAsync2 = promisify2(exec2);
-
-// src/lib/codeIndexSync.ts
-var wired = false;
-function wireCodeIndexToFileWatcher() {
-  if (wired) return;
-  wired = true;
-  registerWatcherSubscriber((cwd, onDirty) => {
-    fileWatcher.subscribe(cwd, (events) => {
-      if (events.some((e) => e.type === "file" || e.type === "git")) {
-        onDirty();
-      }
-    });
-  });
+  });
 }
 
 // src/lib/globalStateBroadcast.ts
 import { WebSocket } from "ws";
-var g2 = globalThis;
-var globalStateClients = g2.__cockpitGlobalStateClients ?? (g2.__cockpitGlobalStateClients = /* @__PURE__ */ new Set());
+var g = globalThis;
+var globalStateClients = g.__cockpitGlobalStateClients ?? (g.__cockpitGlobalStateClients = /* @__PURE__ */ new Set());
 function broadcastToGlobalState(msg) {
   const data = JSON.stringify(msg);
   for (const ws of globalStateClients) {