@titan-design/code-read 0.1.9 → 0.2.0

package/dist/chunk-VXQFCVGB.js

@@ -1,1326 +0,0 @@
-// src/query/contract.ts
-import { toJSONSchema, z as z4 } from "zod";
-
-// src/query/schemas.ts
-import { z } from "zod";
-var NodeKind = z.string();
-var Severity = z.string();
-var ProvenanceKind = z.enum(["measured", "derived", "model"]);
-var Provenance = z.object({
-  kind: ProvenanceKind,
-  source: z.string(),
-  at: z.string().optional()
-});
-var SnapshotInfo = z.object({
-  id: z.number().int(),
-  ref: z.string(),
-  commit: z.string().nullable(),
-  takenAt: z.string(),
-  indexVersion: z.string()
-});
-var MetricDescriptor = z.object({
-  name: z.string(),
-  unit: z.string().nullable(),
-  appliesTo: z.array(NodeKind),
-  rollup: z.enum(["sum", "max", "mean", "none"]),
-  direction: z.enum(["higher-worse", "lower-worse", "neutral"]),
-  absent: z.enum(["zero", "exclude"]),
-  window: z.string().optional(),
-  description: z.string(),
-  provenance: Provenance
-});
-var RuleSummary = z.object({ id: z.string(), type: z.string(), severity: Severity });
-var SnapshotRef = z.union([z.number().int().positive(), z.string().min(1)]);
-var Span = z.object({ startLine: z.number().int(), endLine: z.number().int() });
-var NodeRef = z.object({
-  id: z.string(),
-  kind: NodeKind,
-  name: z.string(),
-  /** The declaring file for a symbol, the directory path for a directory, "" for the repo. */
-  path: z.string(),
-  span: Span.optional()
-});
-var MissingReason = z.string();
-var Capabilities = z.object({
-  findings: z.enum(["none", "check-rules", "store"]),
-  verdicts: z.boolean(),
-  themes: z.boolean(),
-  feedback: z.boolean(),
-  embeddings: z.object({ model: z.string(), embedded: z.number(), symbols: z.number() }).nullable(),
-  cochange: z.boolean(),
-  sourceAtCommit: z.boolean(),
-  excerpts: z.enum(["any", "flagged", "none"])
-});
-
-// src/query/contract-findings.ts
-import { z as z2 } from "zod";
-var FINDINGS_PAGE_MAX = 500;
-var EXCERPT_LINE_CAP = 80;
-var FindingStatus = z2.enum(["new", "carryover", "resolved", "worsened", "improved"]);
-var BaselineFields = {
-  baselineSnapshotId: z2.number().int().optional(),
-  comparable: z2.boolean().optional()
-};
-var Finding = z2.object({
-  /** Opaque and stable across snapshots while the rule, node, and destination are unchanged. */
-  id: z2.string(),
-  snapshotId: z2.number().int(),
-  rule: z2.string(),
-  /** Open string: "check" for check-rule findings today. */
-  tool: z2.string(),
-  severity: Severity,
-  node: NodeRef,
-  destination: NodeRef.optional(),
-  /** The first flagged line range; absent when the finding is about the whole node. */
-  range: Span.optional(),
-  metric: z2.string().optional(),
-  value: z2.number().optional(),
-  threshold: z2.number().optional(),
-  /** How far past the threshold, as a ratio where larger is worse; null when the rule has no threshold. */
-  excess: z2.number().nullable(),
-  /** Present only when a baseline was given. */
-  status: FindingStatus.optional(),
-  message: z2.string(),
-  provenance: Provenance
-});
-var findingsListArgs = z2.object({
-  snapshot: SnapshotRef.optional(),
-  baseline: SnapshotRef.optional(),
-  scope: z2.string().optional(),
-  rule: z2.array(z2.string()).default([]),
-  severity: z2.array(Severity).default([]),
-  tool: z2.array(z2.string()).default([]),
-  provenance: z2.array(ProvenanceKind).default([]),
-  kind: z2.array(z2.string()).default([]),
-  status: z2.array(FindingStatus).default([]),
-  sort: z2.enum(["severity", "excess", "value", "path", "rule"]).default("severity"),
-  order: z2.enum(["asc", "desc"]).default("desc"),
-  offset: z2.number().int().min(0).default(0),
-  limit: z2.number().int().min(0).max(FINDINGS_PAGE_MAX).default(20),
-  facets: z2.boolean().default(false)
-});
-var findingsListResult = z2.object({
-  snapshotId: z2.number().int(),
-  ...BaselineFields,
-  rows: z2.array(Finding),
-  total: z2.number().int(),
-  /** Facet name to value to count, over every row that passed the filters; each facet's counts sum to `total`. */
-  facets: z2.record(z2.string(), z2.record(z2.string(), z2.number().int())).optional()
-});
-var FINDINGS_LIST = {
-  description: "Findings in a snapshot, filtered, sorted, and offset-paginated, with optional facet counts. Check-rule findings are derived on read (provenance 'derived'), so one disappears when its rule or threshold changes. `scope` limits to a node and everything under it. With `baseline`, each row gets a status and resolved findings come back from the baseline.",
-  args: findingsListArgs,
-  result: findingsListResult
-};
-var SourceExcerpt = z2.object({
-  path: z2.string(),
-  startLine: z2.number().int(),
-  endLine: z2.number().int(),
-  text: z2.string(),
-  /** Of the whole file at the snapshot. */
-  contentHash: z2.string(),
-  origin: z2.enum(["commit", "worktree", "export"]),
-  highlights: z2.array(Span),
-  /** True when the cap cut the requested window short. */
-  truncated: z2.boolean()
-});
-var findingGetArgs = z2.object({
-  snapshot: SnapshotRef.optional(),
-  id: z2.string(),
-  baseline: SnapshotRef.optional(),
-  context_lines: z2.number().int().min(0).max(20).default(5)
-});
-var findingGetResult = z2.object({
-  snapshotId: z2.number().int(),
-  ...BaselineFields,
-  finding: Finding,
-  rule: z2.object({ id: z2.string(), type: z2.string(), severity: Severity, text: z2.string() }),
-  measured: z2.object({
-    value: z2.number().nullable(),
-    threshold: z2.number().nullable(),
-    percentile: z2.number().nullable(),
-    siblingMedian: z2.number().nullable(),
-    baselineValue: z2.number().nullable().optional()
-  }),
-  why: z2.string(),
-  excerpt: SourceExcerpt.nullable(),
-  /** Open string: why `excerpt` is null, such as "no-source" or "changed-since-snapshot". */
-  excerptMissing: z2.string().optional(),
-  related: z2.array(Finding)
-});
-var FINDING_GET = {
-  description: "One finding by id with its rule, the measured value in context, a source excerpt of the flagged lines plus `context_lines` either side, and up to 10 related findings on the same node or on graph neighbours.",
-  args: findingGetArgs,
-  result: findingGetResult
-};
-var nodeNeighborsArgs = z2.object({
-  snapshot: SnapshotRef.optional(),
-  id: z2.string(),
-  direction: z2.enum(["in", "out", "both"]).default("both"),
-  edge_kinds: z2.array(z2.string()).default([]),
-  metrics: z2.array(z2.string().min(1)).max(10).default(["loc", "utilization"]),
-  offset: z2.number().int().min(0).default(0),
-  limit: z2.number().int().min(1).max(100).default(20)
-});
-var Neighbor = z2.object({
-  node: NodeRef,
-  kind: z2.string(),
-  weight: z2.number().nullable(),
-  specifier: z2.string().optional(),
-  values: z2.record(z2.string(), z2.number().nullable())
-});
-var nodeNeighborsResult = z2.object({
-  snapshotId: z2.number().int(),
-  node: NodeRef,
-  inbound: z2.array(Neighbor),
-  outbound: z2.array(Neighbor),
-  /** Edges in each direction before `offset` and `limit`; zero for a direction not asked for. */
-  total: z2.object({ inbound: z2.number().int(), outbound: z2.number().int() })
-});
-var NODE_NEIGHBORS = {
-  description: "Edges into and out of one stored node (file, symbol, module, or external), heaviest first, each with the neighbour's metric values. Empty `edge_kinds` means every kind except 'references' unless the node is a symbol.",
-  args: nodeNeighborsArgs,
-  result: nodeNeighborsResult
-};
-
-// src/query/contract-nodes.ts
-import { z as z3 } from "zod";
-var HIERARCHY_ROW_CAP = 5e3;
-var MetricNames = z3.array(z3.string().min(1)).max(40);
-var BaselineFields2 = {
-  baselineSnapshotId: z3.number().int().optional(),
-  comparable: z3.boolean().optional()
-};
-var hierarchyArgs = z3.object({
-  snapshot: SnapshotRef.optional(),
-  root: z3.string().optional(),
-  depth: z3.number().int().min(1).max(8).default(2),
-  metrics: MetricNames.default(["loc"]),
-  baseline: SnapshotRef.optional(),
-  include_symbols: z3.boolean().default(false),
-  exclude_roles: z3.array(z3.string()).default([])
-});
-var HierarchyRow = NodeRef.extend({
-  parentId: z3.string().nullable(),
-  /** Relative to the requested root, which is 0. */
-  depth: z3.number().int(),
-  /** Children in the full tree, symbols included, whatever `depth` and `include_symbols` returned. */
-  childCount: z3.number().int(),
-  role: z3.string().optional(),
-  values: z3.record(z3.string(), z3.number().nullable()),
-  missing: z3.record(z3.string(), MissingReason).optional(),
-  deltas: z3.record(z3.string(), z3.number().nullable()).optional()
-});
-var hierarchyResult = z3.object({
-  snapshotId: z3.number().int(),
-  ...BaselineFields2,
-  nodes: z3.array(HierarchyRow),
-  truncated: z3.boolean()
-});
-var HIERARCHY_GET = {
-  description: "A subtree of the synthesized repo, directory, file, and symbol hierarchy as a flat list with parent ids, shallowest first. Directory values roll up per the metric catalogue; a null value says why in `missing`.",
-  args: hierarchyArgs,
-  result: hierarchyResult
-};
-var nodeGetArgs = z3.object({
-  snapshot: SnapshotRef.optional(),
-  id: z3.string(),
-  baseline: SnapshotRef.optional(),
-  metrics: MetricNames.default([])
-});
-var NodeMetric = z3.object({
-  name: z3.string(),
-  unit: z3.string().nullable(),
-  direction: MetricDescriptor.shape.direction,
-  rollup: MetricDescriptor.shape.rollup,
-  value: z3.number().nullable(),
-  missing: MissingReason.optional(),
-  percentile: z3.number().nullable(),
-  siblingMedian: z3.number().nullable(),
-  siblingRank: z3.number().int().nullable(),
-  siblingCount: z3.number().int(),
-  baseline: z3.number().nullable().optional(),
-  delta: z3.number().nullable().optional()
-});
-var nodeGetResult = z3.object({
-  snapshotId: z3.number().int(),
-  ...BaselineFields2,
-  node: NodeRef.extend({
-    language: z3.string().optional(),
-    role: z3.string().optional(),
-    exported: z3.boolean().optional(),
-    signature: z3.string().optional(),
-    purpose: z3.string().optional()
-  }),
-  ancestors: z3.array(NodeRef),
-  childCounts: z3.record(z3.string(), z3.number().int()),
-  metrics: z3.array(NodeMetric)
-});
-var NODE_GET = {
-  description: "One node by id (a directory id ends in '/', the repo is ''): its containing chain, child counts, and each metric with direction, percentile among same-kind nodes, sibling median and rank, and a delta against an optional baseline.",
-  args: nodeGetArgs,
-  result: nodeGetResult
-};
-var nodeResolveArgs = z3.object({
-  snapshot: SnapshotRef.optional(),
-  query: z3.string().min(1).optional(),
-  path: z3.string().min(1).optional(),
-  line: z3.number().int().min(1).optional(),
-  limit: z3.number().int().min(1).max(50).default(10)
-});
-var nodeResolveResult = z3.object({
-  candidates: z3.array(
-    z3.object({
-      node: NodeRef,
-      score: z3.number(),
-      /** Open string: "exact" | "span" | "suffix" | "prefix" | "substring" today. */
-      match: z3.string()
-    })
-  )
-});
-var NODE_RESOLVE = {
-  description: "Turn a loose reference into ranked candidate node ids. Pass exactly one of `query` (a path, path:line, symbol name, or file#Scope.name) or `path` with an optional `line`; a line resolves to the innermost symbol whose span contains it.",
-  args: nodeResolveArgs,
-  result: nodeResolveResult
-};
-
-// src/query/contract.ts
-var CODE_READ_API_VERSION = "0.1.2";
-var describeArgs = z4.object({});
-var describeResult = z4.object({
-  api: z4.string(),
-  dataset: z4.enum(["live", "static"]),
-  commands: z4.array(z4.string()),
-  newest: SnapshotInfo.nullable(),
-  indexVersions: z4.array(z4.string()),
-  capabilities: Capabilities,
-  metrics: z4.array(MetricDescriptor),
-  rules: z4.array(RuleSummary)
-});
-var snapshotListArgs = z4.object({
-  ref: z4.string().min(1).optional(),
-  limit: z4.number().int().min(1).max(500).default(50)
-});
-var snapshotListResult = z4.object({ snapshots: z4.array(SnapshotInfo) });
-var CONTRACT = {
-  "api.describe": {
-    description: "Contract version, commands served, capabilities, the newest snapshot, and the metric and rule catalogues. Call first to pin compatibility.",
-    args: describeArgs,
-    result: describeResult
-  },
-  "snapshot.list": {
-    description: "Indexed snapshots, newest first, with ref, commit, time, and index version. Optionally one ref only.",
-    args: snapshotListArgs,
-    result: snapshotListResult
-  },
-  "hierarchy.get": HIERARCHY_GET,
-  "node.get": NODE_GET,
-  "node.resolve": NODE_RESOLVE,
-  "findings.list": FINDINGS_LIST,
-  "finding.get": FINDING_GET,
-  "node.neighbors": NODE_NEIGHBORS
-};
-var COMMAND_NAMES = Object.keys(CONTRACT).sort();
-var AGENT_COMMANDS = [
-  "api.describe",
-  "finding.get",
-  "findings.list",
-  "node.get",
-  "node.neighbors",
-  "node.resolve"
-];
-function serializeContract() {
-  const commands = {};
-  for (const name of COMMAND_NAMES) {
-    const { args, result } = CONTRACT[name];
-    commands[name] = { args: toJSONSchema(args, { io: "input" }), result: toJSONSchema(result) };
-  }
-  return { api: CODE_READ_API_VERSION, commands };
-}
-
-// src/query/model.ts
-function buildReadModel(parts) {
-  const nodeById = new Map(parts.nodes.map((n) => [n.id, n]));
-  return {
-    snapshot: parts.snapshot,
-    nodes: parts.nodes,
-    nodeById,
-    edges: parts.edges,
-    aliases: parts.aliases,
-    metrics: indexMetrics(parts.metrics),
-    metricCatalogue: buildCatalogue(parts, nodeById),
-    findings: parts.findings ?? [],
-    rules: parts.rules ?? []
-  };
-}
-function indexMetrics(metrics) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const m of metrics) {
-    let values = byName.get(m.name);
-    if (!values) byName.set(m.name, values = /* @__PURE__ */ new Map());
-    values.set(m.nodeId, m.value);
-  }
-  return byName;
-}
-function observeMetrics(metrics, nodeById) {
-  const observed = /* @__PURE__ */ new Map();
-  for (const m of metrics) {
-    let entry = observed.get(m.name);
-    if (!entry) observed.set(m.name, entry = { unit: m.unit ?? null, kinds: /* @__PURE__ */ new Set() });
-    const kind = nodeById.get(m.nodeId)?.kind;
-    if (kind) entry.kinds.add(kind);
-  }
-  return observed;
-}
-function buildCatalogue(parts, nodeById) {
-  const observed = observeMetrics(parts.metrics, nodeById);
-  const engine = `code-graph@${parts.snapshot.indexVersion}`;
-  return [...observed.keys()].sort().map((name) => {
-    const entry = parts.describe(name);
-    return entry ? fromCatalogue(entry, engine) : uncatalogued(name, observed.get(name), engine);
-  });
-}
-function fromCatalogue(entry, engine) {
-  const descriptor = {
-    name: entry.name,
-    unit: entry.unit,
-    appliesTo: [...entry.appliesTo],
-    rollup: entry.rollup,
-    direction: entry.direction,
-    absent: entry.absent,
-    description: entry.description,
-    provenance: { kind: "measured", source: `${engine}/${entry.source}` }
-  };
-  if (entry.window !== void 0) descriptor.window = entry.window;
-  return descriptor;
-}
-function uncatalogued(name, seen, engine) {
-  return {
-    name,
-    unit: seen.unit,
-    appliesTo: [...seen.kinds].sort(),
-    rollup: "none",
-    direction: "neutral",
-    absent: "exclude",
-    description: "Not in code-graph's metric catalogue.",
-    provenance: { kind: "measured", source: `${engine}/uncatalogued` }
-  };
-}
-
-// src/query/source.ts
-import { EXIT } from "@titan-design/rpc-protocol";
-var ReadError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "ReadError";
-  }
-  code;
-};
-function snapshotNotFound(snapshotId) {
-  return new ReadError(`No snapshot with id ${snapshotId}`, EXIT.NOINPUT);
-}
-function nodeNotFound(id, snapshotId) {
-  return new ReadError(`No node "${id}" in snapshot ${snapshotId}`, EXIT.NOINPUT);
-}
-function findingNotFound(id, snapshotId) {
-  return new ReadError(`No finding "${id}" in snapshot ${snapshotId}`, EXIT.NOINPUT);
-}
-function invalidArgs(message) {
-  return new ReadError(`Invalid arguments: ${message}`, EXIT.DATAERR);
-}
-
-// src/query/snapshot-ref.ts
-import { EXIT as EXIT2 } from "@titan-design/rpc-protocol";
-var DIGITS = /^\d+$/;
-function resolveSnapshot(source, ref) {
-  const snapshots = source.snapshots();
-  if (ref === void 0) {
-    const newest = snapshots[0];
-    if (!newest) throw new ReadError("No snapshots have been indexed", EXIT2.NOINPUT);
-    return newest;
-  }
-  if (typeof ref === "number" || DIGITS.test(ref)) {
-    const id = Number(ref);
-    const found = snapshots.find((s) => s.id === id);
-    if (!found) throw snapshotNotFound(id);
-    return found;
-  }
-  const newestOfRef = snapshots.find((s) => s.ref === ref);
-  if (!newestOfRef) throw new ReadError(`No snapshot of ref "${ref}"`, EXIT2.NOINPUT);
-  return newestOfRef;
-}
-function modelFor(source, ref) {
-  return source.model(resolveSnapshot(source, ref).id);
-}
-
-// src/query/rollup.ts
-var KIND_RANK = { repo: 0, directory: 1, file: 2, symbol: 3 };
-var EMPTY = { sum: 0, count: 0, max: -Infinity };
-function leafKind(descriptor) {
-  if (descriptor.appliesTo.includes("file")) return "file";
-  return descriptor.appliesTo.includes("symbol") ? "symbol" : null;
-}
-function rank(kind) {
-  return KIND_RANK[kind] ?? Infinity;
-}
-function storedValue(descriptor, values, id) {
-  const value = values?.get(id);
-  if (value !== void 0 && value !== null) return { value };
-  if (value === void 0 && descriptor.absent === "zero") return { value: 0 };
-  return { value: null, missing: "not-measured" };
-}
-function merge(a, b) {
-  return { sum: a.sum + b.sum, count: a.count + b.count, max: Math.max(a.max, b.max) };
-}
-function finalValue(rule, agg) {
-  if (agg.count === 0) return { value: null, missing: "not-measured" };
-  if (rule === "max") return { value: agg.max };
-  if (rule === "mean") return { value: agg.sum / agg.count };
-  return { value: agg.sum };
-}
-function buildColumn(model, name) {
-  const descriptor = model.metricCatalogue.find((m) => m.name === name);
-  if (!descriptor) return { descriptor, valueOf: () => ({ value: null, missing: "not-in-snapshot" }) };
-  const values = model.metrics.get(name);
-  const leaf = leafKind(descriptor);
-  const aggregates = /* @__PURE__ */ new Map();
-  const own = (node) => storedValue(descriptor, values, node.ref.id);
-  const aggregate = (node) => {
-    const cached = aggregates.get(node);
-    if (cached) return cached;
-    let agg = EMPTY;
-    if (node.ref.kind === leaf) {
-      const v = own(node).value;
-      if (v !== null) agg = { sum: v, count: 1, max: v };
-    }
-    for (const child of node.children) if (rank(child.ref.kind) <= rank(leaf ?? "")) agg = merge(agg, aggregate(child));
-    aggregates.set(node, agg);
-    return agg;
-  };
-  const valueOf2 = (node) => {
-    if (node.stored && descriptor.appliesTo.includes(node.ref.kind)) return own(node);
-    if (leaf === null || rank(node.ref.kind) >= rank(leaf)) return { value: null, missing: "not-applicable" };
-    if (descriptor.rollup === "none") return { value: null, missing: "no-rollup" };
-    return finalValue(descriptor.rollup, aggregate(node));
-  };
-  return { descriptor, valueOf: valueOf2 };
-}
-var columns = /* @__PURE__ */ new WeakMap();
-function columnFor(model, tree, name) {
-  let byName = columns.get(tree);
-  if (!byName) columns.set(tree, byName = /* @__PURE__ */ new Map());
-  let column = byName.get(name);
-  if (!column) byName.set(name, column = buildColumn(model, name));
-  return column;
-}
-function describesKind(descriptor, kind) {
-  if (descriptor.appliesTo.includes(kind)) return true;
-  const leaf = leafKind(descriptor);
-  return leaf !== null && rank(kind) < rank(leaf);
-}
-
-// src/query/tree.ts
-var REPO_ID = "";
-var SYMBOL_SEP = "#";
-function directoryId(path) {
-  return path === "" ? REPO_ID : `${path}/`;
-}
-function spanOf(node) {
-  const { startLine, endLine } = node.attrs;
-  return typeof startLine === "number" && typeof endLine === "number" ? { startLine, endLine } : void 0;
-}
-function toRef(node) {
-  const sep = node.kind === "symbol" ? node.id.indexOf(SYMBOL_SEP) : -1;
-  const ref = { id: node.id, kind: node.kind, name: node.name, path: sep < 0 ? node.id : node.id.slice(0, sep) };
-  const span = spanOf(node);
-  if (span) ref.span = span;
-  return ref;
-}
-function treeNode(ref, parentId, stored) {
-  return stored ? { ref, parentId, depth: 0, stored, children: [] } : { ref, parentId, depth: 0, children: [] };
-}
-function dirPath(fileId) {
-  const slash = fileId.lastIndexOf("/");
-  return slash < 0 ? "" : fileId.slice(0, slash);
-}
-function ensureDirectory(byId, path) {
-  const id = directoryId(path);
-  const existing = byId.get(id);
-  if (existing) return existing;
-  const parent = ensureDirectory(byId, dirPath(path));
-  const name = path.slice(path.lastIndexOf("/") + 1);
-  const dir = treeNode({ id, kind: "directory", name, path }, parent.ref.id);
-  parent.children.push(dir);
-  byId.set(id, dir);
-  return dir;
-}
-function attach(byId, parent, stored) {
-  const node = treeNode(toRef(stored), parent.ref.id, stored);
-  parent.children.push(node);
-  byId.set(stored.id, node);
-}
-function containsStrictly(outer, inner) {
-  const wider = outer.endLine - outer.startLine > inner.endLine - inner.startLine;
-  return wider && outer.startLine <= inner.startLine && inner.endLine <= outer.endLine;
-}
-function innermostEnclosing(symbol, siblings) {
-  const span = spanOf(symbol);
-  if (!span) return void 0;
-  let best;
-  let bestSpan;
-  for (const other of siblings) {
-    const outer = spanOf(other);
-    if (other === symbol || !outer || !containsStrictly(outer, span)) continue;
-    if (!bestSpan || outer.endLine - outer.startLine < bestSpan.endLine - bestSpan.startLine) [best, bestSpan] = [other, outer];
-  }
-  return best;
-}
-function symbolParentId(symbol, fileId, bySymbolId, siblings) {
-  const segments = symbol.name.split(".");
-  for (let n = segments.length - 1; n > 0; n--) {
-    const scopeId = `${fileId}${SYMBOL_SEP}${segments.slice(0, n).join(".")}`;
-    if (bySymbolId.has(scopeId)) return scopeId;
-  }
-  return innermostEnclosing(symbol, siblings)?.id ?? fileId;
-}
-function symbolsByFile(model, byId) {
-  const out = /* @__PURE__ */ new Map();
-  for (const node of model.nodes) {
-    if (node.kind !== "symbol" || node.parentId === null || !byId.has(node.parentId)) continue;
-    const list = out.get(node.parentId);
-    if (list) list.push(node);
-    else out.set(node.parentId, [node]);
-  }
-  return out;
-}
-function attachSymbols(model, byId) {
-  for (const [fileId, symbols] of symbolsByFile(model, byId)) {
-    const bySymbolId = new Map(symbols.map((s) => [s.id, s]));
-    const parentOf = new Map(symbols.map((s) => [s.id, symbolParentId(s, fileId, bySymbolId, symbols)]));
-    const pending = [...symbols];
-    while (pending.length > 0) {
-      const ready = pending.filter((s) => byId.has(parentOf.get(s.id)));
-      if (ready.length === 0) for (const s of pending) parentOf.set(s.id, fileId);
-      for (const s of ready) attach(byId, byId.get(parentOf.get(s.id)), s);
-      for (const s of ready) pending.splice(pending.indexOf(s), 1);
-    }
-  }
-}
-var KIND_ORDER = { directory: 0, file: 1, symbol: 2 };
-function compareSiblings(a, b) {
-  const byKind = (KIND_ORDER[a.ref.kind] ?? 3) - (KIND_ORDER[b.ref.kind] ?? 3);
-  if (byKind !== 0) return byKind;
-  const byLine = (a.ref.span?.startLine ?? Infinity) - (b.ref.span?.startLine ?? Infinity);
-  if (byLine !== 0 && !Number.isNaN(byLine)) return byLine;
-  return a.ref.id < b.ref.id ? -1 : a.ref.id > b.ref.id ? 1 : 0;
-}
-function finish(node, depth) {
-  node.depth = depth;
-  node.children.sort(compareSiblings);
-  for (const child of node.children) finish(child, depth + 1);
-}
-function buildTree(model, excludeRoles) {
-  const root = treeNode({ id: REPO_ID, kind: "repo", name: ".", path: "" }, null);
-  const byId = /* @__PURE__ */ new Map([[REPO_ID, root]]);
-  for (const node of model.nodes) {
-    if (node.kind !== "file" || node.role !== void 0 && excludeRoles.has(node.role)) continue;
-    attach(byId, ensureDirectory(byId, dirPath(node.id)), node);
-  }
-  attachSymbols(model, byId);
-  finish(root, 0);
-  return { root, byId };
-}
-var trees = /* @__PURE__ */ new WeakMap();
-function treeFor(model, excludeRoles = []) {
-  const roles = [...new Set(excludeRoles)].sort();
-  const key = roles.join("\n");
-  let byKey = trees.get(model);
-  if (!byKey) trees.set(model, byKey = /* @__PURE__ */ new Map());
-  let tree = byKey.get(key);
-  if (!tree) byKey.set(key, tree = buildTree(model, new Set(roles)));
-  return tree;
-}
-
-// src/query/baseline.ts
-function openBaseline(source, ref, excludeRoles = []) {
-  if (ref === void 0) return void 0;
-  const model = modelFor(source, ref);
-  return { model, tree: treeFor(model, excludeRoles) };
-}
-function baselineValue(baseline, id, name) {
-  const node = baseline.tree.byId.get(id);
-  return node ? columnFor(baseline.model, baseline.tree, name).valueOf(node).value : null;
-}
-function baselineFields(current, baseline) {
-  if (!baseline) return {};
-  return {
-    baselineSnapshotId: baseline.model.snapshot.id,
-    comparable: baseline.model.snapshot.indexVersion === current.snapshot.indexVersion
-  };
-}
-function delta(value, before) {
-  return value !== null && before !== null ? value - before : null;
-}
-
-// src/query/excerpt.ts
-function excerptWindow(ranges, context, lineCount) {
-  const from = ranges.length === 0 ? 1 : Math.max(1, Math.min(...ranges.map((r) => r.startLine)) - context);
-  const wanted = ranges.length === 0 ? lineCount : Math.min(lineCount, Math.max(...ranges.map((r) => r.endLine)) + context);
-  const to = Math.min(wanted, from + EXCERPT_LINE_CAP - 1);
-  return { from, to, truncated: to < wanted };
-}
-function clipped(ranges, from, to) {
-  return ranges.filter((r) => r.endLine >= from && r.startLine <= to).map((r) => ({ startLine: Math.max(r.startLine, from), endLine: Math.min(r.endLine, to) }));
-}
-function holds(window, from, to) {
-  return from >= window.startLine && to <= window.startLine + window.lines.length - 1;
-}
-function buildExcerpt(read, ranges, context) {
-  if ("unavailable" in read) return { excerpt: null, missing: read.unavailable };
-  const { from, to, truncated } = excerptWindow(ranges, context, read.lineCount);
-  if (to >= from && !holds(read, from, to)) return { excerpt: null, missing: "not-in-export" };
-  const text = read.lines.slice(from - read.startLine, to - read.startLine + 1).join("\n");
-  const excerpt = {
-    path: read.path,
-    startLine: from,
-    endLine: to,
-    text,
-    contentHash: read.contentHash,
-    origin: read.origin,
-    highlights: clipped(ranges, from, to),
-    truncated
-  };
-  return { excerpt };
-}
-
-// src/query/finding-rows.ts
-var SEVERITY_RANK = { error: 2, warning: 1, info: 0 };
-var CHECK_TOOL = "check";
-function refFor(model, id) {
-  const node = model.nodeById.get(id);
-  return node ? toRef(node) : { id, kind: "unknown", name: id, path: id };
-}
-function excessOf(ruleType, value, threshold) {
-  if (value === void 0 || threshold === void 0) return null;
-  if (ruleType === "metric-min") return value > 0 ? threshold / value : null;
-  return threshold > 0 ? value / threshold : null;
-}
-function toFinding(model, f, rules) {
-  const out = {
-    id: f.id,
-    snapshotId: model.snapshot.id,
-    rule: f.rule,
-    tool: CHECK_TOOL,
-    severity: f.severity,
-    node: refFor(model, f.nodeId),
-    excess: excessOf(rules.get(f.rule)?.type, f.value, f.threshold),
-    message: f.message,
-    provenance: { kind: "derived", source: `${CHECK_TOOL}/${f.rule}` }
-  };
-  if (f.destinationId !== void 0) out.destination = refFor(model, f.destinationId);
-  if (f.ranges?.[0]) out.range = f.ranges[0];
-  if (f.metric !== void 0) out.metric = f.metric;
-  if (f.value !== void 0) out.value = f.value;
-  if (f.threshold !== void 0) out.threshold = f.threshold;
-  return out;
-}
-var rowsByModel = /* @__PURE__ */ new WeakMap();
-function findingsFor(model) {
-  let rows = rowsByModel.get(model);
-  if (!rows) {
-    const rules = new Map(model.rules.map((r) => [r.id, r]));
-    rowsByModel.set(model, rows = model.findings.map((f) => toFinding(model, f, rules)));
-  }
-  return rows;
-}
-function statusAgainst(current, before) {
-  if (!before) return "new";
-  if (current.excess === null || before.excess === null || current.excess === before.excess) return "carryover";
-  return current.excess > before.excess ? "worsened" : "improved";
-}
-function withStatus(current, baseline) {
-  const before = new Map(baseline.map((f) => [f.id, f]));
-  const now = new Set(current.map((f) => f.id));
-  const rows = current.map((f) => ({ ...f, status: statusAgainst(f, before.get(f.id)) }));
-  for (const f of baseline) if (!now.has(f.id)) rows.push({ ...f, status: "resolved" });
-  return rows;
-}
-var severityRank = (f) => SEVERITY_RANK[f.severity] ?? -1;
-var byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-function byNullable(a, b, sign) {
-  const [x, y] = [a ?? null, b ?? null];
-  if (x === null || y === null) return x === y ? 0 : x === null ? 1 : -1;
-  return sign * (x - y);
-}
-var PRIMARY = {
-  severity: (sign) => (a, b) => sign * (severityRank(a) - severityRank(b)),
-  excess: (sign) => (a, b) => byNullable(a.excess, b.excess, sign),
-  value: (sign) => (a, b) => byNullable(a.value, b.value, sign),
-  path: (sign) => (a, b) => sign * byText(a.node.path, b.node.path),
-  rule: (sign) => (a, b) => sign * byText(a.rule, b.rule)
-};
-var TIES = [
-  PRIMARY.severity(-1),
-  PRIMARY.excess(-1),
-  PRIMARY.path(1),
-  PRIMARY.rule(1),
-  (a, b) => byText(a.id, b.id)
-];
-function compareFindings(sort, order) {
-  const chain = [PRIMARY[sort](order === "asc" ? 1 : -1), ...TIES];
-  return (a, b) => {
-    for (const compare of chain) {
-      const c = compare(a, b);
-      if (c !== 0) return c;
-    }
-    return 0;
-  };
-}
-
-// src/query/neighbors.ts
-var adjacencies = /* @__PURE__ */ new WeakMap();
-function push(map, key, edge) {
-  const list = map.get(key);
-  if (list) list.push(edge);
-  else map.set(key, [edge]);
-}
-function adjacencyOf(model) {
-  let adjacency = adjacencies.get(model);
-  if (!adjacency) {
-    const inbound = /* @__PURE__ */ new Map();
-    const outbound = /* @__PURE__ */ new Map();
-    for (const edge of model.edges) {
-      push(inbound, edge.dstId, edge);
-      push(outbound, edge.srcId, edge);
-    }
-    adjacencies.set(model, adjacency = { inbound, outbound });
-  }
-  return adjacency;
-}
-var weightOf = (edge) => typeof edge.attrs.weight === "number" ? edge.attrs.weight : null;
-function valueOf(model, tree, id, name) {
-  const node = tree.byId.get(id);
-  if (node) return columnFor(model, tree, name).valueOf(node).value;
-  return model.metrics.get(name)?.get(id) ?? null;
-}
-function toNeighbor(model, tree, edge, otherId, metrics) {
-  const neighbor = { node: refFor(model, otherId), kind: edge.kind, weight: weightOf(edge), values: {} };
-  if (typeof edge.attrs.specifier === "string") neighbor.specifier = edge.attrs.specifier;
-  for (const name of metrics) neighbor.values[name] = valueOf(model, tree, otherId, name);
-  return neighbor;
-}
-function compareNeighbors(a, b) {
-  const [x, y] = [a.weight ?? -Infinity, b.weight ?? -Infinity];
-  if (x !== y) return y - x;
-  if (a.node.id !== b.node.id) return a.node.id < b.node.id ? -1 : 1;
-  return a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0;
-}
-function edgeFilter(kinds, nodeKind) {
-  if (kinds.length > 0) return (edge) => kinds.includes(edge.kind);
-  return nodeKind === "symbol" ? () => true : (edge) => edge.kind !== "references";
-}
-function side(edges, other, p) {
-  const all = (edges ?? []).filter(p.keep).map((e) => p.build(e, other(e))).sort(compareNeighbors);
-  return { rows: all.slice(p.offset, p.offset + p.limit), total: all.length };
-}
-function getNeighbors(source, args) {
-  const model = modelFor(source, args.snapshot);
-  const tree = treeFor(model);
-  const node = model.nodeById.get(args.id);
-  if (!node && tree.byId.has(args.id)) throw invalidArgs(`${args.id} is synthesized; node.neighbors needs a stored node`);
-  if (!node) throw nodeNotFound(args.id, model.snapshot.id);
-  const { inbound, outbound } = adjacencyOf(model);
-  const metrics = [...new Set(args.metrics)];
-  const paging = {
-    keep: edgeFilter(args.edge_kinds, node.kind),
-    build: (e, id) => toNeighbor(model, tree, e, id, metrics),
-    offset: args.offset,
-    limit: args.limit
-  };
-  const none = { rows: [], total: 0 };
-  const ins = args.direction === "out" ? none : side(inbound.get(node.id), (e) => e.srcId, paging);
-  const outs = args.direction === "in" ? none : side(outbound.get(node.id), (e) => e.dstId, paging);
-  return {
-    snapshotId: model.snapshot.id,
-    node: refFor(model, node.id),
-    inbound: ins.rows,
-    outbound: outs.rows,
-    total: { inbound: ins.total, outbound: outs.total }
-  };
-}
-
-// src/query/stats.ts
-var sortedByKind = /* @__PURE__ */ new WeakMap();
-function valuesOf(column, nodes, kind) {
-  const out = [];
-  for (const node of nodes) {
-    if (node.ref.kind !== kind) continue;
-    const { value } = column.valueOf(node);
-    if (value !== null) out.push(value);
-  }
-  return out;
-}
-function sortedPeers(column, tree, kind) {
-  let byKind = sortedByKind.get(column);
-  if (!byKind) sortedByKind.set(column, byKind = /* @__PURE__ */ new Map());
-  let sorted = byKind.get(kind);
-  if (!sorted) byKind.set(kind, sorted = valuesOf(column, tree.byId.values(), kind).sort((a, b) => a - b));
-  return sorted;
-}
-function countAtMost(sorted, value) {
-  let lo = 0;
-  let hi = sorted.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    if (sorted[mid] <= value) lo = mid + 1;
-    else hi = mid;
-  }
-  return lo;
-}
-function median(values) {
-  if (values.length === 0) return null;
-  const sorted = [...values].sort((a, b) => a - b);
-  const mid = sorted.length >>> 1;
-  return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-}
-var round1 = (n) => Math.round(n * 10) / 10;
-function peerStats(column, tree, node, value) {
-  const parent = node.parentId === null ? void 0 : tree.byId.get(node.parentId);
-  const siblings = valuesOf(column, parent ? parent.children : [node], node.ref.kind);
-  if (value === null) return { percentile: null, siblingMedian: median(siblings), siblingRank: null, siblingCount: siblings.length };
-  const peers = sortedPeers(column, tree, node.ref.kind);
-  return {
-    percentile: peers.length === 0 ? null : round1(100 * countAtMost(peers, value) / peers.length),
-    siblingMedian: median(siblings),
-    siblingRank: 1 + siblings.filter((v) => v > value).length,
-    siblingCount: siblings.length
-  };
-}
-
-// src/query/finding-get.ts
-var RELATED_CAP = 10;
-function measure(model, finding, baseline) {
-  const measured = {
-    value: finding.value ?? null,
-    threshold: finding.threshold ?? null,
-    percentile: null,
-    siblingMedian: null
-  };
-  const tree = treeFor(model);
-  const node = tree.byId.get(finding.node.id);
-  const metric = finding.metric;
-  if (node && metric !== void 0 && model.metrics.has(metric)) {
-    const column = columnFor(model, tree, metric);
-    const stats = peerStats(column, tree, node, column.valueOf(node).value);
-    measured.percentile = stats.percentile;
-    measured.siblingMedian = stats.siblingMedian;
-  }
-  if (baseline && metric !== void 0) measured.baselineValue = baselineValue(baseline, finding.node.id, metric);
-  return measured;
-}
-function neighbourIds(model, id) {
-  const { inbound, outbound } = adjacencyOf(model);
-  const ids = /* @__PURE__ */ new Set();
-  for (const e of inbound.get(id) ?? []) if (e.kind !== "references") ids.add(e.srcId);
-  for (const e of outbound.get(id) ?? []) if (e.kind !== "references") ids.add(e.dstId);
-  return ids;
-}
-function relatedTo(model, rows, finding) {
-  const near = neighbourIds(model, finding.node.id);
-  const order = compareFindings("severity", "desc");
-  const sameNode = rows.filter((f) => f.id !== finding.id && f.node.id === finding.node.id).sort(order);
-  const sameRule = rows.filter((f) => f.rule === finding.rule && f.node.id !== finding.node.id && near.has(f.node.id)).sort(order);
-  return [...sameNode, ...sameRule].slice(0, RELATED_CAP);
-}
-function ruleOf(model, finding) {
-  return model.rules.find((r) => r.id === finding.rule) ?? { id: finding.rule, type: "unknown", severity: finding.severity, text: "" };
-}
-function excerptOf(source, model, finding, context) {
-  if (!source.readSource) return { excerpt: null, missing: "no-source" };
-  const stored = model.findings.find((f) => f.id === finding.id);
-  return buildExcerpt(source.readSource(model.snapshot.id, finding.node.path), stored?.ranges ?? [], context);
-}
-function getFinding(source, args) {
-  const model = modelFor(source, args.snapshot);
-  const baseline = openBaseline(source, args.baseline);
-  const current = findingsFor(model);
-  const rows = baseline ? withStatus(current, findingsFor(baseline.model)).filter((f) => f.status !== "resolved") : current;
-  const finding = rows.find((f) => f.id === args.id);
-  if (!finding) throw findingNotFound(args.id, model.snapshot.id);
-  const rule = ruleOf(model, finding);
-  const { excerpt, missing } = excerptOf(source, model, finding, args.context_lines);
-  const result = {
-    snapshotId: model.snapshot.id,
-    ...baselineFields(model, baseline),
-    finding,
-    rule,
-    measured: measure(model, finding, baseline),
-    why: rule.text ? `${rule.text} Here: ${finding.message}.` : finding.message,
-    excerpt,
-    related: relatedTo(model, rows, finding)
-  };
-  if (missing !== void 0) result.excerptMissing = missing;
-  return result;
-}
-
-// src/query/findings-list.ts
-function childUnder(prefix, ref) {
-  if (ref.kind === "external" || !ref.path.startsWith(prefix)) return ref.id;
-  const rest = ref.path.slice(prefix.length);
-  const slash = rest.indexOf("/");
-  return slash < 0 ? ref.path : directoryId(prefix + rest.slice(0, slash));
-}
-function scopeOf(node) {
-  const { kind, id, path } = node.ref;
-  if (kind === "repo") return { contains: () => true, childOf: (ref) => childUnder("", ref) };
-  if (kind === "directory") {
-    const prefix = `${path}/`;
-    return { contains: (ref) => ref.path.startsWith(prefix), childOf: (ref) => childUnder(prefix, ref) };
-  }
-  if (kind === "file") return { contains: (ref) => ref.path === id, childOf: (ref) => ref.id };
-  return { contains: (ref) => ref.id === id || ref.id.startsWith(`${id}.`), childOf: (ref) => ref.id };
-}
-function oneOf(allowed, pick) {
-  if (allowed.length === 0) return () => true;
-  const set = new Set(allowed);
-  return (f) => {
-    const value = pick(f);
-    return value !== void 0 && set.has(value);
-  };
-}
-function filtersFor(args, scope) {
-  return [
-    (f) => scope.contains(f.node),
-    oneOf(args.rule, (f) => f.rule),
-    oneOf(args.severity, (f) => f.severity),
-    oneOf(args.tool, (f) => f.tool),
-    oneOf(args.provenance, (f) => f.provenance.kind),
-    oneOf(args.kind, (f) => f.node.kind),
-    oneOf(args.status, (f) => f.status)
-  ];
-}
-var FACETS = {
-  rule: (f) => f.rule,
-  severity: (f) => f.severity,
-  tool: (f) => f.tool,
-  provenance: (f) => f.provenance.kind,
-  kind: (f) => f.node.kind,
-  child: (f, scope) => scope.childOf(f.node),
-  status: (f) => f.status
-};
-function sortedCounts(counts) {
-  return Object.fromEntries([...counts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
-}
-function facetCounts(rows, scope, withBaseline) {
-  const out = {};
-  for (const [name, pick] of Object.entries(FACETS)) {
-    if (name === "status" && !withBaseline) continue;
-    const counts = /* @__PURE__ */ new Map();
-    for (const f of rows) {
-      const value = pick(f, scope) ?? "";
-      counts.set(value, (counts.get(value) ?? 0) + 1);
-    }
-    out[name] = sortedCounts(counts);
-  }
-  return out;
-}
-function listFindings(source, args) {
-  const model = modelFor(source, args.snapshot);
-  const baseline = openBaseline(source, args.baseline);
-  if (args.status.length > 0 && !baseline) throw invalidArgs("status needs a baseline");
-  const root = treeFor(model).byId.get(args.scope ?? REPO_ID);
-  if (!root) throw nodeNotFound(args.scope ?? REPO_ID, model.snapshot.id);
-  const scope = scopeOf(root);
-  const all = baseline ? withStatus(findingsFor(model), findingsFor(baseline.model)) : findingsFor(model);
-  const filters = filtersFor(args, scope);
-  const kept = all.filter((f) => filters.every((keep) => keep(f))).sort(compareFindings(args.sort, args.order));
-  const result = {
-    snapshotId: model.snapshot.id,
-    ...baselineFields(model, baseline),
-    rows: kept.slice(args.offset, args.offset + args.limit),
-    total: kept.length
-  };
-  if (args.facets) result.facets = facetCounts(kept, scope, baseline !== void 0);
-  return result;
-}
-
-// src/query/hierarchy.ts
-function collectRows(root, depth, includeSymbols) {
-  const rows = [];
-  const queue = [root];
-  for (let i = 0; i < queue.length; i++) {
-    const node = queue[i];
-    if (rows.length === HIERARCHY_ROW_CAP) return { rows, truncated: true };
-    rows.push(node);
-    if (node.depth - root.depth >= depth) continue;
-    for (const child of node.children) if (includeSymbols || child.ref.kind !== "symbol") queue.push(child);
-  }
-  return { rows, truncated: false };
-}
-function toRow(node, rootDepth, columns2, names, baseline) {
-  const row = { ...node.ref, parentId: node.parentId, depth: node.depth - rootDepth, childCount: node.children.length, values: {} };
-  if (node.stored?.role !== void 0) row.role = node.stored.role;
-  const missing = {};
-  const deltas = {};
-  names.forEach((name, i) => {
-    const { value, missing: reason } = columns2[i].valueOf(node);
-    row.values[name] = value;
-    if (reason) missing[name] = reason;
-    if (!baseline) return;
-    deltas[name] = delta(value, baselineValue(baseline, node.ref.id, name));
-  });
-  if (Object.keys(missing).length > 0) row.missing = missing;
-  if (baseline) row.deltas = deltas;
-  return row;
-}
-function getHierarchy(source, args) {
-  const model = modelFor(source, args.snapshot);
-  const tree = treeFor(model, args.exclude_roles);
-  const root = tree.byId.get(args.root ?? REPO_ID);
-  if (!root) throw nodeNotFound(args.root ?? REPO_ID, model.snapshot.id);
-  const baseline = openBaseline(source, args.baseline, args.exclude_roles);
-  const names = [...new Set(args.metrics)];
-  const columns2 = names.map((name) => columnFor(model, tree, name));
-  const { rows, truncated } = collectRows(root, args.depth, args.include_symbols);
-  const nodes = rows.map((node) => toRow(node, root.depth, columns2, names, baseline));
-  return { snapshotId: model.snapshot.id, ...baselineFields(model, baseline), nodes, truncated };
-}
-
-// src/query/node-get.ts
-function ancestorsOf(tree, node) {
-  const chain = [];
-  for (let id = node.parentId; id !== null; ) {
-    const parent = tree.byId.get(id);
-    chain.push(parent.ref);
-    id = parent.parentId;
-  }
-  return chain.reverse();
-}
-function childCounts(node) {
-  const counts = {};
-  for (const child of node.children) counts[child.ref.kind] = (counts[child.ref.kind] ?? 0) + 1;
-  return counts;
-}
-function describeNode(node) {
-  const out = { ...node.ref };
-  const stored = node.stored;
-  if (!stored) return out;
-  if (stored.language !== void 0) out.language = stored.language;
-  if (stored.role !== void 0) out.role = stored.role;
-  const { exported, signature, purpose } = stored.attrs;
-  if (typeof exported === "boolean") out.exported = exported;
-  if (typeof signature === "string") out.signature = signature;
-  if (typeof purpose === "string") out.purpose = purpose;
-  return out;
-}
-function metricNames(model, kind, requested) {
-  if (requested.length > 0) return [...new Set(requested)];
-  return model.metricCatalogue.filter((d) => describesKind(d, kind)).map((d) => d.name);
-}
-function measure2(model, tree, node, name, baseline) {
-  const column = columnFor(model, tree, name);
-  const { value, missing } = column.valueOf(node);
-  const d = column.descriptor;
-  const metric = {
-    name,
-    unit: d?.unit ?? null,
-    direction: d?.direction ?? "neutral",
-    rollup: d?.rollup ?? "none",
-    value,
-    ...missing ? { missing } : {},
-    ...peerStats(column, tree, node, value)
-  };
-  if (!baseline) return metric;
-  metric.baseline = baselineValue(baseline, node.ref.id, name);
-  metric.delta = delta(value, metric.baseline);
-  return metric;
-}
-function getNode(source, args) {
-  const model = modelFor(source, args.snapshot);
-  const tree = treeFor(model);
-  const node = tree.byId.get(args.id);
-  if (!node) throw nodeNotFound(args.id, model.snapshot.id);
-  const baseline = openBaseline(source, args.baseline);
-  return {
-    snapshotId: model.snapshot.id,
-    ...baselineFields(model, baseline),
-    node: describeNode(node),
-    ancestors: ancestorsOf(tree, node),
-    childCounts: childCounts(node),
-    metrics: metricNames(model, node.ref.kind, args.metrics).map((name) => measure2(model, tree, node, name, baseline))
-  };
-}
-
-// src/query/resolve.ts
-var SEARCHED_KINDS = /* @__PURE__ */ new Set(["directory", "file", "symbol"]);
-var PATH_LINE = /^([^#]+):(\d+)$/;
-function scoreNode(node, q) {
-  const id = (node.ref.kind === "directory" ? node.ref.path : node.ref.id).toLowerCase();
-  const name = node.ref.name.toLowerCase();
-  if (id === q || name === q) return { score: 100, match: "exact" };
-  if (id.endsWith(`/${q}`) || id.endsWith(`#${q}`)) return { score: 80, match: "suffix" };
-  if (node.ref.kind === "symbol" && name.endsWith(`.${q}`)) return { score: 80, match: "suffix" };
-  if (name.startsWith(q)) return { score: 60, match: "prefix" };
-  if (id.includes(q)) return { score: 40, match: "substring" };
-  if (name.includes(q)) return { score: 30, match: "substring" };
-  return null;
-}
-function normalize(query) {
-  const q = query.toLowerCase();
-  return q.length > 1 && q.endsWith("/") ? q.slice(0, -1) : q;
-}
-function rank2(tree, query, kinds) {
-  const q = normalize(query);
-  const hits = [];
-  for (const node of tree.byId.values()) {
-    if (!kinds.has(node.ref.kind)) continue;
-    const scored = scoreNode(node, q);
-    if (scored) hits.push({ node: node.ref, ...scored });
-  }
-  return hits.sort((a, b) => b.score - a.score || (a.node.id < b.node.id ? -1 : a.node.id > b.node.id ? 1 : 0));
-}
-function innermostContaining(file, line) {
-  let best = null;
-  const visit = (node) => {
-    for (const child of node.children) {
-      const span = child.ref.span;
-      if (span && span.startLine <= line && line <= span.endLine) {
-        const bestSpan = best?.ref.span;
-        if (!bestSpan || span.endLine - span.startLine < bestSpan.endLine - bestSpan.startLine) best = child;
-      }
-      visit(child);
-    }
-  };
-  visit(file);
-  return best;
-}
-function resolvePath(tree, path, line) {
-  const files = rank2(tree, path, /* @__PURE__ */ new Set(["file"]));
-  if (line === void 0) return files;
-  return files.map((hit) => {
-    const symbol = innermostContaining(tree.byId.get(hit.node.id), line);
-    return symbol ? { node: symbol.ref, score: hit.score, match: "span" } : hit;
-  });
-}
-function pathAndLine(args) {
-  if (args.path !== void 0) return { path: args.path, line: args.line };
-  const m = PATH_LINE.exec(args.query);
-  return m ? { path: m[1], line: Number(m[2]) } : null;
-}
-function resolveNode(source, args) {
-  if (args.query === void 0 === (args.path === void 0)) throw invalidArgs("pass exactly one of query or path");
-  if (args.line !== void 0 && args.path === void 0) throw invalidArgs("line needs path");
-  const tree = treeFor(modelFor(source, args.snapshot));
-  const located = pathAndLine(args);
-  const candidates = located ? resolvePath(tree, located.path, located.line) : rank2(tree, args.query, SEARCHED_KINDS);
-  return { candidates: candidates.slice(0, args.limit) };
-}
-
-// src/query/commands.ts
-function describeApi(source) {
-  const facts = source.facts();
-  const snapshots = source.snapshots();
-  const newest = snapshots[0] ?? null;
-  return {
-    api: CODE_READ_API_VERSION,
-    dataset: facts.dataset,
-    commands: [...facts.commands],
-    newest,
-    indexVersions: [...new Set(snapshots.map((s) => s.indexVersion))],
-    capabilities: facts.capabilities,
-    metrics: newest ? [...source.model(newest.id).metricCatalogue] : [],
-    rules: [...facts.rules]
-  };
-}
-function listSnapshots(source, args) {
-  const matching = source.snapshots().filter((s) => args.ref === void 0 || s.ref === args.ref);
-  return { snapshots: matching.slice(0, args.limit) };
-}
-var QUERIES = {
-  "api.describe": describeApi,
-  "snapshot.list": listSnapshots,
-  "hierarchy.get": getHierarchy,
-  "node.get": getNode,
-  "node.resolve": resolveNode,
-  "findings.list": listFindings,
-  "finding.get": getFinding,
-  "node.neighbors": getNeighbors
-};
-
-// src/query/resolver.ts
-import { EXIT as EXIT3, errorEnvelope, successEnvelope } from "@titan-design/rpc-protocol";
-function isCommandName(name) {
-  return Object.hasOwn(CONTRACT, name);
-}
-function formatIssues(error) {
-  return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-}
-function describeFailure(err) {
-  const code = err?.code;
-  const message = err instanceof Error ? err.message : String(err);
-  return { message, code: typeof code === "number" ? code : EXIT3.GENERIC };
-}
-function createQueryResolver(source) {
-  return (name, rawArgs) => {
-    if (!isCommandName(name)) return errorEnvelope(`Unknown command: ${name}`, EXIT3.USAGE);
-    if (!source.facts().commands.includes(name)) {
-      return errorEnvelope(`${name} is not available from a ${source.facts().dataset} dataset`, EXIT3.UNAVAILABLE);
-    }
-    const parsed = CONTRACT[name].args.safeParse(rawArgs ?? {});
-    if (!parsed.success) return errorEnvelope(`Invalid arguments: ${formatIssues(parsed.error)}`, EXIT3.DATAERR);
-    try {
-      const query = QUERIES[name];
-      return successEnvelope(query(source, parsed.data));
-    } catch (err) {
-      const { message, code } = describeFailure(err);
-      return errorEnvelope(message, code);
-    }
-  };
-}
-
-export {
-  NodeKind,
-  Severity,
-  ProvenanceKind,
-  Provenance,
-  SnapshotInfo,
-  MetricDescriptor,
-  RuleSummary,
-  SnapshotRef,
-  Span,
-  NodeRef,
-  MissingReason,
-  Capabilities,
-  FINDINGS_PAGE_MAX,
-  EXCERPT_LINE_CAP,
-  FindingStatus,
-  Finding,
-  SourceExcerpt,
-  HIERARCHY_ROW_CAP,
-  CODE_READ_API_VERSION,
-  CONTRACT,
-  COMMAND_NAMES,
-  AGENT_COMMANDS,
-  serializeContract,
-  buildReadModel,
-  ReadError,
-  snapshotNotFound,
-  nodeNotFound,
-  findingNotFound,
-  invalidArgs,
-  resolveSnapshot,
-  excessOf,
-  getNeighbors,
-  RELATED_CAP,
-  getFinding,
-  listFindings,
-  getHierarchy,
-  getNode,
-  resolveNode,
-  describeApi,
-  listSnapshots,
-  QUERIES,
-  createQueryResolver
-};
-//# sourceMappingURL=chunk-VXQFCVGB.js.map