@titan-design/code-read 0.1.8 → 0.2.0

package/dist/chunk-7FNTXO7C.js

@@ -0,0 +1,2344 @@
+// src/query/contract.ts
+import { toJSONSchema, z as z10 } 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-hotspots.ts
+import { z as z3 } from "zod";
+var HOTSPOTS_PAGE_MAX = 500;
+var ChurnWindow = z3.string().regex(/^(?:[1-9]\d*d|lifetime)$/);
+var HotspotMark = z3.enum(["new", "worsened"]);
+var Hotspot = z3.object({
+  node: NodeRef,
+  /** Commits touching the file in the window; a symbol reads its declaring file's churn. */
+  churn: z3.number(),
+  /** File: max cognitive complexity over its functions (cyclomatic when cognitive is absent). Symbol: its own, else its file's. */
+  complexity: z3.number(),
+  /** The age discount applied to the score, 1 for none; the symbol grain applies none. */
+  recency: z3.number(),
+  /** File: round(churn × complexity × recency). Symbol: utilization × complexity × churn (blast radius). */
+  score: z3.number(),
+  /** Symbol grain only. */
+  utilization: z3.number().optional(),
+  /** Present only with a baseline; null when the node was no hotspot there. */
+  baselineScore: z3.number().nullable().optional(),
+  /** Present only with a baseline, and only for a row that is new or scores higher than at the baseline. */
+  mark: HotspotMark.optional()
+});
+var hotspotsListArgs = z3.object({
+  snapshot: SnapshotRef.optional(),
+  baseline: SnapshotRef.optional(),
+  grain: z3.enum(["file", "symbol"]).default("file"),
+  window: ChurnWindow.default("30d"),
+  /** Keep rows scoring at least this; the threshold is the caller's policy. */
+  cutoff: z3.number().min(0).optional(),
+  offset: z3.number().int().min(0).default(0),
+  limit: z3.number().int().min(0).max(HOTSPOTS_PAGE_MAX).default(20)
+});
+var hotspotsListResult = z3.object({
+  snapshotId: z3.number().int(),
+  ...BaselineFields,
+  rows: z3.array(Hotspot),
+  /** Rows at or above the cutoff, before `offset` and `limit`. */
+  total: z3.number().int()
+});
+var HOTSPOTS_LIST = {
+  description: "Files or symbols ranked by hotspot score, highest first, offset-paginated. File grain scores churn \xD7 complexity \xD7 recency over the churn `window`; symbol grain scores blast radius, utilization \xD7 complexity \xD7 file churn. Generated files and their symbols are left out. `cutoff` keeps rows scoring at least that. With `baseline`, each row gets its baseline score and is marked new or worsened.",
+  args: hotspotsListArgs,
+  result: hotspotsListResult
+};
+
+// src/query/contract-nodes.ts
+import { z as z5 } from "zod";
+
+// src/query/contract-node-lenses.ts
+import { z as z4 } from "zod";
+var NodeLens = z4.enum(["exports", "score", "centrality", "coupling", "tests"]);
+var ExportRow = z4.object({
+  name: z4.string(),
+  utilization: z4.number(),
+  /** The symbol's own cognitive complexity; null for a class, a type, or a re-export. */
+  cognitive: z4.number().nullable(),
+  /** Distinct files that reference the symbol. */
+  consumers: z4.number().int(),
+  exported: z4.boolean()
+});
+var ScoreBreakdown = z4.object({
+  grain: z4.enum(["file", "symbol"]),
+  window: z4.string(),
+  score: z4.number(),
+  churn: z4.number().optional(),
+  complexity: z4.number().optional(),
+  recency: z4.number().optional(),
+  /** Symbol grain only. */
+  utilization: z4.number().optional(),
+  /** 1 is the highest score; null at a score of 0. */
+  rank: z4.number().int().nullable(),
+  /** Nodes of the grain with a non-zero score. */
+  ranked: z4.number().int()
+});
+var Centrality = z4.object({
+  score: z4.number().nullable(),
+  rank: z4.number().int().nullable(),
+  /** Files in the reading order; every one of them has a rank. */
+  of: z4.number().int()
+});
+var CoupledPartners = z4.object({
+  /** False until co-change pairs are stored in the index; `partners` is then empty. */
+  measured: z4.boolean(),
+  partners: z4.array(z4.object({ node: NodeRef, count: z4.number().int() }))
+});
+var LinkedTests = z4.object({
+  /** Test files linked by path convention, such as `a.test.ts` beside `a.ts`. */
+  tests: z4.array(NodeRef),
+  /** The indexer's `linked_test_count`, which also counts tests linked by co-editing; null when the index holds no such metric. */
+  indexedCount: z4.number().int().nullable(),
+  /** False until co-change pairs are stored, so `tests` holds path-linked tests only. */
+  coEditMeasured: z4.boolean()
+});
+var NodeLenses = z4.object({
+  exports: z4.array(ExportRow).nullable().optional(),
+  score: ScoreBreakdown.nullable().optional(),
+  centrality: Centrality.nullable().optional(),
+  coupling: CoupledPartners.nullable().optional(),
+  tests: LinkedTests.nullable().optional()
+});
+
+// src/query/contract-nodes.ts
+var HIERARCHY_ROW_CAP = 5e3;
+var MetricNames = z5.array(z5.string().min(1)).max(40);
+var BaselineFields2 = {
+  baselineSnapshotId: z5.number().int().optional(),
+  comparable: z5.boolean().optional()
+};
+var hierarchyArgs = z5.object({
+  snapshot: SnapshotRef.optional(),
+  root: z5.string().optional(),
+  depth: z5.number().int().min(1).max(8).default(2),
+  metrics: MetricNames.default(["loc"]),
+  baseline: SnapshotRef.optional(),
+  include_symbols: z5.boolean().default(false),
+  exclude_roles: z5.array(z5.string()).default([])
+});
+var HierarchyRow = NodeRef.extend({
+  parentId: z5.string().nullable(),
+  /** Relative to the requested root, which is 0. */
+  depth: z5.number().int(),
+  /** Children in the full tree, symbols included, whatever `depth` and `include_symbols` returned. */
+  childCount: z5.number().int(),
+  role: z5.string().optional(),
+  values: z5.record(z5.string(), z5.number().nullable()),
+  missing: z5.record(z5.string(), MissingReason).optional(),
+  deltas: z5.record(z5.string(), z5.number().nullable()).optional()
+});
+var hierarchyResult = z5.object({
+  snapshotId: z5.number().int(),
+  ...BaselineFields2,
+  nodes: z5.array(HierarchyRow),
+  truncated: z5.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 = z5.object({
+  snapshot: SnapshotRef.optional(),
+  id: z5.string(),
+  baseline: SnapshotRef.optional(),
+  metrics: MetricNames.default([]),
+  /** Extra readings of the node; with none the result carries no `lenses` field. */
+  lenses: z5.array(NodeLens).max(NodeLens.options.length).default([]),
+  /** The churn window the `score` lens reads. */
+  window: ChurnWindow.default("30d")
+});
+var NodeMetric = z5.object({
+  name: z5.string(),
+  unit: z5.string().nullable(),
+  direction: MetricDescriptor.shape.direction,
+  rollup: MetricDescriptor.shape.rollup,
+  value: z5.number().nullable(),
+  missing: MissingReason.optional(),
+  percentile: z5.number().nullable(),
+  siblingMedian: z5.number().nullable(),
+  siblingRank: z5.number().int().nullable(),
+  siblingCount: z5.number().int(),
+  baseline: z5.number().nullable().optional(),
+  delta: z5.number().nullable().optional()
+});
+var nodeGetResult = z5.object({
+  snapshotId: z5.number().int(),
+  ...BaselineFields2,
+  node: NodeRef.extend({
+    language: z5.string().optional(),
+    role: z5.string().optional(),
+    exported: z5.boolean().optional(),
+    signature: z5.string().optional(),
+    purpose: z5.string().optional()
+  }),
+  ancestors: z5.array(NodeRef),
+  childCounts: z5.record(z5.string(), z5.number().int()),
+  metrics: z5.array(NodeMetric),
+  /** Present only when `lenses` asked for any. */
+  lenses: NodeLenses.optional()
+});
+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. Optional `lenses` add a file's exports, its hotspot score breakdown, its centrality rank, co-changed partners (unmeasured until pairs are stored), and its linked tests.",
+  args: nodeGetArgs,
+  result: nodeGetResult
+};
+var nodeResolveArgs = z5.object({
+  snapshot: SnapshotRef.optional(),
+  query: z5.string().min(1).optional(),
+  path: z5.string().min(1).optional(),
+  line: z5.number().int().min(1).optional(),
+  limit: z5.number().int().min(1).max(50).default(10)
+});
+var nodeResolveResult = z5.object({
+  candidates: z5.array(
+    z5.object({
+      node: NodeRef,
+      score: z5.number(),
+      /** Open string: "exact" | "span" | "suffix" | "prefix" | "substring" today. */
+      match: z5.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-overview.ts
+import { DEFAULT_HEALTH_WEIGHTS } from "@titan-design/code-graph/analysis";
+import { z as z6 } from "zod";
+var OVERVIEW_ROWS_MAX = 50;
+var AttentionSignalKey = z6.enum(["hotspots", "findings", "complexity", "hidden-coupling"]);
+var AttentionSignal = z6.object({
+  key: AttentionSignalKey,
+  label: z6.string(),
+  penalty: z6.number(),
+  cap: z6.number(),
+  /** False when the index does not hold the signal's input yet; its penalty is then 0. */
+  measured: z6.boolean(),
+  detail: z6.string()
+});
+var LookFirstReason = z6.enum(["over-cutoff", "findings", "churn-complexity"]);
+var LookFirstRow = z6.object({
+  node: NodeRef,
+  score: z6.number(),
+  churn: z6.number(),
+  complexity: z6.number(),
+  recency: z6.number(),
+  /** Why the row is here; `churn-complexity` only when no other reason applies. */
+  reasons: z6.array(LookFirstReason)
+});
+var ReadingOrderRow = z6.object({ node: NodeRef, centrality: z6.number() });
+var weightShape = (w) => ({ each: z6.number().min(0).default(w.each), cap: z6.number().min(0).default(w.cap) });
+var weight = (w) => z6.object(weightShape(w)).prefault({});
+var { findings, complexity } = DEFAULT_HEALTH_WEIGHTS;
+var signalWeights = z6.object({
+  hotspots: weight(DEFAULT_HEALTH_WEIGHTS.hotspots),
+  findings: z6.object({
+    each_new: z6.number().min(0).default(findings.eachNew),
+    each_carry: z6.number().min(0).default(findings.eachCarry),
+    cap: z6.number().min(0).default(findings.cap)
+  }).prefault({}),
+  complexity: z6.object({ ...weightShape(complexity), budget: z6.number().min(0).default(complexity.budget) }).prefault({}),
+  hidden_coupling: weight(DEFAULT_HEALTH_WEIGHTS.hiddenCoupling)
+}).prefault({});
+var overviewGetArgs = z6.object({
+  snapshot: SnapshotRef.optional(),
+  baseline: SnapshotRef.optional(),
+  window: ChurnWindow.default("30d"),
+  /** A file scoring at least this is over the cutoff; the threshold is the caller's policy. */
+  cutoff: z6.number().min(0).default(3e3),
+  weights: signalWeights,
+  /** Rules left out of the findings signal, such as one already counted as a hotspot over the cutoff. */
+  exclude_rules: z6.array(z6.string()).default([]),
+  /** Also return `combined`, 100 minus every signal's penalty. */
+  combined: z6.boolean().default(false),
+  reading_limit: z6.number().int().min(0).max(OVERVIEW_ROWS_MAX).default(6),
+  look_limit: z6.number().int().min(0).max(OVERVIEW_ROWS_MAX).default(8)
+});
+var FindingCounts = z6.object({
+  open: z6.number().int(),
+  /** Status counts against the baseline; present only with one. */
+  new: z6.number().int().optional(),
+  carryover: z6.number().int().optional(),
+  resolved: z6.number().int().optional()
+});
+var overviewGetResult = z6.object({
+  snapshotId: z6.number().int(),
+  ...BaselineFields,
+  kpis: z6.object({
+    hotspotsOverCutoff: z6.number().int(),
+    /** Highest file complexity among files with churn in the window. */
+    maxComplexity: z6.number(),
+    /** Files with a bus factor of 1 in the window. */
+    knowledgeSilos: z6.number().int(),
+    findings: FindingCounts
+  }),
+  signals: z6.array(AttentionSignal),
+  /** Present only when asked for: one number hides which signal moved, so read `signals` first. */
+  combined: z6.number().optional(),
+  readingOrder: z6.array(ReadingOrderRow),
+  lookFirst: z6.array(LookFirstRow)
+});
+var OVERVIEW_GET = {
+  description: "Where to look first in a snapshot: KPIs, named attention signals (hotspots over `cutoff`, findings, complexity over budget, hidden coupling) each weighted and capped by the caller's `weights`, a reading order of files by PageRank centrality, and the top hotspots with the reasons each is listed. With `baseline`, findings count as new, carried over, or resolved. `combined` optionally adds 100 minus the penalties; it is a secondary summary, not a verdict.",
+  args: overviewGetArgs,
+  result: overviewGetResult
+};
+
+// src/query/contract-changes.ts
+import { z as z7 } from "zod";
+var CHANGES_ROWS_MAX = 500;
+var ScoreChange = z7.object({
+  node: NodeRef,
+  before: z7.number(),
+  after: z7.number(),
+  delta: z7.number()
+});
+var NewFile = z7.object({ node: NodeRef, score: z7.number() });
+var FindingChange = z7.object({ finding: Finding, before: z7.number(), delta: z7.number() });
+var Regression = ScoreChange.extend({ findings: z7.array(z7.string()) });
+var CoChangePair = z7.object({ a: NodeRef, b: NodeRef, count: z7.number().int() });
+var changesGetArgs = z7.object({
+  snapshot: SnapshotRef.optional(),
+  baseline: SnapshotRef,
+  window: ChurnWindow.default("30d"),
+  /** A file scoring at least this is over the cutoff; the threshold is the caller's policy. */
+  cutoff: z7.number().min(0).default(3e3),
+  limit: z7.number().int().min(0).max(CHANGES_ROWS_MAX).default(20)
+});
+var changesGetResult = z7.object({
+  snapshotId: z7.number().int(),
+  baselineSnapshotId: z7.number().int(),
+  /** False across index versions; every list is then empty, because the two indexes measure differently. */
+  comparable: z7.boolean(),
+  files: z7.object({
+    /** Below the cutoff at the baseline, at or above it now; highest delta first. */
+    crossedCutoff: z7.array(ScoreChange),
+    /** Files the baseline does not hold; highest score first. */
+    added: z7.array(NewFile)
+  }),
+  findings: z7.object({
+    new: z7.array(Finding),
+    worsened: z7.array(FindingChange),
+    improved: z7.array(FindingChange),
+    resolved: z7.array(Finding)
+  }),
+  coupling: z7.object({
+    /** False until co-change pairs are stored in the index; `added` is then empty. */
+    measured: z7.boolean(),
+    added: z7.array(CoChangePair)
+  }),
+  regressions: z7.array(Regression),
+  counts: z7.object({
+    crossedCutoff: z7.number().int(),
+    newFiles: z7.number().int(),
+    newFindings: z7.number().int(),
+    worsened: z7.number().int(),
+    improved: z7.number().int(),
+    resolved: z7.number().int(),
+    newCoupling: z7.number().int(),
+    regressions: z7.number().int()
+  })
+});
+var CHANGES_GET = {
+  description: "What changed between a `baseline` snapshot and this one: files that crossed the hotspot `cutoff`, files the baseline does not hold, findings new, worsened, improved, or resolved, new co-change coupling (unmeasured until pairs are stored), and regressions: files whose hotspot score rose and that carry an open finding. Each list holds at most `limit` rows; `counts` holds the full sizes. Across index versions `comparable` is false and every list is empty.",
+  args: changesGetArgs,
+  result: changesGetResult
+};
+
+// src/query/contract-paths-impact.ts
+import { z as z8 } from "zod";
+var PATHS_IMPACT_MAX = 500;
+var FindingDelta = z8.object({
+  new: z8.number().int(),
+  worsened: z8.number().int(),
+  improved: z8.number().int(),
+  resolved: z8.number().int()
+});
+var PathDelta = z8.object({
+  inBaseline: z8.boolean(),
+  /** A file with no score at the baseline counts as 0, as in `changes.get`; null when the baseline does not hold it. */
+  scoreBefore: z8.number().nullable(),
+  /** Current score minus `scoreBefore`; null when `scoreBefore` is. */
+  score: z8.number().nullable(),
+  complexityBefore: z8.number().nullable(),
+  /** Current complexity minus `complexityBefore`; null when either is unmeasured. */
+  complexity: z8.number().nullable(),
+  findings: FindingDelta
+});
+var PathHotspot = z8.object({
+  /** The file grain's score over the window, as `hotspots.list` scores it; 0 when the file has no churn or no complexity. */
+  score: z8.number(),
+  /** The file's position in `hotspots.list` at the same window, 1 the highest; null at a score of 0. */
+  rank: z8.number().int().nullable()
+});
+var IndexedPath = z8.object({
+  status: z8.literal("indexed"),
+  /** The path as given. */
+  input: z8.string(),
+  /** Repo-relative, the file's node id. */
+  path: z8.string(),
+  node: NodeRef,
+  /** The complexity factor of the hotspot score (max cognitive, else max cyclomatic); null when unmeasured. */
+  complexity: z8.number().nullable(),
+  hotspot: PathHotspot,
+  /** Open findings on the file or a symbol in it, worst first. With a baseline each carries a status. */
+  findings: z8.array(Finding),
+  /** Absent without a baseline; null when the baseline is not comparable (another index version). */
+  delta: PathDelta.nullable().optional()
+});
+var NotIndexedPath = z8.object({ status: z8.literal("not-indexed"), input: z8.string(), path: z8.string() });
+var OutsideRepoPath = z8.object({ status: z8.literal("outside-repo"), input: z8.string() });
+var PathImpact = z8.discriminatedUnion("status", [IndexedPath, NotIndexedPath, OutsideRepoPath]);
+var ImpactRollup = z8.object({
+  indexed: z8.number().int(),
+  notIndexed: z8.number().int(),
+  outsideRepo: z8.number().int(),
+  /** Sum of the indexed files' hotspot scores. */
+  score: z8.number(),
+  /** Highest complexity over the indexed files; null when none is measured. */
+  maxComplexity: z8.number().nullable(),
+  /** Best (lowest) hotspot rank over the indexed files; null when none ranks. */
+  topRank: z8.number().int().nullable(),
+  openFindings: z8.number().int(),
+  /** The rows' deltas summed, plus the resolved findings of not-indexed (deleted) files that the baseline held; present and null exactly when every row's `delta` is. */
+  delta: z8.object({ score: z8.number(), findings: FindingDelta }).nullable().optional()
+});
+var pathsImpactArgs = z8.object({
+  snapshot: SnapshotRef.optional(),
+  baseline: SnapshotRef.optional(),
+  /** Repo-relative paths; a leading `./` is dropped. An absolute path counts only when it lies under `root`. */
+  paths: z8.array(z8.string()).max(PATHS_IMPACT_MAX),
+  /** The absolute directory the repo is checked out at, such as a worktree, so absolute paths under it can be read. A root above the index's repo root is rejected as invalid arguments. */
+  root: z8.string().optional(),
+  window: ChurnWindow.default("30d")
+});
+var pathsImpactResult = z8.object({
+  snapshotId: z8.number().int(),
+  ...BaselineFields,
+  /** One row per distinct path, in the order first given. */
+  rows: z8.array(PathImpact),
+  /** Files with a non-zero hotspot score at the window; the denominator for `hotspot.rank`. */
+  ranked: z8.number().int(),
+  rollup: ImpactRollup
+});
+var PATHS_IMPACT = {
+  description: "What a set of files weighs in the code graph, such as the files a change touches: per file its complexity, its hotspot score and rank as `hotspots.list` ranks them at `window`, and its open findings, plus a rollup. A path the snapshot does not hold answers status 'not-indexed', and one outside the repo 'outside-repo'; neither is an error. With `baseline`, each indexed row gets a score, complexity, and findings delta, and the rollup delta also counts the resolved findings of a not-indexed path the baseline held (a deleted file); without one, `delta` is absent.",
+  args: pathsImpactArgs,
+  result: pathsImpactResult
+};
+
+// src/query/contract-packages.ts
+import { z as z9 } from "zod";
+var PACKAGES_MAX = 500;
+var PackageLayer = z9.discriminatedUnion("status", [
+  z9.object({ status: z9.literal("declared"), tier: z9.number().int(), rule: z9.string() }),
+  z9.object({ status: z9.literal("undeclared") })
+]);
+var PackageStatsRow = z9.object({
+  /** The package root, a repo-relative path prefix such as `packages/cli`. */
+  id: z9.string(),
+  /** The root's last path segment; the index holds no package manifests. */
+  name: z9.string(),
+  fileCount: z9.number().int(),
+  internalEdges: z9.number().int(),
+  outgoingEdges: z9.number().int(),
+  incomingEdges: z9.number().int(),
+  /** internal / (internal + outgoing); 0 with neither. */
+  cohesion: z9.number(),
+  /** outgoing / (outgoing + incoming), Martin's I; 0 with neither. */
+  instability: z9.number(),
+  /** Share of the package's files with role "types", a stand-in for Martin's A. */
+  abstractness: z9.number(),
+  /** code-graph's instability band: at most 0.3 foundation, at least 0.9 top. Measured, unlike `layer`. */
+  band: z9.enum(["foundation", "middle", "top"]),
+  /** Open string: "weak-boundary" today. */
+  flags: z9.array(z9.string()),
+  layer: PackageLayer
+});
+var CrossEdge = z9.object({
+  from: z9.string(),
+  to: z9.string(),
+  edges: z9.number().int(),
+  /** edges / files(from). */
+  intensity: z9.number(),
+  /** At least 0.6 tight, at least 0.3 moderate. */
+  flag: z9.enum(["tight", "moderate", "none"])
+});
+var packagesStatsArgs = z9.object({
+  snapshot: SnapshotRef.optional(),
+  /** Package roots as repo-relative path prefixes; omitted means every package the tier config declares. */
+  packages: z9.array(z9.string().min(1)).max(PACKAGES_MAX).optional()
+});
+var packagesStatsResult = z9.object({
+  snapshotId: z9.number().int(),
+  /** Where the package roots came from: the `packages` argument, or the `layered-deps` rules; `none` when neither names one. */
+  packagesFrom: z9.enum(["args", "tiers", "none"]),
+  /** Newman-Girvan modularity Q of the package partition; 0 with no edges. */
+  modularity: z9.number(),
+  /** File-to-file edges with both ends in a package, internal and cross. */
+  totalEdges: z9.number().int(),
+  /** Files counted under no package root. */
+  unassignedFiles: z9.number().int(),
+  /** One row per package root, by id. */
+  packages: z9.array(PackageStatsRow),
+  /** By `from`, then `to`. */
+  crossEdges: z9.array(CrossEdge)
+});
+var PACKAGES_STATS = {
+  description: "Package structure for a snapshot: per package its file count, internal, outgoing, and incoming edges, cohesion, instability, abstractness, and its tier in the repo's layered-deps rules, plus the package-to-package edges and the snapshot's modularity. Test and fixture files are left out, as code-graph's arch view leaves them out. A package no tier names has layer status 'undeclared'.",
+  args: packagesStatsArgs,
+  result: packagesStatsResult
+};
+
+// src/query/contract.ts
+var CODE_READ_API_VERSION = "0.1.8";
+var describeArgs = z10.object({});
+var describeResult = z10.object({
+  api: z10.string(),
+  dataset: z10.enum(["live", "static"]),
+  commands: z10.array(z10.string()),
+  newest: SnapshotInfo.nullable(),
+  indexVersions: z10.array(z10.string()),
+  capabilities: Capabilities,
+  metrics: z10.array(MetricDescriptor),
+  rules: z10.array(RuleSummary)
+});
+var snapshotListArgs = z10.object({
+  ref: z10.string().min(1).optional(),
+  limit: z10.number().int().min(1).max(500).default(50)
+});
+var snapshotListResult = z10.object({ snapshots: z10.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,
+  "hotspots.list": HOTSPOTS_LIST,
+  "overview.get": OVERVIEW_GET,
+  "changes.get": CHANGES_GET,
+  "paths.impact": PATHS_IMPACT,
+  "packages.stats": PACKAGES_STATS
+};
+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/changes.ts
+import {
+  bucketViolations,
+  computeReportDrift as computeReportDrift2,
+  hotspotScoreOf,
+  keepNode as keepNode2
+} from "@titan-design/code-graph/analysis";
+
+// 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 best2;
+  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) [best2, bestSpan] = [other, outer];
+  }
+  return best2;
+}
+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/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 compare2 of chain) {
+      const c = compare2(a, b);
+      if (c !== 0) return c;
+    }
+    return 0;
+  };
+}
+
+// src/query/hotspots.ts
+import {
+  buildBlastRadius,
+  buildReportContext,
+  collectNodeMetrics,
+  collectSymbolUtil,
+  computeReportDrift,
+  keepNode,
+  topHotspots
+} from "@titan-design/code-graph/analysis";
+
+// 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/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/hotspots.ts
+var NO_ROLES = /* @__PURE__ */ new Set();
+function toGraphNode(node) {
+  const out = { id: node.id, kind: node.kind, name: node.name, attrs: node.attrs };
+  if (node.parentId !== null) out.parentId = node.parentId;
+  if (node.role !== void 0) out.role = node.role;
+  return out;
+}
+function metricRows(model) {
+  const rows = [];
+  for (const [name, byNode] of model.metrics) for (const [nodeId, value] of byNode) rows.push({ nodeId, name, value });
+  return rows;
+}
+var inputs = /* @__PURE__ */ new WeakMap();
+function inputsFor(model) {
+  let found = inputs.get(model);
+  if (!found) inputs.set(model, found = { nodes: model.nodes.map(toGraphNode), metrics: metricRows(model) });
+  return found;
+}
+function symbolRows(rows, ctx) {
+  const metrics = collectNodeMetrics([...rows.metrics]);
+  const symbols = collectSymbolUtil(rows.nodes, metrics).filter((s) => keepNode(ctx, s.fileId));
+  const churn = ctx.metricsByName.get(`churn_${ctx.windowSuffix}`) ?? /* @__PURE__ */ new Map();
+  return buildBlastRadius(symbols, metrics, churn, Infinity).map((b) => ({
+    nodeId: b.symbolId,
+    churn: b.churn,
+    complexity: b.complexity,
+    recency: 1,
+    score: b.score,
+    utilization: b.utilization
+  }));
+}
+function windowDays(window) {
+  return window === "lifetime" ? "lifetime" : Number.parseInt(window, 10);
+}
+var byScoreThenId = (a, b) => b.score - a.score || (a.nodeId < b.nodeId ? -1 : a.nodeId > b.nodeId ? 1 : 0);
+function reportContext(model, window) {
+  return buildReportContext({ ...inputsFor(model), excluders: [], excludedRoles: NO_ROLES, windowDays: windowDays(window) });
+}
+function scoredRows(model, args) {
+  const ctx = reportContext(model, args.window);
+  const scored = args.grain === "file" ? topHotspots(ctx, Infinity) : symbolRows(inputsFor(model), ctx);
+  return scored.sort(byScoreThenId);
+}
+function driftBaseline(info) {
+  const { commit, ...rest } = info;
+  return { ...rest, commitHash: commit, attrs: {} };
+}
+function compare(current, before, baseline) {
+  const drift = computeReportDrift({
+    baselineSnapshot: driftBaseline(baseline),
+    currentHotspots: current,
+    baselineHotspots: before,
+    currentHotspotScore: () => 0,
+    currentSilos: [],
+    baselineSilos: [],
+    currentBusFactor: () => void 0,
+    currentCoupling: [],
+    baselineCoupling: []
+  });
+  const marks = /* @__PURE__ */ new Map();
+  for (const r of drift.newHotspots) marks.set(r.nodeId, "new");
+  for (const r of drift.worsenedHotspots) marks.set(r.nodeId, "worsened");
+  return { scores: new Map(before.map((r) => [r.nodeId, r.score])), marks };
+}
+function toHotspot(model, r, comparison) {
+  const row = { node: toRef(model.nodeById.get(r.nodeId)), churn: r.churn, complexity: r.complexity, recency: r.recency, score: r.score };
+  if (r.utilization !== void 0) row.utilization = r.utilization;
+  if (!comparison) return row;
+  row.baselineScore = comparison.scores.get(r.nodeId) ?? null;
+  const mark = comparison.marks.get(r.nodeId);
+  if (mark) row.mark = mark;
+  return row;
+}
+function listHotspots(source, args) {
+  const model = modelFor(source, args.snapshot);
+  const baseline = openBaseline(source, args.baseline);
+  const rows = scoredRows(model, args);
+  const comparison = baseline ? compare(rows, scoredRows(baseline.model, args), baseline.model.snapshot) : void 0;
+  const { cutoff } = args;
+  const kept = cutoff === void 0 ? rows : rows.filter((r) => r.score >= cutoff);
+  return {
+    snapshotId: model.snapshot.id,
+    ...baselineFields(model, baseline),
+    rows: kept.slice(args.offset, args.offset + args.limit).map((r) => toHotspot(model, r, comparison)),
+    total: kept.length
+  };
+}
+
+// src/query/changes.ts
+var byDeltaThenId = (a, b) => b.delta - a.delta || compareIds(a.node.id, b.node.id);
+var compareIds = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function risingFiles(current, baseline, args) {
+  const scored = (model) => scoredRows(model, { grain: "file", window: args.window });
+  const drift = computeReportDrift2({
+    baselineSnapshot: driftBaseline(baseline.model.snapshot),
+    currentHotspots: scored(current.model),
+    baselineHotspots: scored(baseline.model),
+    currentHotspotScore: (id) => hotspotScoreOf(current.ctx, id),
+    baselineHotspotScore: (id) => baseline.model.nodeById.has(id) ? hotspotScoreOf(baseline.ctx, id) : void 0,
+    currentSilos: [],
+    baselineSilos: [],
+    currentBusFactor: () => void 0,
+    currentCoupling: [],
+    baselineCoupling: []
+  });
+  const climbed = drift.newHotspots.flatMap((r) => r.before === void 0 ? [] : [{ ...r, after: r.score, before: r.before, delta: r.score - r.before }]);
+  const node = (id) => toRef(current.model.nodeById.get(id));
+  return [...drift.worsenedHotspots, ...climbed].map((r) => ({ node: node(r.nodeId), before: r.before, after: r.after, delta: r.delta }));
+}
+function addedFiles(current, baseline) {
+  return current.model.nodes.filter((n) => n.kind === "file" && !baseline.model.nodeById.has(n.id) && keepNode2(current.ctx, n.id)).map((n) => ({ node: toRef(n), score: hotspotScoreOf(current.ctx, n.id) })).sort((a, b) => b.score - a.score || compareIds(a.node.id, b.node.id));
+}
+function keyed(model) {
+  return findingsFor(model).map((row) => {
+    const k = { ruleId: row.rule, nodeId: row.node.id, row };
+    if (row.destination) k.destinationId = row.destination.id;
+    if (row.value !== void 0) k.value = row.value;
+    return k;
+  });
+}
+function bucketFindings(baseline, current) {
+  return bucketViolations(keyed(baseline), keyed(current));
+}
+function findingChanges(current, baseline) {
+  const buckets = bucketFindings(baseline, current);
+  const change = (u) => ({ finding: u.to.row, before: u.from.value, delta: u.delta });
+  return {
+    new: buckets.newViolations.map((v) => v.row),
+    worsened: buckets.worsened.map(change).sort((a, b) => b.delta - a.delta),
+    improved: buckets.improved.map(change).sort((a, b) => a.delta - b.delta),
+    resolved: buckets.resolvedViolations.map((v) => v.row)
+  };
+}
+function regressions(rising, current) {
+  const open = /* @__PURE__ */ new Map();
+  for (const f of findingsFor(current)) open.set(f.node.path, [...open.get(f.node.path) ?? [], f.id]);
+  return rising.flatMap((r) => {
+    const ids = open.get(r.node.id);
+    return ids ? [{ ...r, findings: [...ids].sort(compareIds) }] : [];
+  });
+}
+function diff(current, baseline, args) {
+  const rising = risingFiles(current, baseline, args).sort(byDeltaThenId);
+  return {
+    files: {
+      crossedCutoff: rising.filter((r) => r.after >= args.cutoff && r.before < args.cutoff),
+      added: addedFiles(current, baseline)
+    },
+    findings: findingChanges(current.model, baseline.model),
+    // Co-change pairs are not stored in the index yet, so new coupling cannot be measured here.
+    coupling: { measured: false, added: [] },
+    regressions: regressions(rising, current.model)
+  };
+}
+var EMPTY2 = {
+  files: { crossedCutoff: [], added: [] },
+  findings: { new: [], worsened: [], improved: [], resolved: [] },
+  coupling: { measured: false, added: [] },
+  regressions: []
+};
+function counts(lists) {
+  const { files, findings: findings2 } = lists;
+  return {
+    crossedCutoff: files.crossedCutoff.length,
+    newFiles: files.added.length,
+    newFindings: findings2.new.length,
+    worsened: findings2.worsened.length,
+    improved: findings2.improved.length,
+    resolved: findings2.resolved.length,
+    newCoupling: lists.coupling.added.length,
+    regressions: lists.regressions.length
+  };
+}
+function capped(lists, limit) {
+  const cap = (rows) => rows.slice(0, limit);
+  const { files, findings: findings2, coupling } = lists;
+  return {
+    files: { crossedCutoff: cap(files.crossedCutoff), added: cap(files.added) },
+    findings: { new: cap(findings2.new), worsened: cap(findings2.worsened), improved: cap(findings2.improved), resolved: cap(findings2.resolved) },
+    coupling: { measured: coupling.measured, added: cap(coupling.added) },
+    regressions: cap(lists.regressions)
+  };
+}
+function getChanges(source, args) {
+  const side2 = (model) => ({ model, ctx: reportContext(model, args.window) });
+  const current = side2(modelFor(source, args.snapshot));
+  const baseline = side2(modelFor(source, args.baseline));
+  const comparable = baseline.model.snapshot.indexVersion === current.model.snapshot.indexVersion;
+  const lists = comparable ? diff(current, baseline, args) : EMPTY2;
+  return {
+    snapshotId: current.model.snapshot.id,
+    baselineSnapshotId: baseline.model.snapshot.id,
+    comparable,
+    ...capped(lists, args.limit),
+    counts: counts(lists)
+  };
+}
+
+// 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/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) {
+  const rule = model.rules.find((r) => r.id === finding.rule);
+  if (!rule) return { id: finding.rule, type: "unknown", severity: finding.severity, text: "" };
+  return { id: rule.id, type: rule.type, severity: rule.severity, text: rule.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(counts2) {
+  return Object.fromEntries([...counts2].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 counts2 = /* @__PURE__ */ new Map();
+    for (const f of rows) {
+      const value = pick(f, scope) ?? "";
+      counts2.set(value, (counts2.get(value) ?? 0) + 1);
+    }
+    out[name] = sortedCounts(counts2);
+  }
+  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-lenses.ts
+import {
+  buildHotExports,
+  collectNodeMetrics as collectNodeMetrics2,
+  collectSymbolUtil as collectSymbolUtil2,
+  computeSymbolConsumers,
+  linkTestsToSources,
+  topCentralFiles
+} from "@titan-design/code-graph/analysis";
+function perModel(derive) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (model) => {
+    if (!cache.has(model)) cache.set(model, derive(model));
+    return cache.get(model);
+  };
+}
+var centralFiles = perModel((model) => {
+  const nodes = inputsFor(model).nodes.filter((n) => n.kind !== "symbol");
+  const edges = model.edges.filter((e) => e.kind !== "references" && e.kind !== "calls");
+  return topCentralFiles(nodes, edges, reportContext(model, "lifetime"), Infinity);
+});
+var symbolFacts = perModel((model) => {
+  const { nodes, metrics: rows } = inputsFor(model);
+  const metrics = collectNodeMetrics2([...rows]);
+  const references = model.edges.filter((e) => e.kind === "references");
+  const consumers = new Map(computeSymbolConsumers(references).map((s) => [s.symbolId, s.consumers.length]));
+  return { metrics, symbols: collectSymbolUtil2(nodes, metrics), consumers };
+});
+var testLinks = perModel((model) => linkTestsToSources(inputsFor(model).nodes, []));
+function exportsOf(model, fileId) {
+  const { metrics, symbols, consumers } = symbolFacts(model);
+  const declared = symbols.filter((s) => s.fileId === fileId);
+  const rows = buildHotExports(declared, /* @__PURE__ */ new Set([fileId]), metrics, consumers)[fileId] ?? [];
+  return rows.map((r) => ({ name: r.name, utilization: r.utilization, cognitive: r.cognitive ?? null, consumers: r.consumers, exported: r.exported }));
+}
+function scoreOf(model, node, window) {
+  const grain = node.ref.kind;
+  if (grain !== "file" && grain !== "symbol") return null;
+  const rows = scoredRows(model, { grain, window });
+  const at = rows.findIndex((r) => r.nodeId === node.ref.id);
+  if (at < 0) return { grain, window, score: 0, rank: null, ranked: rows.length };
+  const { score, churn, complexity: complexity2, recency, utilization } = rows[at];
+  const factors = utilization === void 0 ? { churn, complexity: complexity2, recency } : { churn, complexity: complexity2, recency, utilization };
+  return { grain, window, score, ...factors, rank: at + 1, ranked: rows.length };
+}
+function centralityOf(model, fileId) {
+  const rows = centralFiles(model);
+  const at = rows.findIndex((r) => r.nodeId === fileId);
+  return { score: at < 0 ? null : rows[at].score, rank: at < 0 ? null : at + 1, of: rows.length };
+}
+function testsOf(model, fileId) {
+  const tests = testLinks(model).filter((l) => l.sourceId === fileId).map((l) => toRef(model.nodeById.get(l.testId)));
+  const counts2 = model.metrics.get("linked_test_count");
+  const indexedCount = counts2 ? counts2.get(fileId) ?? 0 : null;
+  return { tests, indexedCount, coEditMeasured: false };
+}
+function lensOf(model, node, lens, window) {
+  if (lens === "score") return scoreOf(model, node, window);
+  if (node.ref.kind !== "file") return null;
+  const id = node.ref.id;
+  if (lens === "exports") return exportsOf(model, id);
+  if (lens === "centrality") return centralityOf(model, id);
+  if (lens === "tests") return testsOf(model, id);
+  return { measured: false, partners: [] };
+}
+function lensesFor(model, node, args) {
+  return Object.fromEntries(args.lenses.map((lens) => [lens, lensOf(model, node, lens, args.window)]));
+}
+
+// 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 counts2 = {};
+  for (const child of node.children) counts2[child.ref.kind] = (counts2[child.ref.kind] ?? 0) + 1;
+  return counts2;
+}
+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)),
+    ...args.lenses.length > 0 ? { lenses: lensesFor(model, node, args) } : {}
+  };
+}
+
+// src/query/overview.ts
+import {
+  computeHealth,
+  topBusFactorRisks
+} from "@titan-design/code-graph/analysis";
+var UNMEASURED = /* @__PURE__ */ new Set(["hidden-coupling"]);
+function findingRows(model, baseline) {
+  const current = findingsFor(model);
+  return baseline ? withStatus(current, findingsFor(baseline.model)) : current.map((f) => ({ ...f, status: "carryover" }));
+}
+function findingCounts(rows, withBaseline) {
+  const count = (status) => rows.filter((f) => f.status === status).length;
+  const open = rows.length - count("resolved");
+  if (!withBaseline) return { open };
+  return { open, new: count("new"), carryover: open - count("new"), resolved: count("resolved") };
+}
+function toWeights(w) {
+  return {
+    hotspots: w.hotspots,
+    findings: { eachNew: w.findings.each_new, eachCarry: w.findings.each_carry, cap: w.findings.cap },
+    complexity: w.complexity,
+    hiddenCoupling: w.hidden_coupling
+  };
+}
+function signals(args, kpis, findings2) {
+  const excluded = new Set(args.exclude_rules);
+  const counted = findings2.filter((f) => f.status !== "resolved" && !excluded.has(f.rule));
+  const newCount = counted.filter((f) => f.status === "new").length;
+  const input = {
+    scary: kpis.hotspotsOverCutoff,
+    newViolations: newCount,
+    carryViolations: counted.length - newCount,
+    maxComplexity: kpis.maxComplexity,
+    hiddenCoupling: 0,
+    scaryCutoff: args.cutoff
+  };
+  const { health, healthBreakdown } = computeHealth(input, toWeights(args.weights));
+  return { signals: healthBreakdown.map((c) => ({ ...c, measured: !UNMEASURED.has(c.key) })), combined: health };
+}
+function readingOrder(model, limit) {
+  return centralFiles(model).slice(0, limit).map((r) => ({ node: toRef(model.nodeById.get(r.nodeId)), centrality: r.score }));
+}
+function lookFirst(model, hotspots, findings2, args) {
+  const flagged = new Set(findings2.filter((f) => f.status !== "resolved").map((f) => f.node.path));
+  return hotspots.slice(0, args.look_limit).map((h) => {
+    const reasons = [];
+    if (h.score >= args.cutoff) reasons.push("over-cutoff");
+    if (flagged.has(h.nodeId)) reasons.push("findings");
+    const { score, churn, complexity: complexity2, recency } = h;
+    const node = toRef(model.nodeById.get(h.nodeId));
+    return { node, score, churn, complexity: complexity2, recency, reasons: reasons.length > 0 ? reasons : ["churn-complexity"] };
+  });
+}
+function getOverview(source, args) {
+  const model = modelFor(source, args.snapshot);
+  const baseline = openBaseline(source, args.baseline);
+  const ctx = reportContext(model, args.window);
+  const hotspots = scoredRows(model, { grain: "file", window: args.window });
+  const findings2 = findingRows(model, baseline);
+  const kpis = {
+    hotspotsOverCutoff: hotspots.filter((h) => h.score >= args.cutoff).length,
+    maxComplexity: hotspots.reduce((max, h) => Math.max(max, h.complexity), 0),
+    knowledgeSilos: topBusFactorRisks(ctx, Infinity).length,
+    findings: findingCounts(findings2, baseline !== void 0)
+  };
+  const { signals: attention, combined } = signals(args, kpis, findings2);
+  return {
+    snapshotId: model.snapshot.id,
+    ...baselineFields(model, baseline),
+    kpis,
+    signals: attention,
+    ...args.combined ? { combined } : {},
+    readingOrder: readingOrder(model, args.reading_limit),
+    lookFirst: lookFirst(model, hotspots, findings2, args)
+  };
+}
+
+// src/query/packages-stats.ts
+import {
+  bucketFilesByPackage,
+  computePartitionQuality,
+  filteredFileIds
+} from "@titan-design/code-graph/analysis";
+var NON_STRUCTURAL = /* @__PURE__ */ new Set(["references", "calls"]);
+var UNDECLARED = { status: "undeclared" };
+var trimRoot = (id) => id.replace(/\/+$/, "");
+function declaredTiers(rules) {
+  const out = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    rule.layers?.forEach((tier, i) => {
+      for (const id of tier.map(trimRoot)) if (!out.has(id)) out.set(id, { status: "declared", tier: i, rule: rule.id });
+    });
+  }
+  return out;
+}
+function packageRoots(args, tiers) {
+  const ids = [...new Set((args.packages ?? [...tiers.keys()]).map(trimRoot))].filter((id) => id !== "").sort();
+  const packagesFrom = args.packages ? "args" : ids.length > 0 ? "tiers" : "none";
+  return { packagesFrom, roots: ids.map((id) => ({ id, name: id.slice(id.lastIndexOf("/") + 1) })) };
+}
+function structuralEdges(model) {
+  return model.edges.filter((e) => !NON_STRUCTURAL.has(e.kind)).map((e) => ({ srcId: e.srcId, dstId: e.dstId, kind: e.kind, attrs: e.attrs }));
+}
+function toRow2(stats, name, layer) {
+  const { pkgId, layer: band, flags, ...measures } = stats;
+  return { id: pkgId, name, ...measures, band, flags: [...flags], layer };
+}
+function packagesStats(source, args) {
+  const model = modelFor(source, args.snapshot);
+  const tiers = declaredTiers(model.rules);
+  const { packagesFrom, roots } = packageRoots(args, tiers);
+  const { nodes } = inputsFor(model);
+  const fileByPackage = bucketFilesByPackage(filteredFileIds(nodes, {}), roots);
+  const quality = computePartitionQuality({ packages: roots, fileByPackage, nodes, edges: structuralEdges(model) });
+  const names = new Map(roots.map((r) => [r.id, r.name]));
+  return {
+    snapshotId: model.snapshot.id,
+    packagesFrom,
+    modularity: quality.modularityQ,
+    totalEdges: quality.totalEdges,
+    unassignedFiles: fileByPackage.get("")?.length ?? 0,
+    packages: quality.perPackage.map((p) => toRow2(p, names.get(p.pkgId), tiers.get(p.pkgId) ?? UNDECLARED)),
+    crossEdges: quality.pairCoupling.map((c) => ({ ...c }))
+  };
+}
+
+// src/query/paths-impact.ts
+import { hotspotComplexityOf, hotspotScoreOf as hotspotScoreOf2 } from "@titan-design/code-graph/analysis";
+var WORST_FIRST = compareFindings("severity", "desc");
+function repoRelative(input, root) {
+  const rel = underRoot(input, root);
+  if (rel === null) return null;
+  const parts = [];
+  for (const segment of rel.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment !== "..") parts.push(segment);
+    else if (parts.pop() === void 0) return null;
+  }
+  return parts.join("/");
+}
+function underRoot(input, root) {
+  if (!input.startsWith("/")) return input;
+  if (root === void 0) return null;
+  const base = root.replace(/\/+$/, "");
+  if (input === base) return "";
+  return input.startsWith(`${base}/`) ? input.slice(base.length + 1) : null;
+}
+var trimmed = (dir) => dir.replace(/\/+$/, "");
+function checkRoot(root, repoRoot) {
+  if (root === void 0 || !repoRoot) return;
+  const base = trimmed(repoRoot);
+  const given = trimmed(root);
+  if (given !== base && `${base}/`.startsWith(`${given}/`)) {
+    throw invalidArgs(`root "${root}" is above the index's repo root; give the repo, or a checkout of it, as root`);
+  }
+}
+var isFile = (model, id) => model.nodeById.get(id)?.kind === "file";
+function sideOf(model, window) {
+  const rows = scoredRows(model, { grain: "file", window });
+  const hotspots = new Map(rows.map((r, i) => [r.nodeId, { score: r.score, rank: i + 1 }]));
+  return { model, ctx: reportContext(model, window), hotspots };
+}
+function openByFile(model) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of findingsFor(model)) {
+    const rows = out.get(f.node.path);
+    if (rows) rows.push(f);
+    else out.set(f.node.path, [f]);
+  }
+  for (const rows of out.values()) rows.sort(WORST_FIRST);
+  return out;
+}
+function statuses(buckets) {
+  const status = /* @__PURE__ */ new Map();
+  for (const u of buckets.unchanged) status.set(u.to.row.id, "carryover");
+  for (const u of buckets.worsened) status.set(u.to.row.id, "worsened");
+  for (const u of buckets.improved) status.set(u.to.row.id, "improved");
+  for (const v of buckets.newViolations) status.set(v.row.id, "new");
+  return status;
+}
+function findingDeltas(buckets) {
+  const out = /* @__PURE__ */ new Map();
+  const count = (v, key) => {
+    const d = out.get(v.row.node.path) ?? { new: 0, worsened: 0, improved: 0, resolved: 0 };
+    d[key] += 1;
+    out.set(v.row.node.path, d);
+  };
+  for (const v of buckets.newViolations) count(v, "new");
+  for (const u of buckets.worsened) count(u.to, "worsened");
+  for (const u of buckets.improved) count(u.to, "improved");
+  for (const v of buckets.resolvedViolations) count(v, "resolved");
+  return out;
+}
+function compareTo(current, baseline) {
+  const buckets = bucketFindings(baseline.model, current.model);
+  return { baseline, status: statuses(buckets), findings: findingDeltas(buckets) };
+}
+function deltaOf(row, comparison) {
+  const { model, ctx } = comparison.baseline;
+  const inBaseline = isFile(model, row.path);
+  const scoreBefore = inBaseline ? hotspotScoreOf2(ctx, row.path) : null;
+  const complexityBefore = inBaseline ? hotspotComplexityOf(ctx, row.path) ?? null : null;
+  return {
+    inBaseline,
+    scoreBefore,
+    score: delta(row.hotspot.score, scoreBefore),
+    complexityBefore,
+    complexity: delta(row.complexity, complexityBefore),
+    findings: comparison.findings.get(row.path) ?? { new: 0, worsened: 0, improved: 0, resolved: 0 }
+  };
+}
+function indexedRow(input, path, reading) {
+  const { current, comparison } = reading;
+  const open = reading.open.get(path) ?? [];
+  const row = {
+    status: "indexed",
+    input,
+    path,
+    node: toRef(current.model.nodeById.get(path)),
+    complexity: hotspotComplexityOf(current.ctx, path) ?? null,
+    hotspot: current.hotspots.get(path) ?? { score: 0, rank: null },
+    findings: comparison ? open.map((f) => ({ ...f, status: comparison.status.get(f.id) ?? "carryover" })) : open
+  };
+  if (comparison !== void 0) row.delta = comparison && deltaOf(row, comparison);
+  return row;
+}
+function rowFor(input, path, reading) {
+  if (path === null) return { status: "outside-repo", input };
+  if (!isFile(reading.current.model, path)) return { status: "not-indexed", input, path };
+  return indexedRow(input, path, reading);
+}
+function rowsFor(args, reading) {
+  const seen = /* @__PURE__ */ new Set();
+  const rows = [];
+  for (const input of args.paths) {
+    const path = repoRelative(input, args.root);
+    const key = path ?? `outside:${input}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push(rowFor(input, path, reading));
+  }
+  return rows;
+}
+var best = (values, pick) => {
+  const measured = values.filter((v) => v !== null);
+  return measured.length > 0 ? pick(...measured) : null;
+};
+function deletedResolved(rows, comparison) {
+  return rows.reduce((sum, r) => sum + (r.status === "not-indexed" ? comparison.findings.get(r.path)?.resolved ?? 0 : 0), 0);
+}
+function rollupDelta(indexed, deleted) {
+  const findings2 = { new: 0, worsened: 0, improved: 0, resolved: 0 };
+  let score = 0;
+  for (const { delta: d, hotspot } of indexed) {
+    score += d.score ?? hotspot.score;
+    for (const key of Object.keys(findings2)) findings2[key] += d.findings[key];
+  }
+  findings2.resolved += deleted;
+  return { score, findings: findings2 };
+}
+function rollupOf(rows, comparison) {
+  const indexed = rows.filter((r) => r.status === "indexed");
+  const rollup = {
+    indexed: indexed.length,
+    notIndexed: rows.filter((r) => r.status === "not-indexed").length,
+    outsideRepo: rows.filter((r) => r.status === "outside-repo").length,
+    score: indexed.reduce((sum, r) => sum + r.hotspot.score, 0),
+    maxComplexity: best(indexed.map((r) => r.complexity), Math.max),
+    topRank: best(indexed.map((r) => r.hotspot.rank), Math.min),
+    openFindings: indexed.reduce((sum, r) => sum + r.findings.length, 0)
+  };
+  if (comparison !== void 0) rollup.delta = comparison && rollupDelta(indexed, deletedResolved(rows, comparison));
+  return rollup;
+}
+function pathsImpact(source, args) {
+  checkRoot(args.root, source.repoRoot);
+  const model = modelFor(source, args.snapshot);
+  const baseline = openBaseline(source, args.baseline);
+  const fields = baselineFields(model, baseline);
+  const current = sideOf(model, args.window);
+  const comparison = baseline && (fields.comparable ? compareTo(current, sideOf(baseline.model, args.window)) : null);
+  const reading = { current, open: openByFile(model), comparison };
+  const rows = rowsFor(args, reading);
+  return { snapshotId: model.snapshot.id, ...fields, rows, ranked: current.hotspots.size, rollup: rollupOf(rows, comparison) };
+}
+
+// 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 best2 = 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 = best2?.ref.span;
+        if (!bestSpan || span.endLine - span.startLine < bestSpan.endLine - bestSpan.startLine) best2 = child;
+      }
+      visit(child);
+    }
+  };
+  visit(file);
+  return best2;
+}
+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,
+  "hotspots.list": listHotspots,
+  "overview.get": getOverview,
+  "changes.get": getChanges,
+  "paths.impact": pathsImpact,
+  "packages.stats": packagesStats
+};
+
+// 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,
+  HOTSPOTS_PAGE_MAX,
+  ChurnWindow,
+  HotspotMark,
+  Hotspot,
+  NodeLens,
+  ExportRow,
+  ScoreBreakdown,
+  Centrality,
+  CoupledPartners,
+  LinkedTests,
+  NodeLenses,
+  HIERARCHY_ROW_CAP,
+  OVERVIEW_ROWS_MAX,
+  AttentionSignal,
+  LookFirstRow,
+  ReadingOrderRow,
+  CHANGES_ROWS_MAX,
+  ScoreChange,
+  NewFile,
+  FindingChange,
+  Regression,
+  CoChangePair,
+  PATHS_IMPACT_MAX,
+  FindingDelta,
+  PathDelta,
+  PathHotspot,
+  PathImpact,
+  ImpactRollup,
+  PACKAGES_MAX,
+  PackageLayer,
+  PackageStatsRow,
+  CrossEdge,
+  CODE_READ_API_VERSION,
+  CONTRACT,
+  COMMAND_NAMES,
+  AGENT_COMMANDS,
+  serializeContract,
+  buildReadModel,
+  ReadError,
+  snapshotNotFound,
+  nodeNotFound,
+  findingNotFound,
+  invalidArgs,
+  resolveSnapshot,
+  excessOf,
+  listHotspots,
+  getChanges,
+  getNeighbors,
+  RELATED_CAP,
+  getFinding,
+  listFindings,
+  getHierarchy,
+  getNode,
+  getOverview,
+  declaredTiers,
+  packagesStats,
+  repoRelative,
+  pathsImpact,
+  resolveNode,
+  describeApi,
+  listSnapshots,
+  QUERIES,
+  createQueryResolver
+};
+//# sourceMappingURL=chunk-7FNTXO7C.js.map