@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/freshness-3K6VU5OT.js

@@ -0,0 +1,174 @@
+import {
+  checkFileFreshness
+} from "./chunk-QLK6ED4Q.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lsp/freshness.ts
+import { watch, existsSync } from "fs";
+import { join } from "path";
+var DEBOUNCE_MS = 300;
+function createFreshnessMonitor(deps) {
+  const { projectId, projectPath, raw } = deps;
+  const log = deps.log ?? (() => {
+  });
+  let watcher = null;
+  let debounceTimer = null;
+  let reindexInFlight = Promise.resolve();
+  let stopped = false;
+  const pending = /* @__PURE__ */ new Map();
+  const lastReindex = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Set();
+  function fileIdFor(path) {
+    return deps.fileIdForPath(path);
+  }
+  function scheduleReindex() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      if (pending.size === 0) return;
+      const changes = Array.from(pending.entries()).map(([p, type]) => ({ path: p, type }));
+      pending.clear();
+      for (const c of changes) inFlight.add(c.path);
+      log("freshness: reindex starting", { count: changes.length });
+      reindexInFlight = (async () => {
+        try {
+          await reindexInFlight;
+        } catch {
+        }
+        try {
+          const res = await deps.reindex(changes);
+          const at = (/* @__PURE__ */ new Date()).toISOString();
+          for (const c of changes) {
+            inFlight.delete(c.path);
+            lastReindex.set(c.path, at);
+          }
+          log("freshness: reindex completed", { ...res });
+        } catch (error) {
+          log("freshness: reindex failed", { error: String(error) });
+        }
+      })();
+    }, DEBOUNCE_MS);
+  }
+  function onWatchEvent(path) {
+    if (stopped) return;
+    let type;
+    try {
+      type = existsSync(path) ? "modified" : "deleted";
+    } catch {
+      type = "deleted";
+    }
+    pending.set(path, type);
+    scheduleReindex();
+  }
+  return {
+    start() {
+      if (watcher || stopped) return;
+      try {
+        watcher = watch(projectPath, { persistent: false, recursive: true }, (_event, filename) => {
+          if (!filename) {
+            void this.fullScan();
+            return;
+          }
+          onWatchEvent(join(projectPath, filename));
+        });
+        watcher.on("error", (err) => {
+          log("freshness: watcher error, falling back to scan-on-read", { error: String(err) });
+          try {
+            watcher?.close();
+          } catch {
+          }
+          watcher = null;
+        });
+        log("freshness: watching", { projectPath, debounceMs: DEBOUNCE_MS });
+      } catch (error) {
+        log("freshness: watch unavailable, falling back to scan-on-read", { error: String(error) });
+        watcher = null;
+      }
+    },
+    async stop() {
+      stopped = true;
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      try {
+        watcher?.close();
+      } catch {
+      }
+      watcher = null;
+      await reindexInFlight.catch(() => {
+      });
+    },
+    async marker(fileId) {
+      let f = null;
+      try {
+        f = checkFileFreshness(raw, fileId);
+      } catch {
+      }
+      const path = f?.path;
+      const pendingReindex = path ? inFlight.has(path) || pending.has(path) : false;
+      const status = f ? f.status : "unknown";
+      return {
+        // unknown counts as stale: we cannot claim freshness for a file we
+        // cannot check. Silence is guilt (contract §4.3).
+        stale: status !== "fresh" || pendingReindex,
+        status,
+        pendingReindex,
+        lastReindexAt: path ? lastReindex.get(path) : void 0
+      };
+    },
+    async fullScan() {
+      const rows = raw.prepare("SELECT id, path FROM brain_file").all();
+      let stale = 0;
+      let missing = 0;
+      const changes = [];
+      for (const row of rows) {
+        const f = checkFileFreshness(raw, row.id);
+        if (!f) continue;
+        if (f.status === "stale") {
+          stale++;
+          changes.push({ path: row.path, type: "modified" });
+        }
+        if (f.status === "missing") {
+          missing++;
+          changes.push({ path: row.path, type: "deleted" });
+        }
+      }
+      if (changes.length > 0) {
+        for (const c of changes) inFlight.add(c.path);
+        const res = await deps.reindex(changes);
+        const at = (/* @__PURE__ */ new Date()).toISOString();
+        for (const c of changes) {
+          inFlight.delete(c.path);
+          lastReindex.set(c.path, at);
+        }
+        log("freshness: full scan reindex", { ...res });
+      }
+      return { checked: rows.length, stale, missing };
+    },
+    pendingFiles() {
+      return Array.from(/* @__PURE__ */ new Set([...pending.keys(), ...inFlight]));
+    },
+    async drain() {
+      const settle = () => new Promise((r) => setTimeout(r, 50));
+      await settle();
+      const deadline = Date.now() + DEBOUNCE_MS * 4 + 2e3;
+      while (Date.now() < deadline && (debounceTimer || pending.size > 0 || inFlight.size > 0)) {
+        if (debounceTimer) await new Promise((r) => setTimeout(r, Math.min(DEBOUNCE_MS, 100)));
+        await reindexInFlight.catch(() => {
+        });
+        if (pending.size === 0 && inFlight.size === 0 && !debounceTimer) {
+          await settle();
+          if (pending.size === 0 && inFlight.size === 0 && !debounceTimer) break;
+        }
+        await new Promise((r) => setTimeout(r, 25));
+      }
+      await reindexInFlight.catch(() => {
+      });
+    }
+  };
+}
+export {
+  DEBOUNCE_MS,
+  createFreshnessMonitor
+};

package/dist/graph-engine-PL5YA7BA.js

@@ -0,0 +1,21 @@
+import {
+  graphTraversal,
+  likeContains,
+  resolveGraphRoot,
+  resolveGraphRootDetailed,
+  traverseGraph
+} from "./chunk-47HKX4AJ.js";
+import "./chunk-UUNHHX4M.js";
+import "./chunk-KLK3PBTO.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-SM7RFQRO.js";
+import "./chunk-L5TDYKYK.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  graphTraversal,
+  likeContains,
+  resolveGraphRoot,
+  resolveGraphRootDetailed,
+  traverseGraph
+};

package/dist/graph_request-MM4REP6H.js

@@ -0,0 +1,350 @@
+import {
+  IDENTITY_TRAVERSABLE_TYPES,
+  memberFileMatches,
+  memberResolutionRecord,
+  resolveMemberIdentity
+} from "./chunk-VL52PL2T.js";
+import {
+  USAGE_COUNT_UNIT_LABEL,
+  isDeclarationRelationship
+} from "./chunk-GBI7V7KY.js";
+import {
+  graphTraversal
+} from "./chunk-47HKX4AJ.js";
+import "./chunk-UUNHHX4M.js";
+import "./chunk-KLK3PBTO.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-SM7RFQRO.js";
+import "./chunk-L5TDYKYK.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lsp/graph_usages.ts
+var USAGES_DECLARED_EXCLUSIONS = {
+  /** A stored row whose BOTH ends are this symbol — an analyzer artifact, not a
+   *  use of anything. Already excluded before this wave (the self-loop fix). */
+  selfReferentialRows: "an analyzer artifact: the row's source and target are the same symbol",
+  /** `contains`/`exports` — how a symbol is DECLARED, never who uses it.
+   *  `Greeter contains greet` is not `Greeter` USING `greet`; it is `greet` being
+   *  a member of `Greeter`. Serving the declaration containment as a caller
+   *  listed a class among the users of its own member, which is the exact
+   *  inversion the vocabulary exists to prevent (src/lsp/relations.ts:
+   *  "a declaration is never a usage"). Measured: `Greeter` was rendered as a
+   *  caller of `greet`.
+   *
+   *  WHY HERE AND NOT IN THE ENGINE'S DEFAULT TYPE LIST: the traversal must walk
+   *  `contains` — a graph rooted at a class cannot reach that class's own
+   *  methods without it (src/intelligence/graph/graph-engine.ts:28-30, where
+   *  dropping it was measured as structural damage). The exclusion is a property
+   *  of the USAGES vocabulary, not of the walk, so it belongs at the usages
+   *  grouping — the module the codebase already calls "the SINGLE owner of the
+   *  grouping" — and `mode: "graph"` keeps serving every stored kind. */
+  declarationContainments: "declaration containments (contains/exports) declare a symbol; they are never usages of it",
+  /** NEW (T3 cross-surface defect): rows the traversal reached only THROUGH the
+   *  owning declaration, a containment walk, or a chain this answer does not
+   *  serve. The owner cascade is right for the graph panel (a class graph must
+   *  reach its members), but in a CALLERS list it made every member inherit the
+   *  whole class's referrers — measured: a method with ZERO callers answered
+   *  six, one per class method's callers plus the class's own instantiators; and
+   *  the class's caller list carried a member's own call re-attributed to the
+   *  class. A "caller" that does not name this symbol is not a caller of it.
+   *  Omitted, counted in `declaredExclusions.counts.*.ownerFamilyRows`, never
+   *  silent. */
+  ownerFamilyRows: "rows reached only through the symbol's owning declaration, a containment walk or a chain that is not served \u2014 they do not name this symbol, so they are not usages of it (the owner-family cascade made a zero-caller method report six callers)"
+};
+function classifyFileLevel(raw) {
+  const imports = [];
+  const exports = [];
+  for (const row of raw) {
+    const entry = { rowId: row.rowId, relationshipType: row.relationshipType, moduleSpecifier: row.moduleSpecifier ?? "", confidence: row.confidence };
+    if (row.relationshipType === "imports" || row.relationshipType === "part_of") imports.push(entry);
+    else if (row.relationshipType === "exports") exports.push(entry);
+    else throw new Error(`bb/graph: file-level classifier received unexpected relationship_type ${row.relationshipType} (row ${row.rowId})`);
+  }
+  imports.sort((a, b) => a.moduleSpecifier.localeCompare(b.moduleSpecifier) || a.rowId.localeCompare(b.rowId));
+  exports.sort((a, b) => a.moduleSpecifier.localeCompare(b.moduleSpecifier) || a.rowId.localeCompare(b.rowId));
+  return { imports, exports };
+}
+function typeCounts(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.relationshipType, (map.get(row.relationshipType) ?? 0) + 1);
+  return [...map.entries()].map(([type, occurrences]) => ({ type, occurrences })).sort((a, b) => a.type.localeCompare(b.type) || b.occurrences - a.occurrences);
+}
+function sortedGroups(groups) {
+  return [...groups].sort(
+    (a, b) => a.file.localeCompare(b.file) || a.name.localeCompare(b.name) || a.symbolId.localeCompare(b.symbolId)
+  );
+}
+function groupSide(edges, nodes, pick, parentOf) {
+  const byNode = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const nodeId = pick(edge);
+    const node = nodes[nodeId];
+    if (node === void 0) {
+      throw new Error(`bb/graph: usages grouping consistency failure \u2014 edge ${edge.from} -> ${edge.to} has no registered node ${nodeId}`);
+    }
+    const parentId = parentOf(edge);
+    if (nodes[parentId] === void 0) {
+      throw new Error(`bb/graph: usages grouping consistency failure \u2014 edge ${edge.from} -> ${edge.to} has no registered parent node ${parentId}`);
+    }
+    let group = byNode.get(nodeId);
+    if (group === void 0) {
+      group = {
+        symbolId: node.id,
+        name: node.name,
+        file: node.file,
+        language: node.language,
+        symbolType: node.symbolType,
+        line: node.line,
+        isExternal: node.isExternal,
+        relationshipTypes: [],
+        occurrences: 0,
+        rows: []
+      };
+      byNode.set(nodeId, group);
+    }
+    group.rows.push({
+      rowId: edge.rowId,
+      relationshipType: edge.relationshipType,
+      callSite: edge.callSite,
+      depth: edge.depth,
+      confidence: edge.confidence,
+      isCrossLanguage: edge.isCrossLanguage,
+      bridgeMechanism: edge.bridgeMechanism,
+      evidenceClass: edge.metadata?.evidenceClass,
+      enrichment: edge.metadata?.enrichment,
+      parentSymbolId: parentId,
+      parentName: nodes[parentId].name
+    });
+  }
+  return byNode;
+}
+function finalize(byNode) {
+  const groups = [...byNode.values()];
+  for (const g of groups) {
+    g.rows.sort((a, b) => a.relationshipType.localeCompare(b.relationshipType) || a.rowId.localeCompare(b.rowId));
+    g.relationshipTypes = typeCounts(g.rows);
+    g.occurrences = g.rows.length;
+  }
+  return sortedGroups(groups);
+}
+function directUsageRows(edges, direction, rootId) {
+  const rendered = [];
+  const excluded = { selfReferentialRows: 0, declarationContainments: 0, ownerFamilyRows: 0 };
+  const servedGroupIds = /* @__PURE__ */ new Set();
+  const deferred = [];
+  const namesRoot = (edge) => direction === "caller" ? edge.to === rootId && edge.targetMatch !== "owner-cascade" : edge.from === rootId;
+  const groupOf = (edge) => direction === "caller" ? edge.from : edge.to;
+  for (const edge of edges) {
+    if (edge.from === edge.to) {
+      excluded.selfReferentialRows++;
+      continue;
+    }
+    if (isDeclarationRelationship(edge.relationshipType)) {
+      excluded.declarationContainments++;
+      continue;
+    }
+    const rowDepth = edge.depth;
+    if (namesRoot(edge)) {
+      if (!rendered.some((r) => r.rowId === edge.rowId)) rendered.push(edge);
+      servedGroupIds.add(groupOf(edge));
+    } else if (rowDepth === 0) {
+      excluded.ownerFamilyRows++;
+    } else {
+      deferred.push(edge);
+    }
+  }
+  for (const edge of deferred) {
+    const parentId = direction === "caller" ? edge.to : edge.from;
+    const extendsServedChain = servedGroupIds.has(parentId) && (direction === "caller" ? edge.targetMatch !== "owner-cascade" : true);
+    if (extendsServedChain) rendered.push(edge);
+    else excluded.ownerFamilyRows++;
+  }
+  return { rendered, excluded };
+}
+function groupUsagesEdges(result) {
+  const rootId = result.root.id;
+  const callerSide = directUsageRows(result.callers ?? [], "caller", rootId);
+  const calleeSide = directUsageRows(result.callees ?? [], "callee", rootId);
+  const callerMap = groupSide(callerSide.rendered, result.nodes ?? {}, (e) => e.from, (e) => e.to);
+  const calleeMap = groupSide(calleeSide.rendered, result.nodes ?? {}, (e) => e.to, (e) => e.from);
+  return {
+    callers: finalize(callerMap),
+    callees: finalize(calleeMap),
+    exclusions: { caller: callerSide.excluded, callee: calleeSide.excluded },
+    candidateRows: { caller: (result.callers ?? []).length, callee: (result.callees ?? []).length }
+  };
+}
+function buildGroupedUsages(result, fileLevel) {
+  const { callers, callees, exclusions, candidateRows } = groupUsagesEdges(result);
+  const crossLanguageGroups = [...callers, ...callees].filter((g) => g.rows.some((r) => r.isCrossLanguage)).length;
+  const root = result.root;
+  const sections = { imports: fileLevel.imports, exports: fileLevel.exports, dependencies: fileLevel.dependencies ?? [] };
+  return {
+    root: { symbolId: root.id, name: root.name, file: root.file, language: root.language, line: root.line },
+    callers,
+    callees,
+    fileLevel: sections,
+    counts: {
+      callerGroups: callers.length,
+      calleeGroups: callees.length,
+      callerRows: callers.reduce((n, g) => n + g.rows.length, 0),
+      calleeRows: callees.reduce((n, g) => n + g.rows.length, 0),
+      fileLevelRows: sections.imports.length + sections.exports.length + sections.dependencies.length,
+      fileDependencyRows: sections.dependencies.length,
+      callerCandidateRows: candidateRows.caller,
+      calleeCandidateRows: candidateRows.callee
+    },
+    summary: {
+      truncated: result.summary.truncated,
+      truncationReason: result.summary.truncationReason,
+      crossLanguageGroups
+    },
+    declaredExclusions: { ...USAGES_DECLARED_EXCLUSIONS, counts: exclusions },
+    countUnit: USAGE_COUNT_UNIT_LABEL,
+    annotations: result.annotations
+  };
+}
+
+// src/lsp/graph_request.ts
+var GRAPH_REQUEST_METHOD = "bb/graph";
+var GRAPH_SCHEMA_VERSION = 2;
+var GRAPH_MODE_GRAPH = "graph";
+var GRAPH_MODE_USAGES = "usages";
+var HUB_USAGES_MAX_DEPTH = 5;
+var GraphRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GraphRequestError";
+  }
+};
+function isIndexedWorkspace(db, projectId) {
+  try {
+    const row = db.prepare("SELECT 1 AS ok FROM brain_symbol WHERE project_id = ? LIMIT 1").get(projectId);
+    return row !== void 0 && row !== null;
+  } catch {
+    return false;
+  }
+}
+async function resolveTraversalRoot(deps, db, projectId, params) {
+  const file = typeof params.file === "string" && params.file.length > 0 ? params.file : void 0;
+  const opts = () => ({
+    direction: params.direction ?? (params.mode === GRAPH_MODE_USAGES ? "both" : void 0),
+    maxDepth: params.maxDepth,
+    relationshipTypes: params.relationshipTypes,
+    includeCrossLanguage: params.includeCrossLanguage
+  });
+  try {
+    const r = await deps.traverse(projectId, params.symbol, opts());
+    const rootType = r.root?.symbolType ?? "";
+    if (rootType && !IDENTITY_TRAVERSABLE_TYPES.includes(rootType)) {
+      const owner = (deps.resolveMember ?? resolveMemberIdentity)(db, projectId, params.symbol, file);
+      if (owner === null) {
+        throw new GraphRequestError(
+          `bb/graph: symbol '${params.symbol}' is not a traversable root (${rootType}) \u2014 no graph exists for it (declared error: the symbol was not found as a traversable root)`
+        );
+      }
+      const rr = await deps.traverse(projectId, owner.name, opts());
+      rr.resolution = memberResolutionRecord(params.symbol, owner.name, file);
+      return rr;
+    }
+    if (file && typeof r.root?.file === "string" && r.root.file !== "" && !memberFileMatches(file, r.root.file)) {
+      throw new GraphRequestError(
+        `bb/graph: symbol '${params.symbol}' resolves to a member in '${r.root.file}' but the hover's identity is '${file}' \u2014 the hinted symbol was not found at that identity; refusing the silent relabel (declared error)`
+      );
+    }
+    return r;
+  } catch (error) {
+    const owner = (deps.resolveMember ?? resolveMemberIdentity)(db, projectId, params.symbol, file);
+    if (owner === null) {
+      const detail = error instanceof Error ? error.message : String(error);
+      if (/^Symbol '.+' not found$/.test(detail)) {
+        throw new GraphRequestError(
+          `bb/graph: symbol '${params.symbol}' not found \u2014 no graph exists (declared error; run \`bb index\` or check the name)`
+        );
+      }
+      throw error;
+    }
+    const r = await deps.traverse(projectId, owner.name, opts());
+    r.resolution = memberResolutionRecord(params.symbol, owner.name, file);
+    return r;
+  }
+}
+async function handleGraphRequest(db, projectId, params, deps = { traverse: graphTraversal }) {
+  if (params === null || typeof params !== "object" || Array.isArray(params)) {
+    throw new GraphRequestError("bb/graph: params must be an object carrying schemaVersion and symbol");
+  }
+  if (params.schemaVersion !== GRAPH_SCHEMA_VERSION) {
+    throw new GraphRequestError(
+      `bb/graph: schema version mismatch \u2014 request carries ${JSON.stringify(params.schemaVersion) ?? "nothing"}, server implements ${GRAPH_SCHEMA_VERSION} (upgrade the client or pin bbLsp.graphSchemaVersion)`
+    );
+  }
+  if (typeof params.symbol !== "string" || params.symbol.length === 0) {
+    throw new GraphRequestError("bb/graph: params.symbol (non-empty string) is required");
+  }
+  if (params.mode !== void 0 && params.mode !== GRAPH_MODE_GRAPH && params.mode !== GRAPH_MODE_USAGES) {
+    throw new GraphRequestError('bb/graph: params.mode must be "graph" or "usages"');
+  }
+  if (params.direction !== void 0 && (params.direction !== "callers" && params.direction !== "callees" && params.direction !== "both")) {
+    throw new GraphRequestError('bb/graph: params.direction must be "callers", "callees", or "both"');
+  }
+  const effectiveDirection = params.direction ?? (params.mode === GRAPH_MODE_USAGES ? "both" : void 0);
+  const requestedDepth = params.maxDepth === void 0 && params.mode === GRAPH_MODE_USAGES ? HUB_USAGES_MAX_DEPTH : params.maxDepth;
+  if (params.maxDepth !== void 0 && (typeof params.maxDepth !== "number" || !Number.isInteger(params.maxDepth) || params.maxDepth < 1 || params.maxDepth > 10)) {
+    throw new GraphRequestError("bb/graph: params.maxDepth must be an integer in [1, 10]");
+  }
+  if (params.relationshipTypes !== void 0) {
+    if (!Array.isArray(params.relationshipTypes) || params.relationshipTypes.some((t) => typeof t !== "string" || t.length === 0)) {
+      throw new GraphRequestError("bb/graph: params.relationshipTypes must be an array of non-empty strings");
+    }
+  }
+  if (params.includeCrossLanguage !== void 0 && typeof params.includeCrossLanguage !== "boolean") {
+    throw new GraphRequestError("bb/graph: params.includeCrossLanguage must be a boolean");
+  }
+  if (db === null || !isIndexedWorkspace(db, projectId)) {
+    throw new GraphRequestError("bb/graph: workspace is not indexed \u2014 run `bb index` first (declared error: an unindexed workspace has no graph to serve)");
+  }
+  const result = await resolveTraversalRoot(deps, db, projectId, params);
+  for (const edge of [...result.callers ?? [], ...result.callees ?? []]) {
+    if (typeof edge.rowId !== "string" || edge.rowId.length === 0) {
+      throw new GraphRequestError(`bb/graph: internal consistency failure \u2014 edge ${edge.from} -> ${edge.to} has no brain_relationship row id (refusing to serve untraceable data)`);
+    }
+  }
+  try {
+    const root = result.root;
+    const rootQualified = root?.id ? db.prepare("SELECT qualified_name FROM brain_symbol WHERE id = ?").get(root.id)?.qualified_name ?? null : null;
+    const annRows = db.prepare(
+      "SELECT author_class, tool_identity, body, time_updated FROM brain_annotation WHERE project_id = ? AND (symbol_name = ? OR symbol_name = ?) AND (symbol_path IS NULL OR symbol_path = ? OR symbol_path = ?) ORDER BY time_updated DESC, id"
+    ).all(projectId, root?.name ?? "", rootQualified, root?.file ?? "", root?.filePath ?? "");
+    result.annotations = annRows;
+  } catch {
+    ;
+    result.annotations = [];
+  }
+  if (params.mode === GRAPH_MODE_USAGES) {
+    const rootNode = result.root;
+    const fileLevelRaw = db.prepare(
+      "SELECT id AS rowId, relationship_type AS relationshipType, target_external AS moduleSpecifier, confidence FROM brain_relationship WHERE project_id = ? AND source_symbol_id IS NULL AND target_symbol_id = ? AND relationship_type IN ('imports', 'exports', 'part_of')"
+    ).all(projectId, rootNode.id);
+    const fileLevel = classifyFileLevel(fileLevelRaw);
+    const fileDepsRaw = db.prepare(
+      "SELECT id AS rowId, relationship_type AS relationshipType, target_external AS moduleSpecifier, confidence FROM brain_relationship WHERE project_id = ? AND relationship_type IN ('imports', 'part_of') AND source_symbol_id IS NULL AND target_symbol_id IS NULL AND source_external = ?"
+    ).all(projectId, rootNode.file);
+    const dependencies = classifyFileLevel(fileDepsRaw).imports;
+    const grouped = buildGroupedUsages(result, { ...fileLevel, dependencies });
+    const res = result.resolution;
+    if (res !== void 0) grouped.resolution = res;
+    return grouped;
+  }
+  return result;
+}
+export {
+  GRAPH_MODE_GRAPH,
+  GRAPH_MODE_USAGES,
+  GRAPH_REQUEST_METHOD,
+  GRAPH_SCHEMA_VERSION,
+  GraphRequestError,
+  HUB_USAGES_MAX_DEPTH,
+  handleGraphRequest,
+  isIndexedWorkspace
+};

package/dist/impact_request-WDE47IZ5.js

@@ -0,0 +1,68 @@
+import {
+  IMPACT_BUDGET,
+  computeImpact
+} from "./chunk-BHB7BYYI.js";
+import "./chunk-VL52PL2T.js";
+import "./chunk-RCMTFSEF.js";
+import "./chunk-47HKX4AJ.js";
+import "./chunk-UUNHHX4M.js";
+import "./chunk-KLK3PBTO.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-SM7RFQRO.js";
+import "./chunk-L5TDYKYK.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lsp/impact_request.ts
+var IMPACT_REQUEST_METHOD = "bb/impact";
+var IMPACT_SCHEMA_VERSION = 1;
+var ImpactRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ImpactRequestError";
+  }
+};
+var IMPACT_REQUEST_BUDGET = IMPACT_BUDGET;
+async function handleImpactRequest(db, projectId, params, deps = { compute: computeImpact }) {
+  if (params === null || typeof params !== "object" || Array.isArray(params)) {
+    throw new ImpactRequestError("bb/impact: params must be an object carrying schemaVersion and symbol");
+  }
+  if (params.schemaVersion !== IMPACT_SCHEMA_VERSION) {
+    throw new ImpactRequestError(
+      `bb/impact: schema version mismatch \u2014 request carries ${JSON.stringify(params.schemaVersion) ?? "nothing"}, server implements ${IMPACT_SCHEMA_VERSION} (upgrade the client) or pin bbLsp.impactSchemaVersion)`
+    );
+  }
+  if (typeof params.symbol !== "string" || params.symbol.length === 0) {
+    throw new ImpactRequestError("bb/impact: params.symbol (non-empty string) is required");
+  }
+  if (db === null) {
+    throw new ImpactRequestError(
+      "bb/impact: workspace is not indexed \u2014 run `bb index` first (declared error: an unindexed workspace has no impact to serve)"
+    );
+  }
+  try {
+    return await deps.compute(
+      db,
+      projectId,
+      params.symbol,
+      {},
+      typeof params.file === "string" && params.file.length > 0 ? params.file : void 0
+    );
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("bb/impact:")) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("not found") || message.includes("unknown symbol") || message.includes("cannot be resolved")) {
+      throw new ImpactRequestError(
+        `bb/impact: symbol "${params.symbol}" is not in the index \u2014 hover a symbol that was indexed (re-run \`bb index\` if it should be)`
+      );
+    }
+    throw new ImpactRequestError(`bb/impact: ${message}`);
+  }
+}
+export {
+  IMPACT_REQUEST_BUDGET,
+  IMPACT_REQUEST_METHOD,
+  IMPACT_SCHEMA_VERSION,
+  ImpactRequestError,
+  handleImpactRequest
+};

package/dist/index-space-IUUN5WYV.js

@@ -0,0 +1,15 @@
+import {
+  checkpointWal,
+  formatSpace,
+  reclaimSpace,
+  shouldVacuumAfterWipe,
+  spaceReport
+} from "./chunk-DYM4FQEE.js";
+import "./chunk-MLKGABMK.js";
+export {
+  checkpointWal,
+  formatSpace,
+  reclaimSpace,
+  shouldVacuumAfterWipe,
+  spaceReport
+};

package/dist/index-status-6BD7UBHR.js

@@ -0,0 +1,34 @@
+import {
+  INDEX_RUN_PHASES,
+  INDEX_STATUS_SCHEMA_VERSION,
+  RESUMABLE_PHASES,
+  TERMINAL_PHASES,
+  clearStatus,
+  composeStatus,
+  decideResume,
+  isRunPhase,
+  readIndexCheckpoint,
+  readLastRun,
+  readLiveStatus,
+  statusPath,
+  writeLiveStatus
+} from "./chunk-VURYFIHW.js";
+import "./chunk-KLK3PBTO.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  INDEX_RUN_PHASES,
+  INDEX_STATUS_SCHEMA_VERSION,
+  RESUMABLE_PHASES,
+  TERMINAL_PHASES,
+  clearStatus,
+  composeStatus,
+  decideResume,
+  isRunPhase,
+  readIndexCheckpoint,
+  readLastRun,
+  readLiveStatus,
+  statusPath,
+  writeLiveStatus
+};