@iowarp/clio-coder 0.3.0

package/dist/chunk-TPOCL34A.js

@@ -0,0 +1,2876 @@
+import {
+  safeResourceWrite
+} from "./chunk-VPAWTYLY.js";
+
+// src/domains/session/workspace/project-type.ts
+import { readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/core/c-header-language.ts
+function isAmbiguousHeaderPath(path) {
+  return path.endsWith(".h");
+}
+var CPP_ONLY_STD_INCLUDES = /* @__PURE__ */ new Set([
+  "algorithm",
+  "any",
+  "array",
+  "atomic",
+  "barrier",
+  "bit",
+  "bitset",
+  "cassert",
+  "cctype",
+  "cerrno",
+  "cfenv",
+  "cfloat",
+  "charconv",
+  "chrono",
+  "cinttypes",
+  "climits",
+  "clocale",
+  "cmath",
+  "codecvt",
+  "compare",
+  "complex",
+  "concepts",
+  "condition_variable",
+  "coroutine",
+  "csetjmp",
+  "csignal",
+  "cstdarg",
+  "cstddef",
+  "cstdint",
+  "cstdio",
+  "cstdlib",
+  "cstring",
+  "ctime",
+  "cuchar",
+  "cwchar",
+  "cwctype",
+  "deque",
+  "exception",
+  "execution",
+  "expected",
+  "filesystem",
+  "flat_map",
+  "flat_set",
+  "format",
+  "forward_list",
+  "fstream",
+  "functional",
+  "future",
+  "generator",
+  "initializer_list",
+  "iomanip",
+  "ios",
+  "iosfwd",
+  "iostream",
+  "istream",
+  "iterator",
+  "latch",
+  "limits",
+  "list",
+  "locale",
+  "map",
+  "mdspan",
+  "memory",
+  "memory_resource",
+  "mutex",
+  "new",
+  "numbers",
+  "numeric",
+  "optional",
+  "ostream",
+  "print",
+  "queue",
+  "random",
+  "ranges",
+  "ratio",
+  "regex",
+  "scoped_allocator",
+  "semaphore",
+  "set",
+  "shared_mutex",
+  "source_location",
+  "span",
+  "spanstream",
+  "sstream",
+  "stack",
+  "stacktrace",
+  "stdexcept",
+  "stop_token",
+  "streambuf",
+  "string",
+  "string_view",
+  "syncstream",
+  "system_error",
+  "thread",
+  "tuple",
+  "type_traits",
+  "typeindex",
+  "typeinfo",
+  "unordered_map",
+  "unordered_set",
+  "utility",
+  "valarray",
+  "variant",
+  "vector",
+  "version"
+]);
+var CPP_SYNTAX_PATTERNS = [
+  /\bnamespace\s+[A-Za-z_{:]/,
+  /\btemplate\s*</,
+  /\btypename\b/,
+  /\bclass\s+[A-Za-z_]/,
+  /\benum\s+(?:class|struct)\b/,
+  /\w::~?[A-Za-z_~]/,
+  /::/,
+  /^\s*(?:public|private|protected)\s*:(?!:)/m,
+  /\b(?:static_cast|dynamic_cast|reinterpret_cast|const_cast)\s*</,
+  /\busing\s+[A-Za-z_]\w*\s*=/,
+  /\busing\s+namespace\b/,
+  /\boperator\s*(?:[+\-*/%^&|~!=<>]|\(\)|\[\])/,
+  /\b(?:constexpr|consteval|constinit|noexcept|nullptr|decltype|thread_local)\b/,
+  /\b(?:virtual|override|friend|mutable)\b/,
+  /\)\s*(?:const|noexcept|override|final)\b/,
+  /^[ \t]*[A-Za-z_]\w*(?:::\w+)*(?:\s*<[^;{}()]+>)?\s*&&?\s*[A-Za-z_]\w*\s*\([^;{}]*\)\s*;/m,
+  /\bauto\s+[A-Za-z_]\w*\s*\([^;{}]*\)\s*->/
+];
+function blank(ch) {
+  return ch === "\n" ? "\n" : " ";
+}
+function stripForScan(text) {
+  let withStrings = "";
+  let code = "";
+  let state = "code";
+  for (let index = 0; index < text.length; index += 1) {
+    const ch = text[index];
+    const next = text[index + 1];
+    if (state === "code") {
+      if (ch === "/" && next === "/") {
+        state = "line-comment";
+        withStrings += " ";
+        code += " ";
+        continue;
+      }
+      if (ch === "/" && next === "*") {
+        state = "block-comment";
+        withStrings += " ";
+        code += " ";
+        continue;
+      }
+      if (ch === '"') state = "string";
+      else if (ch === "'") state = "char";
+      withStrings += ch;
+      code += state === "code" ? ch : " ";
+      continue;
+    }
+    if (state === "line-comment") {
+      if (ch === "\n") state = "code";
+      withStrings += blank(ch);
+      code += blank(ch);
+      continue;
+    }
+    if (state === "block-comment") {
+      if (ch === "*" && next === "/") {
+        state = "code";
+        index += 1;
+        withStrings += " ";
+        code += " ";
+        continue;
+      }
+      withStrings += blank(ch);
+      code += blank(ch);
+      continue;
+    }
+    if (ch === "\\" && next !== void 0) {
+      withStrings += ch + next;
+      code += blank(ch) + blank(next);
+      index += 1;
+      continue;
+    }
+    if (state === "string" && ch === '"' || state === "char" && ch === "'" || ch === "\n") {
+      state = "code";
+      withStrings += ch;
+      code += blank(ch);
+      continue;
+    }
+    withStrings += ch;
+    code += blank(ch);
+  }
+  return { withStrings, code };
+}
+function hasCppInclude(withStrings) {
+  for (const match of withStrings.matchAll(/^[ \t]*#[ \t]*include[ \t]*([<"])([^>"\n]+)[>"]/gm)) {
+    const delimiter = match[1];
+    const target = match[2]?.trim() ?? "";
+    if (/\.(?:hpp|hh|hxx|cuh)$/.test(target)) return true;
+    if (delimiter === "<" && CPP_ONLY_STD_INCLUDES.has(target)) return true;
+  }
+  return false;
+}
+function hasCppMemberDeclaration(code) {
+  for (const match of code.matchAll(/\b(?:class|struct)\s+[A-Za-z_]\w*[^;{]*\{([\s\S]*?)\}/g)) {
+    const body = match[1] ?? "";
+    for (const rawStatement of body.split(";")) {
+      const statement = rawStatement.trim();
+      if (statement.length === 0 || /\(\s*[*&]/.test(statement)) continue;
+      const member = /(?:^|\s)(operator\s*[^\s(]+|~?[A-Za-z_]\w*)\s*\([^{};]*\)\s*(?:const\b|noexcept\b|override\b|final\b|=\s*0\s*)*$/.exec(
+        statement
+      );
+      if (!member) continue;
+      const name = member[1] ?? "";
+      const prefix = statement.slice(0, member.index);
+      if (prefix.includes("[") || /^[_A-Z][_A-Z0-9]*$/.test(name)) continue;
+      return true;
+    }
+  }
+  return false;
+}
+function classifyCHeaderLanguage(text) {
+  const { withStrings, code } = stripForScan(text);
+  if (hasCppInclude(withStrings)) return "c++";
+  if (hasCppMemberDeclaration(code)) return "c++";
+  for (const pattern of CPP_SYNTAX_PATTERNS) {
+    if (pattern.test(code)) return "c++";
+  }
+  return "c";
+}
+
+// src/core/workspace-files.ts
+import { execFile, execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { join, sep } from "node:path";
+import { performance as performance2 } from "node:perf_hooks";
+var DEFAULT_YIELD_BUDGET_MS = 8;
+function createDefaultTick(budgetMs = DEFAULT_YIELD_BUDGET_MS) {
+  let sliceStart = performance2.now();
+  return {
+    async tick() {
+      if (performance2.now() - sliceStart < budgetMs) return;
+      await new Promise((resolve2) => {
+        setImmediate(resolve2);
+      });
+      sliceStart = performance2.now();
+    }
+  };
+}
+var GIT_OUTPUT_LIMIT_BYTES = 128 * 1024 * 1024;
+var MAX_ENUMERATION_DIAGNOSTIC_PATH_CHARS = 200;
+var DEFAULT_WORKSPACE_FALLBACK_LIMITS = Object.freeze({
+  maxVisitedEntries: 1e5,
+  maxDepth: 64,
+  maxPathBytes: 64 * 1024 * 1024,
+  maxDurationMs: 5e3
+});
+var WorkspaceEnumerationLimitError = class extends Error {
+  constructor(kind, limit) {
+    super(`non-Git workspace enumeration exceeded ${kind} limit (${limit})`);
+    this.kind = kind;
+    this.limit = limit;
+    this.name = "WorkspaceEnumerationLimitError";
+  }
+  kind;
+  limit;
+  code = "WORKSPACE_ENUMERATION_LIMIT";
+};
+function boundedDiagnosticPath(path) {
+  const printable = Array.from(path.length > 0 ? path : ".", (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 ? "?" : character;
+  });
+  if (printable.length <= MAX_ENUMERATION_DIAGNOSTIC_PATH_CHARS) return printable.join("");
+  const side = Math.floor((MAX_ENUMERATION_DIAGNOSTIC_PATH_CHARS - 1) / 2);
+  return `${printable.slice(0, side).join("")}\u2026${printable.slice(-side).join("")}`;
+}
+function boundedSystemErrorCode(cause) {
+  if (typeof cause !== "object" || cause === null || !("code" in cause)) return "UNKNOWN";
+  const code = cause.code;
+  return typeof code === "string" && /^[A-Z][A-Z0-9_]{0,31}$/.test(code) ? code : "UNKNOWN";
+}
+var ENUMERATION_OPERATION_LABELS = Object.freeze({
+  "open-root": "open the workspace root",
+  "read-directory": "read a workspace directory",
+  "open-directory": "open a workspace directory",
+  "inspect-entry": "inspect a workspace entry"
+});
+var WorkspaceEnumerationIncompleteError = class extends Error {
+  code = "WORKSPACE_ENUMERATION_INCOMPLETE";
+  operation;
+  path;
+  causeCode;
+  constructor(operation, path, cause) {
+    const diagnosticPath = boundedDiagnosticPath(path);
+    const causeCode = boundedSystemErrorCode(cause);
+    super(
+      `non-Git workspace enumeration could not ${ENUMERATION_OPERATION_LABELS[operation]} at '${diagnosticPath}' (${causeCode})`
+    );
+    this.name = "WorkspaceEnumerationIncompleteError";
+    this.operation = operation;
+    this.path = diagnosticPath;
+    this.causeCode = causeCode;
+  }
+};
+var WORKSPACE_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".clio-coder",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "target",
+  "vendor",
+  ".superpowers",
+  ".codex",
+  ".claude",
+  ".clio-coder-benchmark"
+]);
+function comparePaths(a, b) {
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+function normalizeRelativePath(path) {
+  const posixPath = sep === "\\" ? path.replaceAll("\\", "/") : path;
+  const normalized = posixPath.replace(/^\.\//, "");
+  if (normalized.length === 0 || normalized.includes("\0") || normalized.startsWith("/")) return null;
+  if (/^[A-Za-z]:\//.test(normalized)) return null;
+  const segments = normalized.split("/");
+  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) return null;
+  return segments.join("/");
+}
+function isWorkspacePathExcluded(relPath, excludedDirs = WORKSPACE_EXCLUDED_DIRS) {
+  return relPath.split("/").some((segment) => excludedDirs.has(segment));
+}
+function isDisappearedWorkspaceEntry(cause) {
+  if (typeof cause !== "object" || cause === null || !("code" in cause)) return false;
+  const code = cause.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function isRegularWorkspaceFile(cwd, relPath, requireCompleteSnapshot) {
+  try {
+    const stat = fs.lstatSync(join(cwd, relPath));
+    if (stat.isFile()) return true;
+    if (requireCompleteSnapshot && stat.isDirectory()) {
+      throw new WorkspaceEnumerationIncompleteError("inspect-entry", relPath, { code: "ENTRY_TYPE_CHANGED" });
+    }
+    return false;
+  } catch (cause) {
+    if (cause instanceof WorkspaceEnumerationIncompleteError) throw cause;
+    if (requireCompleteSnapshot) {
+      if (isDisappearedWorkspaceEntry(cause)) return false;
+      throw new WorkspaceEnumerationIncompleteError("inspect-entry", relPath, cause);
+    }
+    return false;
+  }
+}
+function gitVisibleFilesArgs(candidates) {
+  const args = ["--literal-pathspecs", "ls-files", "-z", "--cached", "--others", "--exclude-standard"];
+  if (candidates) args.push("--", ...candidates);
+  return args;
+}
+function splitGitPathOutput(output) {
+  return output.split("\0").filter((path) => path.length > 0);
+}
+function gitVisibleFiles(cwd, candidates) {
+  let output;
+  try {
+    output = execFileSync("git", gitVisibleFilesArgs(candidates), {
+      cwd,
+      maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+  return splitGitPathOutput(output.toString("utf8"));
+}
+function gitVisibleFilesAsync(cwd, candidates) {
+  return new Promise((resolve2) => {
+    execFile("git", gitVisibleFilesArgs(candidates), { cwd, maxBuffer: GIT_OUTPUT_LIMIT_BYTES }, (error, stdout) => {
+      resolve2(error ? null : splitGitPathOutput(stdout));
+    });
+  });
+}
+function resolveFallbackLimits(overrides) {
+  const limits = { ...DEFAULT_WORKSPACE_FALLBACK_LIMITS, ...overrides };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+      throw new RangeError(`workspace fallback ${name} must be a non-negative integer`);
+    }
+  }
+  return limits;
+}
+function fallbackEntryKind(absPath, relPath, entry) {
+  if (!entry) return "disappeared";
+  if (entry.isDirectory()) return "directory";
+  if (entry.isFile()) return "file";
+  try {
+    const stat = fs.lstatSync(absPath);
+    if (stat.isDirectory()) return "directory";
+    if (stat.isFile()) return "file";
+    return "other";
+  } catch (cause) {
+    if (isDisappearedWorkspaceEntry(cause)) return "disappeared";
+    throw new WorkspaceEnumerationIncompleteError("inspect-entry", relPath, cause);
+  }
+}
+function closeFrame(frame) {
+  try {
+    frame.dir.closeSync();
+  } catch {
+  }
+}
+function* fallbackFilesWalk(cwd, excludedDirs, limits, elapsedMs) {
+  let visitedEntries = 0;
+  let pathBytes = 0;
+  let root;
+  try {
+    root = fs.opendirSync(cwd);
+  } catch (cause) {
+    throw new WorkspaceEnumerationIncompleteError("open-root", ".", cause);
+  }
+  const stack = [{ dir: root, absPath: cwd, prefix: "", depth: 0 }];
+  const files = [];
+  try {
+    while (stack.length > 0) {
+      yield;
+      if (elapsedMs() >= limits.maxDurationMs) {
+        throw new WorkspaceEnumerationLimitError("time", limits.maxDurationMs);
+      }
+      const frame = stack.at(-1);
+      if (!frame) break;
+      let entry;
+      try {
+        entry = frame.dir.readSync();
+      } catch (cause) {
+        throw new WorkspaceEnumerationIncompleteError("read-directory", frame.prefix || ".", cause);
+      }
+      if (!entry) {
+        closeFrame(frame);
+        stack.pop();
+        continue;
+      }
+      visitedEntries += 1;
+      if (visitedEntries > limits.maxVisitedEntries) {
+        throw new WorkspaceEnumerationLimitError("entries", limits.maxVisitedEntries);
+      }
+      const depth = frame.depth + 1;
+      if (depth > limits.maxDepth) {
+        throw new WorkspaceEnumerationLimitError("depth", limits.maxDepth);
+      }
+      const relPath = frame.prefix.length > 0 ? `${frame.prefix}/${entry.name}` : entry.name;
+      pathBytes += Buffer.byteLength(relPath, "utf8");
+      if (pathBytes > limits.maxPathBytes) {
+        throw new WorkspaceEnumerationLimitError("path-bytes", limits.maxPathBytes);
+      }
+      const absPath = join(frame.absPath, entry.name);
+      const kind = fallbackEntryKind(absPath, relPath, entry);
+      if (kind === "disappeared" || kind === "other") continue;
+      if (kind === "directory") {
+        if (excludedDirs.has(entry.name)) continue;
+        let child;
+        try {
+          child = fs.opendirSync(absPath);
+        } catch (cause) {
+          if (isDisappearedWorkspaceEntry(cause)) continue;
+          throw new WorkspaceEnumerationIncompleteError("open-directory", relPath, cause);
+        }
+        stack.push({ dir: child, absPath, prefix: relPath, depth });
+        continue;
+      }
+      files.push(relPath);
+    }
+    return files;
+  } finally {
+    for (const frame of stack) closeFrame(frame);
+  }
+}
+function fallbackFiles(cwd, excludedDirs, overrides) {
+  const limits = resolveFallbackLimits(overrides);
+  const startedAt = performance2.now();
+  const walk = fallbackFilesWalk(cwd, excludedDirs, limits, () => performance2.now() - startedAt);
+  let step = walk.next();
+  while (!step.done) step = walk.next();
+  return step.value;
+}
+async function fallbackFilesAsync(cwd, excludedDirs, overrides, cooperate) {
+  const limits = resolveFallbackLimits(overrides);
+  let activeMs = 0;
+  let resumedAt = performance2.now();
+  const walk = fallbackFilesWalk(cwd, excludedDirs, limits, () => activeMs + (performance2.now() - resumedAt));
+  let step = walk.next();
+  while (!step.done) {
+    activeMs += performance2.now() - resumedAt;
+    await cooperate.tick();
+    resumedAt = performance2.now();
+    step = walk.next();
+  }
+  return step.value;
+}
+function* normalizeVisibleFilesSteps(cwd, paths, excludedDirs, requireCompleteSnapshot) {
+  const visible = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    yield;
+    const normalized = normalizeRelativePath(path);
+    if (!normalized) {
+      if (requireCompleteSnapshot) {
+        throw new WorkspaceEnumerationIncompleteError("inspect-entry", path, { code: "INVALID_RELATIVE_PATH" });
+      }
+      continue;
+    }
+    if (isWorkspacePathExcluded(normalized, excludedDirs)) continue;
+    if (isRegularWorkspaceFile(cwd, normalized, requireCompleteSnapshot)) visible.add(normalized);
+  }
+  return [...visible].sort(comparePaths);
+}
+function normalizeVisibleFiles(cwd, paths, excludedDirs, requireCompleteSnapshot = false) {
+  const steps = normalizeVisibleFilesSteps(cwd, paths, excludedDirs, requireCompleteSnapshot);
+  let step = steps.next();
+  while (!step.done) step = steps.next();
+  return step.value;
+}
+async function normalizeVisibleFilesAsync(cwd, paths, excludedDirs, requireCompleteSnapshot, cooperate) {
+  const steps = normalizeVisibleFilesSteps(cwd, paths, excludedDirs, requireCompleteSnapshot);
+  let step = steps.next();
+  while (!step.done) {
+    await cooperate.tick();
+    step = steps.next();
+  }
+  return step.value;
+}
+function enumerateWorkspaceFiles(cwd, excludedDirs = WORKSPACE_EXCLUDED_DIRS, fallbackLimits) {
+  const gitFiles = gitVisibleFiles(cwd);
+  if (gitFiles) return normalizeVisibleFiles(cwd, gitFiles, excludedDirs);
+  return normalizeVisibleFiles(cwd, fallbackFiles(cwd, excludedDirs, fallbackLimits), excludedDirs, true);
+}
+async function enumerateWorkspaceFilesAsync(cwd, excludedDirs = WORKSPACE_EXCLUDED_DIRS, fallbackLimits, cooperate = createDefaultTick()) {
+  const gitFiles = await gitVisibleFilesAsync(cwd);
+  if (gitFiles) return normalizeVisibleFilesAsync(cwd, gitFiles, excludedDirs, false, cooperate);
+  const walked = await fallbackFilesAsync(cwd, excludedDirs, fallbackLimits, cooperate);
+  return normalizeVisibleFilesAsync(cwd, walked, excludedDirs, true, cooperate);
+}
+function filterWorkspaceFileCandidates(cwd, paths, excludedDirs = WORKSPACE_EXCLUDED_DIRS, fallbackLimits) {
+  const candidates = paths.map(normalizeRelativePath).filter((path) => path !== null && !isWorkspacePathExcluded(path, excludedDirs));
+  if (candidates.length === 0) return [];
+  const gitFiles = gitVisibleFiles(cwd, candidates);
+  if (gitFiles) return normalizeVisibleFiles(cwd, gitFiles, excludedDirs);
+  const fallbackVisible = new Set(
+    normalizeVisibleFiles(cwd, fallbackFiles(cwd, excludedDirs, fallbackLimits), excludedDirs, true)
+  );
+  return candidates.filter((path) => fallbackVisible.has(path)).sort(comparePaths);
+}
+
+// src/domains/session/workspace/project-type.ts
+var SOURCE_LANGUAGES = [
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "c",
+  "c++",
+  "java",
+  "ruby",
+  "c#"
+];
+var EXTENSION_LANGUAGES = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".py", "python"],
+  [".pyw", "python"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cc", "c++"],
+  [".cpp", "c++"],
+  [".cxx", "c++"],
+  [".hpp", "c++"],
+  [".hh", "c++"],
+  [".hxx", "c++"],
+  [".cu", "c++"],
+  [".cuh", "c++"],
+  [".java", "java"],
+  [".rb", "ruby"],
+  [".cs", "c#"]
+]);
+var MANIFEST_LANGUAGES = [
+  { name: "package.json", type: "typescript" },
+  { name: "pyproject.toml", type: "python" },
+  { name: "setup.py", type: "python" },
+  { name: "Cargo.toml", type: "rust" },
+  { name: "go.mod", type: "go" },
+  { name: "pom.xml", type: "java" },
+  { name: "CMakeLists.txt", type: "c++" },
+  { name: "compile_commands.json", type: "c++" },
+  { name: "Gemfile", type: "ruby" },
+  { name: "*.csproj", type: "c#" }
+];
+function emptyLanguageCounts() {
+  return {
+    typescript: 0,
+    javascript: 0,
+    python: 0,
+    rust: 0,
+    go: 0,
+    c: 0,
+    "c++": 0,
+    java: 0,
+    ruby: 0,
+    "c#": 0
+  };
+}
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function countManifest(name, manifestCounts) {
+  for (const marker of MANIFEST_LANGUAGES) {
+    if (marker.name.startsWith("*.")) {
+      const ext = marker.name.slice(1);
+      if (name.endsWith(ext)) {
+        manifestCounts[marker.type] = (manifestCounts[marker.type] ?? 0) + 1;
+      }
+    } else {
+      if (name !== marker.name) continue;
+      manifestCounts[marker.type] = (manifestCounts[marker.type] ?? 0) + 1;
+    }
+  }
+}
+function scanFiles(cwd, files, languageCounts, manifestCounts) {
+  for (const path of files) {
+    const name = path.split("/").pop() ?? path;
+    countManifest(name, manifestCounts);
+    if (name.endsWith(".d.ts")) continue;
+    const extension = extensionOf(name);
+    let language = EXTENSION_LANGUAGES.get(extension);
+    if (extension === ".h") {
+      try {
+        language = classifyCHeaderLanguage(readFileSync(join2(cwd, path), "utf8"));
+      } catch {
+        language = "c";
+      }
+    }
+    if (language) languageCounts[language] += 1;
+  }
+}
+function looksLikeDotfiles(files) {
+  const dotDirs = /* @__PURE__ */ new Set();
+  for (const path of files) {
+    const [root, child] = path.split("/", 2);
+    if (child && root?.startsWith("dot-")) dotDirs.add(root);
+  }
+  return dotDirs.size >= 2;
+}
+function dominantFromCounts(counts) {
+  let best;
+  let bestCount = 0;
+  for (const language of SOURCE_LANGUAGES) {
+    const count = counts[language] ?? 0;
+    if (count > bestCount) {
+      best = language;
+      bestCount = count;
+    } else if (count === bestCount && count > 0) {
+      best = void 0;
+    }
+  }
+  return best;
+}
+function detectProjectProfile(cwd) {
+  const languageCounts = emptyLanguageCounts();
+  const manifestCounts = {};
+  const files = enumerateWorkspaceFiles(cwd);
+  scanFiles(cwd, files, languageCounts, manifestCounts);
+  const sourceFiles = SOURCE_LANGUAGES.reduce((sum, language) => sum + languageCounts[language], 0);
+  const dominantSource = dominantFromCounts(languageCounts);
+  const dominantCount = dominantSource ? languageCounts[dominantSource] : 0;
+  const polyglot = sourceFiles > 0 && dominantCount / sourceFiles <= 0.7;
+  if (sourceFiles > 0) {
+    return {
+      projectType: polyglot ? "polyglot" : dominantSource ?? "polyglot",
+      sourceFiles,
+      languageCounts,
+      manifestCounts,
+      ...dominantSource ? { dominantLanguage: dominantSource } : {},
+      polyglot
+    };
+  }
+  const manifestDominant = dominantFromCounts(manifestCounts);
+  if (manifestDominant) {
+    return {
+      projectType: manifestDominant,
+      sourceFiles,
+      languageCounts,
+      manifestCounts,
+      dominantLanguage: manifestDominant,
+      polyglot: false
+    };
+  }
+  const manifestTotal = SOURCE_LANGUAGES.reduce((sum, language) => sum + (manifestCounts[language] ?? 0), 0);
+  if (manifestTotal > 0) {
+    return {
+      projectType: "polyglot",
+      sourceFiles,
+      languageCounts,
+      manifestCounts,
+      polyglot: true
+    };
+  }
+  return {
+    projectType: looksLikeDotfiles(files) ? "dotfiles" : "unknown",
+    sourceFiles,
+    languageCounts,
+    manifestCounts,
+    polyglot: false
+  };
+}
+function detectProjectType(cwd) {
+  return detectProjectProfile(cwd).projectType;
+}
+
+// src/domains/context/codewiki/cooperative.ts
+import { setImmediate as yieldToEventLoop } from "node:timers/promises";
+var INDEX_SLICE_MS = 8;
+var settled = Promise.resolve();
+function createSlicer(sliceMs = INDEX_SLICE_MS) {
+  let deadline = performance.now() + sliceMs;
+  let yields = 0;
+  return {
+    tick() {
+      if (performance.now() < deadline) return settled;
+      yields += 1;
+      return yieldToEventLoop().then(() => {
+        deadline = performance.now() + sliceMs;
+      });
+    },
+    get yields() {
+      return yields;
+    }
+  };
+}
+
+// src/domains/context/codewiki/indexer.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { readFile as readFileAsync } from "node:fs/promises";
+import { dirname as dirname2, join as join4, relative, resolve } from "node:path";
+
+// src/domains/context/codewiki/cmake.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".c",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".cu",
+  ".cuh",
+  ".h",
+  ".hh",
+  ".hpp",
+  ".hxx",
+  ".java",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".pyw",
+  ".rb",
+  ".rs",
+  ".cs",
+  ".ts",
+  ".tsx"
+]);
+var TARGET_SOURCE_KEYWORDS = /* @__PURE__ */ new Set([
+  "PUBLIC",
+  "PRIVATE",
+  "INTERFACE",
+  "BEFORE",
+  "FILE_SET",
+  "TYPE",
+  "BASE_DIRS",
+  "FILES"
+]);
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort(compareStrings);
+}
+function lineStarts(text) {
+  const starts = [0];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") starts.push(index + 1);
+  }
+  return starts;
+}
+function lineAt(starts, offset) {
+  let low = 0;
+  let high = starts.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if ((starts[middle] ?? 0) <= offset) low = middle + 1;
+    else high = middle;
+  }
+  return Math.max(1, low);
+}
+function readBracketBlock(text, index) {
+  if (text[index] !== "[") return null;
+  let delimiterEnd = index + 1;
+  while (text[delimiterEnd] === "=") delimiterEnd += 1;
+  if (text[delimiterEnd] !== "[") return null;
+  const equals = text.slice(index + 1, delimiterEnd);
+  const close = `]${equals}]`;
+  const contentStart = delimiterEnd + 1;
+  const closeStart = text.indexOf(close, contentStart);
+  if (closeStart === -1) return null;
+  return {
+    content: text.slice(contentStart, closeStart),
+    end: closeStart + close.length
+  };
+}
+function skipComment(text, index) {
+  const bracket = readBracketBlock(text, index + 1);
+  if (bracket) return bracket.end;
+  const newline = text.indexOf("\n", index + 1);
+  return newline === -1 ? text.length : newline + 1;
+}
+function skipTrivia(text, start) {
+  let index = start;
+  while (index < text.length) {
+    if (/\s/.test(text[index] ?? "")) {
+      index += 1;
+      continue;
+    }
+    if (text[index] === "#") {
+      index = skipComment(text, index);
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+function readQuotedArgument(text, start) {
+  let content = "";
+  for (let index = start + 1; index < text.length; index += 1) {
+    const current = text[index] ?? "";
+    if (current === '"') return { content, end: index + 1 };
+    if (current === "\\") {
+      const next = text[index + 1];
+      if (next === void 0) return null;
+      if (next === "\n") {
+        index += 1;
+        continue;
+      }
+      content += next;
+      index += 1;
+      continue;
+    }
+    content += current;
+  }
+  return null;
+}
+function parseInvocation(text, name, line2, openParen) {
+  const args = [];
+  let current = "";
+  let depth = 1;
+  let index = openParen + 1;
+  const flush = () => {
+    if (current.length > 0) args.push(current);
+    current = "";
+  };
+  while (index < text.length) {
+    const char = text[index] ?? "";
+    if (/\s/.test(char)) {
+      flush();
+      index += 1;
+      continue;
+    }
+    if (char === "#") {
+      flush();
+      index = skipComment(text, index);
+      continue;
+    }
+    if (char === '"') {
+      const quoted = readQuotedArgument(text, index);
+      if (!quoted) return null;
+      current += quoted.content;
+      index = quoted.end;
+      continue;
+    }
+    if (char === "[") {
+      const bracket = readBracketBlock(text, index);
+      if (bracket) {
+        current += bracket.content;
+        index = bracket.end;
+        continue;
+      }
+    }
+    if (char === "\\") {
+      const next = text[index + 1];
+      if (next === void 0) return null;
+      if (next === "\n") {
+        index += 2;
+        continue;
+      }
+      current += next;
+      index += 2;
+      continue;
+    }
+    if (char === ";" && depth === 1) {
+      flush();
+      index += 1;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      current += char;
+      index += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        flush();
+        return {
+          invocation: { name, line: line2, args },
+          end: index + 1
+        };
+      }
+      current += char;
+      index += 1;
+      continue;
+    }
+    current += char;
+    index += 1;
+  }
+  return null;
+}
+function scanInvocations(text) {
+  const invocations = [];
+  const starts = lineStarts(text);
+  let index = 0;
+  while (index < text.length) {
+    index = skipTrivia(text, index);
+    if (index >= text.length) break;
+    if (text[index] === '"') {
+      const quoted = readQuotedArgument(text, index);
+      index = quoted?.end ?? text.length;
+      continue;
+    }
+    if (text[index] === "[") {
+      const bracket = readBracketBlock(text, index);
+      if (bracket) {
+        index = bracket.end;
+        continue;
+      }
+    }
+    const name = /^[A-Za-z_][A-Za-z_0-9]*/.exec(text.slice(index))?.[0];
+    if (!name) {
+      index += 1;
+      continue;
+    }
+    const nameStart = index;
+    const openParen = skipTrivia(text, index + name.length);
+    if (text[openParen] !== "(") {
+      index += name.length;
+      continue;
+    }
+    const parsed = parseInvocation(text, name.toLowerCase(), lineAt(starts, nameStart), openParen);
+    if (!parsed) {
+      index = openParen + 1;
+      continue;
+    }
+    invocations.push(parsed.invocation);
+    index = parsed.end;
+  }
+  return invocations;
+}
+function literal(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.includes("$")) return null;
+  return trimmed.replace(/\\/g, "/");
+}
+function literalTarget(value) {
+  const target = literal(value);
+  return target && /^[A-Za-z0-9_.:+-]+$/.test(target) ? target : null;
+}
+function relativeSpecifier(value) {
+  if (value.startsWith("/") || /^[A-Za-z]:\//.test(value)) return null;
+  const normalized = value.replace(/^\.\//, "").replace(/\/+$/g, "");
+  if (normalized.length === 0) return null;
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+function sourceSpecifier(value) {
+  const path = literal(value);
+  if (!path || path.includes(";") || path.startsWith("-") || TARGET_SOURCE_KEYWORDS.has(path.toUpperCase())) return null;
+  const withoutQuery = path.split(/[?#]/, 1)[0] ?? path;
+  const dot = withoutQuery.lastIndexOf(".");
+  if (dot === -1 || !SOURCE_EXTENSIONS.has(withoutQuery.slice(dot).toLowerCase())) return null;
+  return relativeSpecifier(path);
+}
+function childCMakeSpecifier(value) {
+  const directory = literal(value);
+  if (!directory) return null;
+  const relative2 = relativeSpecifier(directory);
+  if (!relative2) return null;
+  return `${relative2}/CMakeLists.txt`.replace(/\/\//g, "/");
+}
+function isCMakePath(path) {
+  const name = path.split("/").at(-1) ?? path;
+  return name === "CMakeLists.txt" || name.toLowerCase().endsWith(".cmake");
+}
+function extractCMake(text) {
+  const symbols = [];
+  const imports = [];
+  for (const invocation of scanInvocations(text)) {
+    if (invocation.name === "add_subdirectory") {
+      const child = childCMakeSpecifier(invocation.args[0]);
+      if (child) imports.push(child);
+      continue;
+    }
+    if (invocation.name === "add_library" || invocation.name === "add_executable") {
+      const target = literalTarget(invocation.args[0]);
+      if (!target) continue;
+      symbols.push({ name: target, kind: "const", line: invocation.line });
+      if (invocation.args[1]?.toUpperCase() === "ALIAS") continue;
+      for (const arg of invocation.args.slice(1)) {
+        const source = sourceSpecifier(arg);
+        if (source) imports.push(source);
+      }
+      continue;
+    }
+    if (invocation.name === "target_sources") {
+      if (!literalTarget(invocation.args[0])) continue;
+      for (const arg of invocation.args.slice(1)) {
+        const source = sourceSpecifier(arg);
+        if (source) imports.push(source);
+      }
+    }
+  }
+  return {
+    symbols: symbols.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name)),
+    imports: uniqueSorted(imports)
+  };
+}
+
+// src/domains/context/codewiki/tree-sitter.ts
+import { createRequire } from "node:module";
+import { dirname, join as join3 } from "node:path";
+import TreeSitter from "@vscode/tree-sitter-wasm";
+var require2 = createRequire(import.meta.url);
+var { Language, Parser } = TreeSitter;
+var VSCODE_WASM_DIR = dirname(require2.resolve("@vscode/tree-sitter-wasm"));
+var WASM_BY_GRAMMAR = {
+  typescript: join3(VSCODE_WASM_DIR, "tree-sitter-typescript.wasm"),
+  tsx: join3(VSCODE_WASM_DIR, "tree-sitter-tsx.wasm"),
+  javascript: join3(VSCODE_WASM_DIR, "tree-sitter-javascript.wasm"),
+  python: join3(VSCODE_WASM_DIR, "tree-sitter-python.wasm"),
+  go: join3(VSCODE_WASM_DIR, "tree-sitter-go.wasm"),
+  rust: join3(VSCODE_WASM_DIR, "tree-sitter-rust.wasm"),
+  // VS Code does not currently ship a C grammar; its runtime accepts this
+  // ABI-compatible compact C side module from tree-sitter-wasms.
+  c: require2.resolve("tree-sitter-wasms/out/tree-sitter-c.wasm"),
+  cpp: join3(VSCODE_WASM_DIR, "tree-sitter-cpp.wasm"),
+  java: join3(VSCODE_WASM_DIR, "tree-sitter-java.wasm"),
+  ruby: join3(VSCODE_WASM_DIR, "tree-sitter-ruby.wasm"),
+  c_sharp: join3(VSCODE_WASM_DIR, "tree-sitter-c-sharp.wasm")
+};
+var NAME_NODE_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "type_identifier",
+  "property_identifier",
+  "field_identifier",
+  "constant",
+  "constant_identifier"
+]);
+var FUNCTION_LIKE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function_expression",
+  "generator_function",
+  "generator_function_declaration",
+  "generator_function_expression",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+  "function_item",
+  "lambda",
+  "lambda_expression",
+  "func_literal",
+  "method",
+  "singleton_method",
+  "do_block",
+  "method_declaration",
+  "constructor_declaration",
+  "local_function_statement"
+]);
+var PY_SCOPE_NODE_TYPES = /* @__PURE__ */ new Set(["function_definition", "class_definition"]);
+var parserInit = null;
+function ensureParserInit() {
+  parserInit ??= Parser.init({
+    locateFile() {
+      return join3(VSCODE_WASM_DIR, "tree-sitter.wasm");
+    }
+  });
+  return parserInit;
+}
+function grammarForPath(path, lang) {
+  if (lang === "typescript") return path.endsWith(".tsx") ? "tsx" : "typescript";
+  if (lang === "javascript") return "javascript";
+  if (lang === "python") return "python";
+  if (lang === "go") return "go";
+  if (lang === "rust") return "rust";
+  if (lang === "c") return "c";
+  if (lang === "c++") return "cpp";
+  if (lang === "java") return "java";
+  if (lang === "ruby") return "ruby";
+  if (lang === "c#") return "c_sharp";
+  return null;
+}
+function line(node) {
+  return node.startPosition.row + 1;
+}
+function sig(node) {
+  return node.text.split(/\r?\n/, 1)[0]?.trim().slice(0, 240) ?? "";
+}
+function namedChildren(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function firstNamedDescendant(node, types = NAME_NODE_TYPES) {
+  if (types.has(node.type)) return node;
+  for (const child of namedChildren(node)) {
+    const found = firstNamedDescendant(child, types);
+    if (found) return found;
+  }
+  return null;
+}
+function nameFromNode(node) {
+  const direct = node.childForFieldName("name");
+  if (direct) return firstNamedDescendant(direct)?.text ?? direct.text;
+  for (const child of namedChildren(node)) {
+    if (NAME_NODE_TYPES.has(child.type)) return child.text;
+  }
+  return firstNamedDescendant(node)?.text ?? null;
+}
+function hasAncestor(node, type) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === type) return true;
+    current = current.parent;
+  }
+  return false;
+}
+function hasFunctionLikeAncestor(node) {
+  let current = node.parent;
+  while (current) {
+    if (FUNCTION_LIKE_NODE_TYPES.has(current.type)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+function nearestAncestorType(node, types) {
+  let current = node.parent;
+  while (current) {
+    if (types.has(current.type)) return current.type;
+    current = current.parent;
+  }
+  return null;
+}
+function addSymbol(target, node, kind, name = nameFromNode(node)) {
+  if (!name) return;
+  const clean = name.trim();
+  if (clean.length === 0) return;
+  target.push({ name: clean, kind, line: line(node), sig: sig(node) });
+}
+function descendants(root, types) {
+  return root.descendantsOfType(types).filter((node) => node !== null);
+}
+function compareStrings2(a, b) {
+  return a.localeCompare(b);
+}
+function uniqueSorted2(values) {
+  return [...new Set([...values].filter((value) => value.trim().length > 0))].sort(compareStrings2);
+}
+function cleanStringLiteral(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("`") && trimmed.endsWith("`") || trimmed.startsWith("<") && trimmed.endsWith(">")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function stringValue(node) {
+  if (!node) return null;
+  const value = cleanStringLiteral(node.text);
+  return value.length > 0 ? value : null;
+}
+function firstStringDescendant(node) {
+  if (!node) return null;
+  if (node.type === "string" || node.type === "string_literal" || node.type === "interpreted_string_literal" || node.type === "raw_string_literal" || node.type === "system_lib_string") {
+    return node;
+  }
+  for (const child of namedChildren(node)) {
+    const found = firstStringDescendant(child);
+    if (found) return found;
+  }
+  return null;
+}
+function firstStringValue(node) {
+  return stringValue(firstStringDescendant(node));
+}
+function extractTsJs(root) {
+  const symbols = [];
+  for (const node of descendants(root, ["function_declaration", "generator_function_declaration"])) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "func");
+  }
+  for (const node of descendants(root, "class_declaration")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "class");
+  }
+  for (const node of descendants(root, "interface_declaration")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "iface");
+  }
+  for (const node of descendants(root, ["type_alias_declaration", "enum_declaration"])) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "type");
+  }
+  for (const node of descendants(root, "method_definition")) {
+    if (node.parent?.type !== "class_body") continue;
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "method");
+  }
+  for (const node of descendants(root, "variable_declarator")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const parentText = node.parent?.text ?? "";
+    addSymbol(symbols, node, parentText.trimStart().startsWith("const") ? "const" : "var");
+  }
+  return symbols;
+}
+function extractPython(root) {
+  const symbols = [];
+  for (const node of descendants(root, "function_definition")) {
+    const scope = nearestAncestorType(node, PY_SCOPE_NODE_TYPES);
+    if (scope === "function_definition") continue;
+    addSymbol(symbols, node, scope === "class_definition" ? "method" : "func");
+  }
+  for (const node of descendants(root, "class_definition")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "class");
+  }
+  for (const node of descendants(root, "assignment")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const left = node.childForFieldName("left") ?? node.namedChild(0);
+    if (!left) continue;
+    const name = firstNamedDescendant(left)?.text;
+    if (name) addSymbol(symbols, node, /^[A-Z][A-Z0-9_]*$/.test(name) ? "const" : "var", name);
+  }
+  return symbols;
+}
+function extractGo(root) {
+  const symbols = [];
+  for (const node of descendants(root, "function_declaration")) addSymbol(symbols, node, "func");
+  for (const node of descendants(root, "method_declaration")) addSymbol(symbols, node, "method");
+  for (const node of descendants(root, "type_spec")) {
+    addSymbol(symbols, node, node.text.includes("interface") ? "iface" : "type");
+  }
+  for (const node of descendants(root, "const_spec")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "const");
+  }
+  for (const node of descendants(root, "var_spec")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "var");
+  }
+  return symbols;
+}
+function extractRust(root) {
+  const symbols = [];
+  for (const node of descendants(root, "function_item")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const isMethod = hasAncestor(node, "impl_item") || hasAncestor(node, "trait_item");
+    addSymbol(symbols, node, isMethod ? "method" : "func");
+  }
+  for (const node of descendants(root, ["struct_item", "enum_item", "type_item"])) addSymbol(symbols, node, "type");
+  for (const node of descendants(root, "trait_item")) addSymbol(symbols, node, "trait");
+  for (const node of descendants(root, "const_item")) addSymbol(symbols, node, "const");
+  for (const node of descendants(root, "static_item")) addSymbol(symbols, node, "var");
+  return symbols;
+}
+var C_FAMILY_CLASS_SCOPES = /* @__PURE__ */ new Set(["class_specifier", "struct_specifier", "union_specifier"]);
+function cFamilyDeclaredTypeName(node) {
+  const name = node.childForFieldName("name");
+  return name ? name.text.trim() || null : null;
+}
+function cFamilyDeclaratorName(node) {
+  if (NAME_NODE_TYPES.has(node.type)) return node.text.trim() || null;
+  const declarator = node.childForFieldName("declarator") ?? node.childForFieldName("name");
+  if (declarator) return cFamilyDeclaratorName(declarator);
+  if (node.type === "parenthesized_declarator" || node.type === "abstract_parenthesized_declarator" || node.type === "attributed_declarator") {
+    for (const child of namedChildren(node)) {
+      const name = cFamilyDeclaratorName(child);
+      if (name) return name;
+    }
+  }
+  return null;
+}
+function cFamilyDeclarators(node) {
+  return node.childrenForFieldName("declarator").filter((child) => child !== null);
+}
+function uniqueCFamilySymbols(symbols) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    const key = `${symbol.name}\0${symbol.kind}\0${symbol.line}`;
+    if (!unique.has(key)) unique.set(key, symbol);
+  }
+  return [...unique.values()];
+}
+function cFamilyFunctionDeclarator(node) {
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return null;
+  const candidates = [
+    ...declarator.type === "function_declarator" ? [declarator] : [],
+    ...declarator.descendantsOfType("function_declarator")
+  ];
+  for (let index = candidates.length - 1; index >= 0; index -= 1) {
+    const candidate = candidates[index];
+    const inner = candidate?.childForFieldName("declarator");
+    if (inner && inner.type !== "parenthesized_declarator") return candidate ?? null;
+  }
+  return null;
+}
+function cFamilyFunctionName(node) {
+  const fnDeclarator = cFamilyFunctionDeclarator(node);
+  const inner = fnDeclarator?.childForFieldName("declarator");
+  if (!inner) return null;
+  let name = inner;
+  while (name.type === "qualified_identifier") {
+    const unqualified = name.childForFieldName("name");
+    if (!unqualified) break;
+    name = unqualified;
+  }
+  if (name.type === "template_function") name = name.childForFieldName("name") ?? name;
+  return name.text;
+}
+function cFamilyFunctionQualifier(node) {
+  const inner = cFamilyFunctionDeclarator(node)?.childForFieldName("declarator");
+  if (inner?.type !== "qualified_identifier") return null;
+  const parts = inner.text.split("::");
+  parts.pop();
+  return parts.join("::") || null;
+}
+function cFamilyQualifiedMethod(node, classNames, namespaceNames) {
+  const qualifier = cFamilyFunctionQualifier(node);
+  if (!qualifier) return false;
+  const last = qualifier.split("::").at(-1) ?? qualifier;
+  if (classNames.has(last)) return true;
+  if (namespaceNames.has(last) || namespaceNames.has(qualifier)) return false;
+  return /^[A-Z_]/.test(last);
+}
+function extractCFamily(root) {
+  const symbols = [];
+  const classNames = new Set(
+    descendants(root, ["class_specifier", "struct_specifier", "union_specifier"]).map((node) => cFamilyDeclaredTypeName(node)).filter((name) => name !== null)
+  );
+  const namespaceNames = new Set(
+    descendants(root, "namespace_definition").map((node) => nameFromNode(node)).filter((name) => name !== null)
+  );
+  for (const node of descendants(root, "function_definition")) {
+    const kind = nearestAncestorType(node, C_FAMILY_CLASS_SCOPES) || cFamilyQualifiedMethod(node, classNames, namespaceNames) ? "method" : "func";
+    addSymbol(symbols, node, kind, cFamilyFunctionName(node) ?? nameFromNode(node));
+  }
+  for (const node of descendants(root, ["declaration", "field_declaration"])) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const name = cFamilyFunctionName(node);
+    if (!name) continue;
+    const isTypedef = namedChildren(node).some(
+      (child) => child.type === "storage_class_specifier" && child.text === "typedef"
+    );
+    const kind = isTypedef ? "type" : nearestAncestorType(node, C_FAMILY_CLASS_SCOPES) || cFamilyQualifiedMethod(node, classNames, namespaceNames) ? "method" : "func";
+    addSymbol(symbols, node, kind, name);
+  }
+  for (const node of descendants(root, ["class_specifier", "struct_specifier", "union_specifier", "enum_specifier"])) {
+    const name = cFamilyDeclaredTypeName(node);
+    if (name) addSymbol(symbols, node, node.type === "class_specifier" ? "class" : "type", name);
+  }
+  for (const node of descendants(root, "type_definition")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    for (const declarator of cFamilyDeclarators(node)) {
+      const name = cFamilyDeclaratorName(declarator);
+      if (name) addSymbol(symbols, node, "type", name);
+    }
+  }
+  for (const node of descendants(root, "alias_declaration")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const name = node.childForFieldName("name")?.text.trim();
+    if (name) addSymbol(symbols, node, "type", name);
+  }
+  return uniqueCFamilySymbols(symbols);
+}
+function extractJava(root) {
+  const symbols = [];
+  for (const node of descendants(root, "class_declaration")) addSymbol(symbols, node, "class");
+  for (const node of descendants(root, "interface_declaration")) addSymbol(symbols, node, "iface");
+  for (const node of descendants(root, "enum_declaration")) addSymbol(symbols, node, "type");
+  for (const node of descendants(root, "method_declaration")) addSymbol(symbols, node, "method");
+  for (const node of descendants(root, "field_declaration")) {
+    const modifiers = namedChildren(node).find((child) => child.type === "modifiers")?.text ?? "";
+    const staticFinal = /\bstatic\b/.test(modifiers) && /\bfinal\b/.test(modifiers);
+    for (const declarator of namedChildren(node)) {
+      if (declarator.type !== "variable_declarator") continue;
+      const name = declarator.childForFieldName("name")?.text ?? namedChildren(declarator).find((child) => child.type === "identifier")?.text;
+      if (!name) continue;
+      const isConst = staticFinal || /^[A-Z][A-Z0-9_]*$/.test(name);
+      addSymbol(symbols, declarator, isConst ? "const" : "var", name);
+    }
+  }
+  return symbols;
+}
+function extractRuby(root) {
+  const symbols = [];
+  for (const node of descendants(root, ["method", "singleton_method"])) addSymbol(symbols, node, "func");
+  for (const node of descendants(root, "class")) addSymbol(symbols, node, "class");
+  for (const node of descendants(root, "module")) addSymbol(symbols, node, "type");
+  for (const node of descendants(root, "assignment")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const name = nameFromNode(node);
+    if (name) addSymbol(symbols, node, /^[A-Z]/.test(name) ? "const" : "var", name);
+  }
+  return symbols;
+}
+function extractCSharp(root) {
+  const symbols = [];
+  for (const node of descendants(root, "class_declaration")) {
+    if (!hasFunctionLikeAncestor(node)) addSymbol(symbols, node, "class");
+  }
+  for (const node of descendants(root, "interface_declaration")) {
+    if (!hasFunctionLikeAncestor(node)) addSymbol(symbols, node, "iface");
+  }
+  for (const node of descendants(root, ["enum_declaration", "struct_declaration", "record_declaration"])) {
+    if (!hasFunctionLikeAncestor(node)) addSymbol(symbols, node, "type");
+  }
+  for (const node of descendants(root, ["method_declaration", "constructor_declaration"]))
+    addSymbol(symbols, node, "method");
+  for (const node of descendants(root, "property_declaration")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    addSymbol(symbols, node, "var");
+  }
+  for (const node of descendants(root, "field_declaration")) {
+    if (hasFunctionLikeAncestor(node)) continue;
+    const text = node.text;
+    const isConst = /\bconst\b/.test(text) || /\bstatic\b/.test(text) && /\breadonly\b/.test(text);
+    addSymbol(symbols, node, isConst ? "const" : "var");
+  }
+  return symbols;
+}
+function extractSymbolsByGrammar(grammar, root) {
+  if (grammar === "typescript" || grammar === "tsx" || grammar === "javascript") return extractTsJs(root);
+  if (grammar === "python") return extractPython(root);
+  if (grammar === "go") return extractGo(root);
+  if (grammar === "rust") return extractRust(root);
+  if (grammar === "c" || grammar === "cpp") return extractCFamily(root);
+  if (grammar === "java") return extractJava(root);
+  if (grammar === "ruby") return extractRuby(root);
+  if (grammar === "c_sharp") return extractCSharp(root);
+  return [];
+}
+function extractTsJsImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "import_statement")) {
+    const source = stringValue(node.childForFieldName("source")) ?? firstStringValue(node);
+    if (source) imports.push(source);
+  }
+  for (const node of descendants(root, "export_statement")) {
+    const source = stringValue(node.childForFieldName("source"));
+    if (source) imports.push(source);
+  }
+  for (const node of descendants(root, "call_expression")) {
+    const callee = node.childForFieldName("function");
+    if (!callee || callee.text !== "require" && callee.text !== "import" && callee.type !== "import") continue;
+    const source = firstStringValue(node.childForFieldName("arguments"));
+    if (source) imports.push(source);
+  }
+  return uniqueSorted2(imports);
+}
+function extractPythonImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "import_statement")) {
+    for (const child of namedChildren(node)) {
+      if (child.type === "dotted_name") imports.push(child.text);
+      if (child.type === "aliased_import") {
+        const name = child.childForFieldName("name") ?? child.namedChild(0);
+        if (name) imports.push(name.text);
+      }
+    }
+  }
+  for (const node of descendants(root, "import_from_statement")) {
+    const moduleName = node.childForFieldName("module_name") ?? namedChildren(node).find((child) => child.type === "relative_import" || child.type === "dotted_name");
+    if (moduleName) imports.push(moduleName.text);
+  }
+  return uniqueSorted2(imports);
+}
+function extractGoImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "import_spec")) {
+    const source = stringValue(node.childForFieldName("path"));
+    if (source) imports.push(source);
+  }
+  return uniqueSorted2(imports);
+}
+function extractRustImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "use_declaration")) {
+    const argument = node.childForFieldName("argument") ?? node.namedChild(0);
+    if (argument) imports.push(argument.text.trim());
+  }
+  for (const node of descendants(root, "extern_crate_declaration")) {
+    const name = node.childForFieldName("name") ?? namedChildren(node).find((child) => child.type === "identifier");
+    if (name) imports.push(name.text.trim());
+  }
+  return uniqueSorted2(imports);
+}
+function extractCFamilyImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "preproc_include")) {
+    const sourceNode = node.childForFieldName("path") ?? firstStringDescendant(node);
+    const source = stringValue(sourceNode);
+    if (!source) continue;
+    const quoted = sourceNode?.text.trim().startsWith('"') === true;
+    imports.push(quoted && !source.startsWith(".") && !source.startsWith("/") ? `./${source}` : source);
+  }
+  return uniqueSorted2(imports);
+}
+function extractJavaImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "import_declaration")) {
+    const source = node.text.replace(/^import\s+/, "").replace(/^static\s+/, "").replace(/;$/, "").trim();
+    if (source) imports.push(source);
+  }
+  return uniqueSorted2(imports);
+}
+function extractRubyImports(root) {
+  return uniqueSorted2([
+    ...Array.from(root.text.matchAll(/^\s*require\s+["']([^"']+)["']/gm), (match) => match[1] ?? ""),
+    ...Array.from(root.text.matchAll(/^\s*require_relative\s+["']([^"']+)["']/gm), (match) => `./${match[1] ?? ""}`)
+  ]);
+}
+function extractCSharpImports(root) {
+  const imports = [];
+  for (const node of descendants(root, "using_directive")) {
+    let source = node.text.replace(/^using\s+/, "").replace(/;$/, "").trim();
+    if (source.startsWith("static ")) source = source.slice("static ".length).trim();
+    const aliasIndex = source.indexOf("=");
+    if (aliasIndex !== -1) source = source.slice(aliasIndex + 1).trim();
+    if (source) imports.push(source);
+  }
+  return uniqueSorted2(imports);
+}
+function extractImportsByGrammar(grammar, root) {
+  if (grammar === "typescript" || grammar === "tsx" || grammar === "javascript") return extractTsJsImports(root);
+  if (grammar === "python") return extractPythonImports(root);
+  if (grammar === "go") return extractGoImports(root);
+  if (grammar === "rust") return extractRustImports(root);
+  if (grammar === "c" || grammar === "cpp") return extractCFamilyImports(root);
+  if (grammar === "java") return extractJavaImports(root);
+  if (grammar === "ruby") return extractRubyImports(root);
+  if (grammar === "c_sharp") return extractCSharpImports(root);
+  return [];
+}
+function sortSymbols(symbols) {
+  return symbols.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind));
+}
+function grammarForSourceFile(path, text) {
+  if (isAmbiguousHeaderPath(path)) return classifyCHeaderLanguage(text) === "c++" ? "cpp" : "c";
+  return grammarForPath(path, languageFromPath(path));
+}
+function grammarCandidatesForSourceFile(path) {
+  if (isAmbiguousHeaderPath(path)) return ["c", "cpp"];
+  const grammar = grammarForPath(path, languageFromPath(path));
+  return grammar ? [grammar] : [];
+}
+async function createTreeSitterExtractor() {
+  await ensureParserInit();
+  const parsers = /* @__PURE__ */ new Map();
+  const loading = /* @__PURE__ */ new Map();
+  const loadGrammar = (grammar) => {
+    if (parsers.has(grammar)) return Promise.resolve();
+    let pending = loading.get(grammar);
+    if (!pending) {
+      pending = Language.load(WASM_BY_GRAMMAR[grammar]).then((language) => {
+        const parser = new Parser();
+        parser.setLanguage(language);
+        parsers.set(grammar, parser);
+      }).finally(() => {
+        loading.delete(grammar);
+      });
+      loading.set(grammar, pending);
+    }
+    return pending;
+  };
+  return {
+    langs: ["typescript", "javascript", "python", "go", "rust", "c", "c++", "java", "ruby", "c#"],
+    async ensureGrammarsForPaths(paths) {
+      const needed = /* @__PURE__ */ new Set();
+      for (const path of paths) {
+        for (const grammar of grammarCandidatesForSourceFile(path)) needed.add(grammar);
+      }
+      await Promise.all([...needed].map(loadGrammar));
+    },
+    extract(path, text) {
+      const grammar = grammarForSourceFile(path, text);
+      if (!grammar || text.trim().length === 0) return { symbols: [], imports: [] };
+      const parser = parsers.get(grammar);
+      if (!parser) throw new Error(`tree-sitter grammar not loaded for ${path}`);
+      let tree = null;
+      try {
+        const parsed = parser.parse(text);
+        if (!parsed) throw new Error(`tree-sitter returned no tree for ${path}`);
+        tree = parsed;
+        const symbols = sortSymbols(extractSymbolsByGrammar(grammar, parsed.rootNode));
+        return {
+          symbols,
+          imports: extractImportsByGrammar(grammar, parsed.rootNode)
+        };
+      } catch {
+        throw new Error(`tree-sitter parse failed for ${path}`);
+      } finally {
+        tree?.delete();
+      }
+    }
+  };
+}
+function languageFromPath(path) {
+  if (/\.[cm]?tsx?$/.test(path)) return "typescript";
+  if (/\.[cm]?jsx?$/.test(path)) return "javascript";
+  if (path.endsWith(".py") || path.endsWith(".pyw")) return "python";
+  if (path.endsWith(".go")) return "go";
+  if (path.endsWith(".rs")) return "rust";
+  if (/\.(cc|cpp|cxx|hpp|hh|hxx|cu|cuh)$/.test(path)) return "c++";
+  if (/\.(c|h)$/.test(path)) return "c";
+  if (path.endsWith(".java")) return "java";
+  if (path.endsWith(".rb")) return "ruby";
+  if (path.endsWith(".cs")) return "c#";
+  return "config";
+}
+
+// src/domains/context/codewiki/indexer.ts
+var CODEWIKI_SYMBOL_KINDS_WITH_SIG = /* @__PURE__ */ new Set(["func", "class", "method", "type"]);
+var CODEWIKI_VERSION = 5;
+var treeSitterExtractorPromise = null;
+function loadTreeSitterExtractor() {
+  treeSitterExtractorPromise ??= createTreeSitterExtractor();
+  return treeSitterExtractorPromise;
+}
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".py", "python"],
+  [".pyw", "python"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cc", "c++"],
+  [".cpp", "c++"],
+  [".cxx", "c++"],
+  [".hpp", "c++"],
+  [".hh", "c++"],
+  [".hxx", "c++"],
+  [".cu", "c++"],
+  [".cuh", "c++"],
+  [".java", "java"],
+  [".rb", "ruby"],
+  [".cs", "c#"]
+]);
+var CONFIG_FILE_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "CMakeLists.txt",
+  "compile_commands.json",
+  "Gemfile"
+]);
+var RESOLUTION_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".c",
+  ".h",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".cu",
+  ".cuh",
+  ".java",
+  ".rb",
+  ".cs"
+];
+function compareStrings3(a, b) {
+  return a.localeCompare(b);
+}
+function stableFileId(path) {
+  return `f_${createHash("sha256").update(path).digest("hex").slice(0, 16)}`;
+}
+function contentHash(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function defaultReadFile(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function extensionOf2(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function normalizeRel(cwd, filePath) {
+  return relative(cwd, filePath).split("\\").join("/");
+}
+function normalizeInputPath(path) {
+  return path.split("\\").join("/").replace(/^\.\//, "");
+}
+function sourceLanguageForPath(relPath) {
+  if (relPath.endsWith(".d.ts")) return null;
+  return SOURCE_EXTENSIONS2.get(extensionOf2(relPath)) ?? null;
+}
+function languageForPath(relPath) {
+  const source = sourceLanguageForPath(relPath);
+  if (source) return source;
+  const name = relPath.split("/").pop() ?? relPath;
+  return CONFIG_FILE_NAMES.has(name) || name.endsWith(".csproj") || name.toLowerCase().endsWith(".cmake") ? "config" : null;
+}
+function isIndexablePath(relPath) {
+  if (relPath.split("/").some((segment) => WORKSPACE_EXCLUDED_DIRS.has(segment))) return false;
+  return languageForPath(relPath) !== null;
+}
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  return text.endsWith("\n") ? text.split("\n").length - 1 : text.split("\n").length;
+}
+function roleFor(relPath, language) {
+  if (language === "config") return "config";
+  const lower = relPath.toLowerCase();
+  if (lower.includes("/test/") || lower.includes("/tests/") || /\.(test|spec)\.[cm]?[jt]sx?$/.test(lower) || /(^|\/)test_.*\.py$/.test(lower) || /(^|\/).*_test\.(go|rs|rb)$/.test(lower)) {
+    return "test";
+  }
+  if (/(^|\/)(index|main|server|cli|orchestrator|bootstrap)\.[^.]+$/.test(lower) || lower.endsWith("/__main__.py")) {
+    return "entry";
+  }
+  return "module";
+}
+function firstDocSummary(text) {
+  const jsDoc = /\/\*\*([\s\S]*?)\*\//.exec(text)?.[1];
+  const pythonDoc = /^\s*(?:"""([\s\S]*?)"""|'''([\s\S]*?)''')/.exec(text);
+  const raw = jsDoc ?? pythonDoc?.[1] ?? pythonDoc?.[2];
+  if (!raw) return null;
+  const cleaned = raw.split("\n").map((line2) => line2.replace(/^\s*\*\s?/, "").trim()).filter((line2) => line2.length > 0 && !line2.startsWith("@")).join(" ").replace(/\s+/g, " ").trim();
+  return cleaned.length > 0 ? cleaned.slice(0, 160) : null;
+}
+function sanitizeSymbolName(value) {
+  return value.trim().replace(/^self\./, "").replace(/^this\./, "").slice(0, 160);
+}
+function addSymbol2(target, seen, name, kind, line2, sig2) {
+  if (!name) return;
+  const clean = sanitizeSymbolName(name);
+  if (clean.length === 0) return;
+  const key = `${clean}\0${kind}\0${line2}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  target.push({
+    name: clean,
+    kind,
+    line: line2,
+    ...sig2 && sig2.trim().length > 0 ? { sig: sig2.trim().slice(0, 240) } : {}
+  });
+}
+function uniqueSorted3(values) {
+  return [...new Set([...values].filter((item) => item.length > 0))].sort(compareStrings3);
+}
+function extractWithLineRegex(text, patterns) {
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = text.split(/\r?\n/);
+  for (const [index, line2] of lines.entries()) {
+    for (const pattern of patterns) {
+      const match = pattern.regex.exec(line2);
+      if (!match) continue;
+      const name = match[pattern.nameIndex ?? 1];
+      addSymbol2(symbols, seen, name, pattern.kind, index + 1, line2.trim());
+    }
+  }
+  return symbols.sort(compareSymbols);
+}
+function compareSymbols(a, b) {
+  return a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind);
+}
+function extractMatches(text, regex, group = 1) {
+  const out = [];
+  for (const match of text.matchAll(regex)) {
+    const value = match[group];
+    if (value) out.push(value);
+  }
+  return out;
+}
+function maskCFamilyCommentsAndStrings(text) {
+  const chars = text.split("");
+  let state = "code";
+  for (let index = 0; index < chars.length; index += 1) {
+    const current = chars[index] ?? "";
+    const next = chars[index + 1] ?? "";
+    if (state === "code") {
+      if (current === "/" && next === "/") {
+        chars[index] = " ";
+        chars[index + 1] = " ";
+        state = "line-comment";
+        index += 1;
+      } else if (current === "/" && next === "*") {
+        chars[index] = " ";
+        chars[index + 1] = " ";
+        state = "block-comment";
+        index += 1;
+      } else if (current === "'") {
+        chars[index] = " ";
+        state = "single-quote";
+      } else if (current === '"') {
+        chars[index] = " ";
+        state = "double-quote";
+      }
+      continue;
+    }
+    if (current === "\n") {
+      if (state === "line-comment") state = "code";
+      continue;
+    }
+    chars[index] = " ";
+    if (state === "block-comment" && current === "*" && next === "/") {
+      chars[index + 1] = " ";
+      state = "code";
+      index += 1;
+      continue;
+    }
+    if ((state === "single-quote" || state === "double-quote") && current === "\\") {
+      if (index + 1 < chars.length && chars[index + 1] !== "\n") {
+        chars[index + 1] = " ";
+        index += 1;
+      }
+      continue;
+    }
+    if (state === "single-quote" && current === "'") state = "code";
+    if (state === "double-quote" && current === '"') state = "code";
+  }
+  return chars.join("");
+}
+function cFamilyAliasStatements(text) {
+  const masked = maskCFamilyCommentsAndStrings(text);
+  const statements = [];
+  const token = /\b(?:typedef|using)\b/g;
+  for (let match = token.exec(masked); match; match = token.exec(masked)) {
+    const start = match.index;
+    const lineStart = masked.lastIndexOf("\n", start - 1) + 1;
+    if (masked.slice(lineStart, start).trimStart().startsWith("#")) continue;
+    let braces = 0;
+    let parentheses = 0;
+    let brackets = 0;
+    let end = -1;
+    for (let index = token.lastIndex; index < masked.length; index += 1) {
+      const current = masked[index];
+      if (current === "{") braces += 1;
+      else if (current === "}") braces = Math.max(0, braces - 1);
+      else if (current === "(") parentheses += 1;
+      else if (current === ")") parentheses = Math.max(0, parentheses - 1);
+      else if (current === "[") brackets += 1;
+      else if (current === "]") brackets = Math.max(0, brackets - 1);
+      else if (current === ";" && braces === 0 && parentheses === 0 && brackets === 0) {
+        end = index + 1;
+        break;
+      }
+    }
+    if (end === -1) continue;
+    statements.push({
+      text: text.slice(start, end),
+      masked: masked.slice(start, end),
+      line: 1 + Array.from(masked.slice(0, start).matchAll(/\n/g)).length
+    });
+    token.lastIndex = end;
+  }
+  return statements;
+}
+function stripCFamilyBraceBodies(statement) {
+  let depth = 0;
+  let result = "";
+  for (const current of statement) {
+    if (current === "{") {
+      depth += 1;
+      result += " ";
+      continue;
+    }
+    if (current === "}") {
+      depth = Math.max(0, depth - 1);
+      result += " ";
+      continue;
+    }
+    result += depth === 0 || current === "\n" ? current : " ";
+  }
+  return result;
+}
+function splitCFamilyDeclarators(value) {
+  const parts = [];
+  let start = 0;
+  let parentheses = 0;
+  let brackets = 0;
+  let angles = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const current = value[index];
+    if (current === "(") parentheses += 1;
+    else if (current === ")") parentheses = Math.max(0, parentheses - 1);
+    else if (current === "[") brackets += 1;
+    else if (current === "]") brackets = Math.max(0, brackets - 1);
+    else if (current === "<") angles += 1;
+    else if (current === ">") angles = Math.max(0, angles - 1);
+    else if (current === "," && parentheses === 0 && brackets === 0 && angles === 0) {
+      parts.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(value.slice(start));
+  return parts;
+}
+var C_FAMILY_TYPE_WORDS = /* @__PURE__ */ new Set([
+  "typedef",
+  "const",
+  "volatile",
+  "restrict",
+  "signed",
+  "unsigned",
+  "short",
+  "long",
+  "void",
+  "char",
+  "int",
+  "float",
+  "double",
+  "struct",
+  "union",
+  "enum",
+  "class",
+  "typename",
+  "auto"
+]);
+function stripTrailingCFamilyDeclaratorSuffixes(value) {
+  let end = value.length;
+  while (end > 0) {
+    while (end > 0 && /\s/.test(value[end - 1] ?? "")) end -= 1;
+    const close = value[end - 1];
+    if (close !== ")" && close !== "]") break;
+    const open = close === ")" ? "(" : "[";
+    let depth = 1;
+    let start = end - 1;
+    for (start -= 1; start >= 0; start -= 1) {
+      const current = value[start];
+      if (current === close) depth += 1;
+      else if (current === open) {
+        depth -= 1;
+        if (depth === 0) break;
+      }
+    }
+    if (start < 0) break;
+    if (start === 0 || !/[A-Za-z_0-9)\]]/.test(value[start - 1] ?? "")) break;
+    end = start;
+  }
+  return value.slice(0, end);
+}
+function cFamilyTypedefNames(maskedStatement) {
+  const withoutBodies = stripCFamilyBraceBodies(maskedStatement).replace(/^\s*typedef\b/, "").replace(/;\s*$/, "");
+  const names = [];
+  for (const declarator of splitCFamilyDeclarators(withoutBodies)) {
+    const functionPointerNames = Array.from(
+      declarator.matchAll(
+        /\(\s*(?:[A-Za-z_]\w*\s+)*[*&]+\s*(?:(?:const|volatile|restrict)\s+)*([A-Za-z_]\w*)\s*(?:\[[^\]]*\]\s*)*\)(?=\s*\()/g
+      ),
+      (match) => match[1] ?? ""
+    ).filter((name2) => name2.length > 0);
+    if (functionPointerNames.length > 0) {
+      names.push(...functionPointerNames);
+      continue;
+    }
+    const declaratorWithoutSuffixes = stripTrailingCFamilyDeclaratorSuffixes(declarator);
+    const identifiers = Array.from(declaratorWithoutSuffixes.matchAll(/\b[A-Za-z_]\w*\b/g), (match) => match[0]).filter(
+      (name2) => !C_FAMILY_TYPE_WORDS.has(name2)
+    );
+    const name = identifiers.at(-1);
+    if (name) names.push(name);
+  }
+  return uniqueSorted3(names);
+}
+function extractCFamilyAliasSymbols(text) {
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const statement of cFamilyAliasStatements(text)) {
+    const usingName = /^\s*using\s+([A-Za-z_]\w*)\s*=/.exec(statement.masked)?.[1];
+    const names = usingName ? [usingName] : /^\s*typedef\b/.test(statement.masked) ? cFamilyTypedefNames(statement.masked) : [];
+    const signature = statement.text.replace(/\s+/g, " ").trim();
+    for (const name of names) addSymbol2(symbols, seen, name, "type", statement.line, signature);
+  }
+  return symbols;
+}
+var tsJsExtractor = {
+  langs: ["typescript", "javascript"],
+  extractImports(_path, text) {
+    return uniqueSorted3([
+      ...extractMatches(text, /\bimport\s+(?:type\s+)?(?:[^'"]*?\s+from\s+)?["']([^"']+)["']/g),
+      ...extractMatches(text, /\bexport\s+[^'"]*?\s+from\s+["']([^"']+)["']/g),
+      ...extractMatches(text, /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g),
+      ...extractMatches(text, /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)
+    ]);
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)?/, kind: "func" },
+      { regex: /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/, kind: "func" },
+      { regex: /^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\b/, kind: "class" },
+      { regex: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)\b/, kind: "iface" },
+      { regex: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\b/, kind: "type" },
+      { regex: /^\s*(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)\b/, kind: "type" },
+      { regex: /^(?:\s*export\s+)?const\s+([A-Za-z_$][\w$]*)\b/, kind: "const" },
+      { regex: /^(?:\s*export\s+)?(?:let|var)\s+([A-Za-z_$][\w$]*)\b/, kind: "var" },
+      {
+        regex: /^(?: {2,}|\t+)(?:public\s+|private\s+|protected\s+|static\s+|override\s+|abstract\s+|async\s+|get\s+|set\s+)*(?!(?:if|for|while|switch|catch|return|typeof|else|do|new|await|yield)\b)([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{?$/,
+        kind: "method"
+      }
+    ]);
+    return { symbols, imports: tsJsExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var pythonExtractor = {
+  langs: ["python"],
+  extractImports(_path, text) {
+    return uniqueSorted3([
+      ...extractMatches(text, /^\s*import\s+([A-Za-z_][\w.]*)(?:\s+as\s+\w+)?/gm),
+      ...extractMatches(text, /^\s*from\s+([.\w]+)\s+import\s+/gm)
+    ]);
+  },
+  extract(_path, text) {
+    const rawSymbols = extractWithLineRegex(text, [
+      { regex: /^(\s*)def\s+([A-Za-z_]\w*)\s*\(/, kind: "func", nameIndex: 2 },
+      { regex: /^(\s*)async\s+def\s+([A-Za-z_]\w*)\s*\(/, kind: "func", nameIndex: 2 },
+      { regex: /^\s*class\s+([A-Za-z_]\w*)\b/, kind: "class" },
+      { regex: /^([A-Z][A-Z0-9_]*)\s*=/, kind: "const" },
+      { regex: /^([A-Za-z_]\w*)\s*=/, kind: "var" }
+    ]);
+    const symbols = rawSymbols.map((symbol) => {
+      if ((symbol.kind === "func" || symbol.kind === "var") && /^\s+/.test(symbol.sig ?? "")) {
+        return { ...symbol, kind: symbol.kind === "func" ? "method" : symbol.kind };
+      }
+      return symbol;
+    });
+    return { symbols: symbols.sort(compareSymbols), imports: pythonExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var goExtractor = {
+  langs: ["go"],
+  extractImports(_path, text) {
+    return uniqueSorted3([
+      ...extractMatches(text, /^\s*import\s+"([^"]+)"/gm),
+      ...extractMatches(text, /^\s*"([^"]+)"\s*$/gm)
+    ]);
+  },
+  extract(_path, text) {
+    const rawSymbols = extractWithLineRegex(text, [
+      { regex: /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/, kind: "func" },
+      { regex: /^\s*type\s+([A-Za-z_]\w*)\s+interface\b/, kind: "iface" },
+      { regex: /^\s*type\s+([A-Za-z_]\w*)\s+struct\b/, kind: "type" },
+      { regex: /^\s*type\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^const\s+([A-Za-z_]\w*)\b/, kind: "const" },
+      { regex: /^var\s+([A-Za-z_]\w*)\b/, kind: "var" }
+    ]);
+    const symbols = rawSymbols.map((symbol) => {
+      if (symbol.kind === "func" && /^\s*func\s+\(/.test(symbol.sig ?? "")) return { ...symbol, kind: "method" };
+      return symbol;
+    });
+    return { symbols: symbols.sort(compareSymbols), imports: goExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var rustExtractor = {
+  langs: ["rust"],
+  extractImports(_path, text) {
+    return uniqueSorted3([
+      ...extractMatches(text, /^\s*use\s+([^;]+);/gm).map((item) => item.trim()),
+      ...extractMatches(text, /^\s*extern\s+crate\s+([A-Za-z_]\w*)/gm)
+    ]);
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?fn\s+([A-Za-z_]\w*)\s*[<(]/, kind: "func" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)\b/, kind: "trait" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^(?:\s*pub(?:\([^)]*\))?\s+)?const\s+([A-Za-z_]\w*)\b/, kind: "const" },
+      { regex: /^(?:\s*pub(?:\([^)]*\))?\s+)?static\s+([A-Za-z_]\w*)\b/, kind: "var" }
+    ]);
+    return { symbols, imports: rustExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var cFamilyExtractor = {
+  langs: ["c", "c++"],
+  extractImports(_path, text) {
+    const imports = [];
+    for (const match of text.matchAll(/^\s*#\s*include\s*(?:"([^"]+)"|<([^>]+)>)/gm)) {
+      const quoted = match[1];
+      const system = match[2];
+      if (quoted) imports.push(quoted.startsWith(".") || quoted.startsWith("/") ? quoted : `./${quoted}`);
+      else if (system) imports.push(system);
+    }
+    return uniqueSorted3(imports);
+  },
+  extract(_path, text) {
+    const regexSymbols = extractWithLineRegex(text, [
+      { regex: /^\s*class\s+([A-Za-z_]\w*)\b/, kind: "class" },
+      {
+        regex: /^\s*(?:typedef\s+)?(?:struct\s+|union\s+|enum\s+(?:(?:class|struct)\s+)?)([A-Za-z_]\w*)\b/,
+        kind: "type"
+      },
+      {
+        regex: /^\s*(?!(?:typedef|using)\b)(?:template\s*<[^>]+>\s*)?(?:[A-Za-z_][\w:<>,*&\s]+\s+)+(?:(?:[A-Za-z_]\w*)::)*([~A-Za-z_]\w*)\s*\([^;]*\)\s*(?:const\s*)?(?:noexcept\s*)?(?:;|\{)?$/,
+        kind: "func"
+      },
+      { regex: /^(?:const\s+)?[A-Za-z_][\w:<>,*&\s]+\s+([A-Z][A-Z0-9_]*)\s*=/, kind: "const" }
+    ]);
+    const symbolsByKey = /* @__PURE__ */ new Map();
+    for (const symbol of [...regexSymbols, ...extractCFamilyAliasSymbols(text)]) {
+      const key = `${symbol.name}\0${symbol.kind}\0${symbol.line}`;
+      if (!symbolsByKey.has(key)) symbolsByKey.set(key, symbol);
+    }
+    const symbols = [...symbolsByKey.values()].sort(compareSymbols);
+    return { symbols, imports: cFamilyExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var javaExtractor = {
+  langs: ["java"],
+  extractImports(_path, text) {
+    return uniqueSorted3(extractMatches(text, /^\s*import\s+(?:static\s+)?([A-Za-z_][\w.*]*);/gm));
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*class\s+([A-Za-z_]\w*)\b/, kind: "class" },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*interface\s+([A-Za-z_]\w*)\b/,
+        kind: "iface"
+      },
+      { regex: /^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*enum\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|static\s+|final\s+|synchronized\s+)*[A-Za-z_][\w<>,[\]\s]*\s+([A-Za-z_]\w*)\s*\([^)]*\)\s*\{?$/,
+        kind: "method"
+      },
+      {
+        regex: /^\s*public\s+(?:static\s+|final\s+)*[A-Za-z_][\w<>,[\]\s]*\s+([A-Z][A-Z0-9_]*)\s*=/,
+        kind: "const"
+      }
+    ]);
+    return { symbols, imports: javaExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var rubyExtractor = {
+  langs: ["ruby"],
+  extractImports(_path, text) {
+    return uniqueSorted3([
+      ...extractMatches(text, /^\s*require\s+["']([^"']+)["']/gm),
+      ...extractMatches(text, /^\s*require_relative\s+["']([^"']+)["']/gm).map((item) => `./${item}`)
+    ]);
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*class\s+([A-Z]\w*(?:::[A-Z]\w*)*)\b/, kind: "class" },
+      { regex: /^\s*module\s+([A-Z]\w*(?:::[A-Z]\w*)*)\b/, kind: "type" },
+      { regex: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)\b/, kind: "func" },
+      { regex: /^([A-Z][A-Z0-9_]*)\s*=/, kind: "const" }
+    ]);
+    return { symbols, imports: rubyExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var csharpExtractor = {
+  langs: ["c#"],
+  extractImports(_path, text) {
+    return uniqueSorted3(
+      extractMatches(text, /^\s*using\s+(?:static\s+)?(?:[A-Za-z_]\w*\s*=\s*)?([A-Za-z_][\w.]*)\s*;/gm)
+    );
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|sealed\s+|abstract\s+|partial\s+)*class\s+([A-Za-z_]\w*)\b/,
+        kind: "class"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|partial\s+)*interface\s+([A-Za-z_]\w*)\b/,
+        kind: "iface"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|readonly\s+|partial\s+)*(?:enum|struct|record)\s+([A-Za-z_]\w*)\b/,
+        kind: "type"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|virtual\s+|override\s+|abstract\s+|sealed\s+|async\s+|partial\s+|new\s+)*(?!(?:if|for|foreach|while|switch|catch|return|using|else|do|new|class|interface|enum|struct|record|namespace|lock|throw)\b)[A-Za-z_][\w<>,[\].?\s]*\s+([A-Za-z_]\w*)\s*\([^)]*\)\s*\{?$/,
+        kind: "method"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+)*const\s+[A-Za-z_][\w<>,[\]\s]*\s+([A-Za-z_]\w*)\s*=/,
+        kind: "const"
+      }
+    ]);
+    return { symbols, imports: csharpExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var fallbackExtractors = [
+  tsJsExtractor,
+  pythonExtractor,
+  goExtractor,
+  rustExtractor,
+  cFamilyExtractor,
+  javaExtractor,
+  rubyExtractor,
+  csharpExtractor
+];
+function extractWithExtractors(extractors, language, relPath, text) {
+  const symbols = /* @__PURE__ */ new Map();
+  const imports = [];
+  for (const extractor of extractors) {
+    if (!extractor.langs.includes(language)) continue;
+    const extracted = extractor.extract(relPath, text);
+    for (const symbol of extracted.symbols) {
+      const key = `${symbol.name}\0${symbol.kind}\0${symbol.line}`;
+      if (!symbols.has(key)) symbols.set(key, symbol);
+    }
+    imports.push(...extracted.imports);
+  }
+  return {
+    symbols: [...symbols.values()].sort(compareSymbols),
+    imports: uniqueSorted3(imports)
+  };
+}
+function extractImportsWithExtractors(extractors, language, relPath, text) {
+  const imports = [];
+  for (const extractor of extractors) {
+    if (!extractor.langs.includes(language) || !extractor.extractImports) continue;
+    imports.push(...extractor.extractImports(relPath, text));
+  }
+  return uniqueSorted3(imports);
+}
+function mergeTreeSitterWithRegexImports(language, relPath, text, extracted) {
+  const regexImports = extractImportsWithExtractors(fallbackExtractors, language, relPath, text);
+  return {
+    symbols: extracted.symbols.sort(compareSymbols),
+    imports: uniqueSorted3([...extracted.imports, ...regexImports])
+  };
+}
+function fallbackExtraction(language, relPath, text) {
+  return extractWithExtractors(fallbackExtractors, language, relPath, text);
+}
+function extractSourceFile(language, relPath, text, treeSitterExtractor) {
+  if (!treeSitterExtractor.langs.includes(language)) return fallbackExtraction(language, relPath, text);
+  try {
+    return mergeTreeSitterWithRegexImports(language, relPath, text, treeSitterExtractor.extract(relPath, text));
+  } catch {
+    return fallbackExtraction(language, relPath, text);
+  }
+}
+function buildFile(cwd, relPath, treeSitterExtractor, readFile) {
+  const pathLanguage = languageForPath(relPath);
+  if (!pathLanguage) return null;
+  let text;
+  try {
+    text = readFile(join4(cwd, relPath));
+  } catch {
+    return null;
+  }
+  if (text === null) return null;
+  const language = pathLanguage === "c" && isAmbiguousHeaderPath(relPath) ? classifyCHeaderLanguage(text) : pathLanguage;
+  const file = {
+    id: stableFileId(relPath),
+    path: relPath,
+    lang: language,
+    loc: lineCount(text),
+    role: roleFor(relPath, language),
+    hash: contentHash(text),
+    imports: []
+  };
+  if (text.trim().length === 0) return { file, symbols: [] };
+  const extracted = isCMakePath(relPath) ? extractCMake(text) : language !== "config" ? extractSourceFile(language, relPath, text, treeSitterExtractor) : null;
+  if (!extracted) return { file, symbols: [] };
+  const summary = firstDocSummary(text);
+  const sourceFile = {
+    ...file,
+    imports: extracted.imports,
+    ...summary ? { summary } : {}
+  };
+  const symbols = extracted.symbols.map((symbol) => ({
+    name: symbol.name,
+    kind: symbol.kind,
+    fileId: sourceFile.id,
+    line: symbol.line,
+    ...symbolSigFields(symbol.kind, symbol.sig)
+  }));
+  return {
+    file: sourceFile,
+    symbols
+  };
+}
+function candidatePathsForImport(cwd, fromRel, specifier) {
+  const fromDir = dirname2(join4(cwd, fromRel));
+  const cleaned = specifier.replace(/\\/g, "/");
+  const base = cleaned.startsWith(".") || cleaned.startsWith("/") ? resolve(fromDir, cleaned) : "";
+  if (!base) return [];
+  const candidates = [base];
+  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(`${base}${ext}`);
+  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(join4(base, `index${ext}`));
+  if (cleaned.endsWith(".js")) {
+    const stripped = base.replace(/\.js$/, "");
+    for (const ext of [".ts", ".tsx", ".mts", ".cts"]) candidates.push(`${stripped}${ext}`);
+  }
+  if (/^[.]+[A-Za-z_]/.test(cleaned)) {
+    const pythonModule = cleaned.replace(/^\.+/, "").replace(/\./g, "/");
+    const pythonBase = resolve(fromDir, pythonModule);
+    candidates.push(`${pythonBase}.py`, join4(pythonBase, "__init__.py"));
+  }
+  return uniqueSorted3(
+    candidates.map((candidate) => normalizeRel(cwd, candidate)).filter((candidate) => !candidate.startsWith(".."))
+  );
+}
+function createImportResolver(cwd) {
+  const candidatesByOrigin = /* @__PURE__ */ new Map();
+  const onDisk = /* @__PURE__ */ new Map();
+  const candidatesFor = (fromRel, specifier) => {
+    const key = `${dirname2(fromRel)}\0${specifier}`;
+    let candidates = candidatesByOrigin.get(key);
+    if (!candidates) {
+      candidates = candidatePathsForImport(cwd, fromRel, specifier);
+      candidatesByOrigin.set(key, candidates);
+    }
+    return candidates;
+  };
+  const isFile = (candidate) => {
+    const cached = onDisk.get(candidate);
+    if (cached !== void 0) return cached;
+    let exists;
+    try {
+      exists = statSync(join4(cwd, candidate)).isFile();
+    } catch {
+      exists = false;
+    }
+    onDisk.set(candidate, exists);
+    return exists;
+  };
+  return {
+    resolve(fromRel, specifier, pathToId) {
+      for (const candidate of candidatesFor(fromRel, specifier)) {
+        if (pathToId.has(candidate)) return pathToId.get(candidate) ?? null;
+        if (isFile(candidate)) return null;
+      }
+      return null;
+    }
+  };
+}
+async function buildEdges(cwd, files, slicer) {
+  const pathToId = new Map(files.map((file) => [file.path, file.id]));
+  const resolver = createImportResolver(cwd);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const specifier of file.imports) {
+      await slicer.tick();
+      const target = resolver.resolve(file.path, specifier, pathToId);
+      const edge = target ? { fileId: file.id, toFileId: target } : { fileId: file.id, externalModule: specifier };
+      const key = "toFileId" in edge ? `${edge.fileId}\0${edge.toFileId}` : `${edge.fileId}\0${edge.externalModule}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push(edge);
+    }
+  }
+  return edges.sort(compareEdges);
+}
+function compareFiles(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function compareCodewikiSymbols(a, b) {
+  const pathCmp = a.fileId.localeCompare(b.fileId);
+  return pathCmp || a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind);
+}
+function compareEdges(a, b) {
+  const fileCmp = a.fileId.localeCompare(b.fileId);
+  if (fileCmp !== 0) return fileCmp;
+  const aTarget = "toFileId" in a ? a.toFileId : `~${a.externalModule}`;
+  const bTarget = "toFileId" in b ? b.toFileId : `~${b.externalModule}`;
+  return aTarget.localeCompare(bTarget);
+}
+function promoteSingleSourceEntry(files) {
+  const sourceFiles = files.filter((file) => file.lang !== "config");
+  if (sourceFiles.length !== 1) return files;
+  const only = sourceFiles[0];
+  if (only?.role !== "module") return files;
+  return files.map((file) => file.id === only.id ? { ...file, role: "entry" } : file);
+}
+async function codewikiFromBuiltFiles(cwd, language, builtFiles, slicer) {
+  const baseBuiltFiles = builtFiles.map((item) => ({
+    ...item,
+    file: { ...item.file, role: roleFor(item.file.path, item.file.lang) }
+  }));
+  const files = promoteSingleSourceEntry(baseBuiltFiles.map((item) => item.file).sort(compareFiles));
+  const roleById = new Map(files.map((file) => [file.id, file.role]));
+  const normalizedBuilt = baseBuiltFiles.map((item) => {
+    const role = roleById.get(item.file.id);
+    return role && role !== item.file.role ? { ...item, file: { ...item.file, role } } : item;
+  });
+  const normalizedFiles = normalizedBuilt.map((item) => item.file).sort(compareFiles);
+  return {
+    version: CODEWIKI_VERSION,
+    language,
+    files: normalizedFiles,
+    symbols: normalizedBuilt.flatMap((item) => item.symbols).sort(compareCodewikiSymbols),
+    edges: await buildEdges(cwd, normalizedFiles, slicer)
+  };
+}
+async function buildFromPaths(cwd, language, relPaths, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const sortedPaths = [...relPaths].sort(compareStrings3);
+  const treeSitterExtractor = await loadTreeSitterExtractor();
+  await treeSitterExtractor.ensureGrammarsForPaths(sortedPaths);
+  const readFile = options.readFile ?? defaultReadFile;
+  const builtFiles = [];
+  for (const relPath of sortedPaths) {
+    await slicer.tick();
+    const built = buildFile(cwd, relPath, treeSitterExtractor, readFile);
+    if (built) builtFiles.push(built);
+  }
+  return codewikiFromBuiltFiles(cwd, language, builtFiles, slicer);
+}
+async function buildCodewiki(input, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const files = (await enumerateWorkspaceFilesAsync(input.cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(
+    isIndexablePath
+  );
+  return buildFromPaths(input.cwd, input.language, files, { ...options, slicer });
+}
+async function updateCodewikiPaths(cwd, codewiki, paths, options = {}) {
+  const normalizedPaths = uniqueSorted3(
+    paths.map(normalizeInputPath).filter((path) => path.length > 0 && !path.startsWith(".."))
+  );
+  if (normalizedPaths.length === 0) return codewiki;
+  if (normalizedPaths.some(
+    (path) => path === ".gitignore" || path.endsWith("/.gitignore") || path === ".git/info/exclude" || path === ".git/index" || path === ".gitmodules"
+  )) {
+    return buildCodewiki({ cwd, language: codewiki.language }, options);
+  }
+  const slicer = options.slicer ?? createSlicer();
+  const existingPaths = new Set(codewiki.files.map((file) => file.path));
+  const visiblePaths = new Set(filterWorkspaceFileCandidates(cwd, normalizedPaths, WORKSPACE_EXCLUDED_DIRS));
+  const readFile = options.readFile ?? defaultReadFile;
+  const changedPathSet = new Set(normalizedPaths);
+  const rebuildPaths = [];
+  let hasIndexChange = false;
+  for (const relPath of normalizedPaths) {
+    const wasIndexed = existingPaths.has(relPath);
+    const isCurrentIndexableFile = isIndexablePath(relPath) && visiblePaths.has(relPath);
+    if (!wasIndexed && !isCurrentIndexableFile) continue;
+    hasIndexChange = true;
+    if (isCurrentIndexableFile) rebuildPaths.push(relPath);
+  }
+  if (!hasIndexChange) return codewiki;
+  const rebuiltFiles = [];
+  if (rebuildPaths.length > 0) {
+    const treeSitterExtractor = await loadTreeSitterExtractor();
+    await treeSitterExtractor.ensureGrammarsForPaths(rebuildPaths);
+    for (const relPath of rebuildPaths) {
+      await slicer.tick();
+      const built = buildFile(cwd, relPath, treeSitterExtractor, readFile);
+      if (built) rebuiltFiles.push(built);
+    }
+  }
+  const removedFileIds = new Set(codewiki.files.filter((file) => changedPathSet.has(file.path)).map((file) => file.id));
+  const symbolsByFileId = /* @__PURE__ */ new Map();
+  for (const symbol of codewiki.symbols) {
+    if (removedFileIds.has(symbol.fileId)) continue;
+    const symbols = symbolsByFileId.get(symbol.fileId) ?? [];
+    symbols.push(symbol);
+    symbolsByFileId.set(symbol.fileId, symbols);
+  }
+  const keptFiles = codewiki.files.filter((file) => !changedPathSet.has(file.path)).map((file) => ({ file, symbols: symbolsByFileId.get(file.id) ?? [] }));
+  return codewikiFromBuiltFiles(cwd, codewiki.language, [...keptFiles, ...rebuiltFiles], slicer);
+}
+async function syncCodewiki(cwd, codewiki, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const readFile = options.readFile ?? defaultReadFile;
+  const currentPaths = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(
+    isIndexablePath
+  );
+  const currentFiles = /* @__PURE__ */ new Map();
+  const currentTexts = /* @__PURE__ */ new Map();
+  for (const relPath of currentPaths) {
+    await slicer.tick();
+    const text = readFile(join4(cwd, relPath));
+    if (text !== null) {
+      currentFiles.set(relPath, contentHash(text));
+      currentTexts.set(relPath, text);
+    }
+  }
+  const indexedFiles = new Map(codewiki.files.map((file) => [file.path, file]));
+  const changedPaths = /* @__PURE__ */ new Set();
+  for (const [relPath, hash] of currentFiles) {
+    if (indexedFiles.get(relPath)?.hash !== hash) changedPaths.add(relPath);
+  }
+  for (const relPath of indexedFiles.keys()) {
+    if (!currentFiles.has(relPath)) changedPaths.add(relPath);
+  }
+  if (changedPaths.size === 0) return codewiki;
+  const syncOptions = {
+    ...options,
+    slicer,
+    readFile: (path) => currentTexts.get(normalizeRel(cwd, path)) ?? readFile(path)
+  };
+  return updateCodewikiPaths(cwd, codewiki, [...changedPaths], syncOptions);
+}
+function codewikiPath(cwd) {
+  return join4(cwd, ".clio-coder", "codewiki.json");
+}
+function serializeCodewiki(codewiki) {
+  return `${JSON.stringify(normalizeCodewiki(codewiki))}
+`;
+}
+function writeCodewiki(cwd, codewiki) {
+  const serialized = serializeCodewiki(codewiki);
+  safeResourceWrite(codewikiPath(cwd), serialized, {
+    encoding: "utf8"
+  });
+  return serialized;
+}
+function parseCodewikiRaw(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  return upgradeCodewiki(parsed);
+}
+function readCodewikiRaw(cwd) {
+  const filePath = codewikiPath(cwd);
+  if (!existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const codewiki = parseCodewikiRaw(raw);
+  return codewiki ? { raw, codewiki } : null;
+}
+function readCodewiki(cwd) {
+  return readCodewikiRaw(cwd)?.codewiki ?? null;
+}
+async function readCodewikiAsync(cwd) {
+  let raw;
+  try {
+    raw = await readFileAsync(codewikiPath(cwd), "utf8");
+  } catch {
+    return null;
+  }
+  return parseCodewikiRaw(raw);
+}
+function codewikiEntries(codewiki) {
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const exportsByFile = /* @__PURE__ */ new Map();
+  for (const symbol of codewiki.symbols) {
+    const list = exportsByFile.get(symbol.fileId) ?? [];
+    list.push(symbol.name);
+    exportsByFile.set(symbol.fileId, list);
+  }
+  const importsByFile = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    const list = importsByFile.get(edge.fileId) ?? [];
+    if ("toFileId" in edge) {
+      const target = fileById.get(edge.toFileId);
+      if (target) list.push(target.path);
+    } else {
+      list.push(edge.externalModule);
+    }
+    importsByFile.set(edge.fileId, list);
+  }
+  return codewiki.files.filter((file) => file.lang !== "config").map((file) => ({
+    path: file.path,
+    exports: uniqueSorted3(exportsByFile.get(file.id) ?? []),
+    imports: uniqueSorted3(importsByFile.get(file.id) ?? []),
+    kind: file.role === "entry" ? "entry-point" : file.role === "test" ? "test" : "module",
+    ...file.summary ? { summary: file.summary } : {}
+  })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function codewikiNeedsBackfill(codewiki) {
+  return codewiki.files.some((file) => file.lang !== "config" && file.hash.length === 0);
+}
+function structuralCodewikiHash(codewiki) {
+  return createHash("sha256").update(JSON.stringify(normalizeCodewiki(codewiki))).digest("hex");
+}
+function normalizeCodewikiFile(file) {
+  return {
+    id: file.id,
+    path: file.path,
+    lang: file.lang,
+    loc: file.loc,
+    role: file.role,
+    hash: file.hash,
+    imports: uniqueSorted3(file.imports),
+    ...file.summary ? { summary: file.summary } : {}
+  };
+}
+function symbolSigFields(kind, sig2) {
+  if (!CODEWIKI_SYMBOL_KINDS_WITH_SIG.has(kind)) return {};
+  const clean = sig2?.trim().slice(0, 240);
+  return clean && clean.length > 0 ? { sig: clean } : {};
+}
+function normalizeCodewikiSymbol(symbol) {
+  return {
+    name: symbol.name,
+    kind: symbol.kind,
+    fileId: symbol.fileId,
+    line: symbol.line,
+    ...symbolSigFields(symbol.kind, symbol.sig)
+  };
+}
+function normalizeCodewiki(codewiki) {
+  return {
+    version: CODEWIKI_VERSION,
+    language: codewiki.language,
+    files: codewiki.files.map(normalizeCodewikiFile).sort(compareFiles),
+    symbols: codewiki.symbols.map(normalizeCodewikiSymbol).sort(compareCodewikiSymbols),
+    edges: [...codewiki.edges].sort(compareEdges)
+  };
+}
+function upgradeCodewiki(value) {
+  if (isCodewikiV5(value)) return normalizeCodewiki(value);
+  if (isCodewikiV4(value)) return upgradeV4Codewiki(value);
+  if (isCodewikiV3(value)) return upgradeV3Codewiki(value);
+  if (isCodewikiV2(value)) return upgradeV2Codewiki(value);
+  return null;
+}
+function upgradeV3Codewiki(value) {
+  return normalizeCodewiki({
+    version: CODEWIKI_VERSION,
+    language: value.language,
+    files: value.files.map((file) => ({
+      ...file,
+      hash: "",
+      imports: []
+    })),
+    symbols: value.symbols,
+    edges: value.edges
+  });
+}
+function upgradeV4Codewiki(value) {
+  return normalizeCodewiki({
+    version: CODEWIKI_VERSION,
+    language: value.language,
+    // v5 changes C-family extraction and adds CUDA paths. Blank hashes force
+    // one complete rebuild instead of treating a structurally obsolete v4
+    // artifact as fresh.
+    files: value.files.map((file) => ({ ...file, hash: "" })),
+    symbols: value.symbols,
+    edges: value.edges
+  });
+}
+function upgradeV2Codewiki(value) {
+  const files = value.entries.map((entry) => {
+    const lang = languageForPath(entry.path) ?? (value.language === "unknown" || value.language === "polyglot" || value.language === "dotfiles" ? "config" : value.language);
+    return {
+      id: stableFileId(entry.path),
+      path: entry.path,
+      lang,
+      loc: 0,
+      role: entry.kind === "entry-point" ? "entry" : entry.kind === "test" ? "test" : "module"
+    };
+  });
+  const pathToId = new Map(files.map((file) => [file.path, file.id]));
+  const symbols = [];
+  for (const entry of value.entries) {
+    const fileId = pathToId.get(entry.path);
+    if (!fileId) continue;
+    for (const name of entry.exports) symbols.push({ name, kind: "const", fileId, line: 1 });
+  }
+  const edges = [];
+  for (const entry of value.entries) {
+    const fileId = pathToId.get(entry.path);
+    if (!fileId) continue;
+    for (const item of entry.imports) {
+      const toFileId = pathToId.get(item);
+      edges.push(toFileId ? { fileId, toFileId } : { fileId, externalModule: item });
+    }
+  }
+  return upgradeV3Codewiki({
+    version: 3,
+    language: value.language,
+    files,
+    symbols,
+    edges
+  });
+}
+function isNormalizedRelativeCodewikiPath(path) {
+  if (path.length === 0 || path.includes("\0") || path.includes("\\") || path.startsWith("/")) return false;
+  if (/^[A-Za-z]:\//.test(path)) return false;
+  const segments = path.split("/");
+  return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function hasValidNativeV5Semantics(value) {
+  const fileIds = /* @__PURE__ */ new Set();
+  const filePaths = /* @__PURE__ */ new Set();
+  const locByFileId = /* @__PURE__ */ new Map();
+  for (const file of value.files) {
+    if (fileIds.has(file.id) || filePaths.has(file.path)) return false;
+    if (!isNormalizedRelativeCodewikiPath(file.path) || !/^[0-9a-f]{16}$/.test(file.hash)) return false;
+    fileIds.add(file.id);
+    filePaths.add(file.path);
+    locByFileId.set(file.id, file.loc);
+  }
+  for (const symbol of value.symbols) {
+    const loc = locByFileId.get(symbol.fileId);
+    if (loc === void 0 || symbol.line > loc) return false;
+  }
+  for (const edge of value.edges) {
+    if (!fileIds.has(edge.fileId)) return false;
+    if ("toFileId" in edge && !fileIds.has(edge.toFileId)) return false;
+  }
+  return true;
+}
+function isCodewikiV5(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (obj.version !== CODEWIKI_VERSION || typeof obj.language !== "string") return false;
+  if (!Array.isArray(obj.files) || !Array.isArray(obj.symbols) || !Array.isArray(obj.edges)) return false;
+  if (!obj.files.every(isCodewikiFile) || !obj.symbols.every(isCodewikiSymbol) || !obj.edges.every(isCodewikiEdge)) {
+    return false;
+  }
+  return hasValidNativeV5Semantics(obj);
+}
+function isCodewikiV4(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (obj.version !== 4 || typeof obj.language !== "string") return false;
+  if (!Array.isArray(obj.files) || !Array.isArray(obj.symbols) || !Array.isArray(obj.edges)) return false;
+  return obj.files.every(isCodewikiFile) && obj.symbols.every(isCodewikiSymbol) && obj.edges.every(isCodewikiEdge);
+}
+function isCodewikiV3(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (obj.version !== 3 || typeof obj.language !== "string") return false;
+  if (!Array.isArray(obj.files) || !Array.isArray(obj.symbols) || !Array.isArray(obj.edges)) return false;
+  return obj.files.every(isCodewikiFileV3) && obj.symbols.every(isCodewikiSymbol) && obj.edges.every(isCodewikiEdge);
+}
+function isCodewikiV2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (obj.version !== 2 || typeof obj.generatedAt !== "string" || typeof obj.language !== "string") return false;
+  if (!Array.isArray(obj.entries)) return false;
+  return obj.entries.every(isCodewikiEntry);
+}
+var CODEWIKI_LANGUAGES = /* @__PURE__ */ new Set([
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "c",
+  "c++",
+  "java",
+  "ruby",
+  "c#",
+  "config"
+]);
+var FILE_ROLES = /* @__PURE__ */ new Set(["entry", "test", "module", "config"]);
+var SYMBOL_KINDS = /* @__PURE__ */ new Set(["func", "class", "method", "type", "const", "var", "trait", "iface"]);
+function isCodewikiFile(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  return typeof obj.id === "string" && typeof obj.path === "string" && typeof obj.lang === "string" && CODEWIKI_LANGUAGES.has(obj.lang) && typeof obj.loc === "number" && Number.isInteger(obj.loc) && obj.loc >= 0 && typeof obj.role === "string" && FILE_ROLES.has(obj.role) && typeof obj.hash === "string" && Array.isArray(obj.imports) && obj.imports.every((item) => typeof item === "string") && (!("summary" in obj) || typeof obj.summary === "string");
+}
+function isCodewikiFileV3(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  return typeof obj.id === "string" && typeof obj.path === "string" && typeof obj.lang === "string" && CODEWIKI_LANGUAGES.has(obj.lang) && typeof obj.loc === "number" && Number.isInteger(obj.loc) && obj.loc >= 0 && typeof obj.role === "string" && FILE_ROLES.has(obj.role);
+}
+function isCodewikiSymbol(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.kind === "string" && SYMBOL_KINDS.has(obj.kind) && typeof obj.fileId === "string" && typeof obj.line === "number" && Number.isInteger(obj.line) && obj.line >= 1 && (!("sig" in obj) || typeof obj.sig === "string");
+}
+function isCodewikiEdge(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (typeof obj.fileId !== "string") return false;
+  const hasToFile = typeof obj.toFileId === "string";
+  const hasExternal = typeof obj.externalModule === "string";
+  return hasToFile !== hasExternal;
+}
+function isCodewikiEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (typeof obj.path !== "string") return false;
+  if (!Array.isArray(obj.exports) || obj.exports.some((item) => typeof item !== "string")) return false;
+  if (!Array.isArray(obj.imports) || obj.imports.some((item) => typeof item !== "string")) return false;
+  if (obj.kind !== "entry-point" && obj.kind !== "test" && obj.kind !== "module") return false;
+  if ("summary" in obj && typeof obj.summary !== "string") return false;
+  return true;
+}
+
+export {
+  WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync,
+  detectProjectProfile,
+  detectProjectType,
+  INDEX_SLICE_MS,
+  createSlicer,
+  CODEWIKI_VERSION,
+  isIndexablePath,
+  buildCodewiki,
+  updateCodewikiPaths,
+  syncCodewiki,
+  codewikiPath,
+  writeCodewiki,
+  parseCodewikiRaw,
+  readCodewiki,
+  readCodewikiAsync,
+  codewikiEntries,
+  codewikiNeedsBackfill,
+  structuralCodewikiHash
+};
+//# sourceMappingURL=chunk-TPOCL34A.js.map