@surething/cockpit 1.0.210 → 1.0.212

package/dist/wsServer.mjs

@@ -66,10 +66,10 @@ var fromWebSocket = (ws, proto) => Effect_exports.gen(function* () {
       ws.on("error", onError);
       return { onMessage, onClose, onError };
     }),
-    (handlers) => Effect_exports.sync(() => {
-      ws.off("message", handlers.onMessage);
-      ws.off("close", handlers.onClose);
-      ws.off("error", handlers.onError);
+    (handlers2) => Effect_exports.sync(() => {
+      ws.off("message", handlers2.onMessage);
+      ws.off("close", handlers2.onClose);
+      ws.off("error", handlers2.onError);
     })
   );
   const send = (msg) => Effect_exports.try({
@@ -1188,7 +1188,2733 @@ var runTerminalHandler = (ws, projectCwd) => {
   });
 };
 
+// packages/feature/explorer/src/server/codeMap/projectGraph/codeIndex.ts
+import { promises as fs4 } from "fs";
+import path6 from "path";
+
+// 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 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;
+      }
+    }
+    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));
+  }
+  out.push(...computeFillerBlocks(rootNode, out));
+  return out;
+}
+
+// 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));
+    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));
+    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));
+    }
+  }
+}
+
+// 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/wsServer.ts
+wireCodeIndexToFileWatcher();
 var g_ws = globalThis;
 var globalStateClients = g_ws.__cockpitGlobalStateClients ?? (g_ws.__cockpitGlobalStateClients = /* @__PURE__ */ new Set());
 function broadcastToGlobalState(msg) {