@zipbul/gildash 0.0.1

package/dist/index.js

@@ -0,0 +1,2736 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/gildash.ts
+import path5 from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/parser/parse-source.ts
+import { parseSync as defaultParseSync } from "oxc-parser";
+
+// src/errors.ts
+class GildashError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "GildashError";
+  }
+}
+
+class WatcherError extends GildashError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "WatcherError";
+  }
+}
+
+class ParseError extends GildashError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ParseError";
+  }
+}
+
+class ExtractError extends GildashError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ExtractError";
+  }
+}
+
+class IndexError extends GildashError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "IndexError";
+  }
+}
+
+class StoreError extends GildashError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StoreError";
+  }
+}
+
+class SearchError extends GildashError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SearchError";
+  }
+}
+
+// src/parser/parse-source.ts
+function parseSource(filePath, sourceText, parseSyncFn = defaultParseSync) {
+  try {
+    const { program, errors, comments } = parseSyncFn(filePath, sourceText);
+    return { filePath, program, errors, comments, sourceText };
+  } catch (err) {
+    throw new ParseError(`Failed to parse file: ${filePath}`, { cause: err });
+  }
+}
+
+// src/common/lru-cache.ts
+class LruCache {
+  #capacity;
+  #map = new Map;
+  constructor(capacity) {
+    this.#capacity = Math.max(1, capacity);
+  }
+  get size() {
+    return this.#map.size;
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  get(key) {
+    if (!this.#map.has(key)) {
+      return;
+    }
+    const value = this.#map.get(key);
+    this.#map.delete(key);
+    this.#map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.#map.has(key)) {
+      this.#map.delete(key);
+    }
+    this.#map.set(key, value);
+    if (this.#map.size > this.#capacity) {
+      const oldestKey = this.#map.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.#map.delete(oldestKey);
+      }
+    }
+  }
+  delete(key) {
+    return this.#map.delete(key);
+  }
+  clear() {
+    this.#map.clear();
+  }
+}
+
+// src/parser/parse-cache.ts
+class ParseCache {
+  lru;
+  constructor(capacity = 500) {
+    this.lru = new LruCache(capacity);
+  }
+  get(filePath) {
+    return this.lru.get(filePath);
+  }
+  set(filePath, parsed) {
+    this.lru.set(filePath, parsed);
+  }
+  invalidate(filePath) {
+    this.lru.delete(filePath);
+  }
+  invalidateAll() {
+    this.lru.clear();
+  }
+  size() {
+    return this.lru.size;
+  }
+}
+
+// src/parser/source-position.ts
+function buildLineOffsets(sourceText) {
+  const offsets = [0];
+  for (let i = 0;i < sourceText.length; i++) {
+    if (sourceText[i] === `
+`) {
+      offsets.push(i + 1);
+    }
+  }
+  return offsets;
+}
+function getLineColumn(offsets, offset) {
+  let lo = 0;
+  let hi = offsets.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (offsets[mid] <= offset) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return { line: lo + 1, column: offset - offsets[lo] };
+}
+
+// src/parser/jsdoc-parser.ts
+import { parse } from "comment-parser";
+function parseJsDoc(commentText) {
+  try {
+    let stripped = commentText.trim();
+    if (stripped.startsWith("/**"))
+      stripped = stripped.slice(3);
+    if (stripped.endsWith("*/"))
+      stripped = stripped.slice(0, -2);
+    const blocks = parse(`/** ${stripped} */`);
+    const block = blocks[0] ?? { description: "", tags: [] };
+    return {
+      description: (block.description ?? "").trim(),
+      tags: (block.tags ?? []).map((t) => ({
+        tag: t.tag ?? "",
+        name: t.name ?? "",
+        type: t.type ?? "",
+        description: t.description ?? "",
+        optional: t.optional ?? false,
+        ...t.default !== undefined ? { default: t.default } : {}
+      }))
+    };
+  } catch (err) {
+    throw new ParseError(`Failed to parse JSDoc comment`, { cause: err });
+  }
+}
+
+// src/extractor/symbol-extractor.ts
+function extractSymbols(parsed) {
+  const { program, sourceText, comments } = parsed;
+  const lineOffsets = buildLineOffsets(sourceText);
+  function span(start, end) {
+    return {
+      start: getLineColumn(lineOffsets, start),
+      end: getLineColumn(lineOffsets, end)
+    };
+  }
+  function findJsDocComment(nodeStart) {
+    let best = null;
+    for (const c of comments) {
+      if (c.type !== "Block")
+        continue;
+      if (c.end > nodeStart)
+        continue;
+      if (!c.value.startsWith("*"))
+        continue;
+      if (!best || c.end > best.end) {
+        best = { value: `/*${c.value}*/`, end: c.end };
+      }
+    }
+    if (!best)
+      return;
+    for (const stmt of program.body) {
+      const stmtStart = stmt.start ?? 0;
+      if (stmtStart === nodeStart)
+        continue;
+      if (stmtStart > best.end && stmtStart < nodeStart) {
+        return;
+      }
+    }
+    return best.value;
+  }
+  function typeText(typeAnnotation) {
+    if (!typeAnnotation)
+      return;
+    const inner = typeAnnotation.typeAnnotation ?? typeAnnotation;
+    return sourceText.slice(inner.start, inner.end);
+  }
+  function extractDecorators(decorators) {
+    if (!decorators || decorators.length === 0)
+      return [];
+    return decorators.map((d) => {
+      const expr = d.expression;
+      if (!expr)
+        return { name: "unknown" };
+      if (expr.type === "CallExpression") {
+        const name = expr.callee?.name ?? expr.callee?.property?.name ?? "unknown";
+        const args = (expr.arguments ?? []).map((a) => sourceText.slice(a.start, a.end));
+        return { name, arguments: args.length > 0 ? args : undefined };
+      }
+      if (expr.type === "Identifier")
+        return { name: expr.name ?? "unknown" };
+      return { name: sourceText.slice(expr.start, expr.end) };
+    });
+  }
+  function extractParam(p) {
+    const inner = p.type === "TSParameterProperty" ? p.parameter : p;
+    if (inner?.type === "RestElement") {
+      const argName = inner.argument?.name ?? "unknown";
+      const name2 = `...${argName}`;
+      const typeAnn2 = inner.typeAnnotation;
+      const type2 = typeAnn2 ? typeText(typeAnn2) : undefined;
+      const param2 = { name: name2, isOptional: false };
+      if (type2)
+        param2.type = type2;
+      return param2;
+    }
+    if (inner?.type === "AssignmentPattern") {
+      const left = inner.left;
+      const right = inner.right;
+      const name2 = left?.name ?? "unknown";
+      const typeAnn2 = left?.typeAnnotation;
+      const type2 = typeAnn2 ? typeText(typeAnn2) : undefined;
+      const defaultValue = sourceText.slice(right.start, right.end);
+      const decos2 = extractDecorators(left?.decorators ?? []);
+      const param2 = { name: name2, isOptional: true, defaultValue };
+      if (type2)
+        param2.type = type2;
+      if (decos2.length > 0)
+        param2.decorators = decos2;
+      return param2;
+    }
+    const name = inner?.name ?? inner?.pattern?.name ?? "unknown";
+    const optional = !!inner?.optional;
+    const typeAnn = inner?.typeAnnotation;
+    const type = typeAnn ? typeText(typeAnn) : undefined;
+    const decos = extractDecorators(inner?.decorators ?? []);
+    const param = { name, isOptional: optional };
+    if (type)
+      param.type = type;
+    if (decos.length > 0)
+      param.decorators = decos;
+    return param;
+  }
+  function extractModifiers(node, fn) {
+    const mods = [];
+    if (fn?.async)
+      mods.push("async");
+    if (node.static)
+      mods.push("static");
+    if (node.abstract)
+      mods.push("abstract");
+    if (node.readonly)
+      mods.push("readonly");
+    if (node.override)
+      mods.push("override");
+    if (node.declare)
+      mods.push("declare");
+    if (node.const)
+      mods.push("const");
+    const acc = node.accessibility;
+    if (acc === "private")
+      mods.push("private");
+    else if (acc === "protected")
+      mods.push("protected");
+    else if (acc === "public")
+      mods.push("public");
+    return mods;
+  }
+  function classHeritage(node) {
+    const heritage = [];
+    if (node.superClass) {
+      const name = sourceText.slice(node.superClass.start, node.superClass.end);
+      heritage.push({ kind: "extends", name });
+    }
+    const impls = node.implements ?? [];
+    for (const impl of impls) {
+      const expr = impl.expression ?? impl;
+      const name = sourceText.slice(expr.start, expr.end);
+      heritage.push({ kind: "implements", name });
+    }
+    return heritage;
+  }
+  function interfaceHeritage(node) {
+    const heritage = [];
+    for (const ext of node.extends ?? []) {
+      const expr = ext.expression ?? ext;
+      const name = sourceText.slice(expr.start, expr.end);
+      heritage.push({ kind: "extends", name });
+    }
+    return heritage;
+  }
+  function extractClassMembers(bodyNodes) {
+    const members = [];
+    for (const m of bodyNodes) {
+      if (m.type === "MethodDefinition") {
+        const name = m.key?.name ?? "unknown";
+        const fnValue = m.value;
+        const rawKind = m.kind ?? "method";
+        const methodKind = rawKind === "constructor" ? "constructor" : rawKind === "get" ? "getter" : rawKind === "set" ? "setter" : "method";
+        const mods = extractModifiers(m, fnValue);
+        const params = (fnValue?.params ?? []).map(extractParam);
+        const returnType = typeText(fnValue?.returnType);
+        const s = {
+          kind: "method",
+          name,
+          span: span(m.start, m.end),
+          isExported: false,
+          methodKind,
+          modifiers: mods,
+          parameters: params.length > 0 ? params : undefined,
+          returnType
+        };
+        members.push(s);
+      } else if (m.type === "PropertyDefinition") {
+        const name = m.key?.name ?? "unknown";
+        const mods = extractModifiers(m);
+        const s = {
+          kind: "property",
+          name,
+          span: span(m.start, m.end),
+          isExported: false,
+          modifiers: mods
+        };
+        members.push(s);
+      }
+    }
+    return members;
+  }
+  function extractInterfaceMembers(bodyNodes) {
+    const members = [];
+    for (const m of bodyNodes) {
+      if (m.type === "TSMethodSignature") {
+        const name = m.key?.name ?? "unknown";
+        const params = (m.params ?? []).map(extractParam);
+        const returnType = typeText(m.returnType);
+        members.push({
+          kind: "method",
+          name,
+          span: span(m.start, m.end),
+          isExported: false,
+          modifiers: [],
+          methodKind: "method",
+          parameters: params.length > 0 ? params : undefined,
+          returnType
+        });
+      } else if (m.type === "TSPropertySignature") {
+        const name = m.key?.name ?? "unknown";
+        const typeAnn = typeText(m.typeAnnotation);
+        const s = {
+          kind: "property",
+          name,
+          span: span(m.start, m.end),
+          isExported: false,
+          modifiers: m.readonly ? ["readonly"] : [],
+          returnType: typeAnn
+        };
+        members.push(s);
+      }
+    }
+    return members;
+  }
+  function buildSymbol(node, isExported) {
+    const type = node.type ?? "";
+    if (type === "FunctionDeclaration") {
+      const name = node.id?.name ?? "default";
+      const params = (node.params ?? []).map(extractParam);
+      const returnType = typeText(node.returnType);
+      const mods = extractModifiers(node, node);
+      const decos = extractDecorators(node.decorators ?? []);
+      const typeParameters = node.typeParameters?.params?.map((p) => p.name?.name).filter(Boolean) || undefined;
+      const sym = {
+        kind: "function",
+        name,
+        span: span(node.start, node.end),
+        isExported,
+        modifiers: mods,
+        parameters: params.length > 0 ? params : undefined,
+        returnType,
+        decorators: decos.length > 0 ? decos : undefined
+      };
+      if (typeParameters && typeParameters.length > 0)
+        sym.typeParameters = typeParameters;
+      return sym;
+    }
+    if (type === "ClassDeclaration" || type === "ClassExpression") {
+      const name = node.id?.name ?? "default";
+      const heritage = classHeritage(node);
+      const members = extractClassMembers(node.body?.body ?? []);
+      const decos = extractDecorators(node.decorators ?? []);
+      const mods = extractModifiers(node, node);
+      const typeParameters = node.typeParameters?.params?.map((p) => p.name?.name).filter(Boolean) || undefined;
+      const sym = {
+        kind: "class",
+        name,
+        span: span(node.start, node.end),
+        isExported,
+        modifiers: mods,
+        heritage: heritage.length > 0 ? heritage : undefined,
+        members: members.length > 0 ? members : undefined,
+        decorators: decos.length > 0 ? decos : undefined
+      };
+      if (typeParameters && typeParameters.length > 0)
+        sym.typeParameters = typeParameters;
+      return sym;
+    }
+    if (type === "VariableDeclaration") {
+      const symbols = [];
+      for (const decl of node.declarations ?? []) {
+        const id = decl.id;
+        const init = decl.init;
+        if (id?.type === "ObjectPattern") {
+          for (const prop of id.properties ?? []) {
+            const propName = prop.value?.name ?? prop.key?.name ?? "unknown";
+            symbols.push({
+              kind: "variable",
+              name: propName,
+              span: span(prop.start ?? decl.start, prop.end ?? decl.end),
+              isExported,
+              modifiers: []
+            });
+          }
+          continue;
+        }
+        if (id?.type === "ArrayPattern") {
+          for (const elem of id.elements ?? []) {
+            if (!elem || elem.type !== "Identifier")
+              continue;
+            const elemName = elem.name ?? "unknown";
+            symbols.push({
+              kind: "variable",
+              name: elemName,
+              span: span(elem.start ?? decl.start, elem.end ?? decl.end),
+              isExported,
+              modifiers: []
+            });
+          }
+          continue;
+        }
+        const name = id?.name ?? "unknown";
+        let kind = "variable";
+        let params;
+        let returnType;
+        if (init?.type === "FunctionExpression" || init?.type === "ArrowFunctionExpression") {
+          kind = "function";
+          const rawParams = init.params ?? [];
+          params = rawParams.map(extractParam);
+          returnType = typeText(init.returnType);
+        }
+        const mods = [];
+        symbols.push({
+          kind,
+          name,
+          span: span(decl.start, decl.end),
+          isExported,
+          modifiers: mods,
+          parameters: params,
+          returnType
+        });
+      }
+      if (symbols.length === 0)
+        return null;
+      if (symbols.length === 1)
+        return symbols[0];
+      return symbols;
+    }
+    if (type === "TSTypeAliasDeclaration") {
+      const name = node.id?.name ?? "unknown";
+      return {
+        kind: "type",
+        name,
+        span: span(node.start, node.end),
+        isExported,
+        modifiers: []
+      };
+    }
+    if (type === "TSInterfaceDeclaration") {
+      const name = node.id?.name ?? "unknown";
+      const heritage = interfaceHeritage(node);
+      const members = extractInterfaceMembers(node.body?.body ?? []);
+      const typeParameters = node.typeParameters?.params?.map((p) => p.name?.name).filter(Boolean) || undefined;
+      const sym = {
+        kind: "interface",
+        name,
+        span: span(node.start, node.end),
+        isExported,
+        modifiers: [],
+        heritage: heritage.length > 0 ? heritage : undefined,
+        members: members.length > 0 ? members : undefined
+      };
+      if (typeParameters && typeParameters.length > 0)
+        sym.typeParameters = typeParameters;
+      return sym;
+    }
+    if (type === "TSEnumDeclaration") {
+      const name = node.id?.name ?? "unknown";
+      const mods = extractModifiers(node);
+      const rawMembers = node.body?.members ?? [];
+      const members = rawMembers.map((m) => ({
+        kind: "property",
+        name: m.id?.name ?? m.id?.value ?? "unknown",
+        span: span(m.start, m.end),
+        isExported: false,
+        modifiers: []
+      }));
+      return {
+        kind: "enum",
+        name,
+        span: span(node.start, node.end),
+        isExported,
+        modifiers: mods,
+        members: members.length > 0 ? members : undefined
+      };
+    }
+    return null;
+  }
+  const result = [];
+  for (const node of program.body) {
+    let sym = null;
+    const record = node;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type === "ExportNamedDeclaration") {
+      const n = node;
+      if (n.declaration) {
+        sym = buildSymbol(n.declaration, true);
+        if (sym && !Array.isArray(sym)) {
+          sym.span = span(n.start, n.end);
+        } else if (Array.isArray(sym)) {
+          for (const s of sym)
+            s.span = span(n.start, n.end);
+        }
+      }
+    } else if (type === "ExportDefaultDeclaration") {
+      const n = node;
+      const decl = n.declaration;
+      if (decl) {
+        sym = buildSymbol(decl, true);
+        if (sym && !Array.isArray(sym)) {
+          sym.name = decl.id?.name ?? "default";
+          sym.isExported = true;
+          sym.span = span(n.start, n.end);
+        }
+      }
+    } else {
+      sym = buildSymbol(node, false);
+    }
+    const syms = Array.isArray(sym) ? sym : sym ? [sym] : [];
+    for (const s of syms) {
+      const nodeStart = node.start ?? 0;
+      const jsdocText = findJsDocComment(nodeStart);
+      if (jsdocText) {
+        s.jsDoc = parseJsDoc(jsdocText);
+      }
+      result.push(s);
+    }
+  }
+  return result;
+}
+
+// src/extractor/extractor-utils.ts
+import { resolve, dirname, extname } from "path";
+function resolveImport(currentFilePath, importPath, tsconfigPaths) {
+  const withTypeScriptCandidates = (resolved) => {
+    const extension = extname(resolved);
+    if (extension === "") {
+      return [
+        resolved + ".ts",
+        resolved + "/index.ts",
+        resolved + ".mts",
+        resolved + "/index.mts",
+        resolved + ".cts",
+        resolved + "/index.cts"
+      ];
+    }
+    if (extension === ".js")
+      return [resolved.slice(0, -3) + ".ts"];
+    if (extension === ".mjs")
+      return [resolved.slice(0, -4) + ".mts"];
+    if (extension === ".cjs")
+      return [resolved.slice(0, -4) + ".cts"];
+    return [resolved];
+  };
+  if (importPath.startsWith(".")) {
+    const resolved = resolve(dirname(currentFilePath), importPath);
+    return withTypeScriptCandidates(resolved);
+  }
+  if (tsconfigPaths) {
+    for (const [pattern, targets] of tsconfigPaths.paths) {
+      if (targets.length === 0)
+        continue;
+      const starIdx = pattern.indexOf("*");
+      if (starIdx === -1) {
+        if (importPath === pattern) {
+          const candidates = [];
+          for (const t of targets) {
+            candidates.push(...withTypeScriptCandidates(resolve(tsconfigPaths.baseUrl, t)));
+          }
+          return candidates;
+        }
+      } else {
+        const prefix = pattern.slice(0, starIdx);
+        const suffix = pattern.slice(starIdx + 1);
+        if (importPath.startsWith(prefix) && (suffix === "" || importPath.endsWith(suffix))) {
+          const captured = importPath.slice(prefix.length, suffix === "" ? undefined : importPath.length - suffix.length);
+          const candidates = [];
+          for (const t of targets) {
+            candidates.push(...withTypeScriptCandidates(resolve(tsconfigPaths.baseUrl, t.replace("*", captured))));
+          }
+          return candidates;
+        }
+      }
+    }
+  }
+  return [];
+}
+function buildImportMap(ast, currentFilePath, tsconfigPaths, resolveImportFn = resolveImport) {
+  const map = new Map;
+  const body = ast.body ?? [];
+  for (const node of body) {
+    if (node.type !== "ImportDeclaration")
+      continue;
+    const sourcePath = node.source?.value ?? "";
+    const candidates = resolveImportFn(currentFilePath, sourcePath, tsconfigPaths);
+    if (candidates.length === 0)
+      continue;
+    const resolved = candidates[0];
+    const specifiers = node.specifiers ?? [];
+    for (const spec of specifiers) {
+      switch (spec.type) {
+        case "ImportSpecifier":
+          map.set(spec.local.name, {
+            path: resolved,
+            importedName: spec.imported.name
+          });
+          break;
+        case "ImportDefaultSpecifier":
+          map.set(spec.local.name, {
+            path: resolved,
+            importedName: "default"
+          });
+          break;
+        case "ImportNamespaceSpecifier":
+          map.set(spec.local.name, {
+            path: resolved,
+            importedName: "*"
+          });
+          break;
+      }
+    }
+  }
+  return map;
+}
+
+// src/parser/ast-utils.ts
+var SKIP_KEYS = new Set(["loc", "start", "end", "scope"]);
+function visit(node, callback) {
+  if (!node || typeof node !== "object")
+    return;
+  if (Array.isArray(node)) {
+    for (const item of node)
+      visit(item, callback);
+    return;
+  }
+  const record = node;
+  callback(record);
+  for (const key of Object.keys(record)) {
+    if (SKIP_KEYS.has(key))
+      continue;
+    const child = record[key];
+    if (child && typeof child === "object") {
+      visit(child, callback);
+    }
+  }
+}
+function getStringLiteralValue(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node))
+    return null;
+  const record = node;
+  if ((record.type === "StringLiteral" || record.type === "Literal") && typeof record.value === "string") {
+    return record.value;
+  }
+  return null;
+}
+function getQualifiedName(expr) {
+  if (!expr || typeof expr !== "object" || Array.isArray(expr))
+    return null;
+  const node = expr;
+  if (node.type === "Identifier") {
+    const name = node.name;
+    return { root: name, parts: [], full: name };
+  }
+  if (node.type === "ThisExpression") {
+    return { root: "this", parts: [], full: "this" };
+  }
+  if (node.type === "Super") {
+    return { root: "super", parts: [], full: "super" };
+  }
+  if (node.type === "MemberExpression") {
+    const parts = [];
+    let current = node;
+    while (current.type === "MemberExpression") {
+      const prop = current.property;
+      if (!prop || typeof prop.name !== "string")
+        return null;
+      parts.unshift(prop.name);
+      current = current.object;
+    }
+    let root;
+    if (current.type === "Identifier") {
+      root = current.name;
+    } else if (current.type === "ThisExpression") {
+      root = "this";
+    } else if (current.type === "Super") {
+      root = "super";
+    } else {
+      return null;
+    }
+    const full = [root, ...parts].join(".");
+    return { root, parts, full };
+  }
+  return null;
+}
+
+// src/extractor/imports-extractor.ts
+function extractImports(ast, filePath, tsconfigPaths, resolveImportFn = resolveImport) {
+  const relations = [];
+  const body = ast.body ?? [];
+  for (const node of body) {
+    if (node.type === "ImportDeclaration") {
+      const sourcePath = node.source?.value ?? "";
+      const candidates = resolveImportFn(filePath, sourcePath, tsconfigPaths);
+      if (candidates.length === 0)
+        continue;
+      const resolved = candidates[0];
+      const isType = node.importKind === "type";
+      relations.push({
+        type: "imports",
+        srcFilePath: filePath,
+        srcSymbolName: null,
+        dstFilePath: resolved,
+        dstSymbolName: null,
+        ...isType ? { metaJson: JSON.stringify({ isType: true }) } : {}
+      });
+      continue;
+    }
+    if (node.type === "ExportAllDeclaration" && node.source) {
+      const sourcePath = node.source?.value ?? "";
+      const candidates = resolveImportFn(filePath, sourcePath, tsconfigPaths);
+      if (candidates.length === 0)
+        continue;
+      const resolved = candidates[0];
+      const isType = node.exportKind === "type";
+      const meta = { isReExport: true };
+      if (isType)
+        meta.isType = true;
+      relations.push({
+        type: "imports",
+        srcFilePath: filePath,
+        srcSymbolName: null,
+        dstFilePath: resolved,
+        dstSymbolName: null,
+        metaJson: JSON.stringify(meta)
+      });
+      continue;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.source) {
+      const sourcePath = node.source?.value ?? "";
+      const candidates = resolveImportFn(filePath, sourcePath, tsconfigPaths);
+      if (candidates.length === 0)
+        continue;
+      const resolved = candidates[0];
+      relations.push({
+        type: "imports",
+        srcFilePath: filePath,
+        srcSymbolName: null,
+        dstFilePath: resolved,
+        dstSymbolName: null,
+        metaJson: JSON.stringify({ isReExport: true })
+      });
+    }
+  }
+  visit(ast, (node) => {
+    if (node.type !== "ImportExpression")
+      return;
+    const sourceValue = getStringLiteralValue(node.source);
+    if (!sourceValue)
+      return;
+    const candidates = resolveImportFn(filePath, sourceValue, tsconfigPaths);
+    if (candidates.length === 0)
+      return;
+    const resolved = candidates[0];
+    relations.push({
+      type: "imports",
+      srcFilePath: filePath,
+      srcSymbolName: null,
+      dstFilePath: resolved,
+      dstSymbolName: null,
+      metaJson: JSON.stringify({ isDynamic: true })
+    });
+  });
+  return relations;
+}
+
+// src/extractor/calls-extractor.ts
+function extractCalls(ast, filePath, importMap) {
+  const relations = [];
+  const functionStack = [];
+  const classStack = [];
+  function currentCaller() {
+    if (functionStack.length > 0)
+      return functionStack[functionStack.length - 1] ?? null;
+    return null;
+  }
+  function resolveCallee(qn) {
+    if (!qn)
+      return null;
+    const ref = importMap.get(qn.root);
+    if (qn.parts.length === 0) {
+      if (ref) {
+        return { dstFilePath: ref.path, dstSymbolName: ref.importedName, resolution: "import" };
+      }
+      return { dstFilePath: filePath, dstSymbolName: qn.root, resolution: "local" };
+    } else {
+      if (ref && ref.importedName === "*") {
+        const dstSymbolName = qn.parts[qn.parts.length - 1];
+        return { dstFilePath: ref.path, dstSymbolName, resolution: "namespace" };
+      }
+      return { dstFilePath: filePath, dstSymbolName: qn.full, resolution: "local-member" };
+    }
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    const record = node;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type === "ClassDeclaration" || type === "ClassExpression") {
+      const classNode = record;
+      const className = classNode.id?.name ?? "AnonymousClass";
+      classStack.push(className);
+      walk(classNode.body);
+      classStack.pop();
+      return;
+    }
+    if (type === "FunctionDeclaration") {
+      const functionNode = record;
+      const name = functionNode.id?.name ?? "anonymous";
+      functionStack.push(name);
+      walk(functionNode.body);
+      functionStack.pop();
+      return;
+    }
+    if (type === "VariableDeclarator" && record.init && (record.init?.type === "FunctionExpression" || record.init?.type === "ArrowFunctionExpression")) {
+      const declarator = record;
+      const name = declarator.id?.name ?? "anonymous";
+      functionStack.push(name);
+      walk(declarator.init?.body ?? declarator.init);
+      functionStack.pop();
+      return;
+    }
+    if (type === "MethodDefinition" && record.value) {
+      const method = record;
+      const className = classStack[classStack.length - 1] ?? "";
+      const methodName = method.key?.name ?? "anonymous";
+      const fullName = className ? `${className}.${methodName}` : methodName;
+      functionStack.push(fullName);
+      walk(method.value?.body);
+      functionStack.pop();
+      return;
+    }
+    if (type === "FunctionExpression" || type === "ArrowFunctionExpression") {
+      const parentCaller = currentCaller();
+      const anonymousName = parentCaller ? `${parentCaller}.<anonymous>` : "<anonymous>";
+      functionStack.push(anonymousName);
+      walk(record.body);
+      functionStack.pop();
+      return;
+    }
+    if (type === "CallExpression") {
+      const call = record;
+      const qn = getQualifiedName(call.callee);
+      const dst = resolveCallee(qn);
+      if (dst) {
+        const srcSymbolName = currentCaller();
+        const meta = {};
+        if (srcSymbolName === null)
+          meta.scope = "module";
+        relations.push({
+          type: "calls",
+          srcFilePath: filePath,
+          srcSymbolName,
+          dstFilePath: dst.dstFilePath,
+          dstSymbolName: dst.dstSymbolName,
+          ...Object.keys(meta).length > 0 ? { metaJson: JSON.stringify(meta) } : {}
+        });
+      }
+      walk(call.callee);
+      for (const arg of call.arguments ?? [])
+        walk(arg);
+      return;
+    }
+    if (type === "NewExpression") {
+      const ctorCall = record;
+      const qn = getQualifiedName(ctorCall.callee);
+      const dst = resolveCallee(qn);
+      if (dst) {
+        const srcSymbolName = currentCaller();
+        const meta = { isNew: true };
+        if (srcSymbolName === null)
+          meta.scope = "module";
+        relations.push({
+          type: "calls",
+          srcFilePath: filePath,
+          srcSymbolName,
+          dstFilePath: dst.dstFilePath,
+          dstSymbolName: dst.dstSymbolName,
+          metaJson: JSON.stringify(meta)
+        });
+      }
+      for (const arg of ctorCall.arguments ?? [])
+        walk(arg);
+      return;
+    }
+    for (const key of Object.keys(record)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "scope")
+        continue;
+      const child = record[key];
+      if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+  }
+  walk(ast);
+  return relations;
+}
+
+// src/extractor/heritage-extractor.ts
+function extractHeritage(ast, filePath, importMap) {
+  const relations = [];
+  visit(ast, (node) => {
+    if (node.type === "TSInterfaceDeclaration") {
+      const interfaceName = node.id?.name ?? "AnonymousInterface";
+      const interfaces = node.extends ?? [];
+      for (const item of interfaces) {
+        const expr = item.expression ?? item;
+        const qn = getQualifiedName(expr);
+        if (!qn)
+          continue;
+        const rel = resolveHeritageDst(qn, filePath, importMap);
+        relations.push({
+          type: "extends",
+          srcFilePath: filePath,
+          srcSymbolName: interfaceName,
+          ...rel
+        });
+      }
+      return;
+    }
+    if (node.type !== "ClassDeclaration" && node.type !== "ClassExpression")
+      return;
+    const className = node.id?.name ?? "AnonymousClass";
+    if (node.superClass) {
+      const qn = getQualifiedName(node.superClass);
+      if (qn) {
+        const rel = resolveHeritageDst(qn, filePath, importMap);
+        relations.push({
+          type: "extends",
+          srcFilePath: filePath,
+          srcSymbolName: className,
+          ...rel
+        });
+      }
+    }
+    const impls = node.implements ?? [];
+    for (const impl of impls) {
+      const expr = impl.expression ?? impl;
+      const qn = getQualifiedName(expr);
+      if (!qn)
+        continue;
+      const rel = resolveHeritageDst(qn, filePath, importMap);
+      relations.push({
+        type: "implements",
+        srcFilePath: filePath,
+        srcSymbolName: className,
+        ...rel
+      });
+    }
+  });
+  return relations;
+}
+function resolveHeritageDst(qn, currentFilePath, importMap) {
+  const ref = importMap.get(qn.root);
+  if (ref) {
+    if (ref.importedName === "*") {
+      const dstSymbolName = qn.parts[qn.parts.length - 1] ?? qn.root;
+      return {
+        dstFilePath: ref.path,
+        dstSymbolName,
+        metaJson: JSON.stringify({ isNamespaceImport: true })
+      };
+    }
+    return {
+      dstFilePath: ref.path,
+      dstSymbolName: qn.parts.length > 0 ? qn.full : ref.importedName
+    };
+  }
+  return {
+    dstFilePath: currentFilePath,
+    dstSymbolName: qn.full,
+    metaJson: JSON.stringify({ isLocal: true })
+  };
+}
+
+// src/extractor/relation-extractor.ts
+function extractRelations(ast, filePath, tsconfigPaths) {
+  const importMap = buildImportMap(ast, filePath, tsconfigPaths);
+  const imports = extractImports(ast, filePath, tsconfigPaths);
+  const calls = extractCalls(ast, filePath, importMap);
+  const heritage = extractHeritage(ast, filePath, importMap);
+  return [...imports, ...calls, ...heritage];
+}
+
+// src/store/connection.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync, unlinkSync, existsSync } from "fs";
+import { dirname as dirname2, join } from "path";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
+
+// src/store/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  watcherOwner: () => watcherOwner,
+  symbols: () => symbols,
+  relations: () => relations,
+  files: () => files,
+  FTS_SETUP_SQL: () => FTS_SETUP_SQL
+});
+import { sql } from "drizzle-orm";
+import {
+  sqliteTable,
+  text,
+  integer,
+  real,
+  index,
+  primaryKey,
+  foreignKey,
+  check
+} from "drizzle-orm/sqlite-core";
+var files = sqliteTable("files", {
+  project: text("project").notNull(),
+  filePath: text("file_path").notNull(),
+  mtimeMs: real("mtime_ms").notNull(),
+  size: integer("size").notNull(),
+  contentHash: text("content_hash").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [primaryKey({ columns: [table.project, table.filePath] })]);
+var symbols = sqliteTable("symbols", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  project: text("project").notNull(),
+  filePath: text("file_path").notNull(),
+  kind: text("kind").notNull(),
+  name: text("name").notNull(),
+  startLine: integer("start_line").notNull(),
+  startColumn: integer("start_column").notNull(),
+  endLine: integer("end_line").notNull(),
+  endColumn: integer("end_column").notNull(),
+  isExported: integer("is_exported").notNull().default(0),
+  signature: text("signature"),
+  fingerprint: text("fingerprint"),
+  detailJson: text("detail_json"),
+  contentHash: text("content_hash").notNull(),
+  indexedAt: text("indexed_at").notNull()
+}, (table) => [
+  index("idx_symbols_project_file").on(table.project, table.filePath),
+  index("idx_symbols_project_kind").on(table.project, table.kind),
+  index("idx_symbols_project_name").on(table.project, table.name),
+  index("idx_symbols_fingerprint").on(table.project, table.fingerprint),
+  foreignKey({
+    columns: [table.project, table.filePath],
+    foreignColumns: [files.project, files.filePath]
+  }).onDelete("cascade")
+]);
+var relations = sqliteTable("relations", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  project: text("project").notNull(),
+  type: text("type").notNull(),
+  srcFilePath: text("src_file_path").notNull(),
+  srcSymbolName: text("src_symbol_name"),
+  dstFilePath: text("dst_file_path").notNull(),
+  dstSymbolName: text("dst_symbol_name"),
+  metaJson: text("meta_json")
+}, (table) => [
+  index("idx_relations_src").on(table.project, table.srcFilePath),
+  index("idx_relations_dst").on(table.project, table.dstFilePath),
+  index("idx_relations_type").on(table.project, table.type),
+  foreignKey({
+    columns: [table.project, table.srcFilePath],
+    foreignColumns: [files.project, files.filePath]
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [table.project, table.dstFilePath],
+    foreignColumns: [files.project, files.filePath]
+  }).onDelete("cascade")
+]);
+var watcherOwner = sqliteTable("watcher_owner", {
+  id: integer("id").primaryKey(),
+  pid: integer("pid").notNull(),
+  startedAt: text("started_at").notNull(),
+  heartbeatAt: text("heartbeat_at").notNull()
+}, (table) => [check("watcher_owner_singleton", sql`${table.id} = 1`)]);
+var FTS_SETUP_SQL = [
+  `CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
+     name,
+     file_path,
+     kind,
+     content=symbols,
+     content_rowid=id
+   )`,
+  `CREATE TRIGGER IF NOT EXISTS symbols_ai
+   AFTER INSERT ON symbols BEGIN
+     INSERT INTO symbols_fts(rowid, name, file_path, kind)
+     VALUES (new.id, new.name, new.file_path, new.kind);
+   END`,
+  `CREATE TRIGGER IF NOT EXISTS symbols_ad
+   AFTER DELETE ON symbols BEGIN
+     INSERT INTO symbols_fts(symbols_fts, rowid, name, file_path, kind)
+     VALUES ('delete', old.id, old.name, old.file_path, old.kind);
+   END`,
+  `CREATE TRIGGER IF NOT EXISTS symbols_au
+   AFTER UPDATE ON symbols BEGIN
+     INSERT INTO symbols_fts(symbols_fts, rowid, name, file_path, kind)
+     VALUES ('delete', old.id, old.name, old.file_path, old.kind);
+     INSERT INTO symbols_fts(rowid, name, file_path, kind)
+     VALUES (new.id, new.name, new.file_path, new.kind);
+   END`
+];
+
+// src/store/connection.ts
+class DbConnection {
+  client = null;
+  drizzle = null;
+  dbPath;
+  txDepth = 0;
+  constructor(opts) {
+    this.dbPath = join(opts.projectRoot, ".zipbul", "gildash.db");
+  }
+  get drizzleDb() {
+    if (!this.drizzle)
+      throw new StoreError("Database is not open. Call open() first.");
+    return this.drizzle;
+  }
+  open() {
+    try {
+      mkdirSync(dirname2(this.dbPath), { recursive: true });
+      this.client = new Database(this.dbPath);
+      this.client.run("PRAGMA journal_mode = WAL");
+      this.client.run("PRAGMA foreign_keys = ON");
+      this.client.run("PRAGMA busy_timeout = 5000");
+      this.drizzle = drizzle(this.client, { schema: exports_schema });
+      migrate(this.drizzle, {
+        migrationsFolder: join(import.meta.dirname, "migrations")
+      });
+      for (const sql2 of FTS_SETUP_SQL) {
+        this.client.run(sql2);
+      }
+    } catch (err) {
+      if (this.isCorruptionError(err) && existsSync(this.dbPath)) {
+        this.closeClient();
+        unlinkSync(this.dbPath);
+        for (const ext of ["-wal", "-shm"]) {
+          const p = this.dbPath + ext;
+          if (existsSync(p))
+            unlinkSync(p);
+        }
+        try {
+          this.open();
+          return;
+        } catch (retryErr) {
+          throw new StoreError(`Failed to recover database at ${this.dbPath}`, { cause: retryErr });
+        }
+      }
+      if (err instanceof StoreError)
+        throw err;
+      throw new StoreError(`Failed to open database at ${this.dbPath}`, { cause: err });
+    }
+  }
+  close() {
+    this.closeClient();
+    this.drizzle = null;
+  }
+  transaction(fn) {
+    const db = this.requireClient();
+    if (this.txDepth === 0) {
+      this.txDepth++;
+      try {
+        return db.transaction(() => fn(this))();
+      } finally {
+        this.txDepth--;
+      }
+    }
+    const sp = `sp_${this.txDepth++}`;
+    db.run(`SAVEPOINT "${sp}"`);
+    try {
+      const result = fn(this);
+      db.run(`RELEASE SAVEPOINT "${sp}"`);
+      return result;
+    } catch (err) {
+      db.run(`ROLLBACK TO SAVEPOINT "${sp}"`);
+      db.run(`RELEASE SAVEPOINT "${sp}"`);
+      throw err;
+    } finally {
+      this.txDepth--;
+    }
+  }
+  immediateTransaction(fn) {
+    const db = this.requireClient();
+    this.txDepth++;
+    db.run("BEGIN IMMEDIATE");
+    try {
+      const result = fn();
+      db.run("COMMIT");
+      return result;
+    } catch (err) {
+      db.run("ROLLBACK");
+      throw err;
+    } finally {
+      this.txDepth--;
+    }
+  }
+  query(sql2) {
+    const row = this.requireClient().prepare(sql2).get();
+    if (!row)
+      return null;
+    return Object.values(row)[0];
+  }
+  getTableNames() {
+    const rows = this.requireClient().query("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+    return rows.map((r) => r.name);
+  }
+  selectOwner() {
+    const row = this.requireClient().prepare("SELECT pid, heartbeat_at FROM watcher_owner WHERE id = 1").get();
+    return row ?? undefined;
+  }
+  insertOwner(pid) {
+    const now = new Date().toISOString();
+    this.requireClient().prepare("INSERT INTO watcher_owner (id, pid, started_at, heartbeat_at) VALUES (1, ?, ?, ?)").run(pid, now, now);
+  }
+  replaceOwner(pid) {
+    const now = new Date().toISOString();
+    this.requireClient().prepare("INSERT OR REPLACE INTO watcher_owner (id, pid, started_at, heartbeat_at) VALUES (1, ?, ?, ?)").run(pid, now, now);
+  }
+  touchOwner(pid) {
+    const now = new Date().toISOString();
+    this.requireClient().prepare("UPDATE watcher_owner SET heartbeat_at = ? WHERE id = 1 AND pid = ?").run(now, pid);
+  }
+  deleteOwner(pid) {
+    this.requireClient().prepare("DELETE FROM watcher_owner WHERE id = 1 AND pid = ?").run(pid);
+  }
+  requireClient() {
+    if (!this.client)
+      throw new StoreError("Database is not open. Call open() first.");
+    return this.client;
+  }
+  closeClient() {
+    if (this.client) {
+      this.client.close();
+      this.client = null;
+    }
+  }
+  isCorruptionError(err) {
+    if (!(err instanceof Error))
+      return false;
+    const msg = err.message.toLowerCase();
+    return msg.includes("malformed") || msg.includes("corrupt") || msg.includes("not a database") || msg.includes("disk i/o error") || msg.includes("sqlite_corrupt");
+  }
+}
+
+// src/store/repositories/file.repository.ts
+import { eq, and } from "drizzle-orm";
+class FileRepository {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  getFile(project, filePath) {
+    return this.db.drizzleDb.select().from(files).where(and(eq(files.project, project), eq(files.filePath, filePath))).get() ?? null;
+  }
+  upsertFile(record) {
+    this.db.drizzleDb.insert(files).values({
+      project: record.project,
+      filePath: record.filePath,
+      mtimeMs: record.mtimeMs,
+      size: record.size,
+      contentHash: record.contentHash,
+      updatedAt: record.updatedAt
+    }).onConflictDoUpdate({
+      target: [files.project, files.filePath],
+      set: {
+        mtimeMs: record.mtimeMs,
+        size: record.size,
+        contentHash: record.contentHash,
+        updatedAt: record.updatedAt
+      }
+    }).run();
+  }
+  getAllFiles(project) {
+    return this.db.drizzleDb.select().from(files).where(eq(files.project, project)).all();
+  }
+  getFilesMap(project) {
+    const rows = this.getAllFiles(project);
+    const map = new Map;
+    for (const r of rows)
+      map.set(r.filePath, r);
+    return map;
+  }
+  deleteFile(project, filePath) {
+    this.db.drizzleDb.delete(files).where(and(eq(files.project, project), eq(files.filePath, filePath))).run();
+  }
+}
+
+// src/store/repositories/symbol.repository.ts
+import { eq as eq2, and as and2, sql as sql2, count } from "drizzle-orm";
+
+// src/store/repositories/fts-utils.ts
+function toFtsPrefixQuery(text2) {
+  return text2.trim().split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0).map((token) => `"${token.replaceAll('"', '""')}"*`).join(" ");
+}
+
+// src/store/repositories/symbol.repository.ts
+class SymbolRepository {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  replaceFileSymbols(project, filePath, contentHash, syms) {
+    this.db.drizzleDb.delete(symbols).where(and2(eq2(symbols.project, project), eq2(symbols.filePath, filePath))).run();
+    if (!syms.length)
+      return;
+    const now = new Date().toISOString();
+    for (const sym of syms) {
+      this.db.drizzleDb.insert(symbols).values({
+        project,
+        filePath,
+        kind: sym.kind ?? "unknown",
+        name: sym.name ?? "",
+        startLine: sym.startLine ?? 0,
+        startColumn: sym.startColumn ?? 0,
+        endLine: sym.endLine ?? 0,
+        endColumn: sym.endColumn ?? 0,
+        isExported: sym.isExported ?? 0,
+        signature: sym.signature ?? null,
+        fingerprint: sym.fingerprint ?? null,
+        detailJson: sym.detailJson ?? null,
+        contentHash,
+        indexedAt: sym.indexedAt ?? now
+      }).run();
+    }
+  }
+  getFileSymbols(project, filePath) {
+    return this.db.drizzleDb.select().from(symbols).where(and2(eq2(symbols.project, project), eq2(symbols.filePath, filePath))).all();
+  }
+  searchByName(project, query, opts = {}) {
+    const limit = opts.limit ?? 50;
+    const ftsQuery = toFtsPrefixQuery(query);
+    if (!ftsQuery)
+      return [];
+    let builder = this.db.drizzleDb.select().from(symbols).where(and2(sql2`${symbols.id} IN (SELECT rowid FROM symbols_fts WHERE symbols_fts MATCH ${ftsQuery})`, eq2(symbols.project, project), opts.kind ? eq2(symbols.kind, opts.kind) : undefined)).orderBy(symbols.name).limit(limit);
+    return builder.all();
+  }
+  searchByKind(project, kind) {
+    return this.db.drizzleDb.select().from(symbols).where(and2(eq2(symbols.project, project), eq2(symbols.kind, kind))).orderBy(symbols.name).all();
+  }
+  getStats(project) {
+    const row = this.db.drizzleDb.select({
+      symbolCount: count(),
+      fileCount: sql2`COUNT(DISTINCT ${symbols.filePath})`
+    }).from(symbols).where(eq2(symbols.project, project)).get();
+    return {
+      symbolCount: row?.symbolCount ?? 0,
+      fileCount: row?.fileCount ?? 0
+    };
+  }
+  getByFingerprint(project, fingerprint) {
+    return this.db.drizzleDb.select().from(symbols).where(and2(eq2(symbols.project, project), eq2(symbols.fingerprint, fingerprint))).all();
+  }
+  deleteFileSymbols(project, filePath) {
+    this.db.drizzleDb.delete(symbols).where(and2(eq2(symbols.project, project), eq2(symbols.filePath, filePath))).run();
+  }
+  searchByQuery(opts) {
+    return this.db.drizzleDb.select().from(symbols).where(and2(opts.ftsQuery ? sql2`${symbols.id} IN (SELECT rowid FROM symbols_fts WHERE symbols_fts MATCH ${opts.ftsQuery})` : undefined, opts.project !== undefined ? eq2(symbols.project, opts.project) : undefined, opts.kind ? eq2(symbols.kind, opts.kind) : undefined, opts.filePath !== undefined ? eq2(symbols.filePath, opts.filePath) : undefined, opts.isExported !== undefined ? eq2(symbols.isExported, opts.isExported ? 1 : 0) : undefined)).orderBy(symbols.name).limit(opts.limit).all();
+  }
+}
+
+// src/store/repositories/relation.repository.ts
+import { eq as eq3, and as and3, isNull, or } from "drizzle-orm";
+class RelationRepository {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  replaceFileRelations(project, srcFilePath, rels) {
+    this.db.drizzleDb.delete(relations).where(and3(eq3(relations.project, project), eq3(relations.srcFilePath, srcFilePath))).run();
+    if (!rels.length)
+      return;
+    for (const rel of rels) {
+      this.db.drizzleDb.insert(relations).values({
+        project,
+        type: rel.type ?? "unknown",
+        srcFilePath: rel.srcFilePath ?? srcFilePath,
+        srcSymbolName: rel.srcSymbolName ?? null,
+        dstFilePath: rel.dstFilePath ?? "",
+        dstSymbolName: rel.dstSymbolName ?? null,
+        metaJson: rel.metaJson ?? null
+      }).run();
+    }
+  }
+  getOutgoing(project, srcFilePath, srcSymbolName) {
+    if (srcSymbolName !== undefined) {
+      return this.db.drizzleDb.select({
+        project: relations.project,
+        type: relations.type,
+        srcFilePath: relations.srcFilePath,
+        srcSymbolName: relations.srcSymbolName,
+        dstFilePath: relations.dstFilePath,
+        dstSymbolName: relations.dstSymbolName,
+        metaJson: relations.metaJson
+      }).from(relations).where(and3(eq3(relations.project, project), eq3(relations.srcFilePath, srcFilePath), or(eq3(relations.srcSymbolName, srcSymbolName), isNull(relations.srcSymbolName)))).all();
+    }
+    return this.db.drizzleDb.select({
+      project: relations.project,
+      type: relations.type,
+      srcFilePath: relations.srcFilePath,
+      srcSymbolName: relations.srcSymbolName,
+      dstFilePath: relations.dstFilePath,
+      dstSymbolName: relations.dstSymbolName,
+      metaJson: relations.metaJson
+    }).from(relations).where(and3(eq3(relations.project, project), eq3(relations.srcFilePath, srcFilePath))).all();
+  }
+  getIncoming(project, dstFilePath) {
+    return this.db.drizzleDb.select({
+      project: relations.project,
+      type: relations.type,
+      srcFilePath: relations.srcFilePath,
+      srcSymbolName: relations.srcSymbolName,
+      dstFilePath: relations.dstFilePath,
+      dstSymbolName: relations.dstSymbolName,
+      metaJson: relations.metaJson
+    }).from(relations).where(and3(eq3(relations.project, project), eq3(relations.dstFilePath, dstFilePath))).all();
+  }
+  getByType(project, type) {
+    return this.db.drizzleDb.select({
+      project: relations.project,
+      type: relations.type,
+      srcFilePath: relations.srcFilePath,
+      srcSymbolName: relations.srcSymbolName,
+      dstFilePath: relations.dstFilePath,
+      dstSymbolName: relations.dstSymbolName,
+      metaJson: relations.metaJson
+    }).from(relations).where(and3(eq3(relations.project, project), eq3(relations.type, type))).all();
+  }
+  deleteFileRelations(project, srcFilePath) {
+    this.db.drizzleDb.delete(relations).where(and3(eq3(relations.project, project), eq3(relations.srcFilePath, srcFilePath))).run();
+  }
+  searchRelations(opts) {
+    return this.db.drizzleDb.select({
+      project: relations.project,
+      type: relations.type,
+      srcFilePath: relations.srcFilePath,
+      srcSymbolName: relations.srcSymbolName,
+      dstFilePath: relations.dstFilePath,
+      dstSymbolName: relations.dstSymbolName,
+      metaJson: relations.metaJson
+    }).from(relations).where(and3(opts.project !== undefined ? eq3(relations.project, opts.project) : undefined, opts.srcFilePath !== undefined ? eq3(relations.srcFilePath, opts.srcFilePath) : undefined, opts.srcSymbolName !== undefined ? eq3(relations.srcSymbolName, opts.srcSymbolName) : undefined, opts.dstFilePath !== undefined ? eq3(relations.dstFilePath, opts.dstFilePath) : undefined, opts.dstSymbolName !== undefined ? eq3(relations.dstSymbolName, opts.dstSymbolName) : undefined, opts.type !== undefined ? eq3(relations.type, opts.type) : undefined)).limit(opts.limit).all();
+  }
+  retargetRelations(project, oldFile, oldSymbol, newFile, newSymbol) {
+    const condition = oldSymbol === null ? and3(eq3(relations.project, project), eq3(relations.dstFilePath, oldFile), isNull(relations.dstSymbolName)) : and3(eq3(relations.project, project), eq3(relations.dstFilePath, oldFile), eq3(relations.dstSymbolName, oldSymbol));
+    this.db.drizzleDb.update(relations).set({ dstFilePath: newFile, dstSymbolName: newSymbol }).where(condition).run();
+  }
+}
+
+// src/watcher/project-watcher.ts
+import { subscribe as parcelSubscribe } from "@parcel/watcher";
+import path from "path";
+var WATCHER_IGNORE_GLOBS = [
+  "**/.git/**",
+  "**/.zipbul/**",
+  "**/dist/**",
+  "**/node_modules/**"
+];
+var CONFIG_FILE_NAMES = new Set(["package.json", "tsconfig.json"]);
+function normalizePath(value) {
+  return value.replaceAll("\\", "/");
+}
+function mapEventType(type) {
+  if (type === "update") {
+    return "change";
+  }
+  if (type === "create") {
+    return "create";
+  }
+  return "delete";
+}
+
+class ProjectWatcher {
+  #subscription;
+  #rootPath;
+  #ignoreGlobs;
+  #extensions;
+  #subscribe;
+  #logger;
+  constructor(options, subscribeFn = parcelSubscribe, logger = console) {
+    this.#rootPath = options.projectRoot;
+    this.#ignoreGlobs = [...WATCHER_IGNORE_GLOBS, ...options.ignorePatterns ?? []];
+    this.#extensions = new Set((options.extensions ?? [".ts", ".mts", ".cts"]).map((ext) => ext.toLowerCase()));
+    this.#subscribe = subscribeFn;
+    this.#logger = logger;
+  }
+  async start(onChange) {
+    try {
+      this.#subscription = await this.#subscribe(this.#rootPath, (error, events) => {
+        if (error) {
+          this.#logger.error(new WatcherError("Callback error", { cause: error }));
+          return;
+        }
+        try {
+          for (const rawEvent of events) {
+            const relativePath = normalizePath(path.relative(this.#rootPath, rawEvent.path));
+            if (relativePath.startsWith("..")) {
+              continue;
+            }
+            const baseName = path.basename(relativePath);
+            const extension = path.extname(relativePath).toLowerCase();
+            const isConfigFile = CONFIG_FILE_NAMES.has(baseName);
+            if (!isConfigFile && !this.#extensions.has(extension)) {
+              continue;
+            }
+            if (relativePath.endsWith(".d.ts")) {
+              continue;
+            }
+            onChange({
+              eventType: mapEventType(rawEvent.type),
+              filePath: relativePath
+            });
+          }
+        } catch (callbackError) {
+          this.#logger.error(new WatcherError("Callback error", { cause: callbackError }));
+        }
+      }, {
+        ignore: this.#ignoreGlobs
+      });
+    } catch (error) {
+      throw new WatcherError("Failed to subscribe watcher", { cause: error });
+    }
+  }
+  async close() {
+    if (!this.#subscription) {
+      return;
+    }
+    try {
+      await this.#subscription.unsubscribe();
+      this.#subscription = undefined;
+    } catch (error) {
+      throw new WatcherError("Failed to close watcher", { cause: error });
+    }
+  }
+}
+
+// src/common/project-discovery.ts
+import path2 from "path";
+import { promises as fs } from "fs";
+var DISCOVERY_EXCLUDE = ["**/node_modules/**", "**/.git/**", "**/.zipbul/**", "**/dist/**"];
+async function discoverProjects(projectRoot) {
+  const boundaries = [];
+  for await (const relativePackageJson of fs.glob("**/package.json", {
+    cwd: projectRoot,
+    exclude: DISCOVERY_EXCLUDE
+  })) {
+    const packageDir = path2.dirname(relativePackageJson).replaceAll("\\", "/");
+    const packagePath = path2.join(projectRoot, relativePackageJson);
+    const content = await Bun.file(packagePath).json();
+    const packageName = typeof content?.name === "string" && content.name.length > 0 ? content.name : path2.basename(packageDir === "." ? projectRoot : packageDir);
+    boundaries.push({
+      dir: packageDir,
+      project: packageName
+    });
+  }
+  boundaries.sort((left, right) => right.dir.length - left.dir.length);
+  return boundaries;
+}
+function resolveFileProject(filePath, boundaries, rootProject = "default") {
+  const normalizedFilePath = filePath.replaceAll("\\", "/");
+  for (const boundary of boundaries) {
+    if (boundary.dir === ".") {
+      return boundary.project;
+    }
+    if (normalizedFilePath === boundary.dir || normalizedFilePath.startsWith(`${boundary.dir}/`)) {
+      return boundary.project;
+    }
+  }
+  return rootProject;
+}
+
+// src/common/tsconfig-resolver.ts
+import path3 from "path";
+var cache = new Map;
+async function readConfig(configPath) {
+  const file = Bun.file(configPath);
+  if (!await file.exists()) {
+    return null;
+  }
+  const parsed = await file.json();
+  return typeof parsed === "object" && parsed !== null ? parsed : null;
+}
+async function loadTsconfigPaths(projectRoot) {
+  if (cache.has(projectRoot)) {
+    return cache.get(projectRoot) ?? null;
+  }
+  const tsconfigPath = path3.join(projectRoot, "tsconfig.json");
+  const config = await readConfig(tsconfigPath);
+  if (!config) {
+    cache.set(projectRoot, null);
+    return null;
+  }
+  const compilerOptions = typeof config.compilerOptions === "object" && config.compilerOptions !== null ? config.compilerOptions : null;
+  if (!compilerOptions) {
+    cache.set(projectRoot, null);
+    return null;
+  }
+  const rawBaseUrl = typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : null;
+  const rawPaths = typeof compilerOptions.paths === "object" && compilerOptions.paths !== null ? compilerOptions.paths : null;
+  if (!rawBaseUrl && !rawPaths) {
+    cache.set(projectRoot, null);
+    return null;
+  }
+  const resolvedBaseUrl = rawBaseUrl ? path3.resolve(projectRoot, rawBaseUrl) : projectRoot;
+  const paths = new Map;
+  if (rawPaths) {
+    for (const [pattern, targets] of Object.entries(rawPaths)) {
+      if (!Array.isArray(targets)) {
+        continue;
+      }
+      const normalizedTargets = targets.filter((value) => typeof value === "string");
+      paths.set(pattern, normalizedTargets);
+    }
+  }
+  const result = {
+    baseUrl: resolvedBaseUrl,
+    paths
+  };
+  cache.set(projectRoot, result);
+  return result;
+}
+function clearTsconfigPathsCache(projectRoot) {
+  if (projectRoot) {
+    cache.delete(projectRoot);
+    return;
+  }
+  cache.clear();
+}
+
+// src/common/path-utils.ts
+import path4 from "path";
+function toRelativePath(projectRoot, absolutePath) {
+  return path4.relative(projectRoot, absolutePath).replaceAll("\\", "/");
+}
+function toAbsolutePath(projectRoot, relativePath) {
+  return path4.resolve(projectRoot, relativePath);
+}
+
+// src/common/hasher.ts
+function hashString(input) {
+  const raw = Bun.hash.xxHash64(input);
+  const unsigned = BigInt.asUintN(64, BigInt(raw));
+  return unsigned.toString(16).padStart(16, "0");
+}
+
+// src/indexer/file-indexer.ts
+import { promises as fsPromises } from "fs";
+import { join as join2 } from "path";
+async function detectChanges(opts) {
+  const { projectRoot, extensions, ignorePatterns, fileRepo } = opts;
+  const existingMap = fileRepo.getFilesMap();
+  const seenPaths = new Set;
+  const changed = [];
+  const unchanged = [];
+  const ignoreGlobs = ignorePatterns.map((p) => new Bun.Glob(p));
+  for await (const relativePath of fsPromises.glob("**/*", { cwd: projectRoot })) {
+    if (!extensions.some((ext) => relativePath.endsWith(ext)))
+      continue;
+    if (ignoreGlobs.some((g) => g.match(relativePath)))
+      continue;
+    seenPaths.add(relativePath);
+    const absPath = join2(projectRoot, relativePath);
+    const bunFile = Bun.file(absPath);
+    const { size, lastModified: mtimeMs } = bunFile;
+    const existing = existingMap.get(relativePath);
+    if (!existing) {
+      const text3 = await bunFile.text();
+      const contentHash2 = hashString(text3);
+      changed.push({ filePath: relativePath, contentHash: contentHash2, mtimeMs, size });
+      continue;
+    }
+    if (existing.mtimeMs === mtimeMs && existing.size === size) {
+      unchanged.push({ filePath: relativePath, contentHash: existing.contentHash, mtimeMs, size });
+      continue;
+    }
+    const text2 = await bunFile.text();
+    const contentHash = hashString(text2);
+    if (contentHash === existing.contentHash) {
+      unchanged.push({ filePath: relativePath, contentHash, mtimeMs, size });
+    } else {
+      changed.push({ filePath: relativePath, contentHash, mtimeMs, size });
+    }
+  }
+  const deleted = [];
+  for (const filePath of existingMap.keys()) {
+    if (!seenPaths.has(filePath)) {
+      deleted.push(filePath);
+    }
+  }
+  return { changed, unchanged, deleted };
+}
+
+// src/indexer/symbol-indexer.ts
+function buildSignature(sym) {
+  if (sym.kind === "function" || sym.kind === "method") {
+    const paramCount = sym.parameters?.length ?? 0;
+    const isAsync = sym.modifiers.includes("async") ? 1 : 0;
+    return `params:${paramCount}|async:${isAsync}`;
+  }
+  return null;
+}
+function buildDetailJson(sym) {
+  const detail = {};
+  if (sym.jsDoc)
+    detail.jsDoc = sym.jsDoc;
+  if (sym.kind === "function" || sym.kind === "method") {
+    if (sym.parameters !== undefined)
+      detail.parameters = sym.parameters;
+    if (sym.returnType !== undefined)
+      detail.returnType = sym.returnType;
+  }
+  if (sym.heritage?.length)
+    detail.heritage = sym.heritage;
+  if (sym.decorators?.length)
+    detail.decorators = sym.decorators;
+  if (sym.typeParameters?.length)
+    detail.typeParameters = sym.typeParameters;
+  if (sym.modifiers?.length)
+    detail.modifiers = sym.modifiers;
+  if (sym.members?.length)
+    detail.members = sym.members.map((m) => m.name);
+  return Object.keys(detail).length > 0 ? JSON.stringify(detail) : null;
+}
+function buildRow(sym, name, project, filePath, contentHash) {
+  const signature = buildSignature(sym);
+  const fingerprint = hashString(`${name}|${sym.kind}|${signature ?? ""}`);
+  return {
+    project,
+    filePath,
+    kind: sym.kind,
+    name,
+    startLine: sym.span.start.line,
+    startColumn: sym.span.start.column,
+    endLine: sym.span.end.line,
+    endColumn: sym.span.end.column,
+    isExported: sym.isExported ? 1 : 0,
+    signature,
+    fingerprint,
+    detailJson: buildDetailJson(sym),
+    contentHash,
+    indexedAt: new Date().toISOString()
+  };
+}
+function indexFileSymbols(opts) {
+  const { parsed, project, filePath, contentHash, symbolRepo } = opts;
+  const extracted = extractSymbols(parsed);
+  const rows = [];
+  for (const sym of extracted) {
+    rows.push(buildRow(sym, sym.name, project, filePath, contentHash));
+    for (const member of sym.members ?? []) {
+      rows.push(buildRow(member, `${sym.name}.${member.name}`, project, filePath, contentHash));
+    }
+  }
+  symbolRepo.replaceFileSymbols(project, filePath, contentHash, rows);
+}
+
+// src/indexer/relation-indexer.ts
+function indexFileRelations(opts) {
+  const { ast, project, filePath, relationRepo, projectRoot, tsconfigPaths } = opts;
+  const absFilePath = toAbsolutePath(projectRoot, filePath);
+  const rawRelations = extractRelations(ast, absFilePath, tsconfigPaths);
+  const rows = [];
+  for (const rel of rawRelations) {
+    const relDst = toRelativePath(projectRoot, rel.dstFilePath);
+    if (relDst.startsWith(".."))
+      continue;
+    const relSrc = toRelativePath(projectRoot, rel.srcFilePath);
+    rows.push({
+      project,
+      type: rel.type,
+      srcFilePath: relSrc,
+      srcSymbolName: rel.srcSymbolName ?? null,
+      dstFilePath: relDst,
+      dstSymbolName: rel.dstSymbolName ?? null,
+      metaJson: rel.metaJson ?? null
+    });
+  }
+  relationRepo.replaceFileRelations(project, filePath, rows);
+  return rows.length;
+}
+
+// src/indexer/index-coordinator.ts
+var WATCHER_DEBOUNCE_MS = 100;
+
+class IndexCoordinator {
+  opts;
+  logger;
+  callbacks = new Set;
+  indexingLock = false;
+  pendingEvents = [];
+  debounceTimer = null;
+  currentIndexing = null;
+  pendingFullIndex = false;
+  pendingFullIndexWaiters = [];
+  tsconfigPathsRaw;
+  boundariesRefresh = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.logger = opts.logger ?? console;
+    this.tsconfigPathsRaw = loadTsconfigPaths(opts.projectRoot);
+  }
+  get tsconfigPaths() {
+    return this.tsconfigPathsRaw;
+  }
+  fullIndex() {
+    return this.startIndex(undefined, true);
+  }
+  incrementalIndex(events) {
+    return this.startIndex(events, false);
+  }
+  onIndexed(cb) {
+    this.callbacks.add(cb);
+    return () => this.callbacks.delete(cb);
+  }
+  handleWatcherEvent(event) {
+    if (event.filePath.endsWith("tsconfig.json")) {
+      clearTsconfigPathsCache(this.opts.projectRoot);
+      this.tsconfigPathsRaw = loadTsconfigPaths(this.opts.projectRoot);
+      this.fullIndex().catch((err) => {
+        this.logger.error("[IndexCoordinator] fullIndex failed after tsconfig change:", err);
+      });
+      return;
+    }
+    if (event.filePath.endsWith("package.json")) {
+      const discover = this.opts.discoverProjectsFn ?? discoverProjects;
+      this.boundariesRefresh = discover(this.opts.projectRoot).then((b) => {
+        this.opts.boundaries = b;
+      });
+    }
+    this.pendingEvents.push(event);
+    if (this.debounceTimer === null) {
+      this.debounceTimer = setTimeout(() => {
+        this.debounceTimer = null;
+        this.flushPending();
+      }, WATCHER_DEBOUNCE_MS);
+    }
+  }
+  async shutdown() {
+    if (this.debounceTimer !== null) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.currentIndexing) {
+      await this.currentIndexing;
+    }
+  }
+  startIndex(events, useTransaction) {
+    if (this.indexingLock) {
+      if (useTransaction) {
+        this.pendingFullIndex = true;
+        return new Promise((resolve2, reject) => {
+          this.pendingFullIndexWaiters.push({ resolve: resolve2, reject });
+        });
+      }
+      return this.currentIndexing;
+    }
+    this.indexingLock = true;
+    const work = this.doIndex(events, useTransaction).then((result) => {
+      this.fireCallbacks(result);
+      return result;
+    }).finally(() => {
+      this.indexingLock = false;
+      this.currentIndexing = null;
+      if (this.pendingFullIndex) {
+        this.pendingFullIndex = false;
+        const waiters = this.pendingFullIndexWaiters.splice(0);
+        this.startIndex(undefined, true).then((result) => {
+          for (const waiter of waiters)
+            waiter.resolve(result);
+        }).catch((error) => {
+          for (const waiter of waiters)
+            waiter.reject(error);
+        });
+      } else if (this.pendingEvents.length > 0) {
+        const drained = this.pendingEvents.splice(0);
+        this.startIndex(drained, false).catch((err) => this.logger.error("[IndexCoordinator] incremental drain error", err));
+      }
+    });
+    this.currentIndexing = work;
+    return work;
+  }
+  async doIndex(events, useTransaction) {
+    const start = Date.now();
+    const { fileRepo, symbolRepo, relationRepo, dbConnection } = this.opts;
+    if (this.boundariesRefresh) {
+      await this.boundariesRefresh;
+      this.boundariesRefresh = null;
+    }
+    let changed;
+    let deleted;
+    if (events !== undefined) {
+      changed = events.filter((e) => e.eventType === "create" || e.eventType === "change").map((e) => ({
+        filePath: e.filePath,
+        contentHash: "",
+        mtimeMs: 0,
+        size: 0
+      }));
+      deleted = events.filter((e) => e.eventType === "delete").map((e) => e.filePath);
+    } else {
+      const existingMap = new Map;
+      for (const boundary of this.opts.boundaries) {
+        for (const [key, val] of fileRepo.getFilesMap(boundary.project)) {
+          existingMap.set(key, val);
+        }
+      }
+      const result = await detectChanges({
+        projectRoot: this.opts.projectRoot,
+        extensions: this.opts.extensions,
+        ignorePatterns: this.opts.ignorePatterns,
+        fileRepo: { getFilesMap: () => existingMap }
+      });
+      changed = result.changed;
+      deleted = result.deleted;
+    }
+    const tsconfigPaths = await this.tsconfigPathsRaw ?? undefined;
+    const deletedSymbols = new Map;
+    for (const filePath of deleted) {
+      const project = resolveFileProject(filePath, this.opts.boundaries);
+      const syms = symbolRepo.getFileSymbols(project, filePath);
+      deletedSymbols.set(filePath, syms);
+    }
+    const processDeleted = () => {
+      for (const filePath of deleted) {
+        const project = resolveFileProject(filePath, this.opts.boundaries);
+        symbolRepo.deleteFileSymbols(project, filePath);
+        relationRepo.deleteFileRelations(project, filePath);
+        fileRepo.deleteFile(project, filePath);
+      }
+    };
+    const processChanged = async () => {
+      let symbols2 = 0;
+      let relations2 = 0;
+      const failedFiles = [];
+      for (const file of changed) {
+        try {
+          const r = await this.processFile(file.filePath, file.contentHash || undefined, tsconfigPaths);
+          symbols2 += r.symbolCount;
+          relations2 += r.relCount;
+        } catch (err) {
+          this.logger.error(`[IndexCoordinator] Failed to index ${file.filePath}:`, err);
+          failedFiles.push(file.filePath);
+        }
+      }
+      return { symbols: symbols2, relations: relations2, failedFiles };
+    };
+    let totalSymbols = 0;
+    let totalRelations = 0;
+    let allFailedFiles = [];
+    if (useTransaction) {
+      const { projectRoot, boundaries } = this.opts;
+      const { parseCache } = this.opts;
+      const prereadResults = await Promise.allSettled(changed.map(async (file) => {
+        const absPath = toAbsolutePath(projectRoot, file.filePath);
+        const bunFile = Bun.file(absPath);
+        const text2 = await bunFile.text();
+        const contentHash = file.contentHash || hashString(text2);
+        return { filePath: file.filePath, text: text2, contentHash, mtimeMs: bunFile.lastModified, size: bunFile.size };
+      }));
+      const preread = prereadResults.filter((r) => r.status === "fulfilled").map((r) => r.value);
+      for (const r of prereadResults) {
+        if (r.status === "rejected") {
+          this.logger.error("[IndexCoordinator] Failed to pre-read file:", r.reason);
+        }
+      }
+      const parsedCacheEntries = [];
+      dbConnection.transaction(() => {
+        for (const boundary of boundaries) {
+          const projectFiles = fileRepo.getAllFiles(boundary.project);
+          for (const f of projectFiles) {
+            fileRepo.deleteFile(f.project, f.filePath);
+          }
+        }
+        const parseFn = this.opts.parseSourceFn ?? parseSource;
+        for (const fd of preread) {
+          const project = resolveFileProject(fd.filePath, boundaries);
+          const parsed = parseFn(toAbsolutePath(projectRoot, fd.filePath), fd.text);
+          parsedCacheEntries.push({ filePath: fd.filePath, parsed });
+          fileRepo.upsertFile({
+            project,
+            filePath: fd.filePath,
+            mtimeMs: fd.mtimeMs,
+            size: fd.size,
+            contentHash: fd.contentHash,
+            updatedAt: new Date().toISOString()
+          });
+          indexFileSymbols({ parsed, project, filePath: fd.filePath, contentHash: fd.contentHash, symbolRepo });
+          totalRelations += indexFileRelations({
+            ast: parsed.program,
+            project,
+            filePath: fd.filePath,
+            relationRepo,
+            projectRoot,
+            tsconfigPaths
+          });
+          totalSymbols += symbolRepo.getFileSymbols(project, fd.filePath).length;
+        }
+      });
+      for (const entry of parsedCacheEntries) {
+        parseCache.set(entry.filePath, entry.parsed);
+      }
+    } else {
+      processDeleted();
+      const counts = await processChanged();
+      totalSymbols = counts.symbols;
+      totalRelations = counts.relations;
+      allFailedFiles = counts.failedFiles;
+    }
+    if (!useTransaction) {
+      for (const [oldFile, syms] of deletedSymbols) {
+        for (const sym of syms) {
+          if (!sym.fingerprint)
+            continue;
+          const oldProject = resolveFileProject(oldFile, this.opts.boundaries);
+          const matches = symbolRepo.getByFingerprint(oldProject, sym.fingerprint);
+          if (matches.length === 1) {
+            const newSym = matches[0];
+            relationRepo.retargetRelations(oldProject, oldFile, sym.name, newSym.filePath, newSym.name);
+          }
+        }
+      }
+    }
+    return {
+      indexedFiles: changed.length,
+      removedFiles: deleted.length,
+      totalSymbols,
+      totalRelations,
+      durationMs: Date.now() - start,
+      changedFiles: changed.map((f) => f.filePath),
+      deletedFiles: [...deleted],
+      failedFiles: allFailedFiles
+    };
+  }
+  async processFile(filePath, knownHash, tsconfigPaths) {
+    const { projectRoot, boundaries } = this.opts;
+    const { fileRepo, symbolRepo, relationRepo, parseCache } = this.opts;
+    const absPath = toAbsolutePath(projectRoot, filePath);
+    const bunFile = Bun.file(absPath);
+    const text2 = await bunFile.text();
+    const contentHash = knownHash || hashString(text2);
+    const project = resolveFileProject(filePath, boundaries);
+    const parseFn = this.opts.parseSourceFn ?? parseSource;
+    const parsed = parseFn(absPath, text2);
+    parseCache.set(filePath, parsed);
+    fileRepo.upsertFile({
+      project,
+      filePath,
+      mtimeMs: bunFile.lastModified,
+      size: bunFile.size,
+      contentHash,
+      updatedAt: new Date().toISOString()
+    });
+    indexFileSymbols({ parsed, project, filePath, contentHash, symbolRepo });
+    const relCount = indexFileRelations({
+      ast: parsed.program,
+      project,
+      filePath,
+      relationRepo,
+      projectRoot,
+      tsconfigPaths
+    });
+    const symbolCount = symbolRepo.getFileSymbols(project, filePath).length;
+    return { symbolCount, relCount };
+  }
+  fireCallbacks(result) {
+    for (const cb of this.callbacks) {
+      try {
+        cb(result);
+      } catch (err) {
+        this.logger.error("[IndexCoordinator] onIndexed callback threw:", err);
+      }
+    }
+  }
+  flushPending() {
+    if (this.indexingLock) {
+      return;
+    }
+    if (this.pendingEvents.length > 0) {
+      const events = this.pendingEvents.splice(0);
+      this.startIndex(events, false).catch((err) => this.logger.error("[IndexCoordinator] flushPending startIndex error:", err));
+    }
+  }
+}
+
+// src/watcher/ownership.ts
+function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error && "code" in error) {
+      return error.code !== "ESRCH";
+    }
+    return true;
+  }
+}
+function toEpochMs(value) {
+  const ms = new Date(value).getTime();
+  return Number.isNaN(ms) ? 0 : ms;
+}
+function acquireWatcherRole(db, pid, options = {}) {
+  const now = options.now ?? Date.now;
+  const isAlive = options.isAlive ?? defaultIsAlive;
+  const staleAfterSeconds = options.staleAfterSeconds ?? 90;
+  return db.immediateTransaction(() => {
+    const owner = db.selectOwner();
+    if (!owner) {
+      db.insertOwner(pid);
+      return "owner";
+    }
+    const heartbeatAgeSeconds = Math.floor((now() - toEpochMs(owner.heartbeat_at)) / 1000);
+    if (isAlive(owner.pid) && heartbeatAgeSeconds < staleAfterSeconds) {
+      return "reader";
+    }
+    db.replaceOwner(pid);
+    return "owner";
+  });
+}
+function releaseWatcherRole(db, pid) {
+  db.deleteOwner(pid);
+}
+function updateHeartbeat(db, pid) {
+  db.touchOwner(pid);
+}
+
+// src/search/symbol-search.ts
+function symbolSearch(options) {
+  const { symbolRepo, project, query } = options;
+  const effectiveProject = query.project ?? project;
+  const limit = query.limit ?? 100;
+  const opts = {
+    kind: query.kind,
+    filePath: query.filePath,
+    isExported: query.isExported,
+    project: effectiveProject,
+    limit
+  };
+  if (query.text) {
+    const ftsQuery = toFtsPrefixQuery(query.text);
+    if (ftsQuery)
+      opts.ftsQuery = ftsQuery;
+  }
+  const records = symbolRepo.searchByQuery(opts);
+  return records.map((r) => ({
+    id: r.id,
+    filePath: r.filePath,
+    kind: r.kind,
+    name: r.name,
+    span: {
+      start: { line: r.startLine, column: r.startColumn },
+      end: { line: r.endLine, column: r.endColumn }
+    },
+    isExported: r.isExported === 1,
+    signature: r.signature,
+    fingerprint: r.fingerprint,
+    detail: r.detailJson ? (() => {
+      try {
+        return JSON.parse(r.detailJson);
+      } catch {
+        return {};
+      }
+    })() : {}
+  }));
+}
+
+// src/search/relation-search.ts
+function relationSearch(options) {
+  const { relationRepo, project, query } = options;
+  const effectiveProject = query.project ?? project;
+  const limit = query.limit ?? 500;
+  const records = relationRepo.searchRelations({
+    srcFilePath: query.srcFilePath,
+    srcSymbolName: query.srcSymbolName,
+    dstFilePath: query.dstFilePath,
+    dstSymbolName: query.dstSymbolName,
+    type: query.type,
+    project: effectiveProject,
+    limit
+  });
+  return records.map((r) => ({
+    type: r.type,
+    srcFilePath: r.srcFilePath,
+    srcSymbolName: r.srcSymbolName,
+    dstFilePath: r.dstFilePath,
+    dstSymbolName: r.dstSymbolName,
+    metaJson: r.metaJson ?? undefined
+  }));
+}
+
+// src/search/dependency-graph.ts
+class DependencyGraph {
+  options;
+  adjacencyList = new Map;
+  reverseAdjacencyList = new Map;
+  constructor(options) {
+    this.options = options;
+  }
+  build() {
+    this.adjacencyList = new Map;
+    this.reverseAdjacencyList = new Map;
+    const relations2 = this.options.relationRepo.getByType(this.options.project, "imports");
+    for (const rel of relations2) {
+      const { srcFilePath, dstFilePath } = rel;
+      if (!this.adjacencyList.has(srcFilePath)) {
+        this.adjacencyList.set(srcFilePath, new Set);
+      }
+      this.adjacencyList.get(srcFilePath).add(dstFilePath);
+      if (!this.reverseAdjacencyList.has(dstFilePath)) {
+        this.reverseAdjacencyList.set(dstFilePath, new Set);
+      }
+      this.reverseAdjacencyList.get(dstFilePath).add(srcFilePath);
+    }
+  }
+  getDependencies(filePath) {
+    return Array.from(this.adjacencyList.get(filePath) ?? []);
+  }
+  getDependents(filePath) {
+    return Array.from(this.reverseAdjacencyList.get(filePath) ?? []);
+  }
+  getTransitiveDependents(filePath) {
+    const visited = new Set;
+    const queue = [filePath];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      for (const dependent of this.reverseAdjacencyList.get(current) ?? []) {
+        if (!visited.has(dependent)) {
+          visited.add(dependent);
+          queue.push(dependent);
+        }
+      }
+    }
+    return Array.from(visited);
+  }
+  hasCycle() {
+    const visited = new Set;
+    const inPath = new Set;
+    for (const startNode of this.adjacencyList.keys()) {
+      if (visited.has(startNode))
+        continue;
+      const stack = [{ node: startNode, entered: false }];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.entered) {
+          inPath.delete(current.node);
+          continue;
+        }
+        if (inPath.has(current.node)) {
+          return true;
+        }
+        if (visited.has(current.node)) {
+          continue;
+        }
+        visited.add(current.node);
+        inPath.add(current.node);
+        stack.push({ node: current.node, entered: true });
+        for (const neighbor of this.adjacencyList.get(current.node) ?? []) {
+          if (inPath.has(neighbor)) {
+            return true;
+          }
+          if (!visited.has(neighbor)) {
+            stack.push({ node: neighbor, entered: false });
+          }
+        }
+      }
+    }
+    return false;
+  }
+  getAffectedByChange(changedFiles) {
+    const allAffected = new Set;
+    for (const file of changedFiles) {
+      for (const dep of this.getTransitiveDependents(file)) {
+        allAffected.add(dep);
+      }
+    }
+    return Array.from(allAffected);
+  }
+}
+
+// src/gildash.ts
+var HEARTBEAT_INTERVAL_MS = 30000;
+var HEALTHCHECK_INTERVAL_MS = 60000;
+var MAX_HEALTHCHECK_RETRIES = 10;
+
+class Gildash {
+  projectRoot;
+  db;
+  symbolRepo;
+  relationRepo;
+  parseCache;
+  coordinator;
+  watcher;
+  releaseWatcherRoleFn;
+  parseSourceFn;
+  extractSymbolsFn;
+  extractRelationsFn;
+  symbolSearchFn;
+  relationSearchFn;
+  logger;
+  defaultProject;
+  role;
+  timer = null;
+  signalHandlers = [];
+  closed = false;
+  tsconfigPaths = null;
+  boundaries = [];
+  onIndexedCallbacks = new Set;
+  constructor(opts) {
+    this.projectRoot = opts.projectRoot;
+    this.db = opts.db;
+    this.symbolRepo = opts.symbolRepo;
+    this.relationRepo = opts.relationRepo;
+    this.parseCache = opts.parseCache;
+    this.coordinator = opts.coordinator;
+    this.watcher = opts.watcher;
+    this.releaseWatcherRoleFn = opts.releaseWatcherRoleFn;
+    this.parseSourceFn = opts.parseSourceFn;
+    this.extractSymbolsFn = opts.extractSymbolsFn;
+    this.extractRelationsFn = opts.extractRelationsFn;
+    this.symbolSearchFn = opts.symbolSearchFn;
+    this.relationSearchFn = opts.relationSearchFn;
+    this.logger = opts.logger;
+    this.defaultProject = opts.defaultProject;
+    this.role = opts.role;
+  }
+  static async open(options) {
+    const {
+      projectRoot,
+      extensions = [".ts", ".mts", ".cts"],
+      ignorePatterns = [],
+      parseCacheCapacity = 500,
+      logger = console,
+      existsSyncFn = existsSync2,
+      dbConnectionFactory,
+      watcherFactory,
+      coordinatorFactory,
+      repositoryFactory,
+      acquireWatcherRoleFn = acquireWatcherRole,
+      releaseWatcherRoleFn = releaseWatcherRole,
+      updateHeartbeatFn = updateHeartbeat,
+      discoverProjectsFn = discoverProjects,
+      parseSourceFn = parseSource,
+      extractSymbolsFn = extractSymbols,
+      extractRelationsFn = extractRelations,
+      symbolSearchFn = symbolSearch,
+      relationSearchFn = relationSearch,
+      loadTsconfigPathsFn = loadTsconfigPaths
+    } = options;
+    if (!path5.isAbsolute(projectRoot)) {
+      throw new Error(`Gildash: projectRoot must be an absolute path, got: "${projectRoot}"`);
+    }
+    if (!existsSyncFn(projectRoot)) {
+      throw new Error(`Gildash: projectRoot does not exist: "${projectRoot}"`);
+    }
+    const db = dbConnectionFactory ? dbConnectionFactory() : new DbConnection({ projectRoot });
+    db.open();
+    try {
+      const boundaries = await discoverProjectsFn(projectRoot);
+      const defaultProject = boundaries[0]?.project ?? path5.basename(projectRoot);
+      const repos = repositoryFactory ? repositoryFactory() : (() => {
+        const connection = db;
+        return {
+          fileRepo: new FileRepository(connection),
+          symbolRepo: new SymbolRepository(connection),
+          relationRepo: new RelationRepository(connection),
+          parseCache: new ParseCache(parseCacheCapacity)
+        };
+      })();
+      const role = await Promise.resolve(acquireWatcherRoleFn(db, process.pid, {}));
+      let coordinator = null;
+      let watcher = null;
+      const instance = new Gildash({
+        projectRoot,
+        db,
+        symbolRepo: repos.symbolRepo,
+        relationRepo: repos.relationRepo,
+        parseCache: repos.parseCache,
+        coordinator,
+        watcher,
+        releaseWatcherRoleFn,
+        parseSourceFn,
+        extractSymbolsFn,
+        extractRelationsFn,
+        symbolSearchFn,
+        relationSearchFn,
+        logger,
+        defaultProject,
+        role
+      });
+      clearTsconfigPathsCache(projectRoot);
+      instance.tsconfigPaths = await loadTsconfigPathsFn(projectRoot);
+      instance.boundaries = boundaries;
+      if (role === "owner") {
+        const w = watcherFactory ? watcherFactory() : new ProjectWatcher({ projectRoot, ignorePatterns, extensions }, undefined, logger);
+        const c = coordinatorFactory ? coordinatorFactory() : new IndexCoordinator({
+          projectRoot,
+          boundaries,
+          extensions,
+          ignorePatterns,
+          dbConnection: db,
+          parseCache: repos.parseCache,
+          fileRepo: repos.fileRepo,
+          symbolRepo: repos.symbolRepo,
+          relationRepo: repos.relationRepo,
+          logger
+        });
+        instance.coordinator = c;
+        instance.watcher = w;
+        await w.start((event) => c.handleWatcherEvent?.(event));
+        const timer = setInterval(() => {
+          updateHeartbeatFn(db, process.pid);
+        }, HEARTBEAT_INTERVAL_MS);
+        instance.timer = timer;
+        await c.fullIndex();
+      } else {
+        let retryCount = 0;
+        const healthcheck = async () => {
+          try {
+            const newRole = await Promise.resolve(acquireWatcherRoleFn(db, process.pid, {}));
+            retryCount = 0;
+            if (newRole === "owner") {
+              clearInterval(instance.timer);
+              instance.timer = null;
+              let promotedWatcher = null;
+              let promotedCoordinator = null;
+              try {
+                promotedWatcher = watcherFactory ? watcherFactory() : new ProjectWatcher({ projectRoot, ignorePatterns, extensions }, undefined, logger);
+                promotedCoordinator = coordinatorFactory ? coordinatorFactory() : new IndexCoordinator({
+                  projectRoot,
+                  boundaries,
+                  extensions,
+                  ignorePatterns,
+                  dbConnection: db,
+                  parseCache: repos.parseCache,
+                  fileRepo: repos.fileRepo,
+                  symbolRepo: repos.symbolRepo,
+                  relationRepo: repos.relationRepo,
+                  logger
+                });
+                for (const cb of instance.onIndexedCallbacks) {
+                  promotedCoordinator.onIndexed(cb);
+                }
+                await promotedWatcher.start((event) => promotedCoordinator?.handleWatcherEvent?.(event));
+                const hbTimer = setInterval(() => {
+                  updateHeartbeatFn(db, process.pid);
+                }, HEARTBEAT_INTERVAL_MS);
+                instance.timer = hbTimer;
+                instance.coordinator = promotedCoordinator;
+                instance.watcher = promotedWatcher;
+                await promotedCoordinator.fullIndex();
+              } catch (setupErr) {
+                logger.error("[Gildash] owner promotion failed, reverting to reader", setupErr);
+                if (promotedWatcher) {
+                  await promotedWatcher.close().catch((e) => logger.error("[Gildash] watcher close error during promotion rollback", e));
+                  instance.watcher = null;
+                }
+                if (promotedCoordinator) {
+                  await promotedCoordinator.shutdown().catch((e) => logger.error("[Gildash] coordinator shutdown error during promotion rollback", e));
+                  instance.coordinator = null;
+                }
+                if (instance.timer === null) {
+                  instance.timer = setInterval(healthcheck, HEALTHCHECK_INTERVAL_MS);
+                }
+              }
+            }
+          } catch (err) {
+            retryCount++;
+            logger.error("[Gildash] healthcheck error", err);
+            if (retryCount >= MAX_HEALTHCHECK_RETRIES) {
+              logger.error("[Gildash] healthcheck failed too many times, shutting down");
+              clearInterval(instance.timer);
+              instance.timer = null;
+              instance.close().catch((closeErr) => logger.error("[Gildash] close error during healthcheck shutdown", closeErr));
+            }
+          }
+        };
+        const timer = setInterval(healthcheck, HEALTHCHECK_INTERVAL_MS);
+        instance.timer = timer;
+      }
+      const signals = ["SIGTERM", "SIGINT", "beforeExit"];
+      for (const sig of signals) {
+        const handler = () => {
+          instance.close().catch((err) => logger.error("[Gildash] close error during signal", sig, err));
+        };
+        if (sig === "beforeExit") {
+          process.on("beforeExit", handler);
+        } else {
+          process.on(sig, handler);
+        }
+        instance.signalHandlers.push([sig, handler]);
+      }
+      return instance;
+    } catch (err) {
+      db.close();
+      throw err;
+    }
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const closeErrors = [];
+    for (const [sig, handler] of this.signalHandlers) {
+      if (sig === "beforeExit") {
+        process.off("beforeExit", handler);
+      } else {
+        process.off(sig, handler);
+      }
+    }
+    this.signalHandlers = [];
+    if (this.coordinator) {
+      try {
+        await this.coordinator.shutdown();
+      } catch (err) {
+        closeErrors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    if (this.watcher) {
+      try {
+        await this.watcher.close();
+      } catch (err) {
+        closeErrors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    try {
+      this.releaseWatcherRoleFn(this.db, process.pid);
+    } catch (err) {
+      closeErrors.push(err instanceof Error ? err : new Error(String(err)));
+    }
+    try {
+      this.db.close();
+    } catch (err) {
+      closeErrors.push(err instanceof Error ? err : new Error(String(err)));
+    }
+    if (closeErrors.length > 0) {
+      throw new AggregateError(closeErrors, "Gildash: one or more errors occurred during close()");
+    }
+  }
+  onIndexed(callback) {
+    this.onIndexedCallbacks.add(callback);
+    if (!this.coordinator) {
+      return () => {
+        this.onIndexedCallbacks.delete(callback);
+      };
+    }
+    const unsubscribe = this.coordinator.onIndexed(callback);
+    return () => {
+      this.onIndexedCallbacks.delete(callback);
+      unsubscribe();
+    };
+  }
+  parseSource(filePath, sourceText) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    const parsed = this.parseSourceFn(filePath, sourceText);
+    this.parseCache.set(filePath, parsed);
+    return parsed;
+  }
+  extractSymbols(parsed) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.extractSymbolsFn(parsed);
+  }
+  extractRelations(parsed) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.extractRelationsFn(parsed.program, parsed.filePath, this.tsconfigPaths ?? undefined);
+  }
+  async reindex() {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    if (!this.coordinator) {
+      throw new Error("Gildash: reindex() is not available for readers");
+    }
+    return this.coordinator.fullIndex();
+  }
+  get projects() {
+    return [...this.boundaries];
+  }
+  getStats(project) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.symbolRepo.getStats(project ?? this.defaultProject);
+  }
+  searchSymbols(query) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.symbolSearchFn({ symbolRepo: this.symbolRepo, project: this.defaultProject, query });
+  }
+  searchRelations(query) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.relationSearchFn({ relationRepo: this.relationRepo, project: this.defaultProject, query });
+  }
+  getDependencies(filePath, project, limit = 1e4) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.relationSearchFn({
+      relationRepo: this.relationRepo,
+      project: project ?? this.defaultProject,
+      query: { srcFilePath: filePath, type: "imports", project: project ?? this.defaultProject, limit }
+    }).map((r) => r.dstFilePath);
+  }
+  getDependents(filePath, project, limit = 1e4) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    return this.relationSearchFn({
+      relationRepo: this.relationRepo,
+      project: project ?? this.defaultProject,
+      query: { dstFilePath: filePath, type: "imports", project: project ?? this.defaultProject, limit }
+    }).map((r) => r.srcFilePath);
+  }
+  async getAffected(changedFiles, project) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    const g = new DependencyGraph({
+      relationRepo: this.relationRepo,
+      project: project ?? this.defaultProject
+    });
+    await g.build();
+    return g.getAffectedByChange(changedFiles);
+  }
+  async hasCycle(project) {
+    if (this.closed)
+      throw new Error("Gildash: instance is closed");
+    const g = new DependencyGraph({
+      relationRepo: this.relationRepo,
+      project: project ?? this.defaultProject
+    });
+    await g.build();
+    return g.hasCycle();
+  }
+}
+export {
+  symbolSearch,
+  relationSearch,
+  WatcherError,
+  StoreError,
+  SearchError,
+  ParseError,
+  IndexError,
+  GildashError,
+  Gildash,
+  ExtractError,
+  DependencyGraph
+};
+
+//# debugId=C2664325F1F8637F64756E2164756E21
+//# sourceMappingURL=index.js.map