@titan-design/code-graph 0.10.0 → 0.13.0

package/dist/index.d.ts

@@ -1,63 +1,12 @@
+import { N as NodeKind, G as GraphNode, a as GraphEdge, b as GraphMetric, I as IdAlias, F as FileFingerprint, S as SnapshotRow, c as GraphFragment, d as NodeRole, E as EdgeKind, e as IdAliasReason, T as TestSourceLink, f as NodeMetrics, B as BlastRadiusEntry, R as ReferenceEdgeLite, g as SymbolConsumers, h as SymbolCouplingOptions, i as SymbolCouplingPair, C as CheckRule, j as CheckResult, k as CheckViolation, l as Severity, V as ViolationBuckets } from './browser-BBzShneN.js';
+export { A as ArchEdge, m as ArchPackage, n as ArchResult, o as ArchSubNode, p as BucketableViolation, q as BusFactorChange, r as BusFactorRow, s as CentralRow, t as CheckRulesFile, u as ComputeArchInput, v as ComputeDriftInput, w as CouplingClass, x as CouplingDelta, y as CouplingRow, D as DEFAULT_HEALTH_WEIGHTS, z as DEFAULT_MAX_PACKAGE_SIZE, H as DeadModuleRow, J as EXTERNAL_BUCKET, K as ForbidImportRule, L as GraphReportResult, M as GrowthRiskRow, O as HealthComponent, P as HealthComponentKey, Q as HealthInput, U as HealthWeights, W as HotExport, X as HotspotDelta, Y as HotspotRow, Z as LayeredDepsRule, _ as LinkMethod, $ as LinkTestsOptions, a0 as MetricMaxRule, a1 as MetricMinRule, a2 as MetricOutlierRule, a3 as MetricProductMaxRule, a4 as NewHotspot, a5 as NoInternalOnlyBarrelsRule, a6 as PackageFlag, a7 as PackageLayer, a8 as PackageRoot, a9 as PackageStats, aa as PairCoupling, ab as PairFlag, ac as PartitionQualityInput, ad as PartitionQualityResult, ae as PenaltyWeight, af as ReportContext, ag as ReportContextInput, ah as ReportDrift, ai as SnapshotContext, aj as SymbolConsumerGroup, ak as SymbolConsumerRow, al as SymbolCouplingPayload, am as SymbolCouplingRow, an as SymbolUtil, ao as TestCoverageRow, ap as UnchangedViolation, aq as UntestedRiskRow, ar as UnusedExportRow, as as ViolationIdentity, at as aggregateEdges, au as bucketFilesByPackage, av as bucketViolations, aw as buildBlastRadius, ax as buildCentralFiles, ay as buildHotExports, az as buildNodeMetrics, aA as buildReportContext, aB as buildSymbolCouplingPayload, aC as busFactorOf, aD as classifyCoupling, aE as collectNodeMetrics, aF as collectSymbolUtil, aG as computeArch, aH as computeHealth, aI as computePartitionQuality, aJ as computeReportDrift, aK as computeSymbolConsumers, aL as computeSymbolCoupling, aM as filteredFileIds, aN as groupTestsBySource, aO as hotspotScoreOf, aP as invertBuckets, aQ as keepNode, aR as linkTestsToSources, aS as lookupMetric, aT as packagesReferencedByEdges, aU as pairKey, aV as publicApiFiles, aW as rebasedViolationKey, aX as referencedNodes, aY as testCoverageCountMetrics, aZ as toSortedEdges, a_ as topBusFactorRisks, a$ as topCentralFiles, b0 as topDeadModules, b1 as topGrowthRisks, b2 as topHotspots, b3 as topTestCoverageRisks, b4 as topUntestedRisks, b5 as topUnusedExports, b6 as violationKey } from './browser-BBzShneN.js';
 import { Db, Migration } from '@titan-design/store-sqlite';
+import { FileSystemHost, Project } from 'ts-morph';
 import { Extractor, ParsedFile } from '@titan-design/code-parser';
 export { Extractor, ParsedFile, getLanguageFromPath, getSupportedLanguages, parseFile, shouldIncludeFile } from '@titan-design/code-parser';
-import { Project } from 'ts-morph';
-import { c as CoEditPair, C as ChurnEntry, a as ChurnWindow } from './change-coupling-CyqHgRsm.js';
+import { C as ChurnEntry, a as ChurnWindow } from './change-coupling-CT3bcZMD.js';
 import { Embedder } from '@titan-design/embed';
 
-type NodeKind = "package" | "module" | "file" | "symbol" | "external";
-type EdgeKind = "imports" | "re-exports" | "calls" | "extends" | "implements" | "references" | "depends-on";
-/** `requalify` maps a bare-name symbol id from before index version 0.14.0 to its scope-qualified successor. */
-type IdAliasReason = "rename" | "move" | "merge" | "requalify";
-type NodeRole = "test" | "fixture" | "barrel" | "types" | "config" | "script" | "entry" | "generated" | "source";
-interface GraphNode {
-    id: string;
-    kind: NodeKind;
-    name: string;
-    parentId?: string;
-    language?: string;
-    role?: NodeRole;
-    attrs?: Record<string, unknown>;
-}
-interface GraphEdge {
-    srcId: string;
-    dstId: string;
-    kind: EdgeKind;
-    attrs?: Record<string, unknown>;
-}
-interface GraphMetric {
-    nodeId: string;
-    name: string;
-    value: number | null;
-    unit?: string;
-}
-interface GraphFragment {
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-}
-interface SnapshotRow {
-    id: number;
-    ref: string;
-    commitHash: string | null;
-    takenAt: string;
-    indexVersion: string;
-    attrs: Record<string, unknown>;
-}
-interface IdAlias {
-    oldId: string;
-    newId: string;
-    reason: IdAliasReason;
-}
-interface FileFingerprint {
-    fileId: string;
-    contentHash: string;
-    /**
-     * Comment/whitespace-insensitive parse-structure hash (C-18). Absent on
-     * snapshots written before C-18 (they can only reuse whole unchanged files).
-     */
-    structuralHash?: string;
-}
-
 /** One metric's values over the nodes of one kind in one snapshot; `count` excludes null values. */
 interface MetricAggregate {
     name: string;
@@ -95,6 +44,13 @@ declare class CodeGraphStore {
     private readonly targeted;
     constructor(db: Db);
     createSnapshot(input: SnapshotInsert): number;
+    /**
+     * Run `write` in one transaction so a reader on another connection sees a new
+     * snapshot only once every row written for it is committed, never a snapshot
+     * row whose nodes or edges are still being inserted. The per-table inserts
+     * nest as savepoints inside it.
+     */
+    atomically<T>(write: () => T): T;
     insertNodes(snapshotId: number, nodes: readonly GraphNode[]): void;
     insertEdges(snapshotId: number, edges: readonly GraphEdge[]): void;
     insertMetrics(snapshotId: number, metrics: readonly GraphMetric[]): void;
@@ -185,7 +141,7 @@ declare const FINDING_DDL = "\n  CREATE TABLE IF NOT EXISTS finding (\n    snaps
 declare const SNAPSHOT_SCOPED_TABLES: readonly ["node", "edge", "metric", "id_alias", "file_fingerprint", "finding", "verdict"];
 declare const MIGRATIONS: Migration[];
 /** The top of this package's schema. A code graph database is never shared, so this is the top of one. */
-declare const SCHEMA_VERSION: number;
+declare const SCHEMA_VERSION$1: number;
 
 interface PrunePlan {
     keep: SnapshotRow[];
@@ -206,12 +162,40 @@ declare function runPrune(store: CodeGraphStore, options?: PruneOptions & {
     vacuum?: boolean;
 }): PruneResult;
 
+/**
+ * Where the indexer reads a tree from. Every path is absolute and node ids are
+ * derived from it, so a source that is not the working tree (a git commit, say)
+ * keeps ids byte-identical by answering for the same absolute paths.
+ */
+interface IndexSource {
+    /**
+     * Source files under `rootDirs` that pass the ingest filter for `languages`,
+     * deduped and sorted, so float metrics summed in file order match across sources.
+     */
+    listFiles(rootDirs: readonly string[], languages: readonly string[]): Promise<string[]>;
+    /** UTF-8 content of a file; throws when it does not exist. */
+    readFile(abs: string): string;
+    fileExists(abs: string): boolean;
+    /** The host ts-morph resolves imports and reads tsconfig through. */
+    readonly fileSystem: FileSystemHost;
+    /** Set when the source is a git commit rather than the working tree; undefined for the working tree. */
+    readonly revision?: {
+        /** The repo's toplevel, canonicalized with realpath. */
+        readonly repoRoot: string;
+        readonly commit: string;
+        /** Committer time, seconds since the epoch. */
+        readonly commitEpoch: number;
+    };
+}
+/** The checked-out working tree, read through `node:fs`. The default source. */
+declare function workingTreeSource(): IndexSource;
+
 /**
  * Bumping this invalidates every reuse basis: a snapshot written by a different
  * index version is never reused, so a change to node/edge shape or to a metric's
  * value for the same bytes can never be carried forward from an incompatible graph.
  */
-declare const INDEX_VERSION = "0.18.0";
+declare const INDEX_VERSION = "0.22.0";
 interface IndexOptions {
     /** Roots to walk. Node ids are still rooted at the git toplevel, so importers across roots share an id space. */
     paths: string[];
@@ -235,6 +219,8 @@ interface IndexOptions {
     churnWindows?: number[];
     /** Also store an all-time `lifetime` churn and ownership window over full git history. */
     lifetime?: boolean;
+    /** Where files are listed and read from. Defaults to {@link workingTreeSource}. */
+    source?: IndexSource;
 }
 interface IndexResult {
     snapshotId: number;
@@ -260,9 +246,19 @@ interface IndexResult {
  */
 declare function indexPaths(store: CodeGraphStore, options: IndexOptions): Promise<IndexResult>;
 
+/**
+ * Index `rev`'s tree from git objects, without a checkout and without writing to
+ * the repo. Files keep their `<repo root>/<tree path>` absolute paths, so ids
+ * match a working-tree index of the same commit. Workspace links into the repo
+ * resolve to the commit; installed packages and untracked build output such as
+ * a gitignored dist/ resolve against today's disk.
+ */
+declare function gitTreeSource(repoRoot: string, rev: string): IndexSource;
+
 interface LanguageExtractorOptions {
     repoRoot: string;
     tsConfigPath?: string;
+    source?: IndexSource;
 }
 /**
  * One extractor over every supported language: each delegate already returns an
@@ -285,8 +281,9 @@ declare class LanguageExtractor implements Extractor<GraphFragment> {
  */
 declare class PythonGraphExtractor implements Extractor<GraphFragment> {
     private readonly repoRoot;
+    private readonly source;
     readonly name = "python-graph";
-    constructor(repoRoot: string);
+    constructor(repoRoot: string, source?: IndexSource);
     extract(file: ParsedFile): GraphFragment[];
     private collectImports;
     /**
@@ -301,14 +298,21 @@ interface TsMorphGraphExtractorOptions {
     repoRoot: string;
     tsConfigPath?: string;
     project?: Project;
+    source?: IndexSource;
 }
 declare class TsMorphGraphExtractor implements Extractor<GraphFragment> {
     readonly name = "ts-morph-graph";
     private readonly repoRoot;
     private readonly tsConfigPath?;
     private project?;
+    private readonly ownsProject;
+    private readonly source;
+    private readonly retired;
+    private readonly fileExists;
     constructor(options: TsMorphGraphExtractorOptions);
     extract(file: ParsedFile): GraphFragment[];
+    private retire;
+    private extractFrom;
     private ensureProject;
     private loadSourceFile;
     private buildFileAndModuleNodes;
@@ -411,10 +415,6 @@ interface DeepAstInput {
 /** Deep structural facts for one target, or null when the source is unreadable. */
 declare function computeDeepAst(input: DeepAstInput): DeepAst | null;
 
-declare function fileId(repoRoot: string, absPath: string): string;
-declare function moduleId(repoRoot: string, absPath: string): string;
-declare function parentModuleId(id: string): string | null;
-declare function packageId(name: string): string;
 declare const SYMBOL_ID_SEP = "#";
 declare function symbolId(fileId: string, qualifiedName: string): string;
 /**
@@ -427,6 +427,12 @@ declare function parseSymbolId(id: string): {
     fileId: string;
     name: string;
 } | null;
+
+declare function fileId(repoRoot: string, absPath: string): string;
+declare function moduleId(repoRoot: string, absPath: string): string;
+declare function parentModuleId(id: string): string | null;
+declare function packageId(name: string): string;
+
 declare function externalId(specifier: string): string;
 
 /** SHA-256 of file content. The fingerprint that gates per-file reuse. */
@@ -449,7 +455,7 @@ interface ReadFile {
     hash: string;
 }
 /** Read + hash every source file. Cheap I/O; the parse/extract it gates is not. */
-declare function readSourceFiles(filePaths: readonly string[]): Promise<ReadFile[]>;
+declare function readSourceFiles(filePaths: readonly string[], source?: IndexSource): Promise<ReadFile[]>;
 /**
  * Everything from a prior snapshot needed to rebuild an unchanged file's
  * contribution to the graph without re-parsing it: its content fingerprint,
@@ -530,12 +536,22 @@ declare function pruneDanglingReferences(nodes: ReadonlyMap<string, GraphNode>,
  */
 declare function resolveBarrelEdges(nodes: readonly GraphNode[], edges: readonly GraphEdge[]): GraphEdge[];
 
+/**
+ * Repo-configured role globs, read from `.codewatch/roles.json`. They label
+ * paths no filename convention can (a design system's `lab/` playground is
+ * too generic a directory name to guess), and they beat the built-in role
+ * heuristics. Globs use `.gitattributes` syntax, matched against file ids.
+ */
+type RoleGlobs = Partial<Record<NodeRole, string[]>>;
+
 declare const ALL_ROLES: readonly NodeRole[];
 interface RoleHints {
     /** File begins with a `#!` shebang, i.e. it is an executable entry point. */
     hasShebang?: boolean;
     /** File is codegen output (`.gitattributes linguist-generated` or heuristic). */
     isGenerated?: boolean;
+    /** Role a `.codewatch/roles.json` glob assigns this file. */
+    configuredRole?: NodeRole;
 }
 declare function classifyRole(id: string, hints?: RoleHints): NodeRole;
 interface AnnotateRolesOptions {
@@ -543,7 +559,11 @@ interface AnnotateRolesOptions {
     shebangIds?: ReadonlySet<string>;
     /** Node ids detected as generated (codegen output). */
     generatedIds?: ReadonlySet<string>;
+    /** Configured role globs; see {@link loadRoleGlobs}. */
+    roleGlobs?: RoleGlobs;
 }
+/** Read `<rootDir>/.codewatch/roles.json`; a repo without one configures no globs. */
+declare function loadRoleGlobs(rootDir: string, source?: IndexSource): RoleGlobs;
 interface ReadFileLike {
     filePath: string;
     content: string;
@@ -554,9 +574,17 @@ interface ReadFileLike {
  * `.gitattributes linguist-generated` under `idRoot` plus filename/path
  * heuristics). Lives here so the indexer stays at its file-size ceiling.
  */
-declare function computeRoleHints(readFiles: readonly ReadFileLike[], idRoot: string, toId: (root: string, filePath: string) => string): AnnotateRolesOptions;
+declare function computeRoleHints(readFiles: readonly ReadFileLike[], idRoot: string, toId: (root: string, filePath: string) => string, source?: IndexSource): AnnotateRolesOptions;
 declare function annotateRoles(nodes: readonly GraphNode[], options?: AnnotateRolesOptions): GraphNode[];
 
+/**
+ * Roles of files nothing imports by design, so reachability and dead-export
+ * reports treat them as roots. One list, typed by role, so a new role cannot be
+ * added to one report and missed in another. It lives apart from `roles.ts`,
+ * which reads files, so browser-safe report code can import it.
+ */
+declare const UNIMPORTED_ROLES: ReadonlySet<NodeRole>;
+
 /** True when a path looks generated by filename/dir convention alone. */
 declare function isGeneratedByHeuristic(id: string): boolean;
 /**
@@ -566,7 +594,7 @@ declare function isGeneratedByHeuristic(id: string): boolean;
  */
 declare function isGeneratedFile(id: string, patterns: readonly RegExp[]): boolean;
 /** Read `<rootDir>/.gitattributes` and compile its linguist-generated patterns. */
-declare function loadGeneratedPatterns(rootDir: string): RegExp[];
+declare function loadGeneratedPatterns(rootDir: string, source?: IndexSource): RegExp[];
 
 declare function canonicalMetricName(name: string): string;
 declare function canonicalRole(name: string): NodeRole;
@@ -695,36 +723,6 @@ declare const SYMBOL_METRIC_NAMES: readonly string[];
  */
 declare const EXCEPTION_METRIC_NAMES: readonly string[];
 
-/** How a test↔source pairing was inferred. */
-type LinkMethod = "path" | "coedit";
-interface TestSourceLink {
-    /** Node id of the test file. */
-    testId: string;
-    /** Node id of the (non-test) file it covers. */
-    sourceId: string;
-    method: LinkMethod;
-}
-interface LinkTestsOptions {
-    /** Minimum co-edit count for a pass-2 (coedit) link. Default 2. */
-    minCoEditCount?: number;
-}
-/**
- * Two-pass test↔source linker. Pass 1 pairs each test file with non-test files
- * matching its path conventions (high confidence). Pass 2 supplements tests
- * left unpaired by pass 1 with their strongest co-edited non-test partner from
- * change-coupling. Handles orphan tests (no pairing), orphan/untested sources
- * (no incoming link), and one-to-many pairings (a test matching several
- * sources, or a source covered by several tests).
- */
-declare function linkTestsToSources(nodes: readonly GraphNode[], coEditPairs: readonly CoEditPair[], options?: LinkTestsOptions): TestSourceLink[];
-/**
- * Per-source coverage breadth: how many distinct test files link to each
- * covered source. Emitted only for sources with at least one linked test.
- */
-declare function testCoverageCountMetrics(links: readonly TestSourceLink[]): GraphMetric[];
-/** Map each covered source to the set of test files that link to it. */
-declare function groupTestsBySource(links: readonly TestSourceLink[]): Map<string, Set<string>>;
-
 interface HistoryMetricsOptions {
     /** Primary window: scopes ownership. Default 30. */
     churnWindowDays?: number;
@@ -734,6 +732,8 @@ interface HistoryMetricsOptions {
     includeLifetime?: boolean;
     /** Epoch seconds that windows end at; defaults to the current time. */
     nowEpoch?: number;
+    /** Read history up to this rev instead of HEAD; pair it with the rev's commit time as `nowEpoch`. */
+    rev?: string;
 }
 /** Windows the dashboard switcher offers; churn is stored for each by default. */
 declare const DEFAULT_CHURN_WINDOWS: number[];
@@ -866,6 +866,29 @@ interface SymbolSpan {
  */
 declare function attributeCoverage(coverage: IstanbulCoverage, fileIdOf: (absPath: string) => string | null, symbolsByFile: ReadonlyMap<string, readonly SymbolSpan[]>): GraphMetric[];
 
+type MinifyLanguage = "typescript" | "tsx" | "python";
+/**
+ * Minified source plus its line map. `lineMap[i]` is the 1-based original line
+ * of output line `i + 1`; `originalLine` reads it by output line number.
+ */
+interface MinifiedSource {
+    text: string;
+    lineMap: number[];
+}
+/** The one line that stands in for a leading import block. */
+declare function importMarker(count: number, language: MinifyLanguage): string;
+/** The 1-based original line of a 1-based output line, or undefined past the end. */
+declare function originalLine(minified: MinifiedSource, outputLine: number): number | undefined;
+declare function isMinifyLanguage(language: string): language is MinifyLanguage;
+/**
+ * Safe-minify source for LLM context: drops comments and docstrings, strips
+ * trailing whitespace, collapses blank-line runs and replaces a leading import
+ * block with `importMarker`. It never renames or dedents, so every kept line is
+ * its original line minus comments. Any other language comes back unchanged
+ * with an identity line map.
+ */
+declare function minifySource(text: string, language: string): Promise<MinifiedSource>;
+
 /** Metric-name suffix for a window: `30d`, `180d`, or `lifetime`. */
 declare function windowSuffix(window: ChurnWindow): string;
 /**
@@ -929,159 +952,237 @@ interface RelevanceOptions {
  */
 declare function computeRelevance(nodes: readonly GraphNode[], edges: readonly GraphEdge[], seedIds: readonly string[], options?: RelevanceOptions): Map<string, number>;
 
+/** Marks a gap between two symbols that are not adjacent in their file. */
+declare const ELISION_MARKER = "...";
+/** Ends a line cut at `maxLineChars`; it counts toward the limit. */
+declare const TRUNCATION_SUFFIX = "\u2026";
+declare const DEFAULT_MAX_LINE_CHARS = 120;
+interface SignatureTreeOptions {
+    maxLineChars?: number;
+}
 /**
- * Symbol-level change coupling (C-60). Decomposes a god-file the file-level
- * coupling view rolls up as one blob (e.g. `types.ts`) into *which symbol* is
- * used where. Built on the C-53 `references` edge substrate: `src` is the
- * importing file, `dst` is the imported symbol node id (`<fileId>#<name>`).
+ * Render symbols as a signatures-only tree for LLM context: per file (sorted by
+ * path) a header line, then one line per symbol, with `ELISION_MARKER` between
+ * symbols that are not adjacent. Pure; output is independent of input order.
  *
- * Two slices, both pure functions of the assembled reference edge set (a
- * whole-graph rollup like utilization/PageRank, sound under incremental reuse
- * since it reads the reassembled edges, not a per-file cache):
- *
- * - **Slice C — per-symbol consumers**: invert the edges by `dst`, giving the
- *   set of files that import each symbol. Directly answers "what IN this file is
- *   used where"; covers span-less types/consts that a git-hunk approach cannot.
- * - **Slice B — co-import coupling**: group edges by `src`, and every pair of
- *   symbols co-imported by the same file is a coupling pair. Two symbols that
- *   are always imported together travel together — structural (used-together),
- *   drift-free coupling, as opposed to the temporal (changed-together) git
- *   co-edit signal.
- */
-/** The minimal shape of a `references` edge this module consumes. */
-interface ReferenceEdgeLite {
-    /** Importing file id. */
-    srcId: string;
-    /** Imported symbol node id (`<fileId>#<name>`). */
-    dstId: string;
-}
-/** One symbol's consumer set (Slice C). */
-interface SymbolConsumers {
-    symbolId: string;
-    /** Declaring file, parsed from the symbol id. */
-    fileId: string;
-    /** Export name. */
+ * A line is the symbol's `attrs.signature`, else `<name> (<kind>)`. Symbols
+ * order by `attrs.startLine`, then name, then id. A qualified name
+ * (`Job.run`) indents one level per dot. Symbols with no `startLine`
+ * (exported types and consts) render after the line-ordered ones, sorted by
+ * name then id, and get no elision markers because their position is unknown.
+ */
+declare function renderSignatureTree(nodes: readonly GraphNode[], options?: SignatureTreeOptions): string;
+
+/**
+ * C-74 — deterministic per-file / per-symbol **context dossier** (Class A). A
+ * pure projection of the already-computed graph: no LLM, no source re-parse. The
+ * command layer (graph-context.ts) loads the snapshot and hands the assembled
+ * inputs here; this module owns only the shaping + the markdown render, so it is
+ * unit-testable on synthetic graphs.
+ */
+/** Bumped when the dossier shape changes, so a RAG store can invalidate records. */
+declare const SCHEMA_VERSION = "2";
+interface Provenance {
+    snapshotId: number;
+    ref: string;
+    commitHash: string | null;
+    takenAt: string;
+    indexVersion: string;
+}
+/**
+ * Consumers split by declaring-file role (C-74/G3): for core exports most inbound
+ * references are test files, which is truthful but low-signal for "what production
+ * code depends on this" — so source and test consumers are separated, not flattened.
+ */
+interface Consumers {
+    source: string[];
+    test: string[];
+    counts: {
+        source: number;
+        test: number;
+        total: number;
+    };
+    note: string;
+}
+interface FileOwnership {
+    primaryOwner: string;
+    busFactor: number;
+    authorCount: number;
+}
+/** One of a file's declared symbols, projected for the dossier. */
+interface SymbolLine {
     name: string;
-    /** Distinct importing file ids, sorted. */
-    consumers: string[];
-}
-/** A pair of symbols co-imported by the same file (Slice B). */
-interface SymbolCouplingPair {
-    aId: string;
-    aFile: string;
-    aName: string;
-    bId: string;
-    bFile: string;
-    bName: string;
-    /** Distinct files that import both symbols. */
-    coImports: number;
-    /** True when the two symbols are declared in different files. */
-    crossFile: boolean;
-}
-interface SymbolCouplingOptions {
-    /** Skip pairs co-imported by fewer than this many files. Default 2. */
-    minCoImports?: number;
+    exported: boolean;
+    /** One-line type signature (C-79), when indexed for this declaration. */
+    signature?: string;
+    cognitive?: number;
+    cyclomatic?: number;
+    utilization: number;
+    /** Distinct files that reference this symbol (inbound `references`). */
+    consumers: number;
     /**
-     * Skip importing files that reference more than this many distinct symbols —
-     * a wide barrel-style importer would otherwise explode into O(n²) noise
-     * pairs, mirroring change-coupling's large-commit guard. Default 40.
+     * Symbol-level importance (C-89): the declaring file's PageRank centrality
+     * redistributed across its symbols by utilization share, so a graph-central
+     * file's rank lands on the definitions actually carrying its inbound use.
      */
-    largeImporterThreshold?: number;
+    importance?: number;
 }
+interface SymbolDossier {
+    exported: boolean;
+    /** G1 slot — the one-line type signature indexed from `attrs.signature` (C-79); null when unannotated or unresolvable. */
+    signature: string | null;
+    /** G2 slot — leading docstring / intent. Null today. */
+    purpose: string | null;
+    complexity: {
+        cognitive?: number;
+        cyclomatic?: number;
+    };
+    utilization: number;
+    consumers: Consumers;
+    blastRadius: number;
+    coupledWith: {
+        symbolId: string;
+        name: string;
+        fileId: string;
+        coImports: number;
+    }[];
+}
+interface FileDossier {
+    metrics: NodeMetrics;
+    churn: {
+        windowDays: number;
+        value: number;
+    } | null;
+    centrality: number;
+    ownership: FileOwnership | null;
+    symbols: SymbolLine[];
+    dependsOn: string[];
+    consumers: Consumers;
+    blastRadius: BlastRadiusEntry[];
+}
+interface ContextDossier {
+    schemaVersion: string;
+    target: {
+        id: string;
+        kind: "file" | "symbol";
+        name: string;
+        path: string;
+        span?: {
+            startLine: number;
+            endLine: number;
+        };
+    };
+    provenance: Provenance;
+    symbol?: SymbolDossier;
+    file?: FileDossier;
+    notes: string[];
+}
+interface ContextBuildInput {
+    target: GraphNode;
+    kind: "file" | "symbol";
+    provenance: Provenance;
+    /** All nodes for the snapshot, symbols INCLUDED. */
+    nodes: readonly GraphNode[];
+    /** `references` edges as {srcId=importing file, dstId=symbol id}. */
+    refEdges: readonly ReferenceEdgeLite[];
+    /** `imports` edges as {srcId, dstId} (file → file/external). */
+    importEdges: readonly {
+        srcId: string;
+        dstId: string;
+    }[];
+    metrics: ReadonlyMap<string, NodeMetrics>;
+    churnByFile: ReadonlyMap<string, number>;
+    churnWindowDays: number;
+    centrality: ReadonlyMap<string, number>;
+    ownership: ReadonlyMap<string, FileOwnership> | null;
+    /** File id → node role, for splitting consumers into source vs test (G3). */
+    roleByFile: ReadonlyMap<string, string>;
+}
+declare function buildContextDossier(input: ContextBuildInput): ContextDossier;
+
 /**
- * Group reference edges by imported symbol, yielding each symbol's distinct
- * consuming files (Slice C). Sorted by consumer count desc, then symbol id, so
- * the most broadly-depended-on exports lead.
- */
-declare function computeSymbolConsumers(edges: readonly ReferenceEdgeLite[]): SymbolConsumers[];
-/**
- * Every pair of symbols co-imported by the same file becomes a coupling pair,
- * counted by how many distinct files co-import them (Slice B). Wide importers
- * are dropped to keep the pairing near-linear. Sorted by co-import count desc,
- * cross-file pairs preferred at a tie (they are the actionable ones — a
- * same-file pair is just cohesion within one module).
+ * Human/agent-readable markdown projection of a {@link ContextDossier} (C-74).
+ * The JSON form is the RAG-store record; this is the same facts rendered for a
+ * reader (or an agent that prefers prose). Deterministic — no LLM.
  */
-declare function computeSymbolCoupling(edges: readonly ReferenceEdgeLite[], options?: SymbolCouplingOptions): SymbolCouplingPair[];
+declare function renderContextMarkdown(d: ContextDossier): string;
 
 /**
- * Per-package and per-pair structural quality metrics, plus an overall
- * Newman-Girvan modularity Q for the package partition.
- *
- * Operates on a barrel-resolved edge set by default: edges that land on a
- * file with role="barrel" are rewritten to land on the underlying files
- * the barrel re-exports from (transitively). The intent is to measure the
- * real dependency surface, not the re-export plumbing.
- *
- * See C-8 task notes for the design rationale and empirical calibration
- * data from the 2026-05-21 codewatch dogfood.
+ * C-80 — the **context bundle**: one deterministic pull of the complete paired
+ * context for a symbol/file, the push half of the ingestion API. It wraps the
+ * C-74 dossier with the three things an ingestor needs to embed/answer WITHOUT
+ * opening the file: the raw **source chunk** (source text of the span), the
+ * resolved **graph linkages as explicit edges** (callers / dependencies /
+ * coupled-with — not just counts), and **coverage** (C-63, when the overlay is
+ * ingested). No LLM; a pure projection of the graph + the working-tree source.
  */
-interface PartitionQualityInput {
-    /** Logical packages — at minimum needs an id. */
-    packages: ReadonlyArray<{
-        id: string;
-    }>;
-    /** Package id → list of file ids assigned to that package. */
-    fileByPackage: ReadonlyMap<string, ReadonlyArray<string>>;
-    /** All file/module/external nodes for the snapshot. Used to identify role="barrel". */
-    nodes: readonly GraphNode[];
-    /** All edges for the snapshot. */
-    edges: readonly GraphEdge[];
-    /**
-     * When true, edges landing on a barrel file are resolved through its
-     * re-export chain to the underlying source files. The cheap implementation
-     * fans each barrel import into N synthetic edges (one per re-export
-     * target), which over-attributes — a single `import { x } from "./pkg"`
-     * becomes N edges as if every re-export were used. Default false until
-     * a weighted or symbol-tracking version is available.
-     */
-    resolveBarrels?: boolean;
-}
-type PackageFlag = "weak-boundary";
-type PairFlag = "tight" | "moderate" | "none";
-type PackageLayer = "top" | "middle" | "foundation";
-interface PackageStats {
-    pkgId: string;
-    fileCount: number;
-    internalEdges: number;
-    outgoingEdges: number;
-    incomingEdges: number;
-    /** internal / (internal + outgoing) — higher = more self-contained. */
-    cohesion: number;
-    /** outgoing / (outgoing + incoming) — Martin's I metric at the package level. */
-    instability: number;
-    /**
-     * Abstractness proxy A ∈ [0,1]: share of the package's files with role
-     * "types" (dedicated type/interface definitions). codewatch has no
-     * symbol-level abstract/concrete counts, so this file-role ratio stands in
-     * for Martin's A. Enables the instability×abstractness main-sequence plot.
-     */
-    abstractness: number;
-    layer: PackageLayer;
-    flags: PackageFlag[];
+declare const BUNDLE_SCHEMA_VERSION = "2";
+interface SourceChunk {
+    /** Repo-relative file id the chunk was read from. */
+    path: string;
+    /** 1-based inclusive line span for a symbol; null for a whole-file target. */
+    span: {
+        startLine: number;
+        endLine: number;
+    } | null;
+    /** The source text, or null when the file could not be read. */
+    text: string | null;
+    note?: string;
 }
-interface PairCoupling {
+/** A resolved graph linkage, deterministic and directional relative to the target. */
+interface BundleEdge {
     from: string;
     to: string;
-    edges: number;
-    /** edges / files(from) — fraction of from-side files contributing dependencies into `to`. */
-    intensity: number;
-    flag: PairFlag;
+    kind: string;
+    weight: number;
+    /**
+     * Seeded-PageRank relevance of this edge's neighbour to the target (C-89).
+     * Present only when the target was seeded (the bundle path); the neighbour is
+     * whichever endpoint is not the target's file. Edges are ordered by it, so the
+     * most target-relevant linkages lead, not the globally-famous ones.
+     */
+    relevance?: number;
+}
+interface BundleEdges {
+    /** Inbound — who references/imports the target. */
+    callers: BundleEdge[];
+    /** Outbound — what the target references/imports. */
+    dependencies: BundleEdge[];
+    /** Co-import coupling partners (symbol targets only). */
+    coupledWith: BundleEdge[];
+    note: string;
+}
+interface Coverage {
+    pct: number | null;
+    note?: string;
 }
-interface PartitionQualityResult {
-    modularityQ: number;
-    totalEdges: number;
-    perPackage: PackageStats[];
-    pairCoupling: PairCoupling[];
-    /** Total raised flags across packages + pairs (excluding "moderate"). */
-    flagsCount: number;
+interface ContextBundle {
+    schemaVersion: string;
+    dossier: ContextDossier;
+    source: SourceChunk;
+    edges: BundleEdges;
+    coverage: Coverage;
 }
-declare function computePartitionQuality(input: PartitionQualityInput): PartitionQualityResult;
-/**
- * Invert a package→files bucket map into a file→package lookup, skipping the
- * empty-string "unassigned" bucket. Shared by partition-quality and the CLI's
- * arch/wiki package rollups, which all need the same file→package direction.
- */
-declare function invertBuckets(fileByPackage: ReadonlyMap<string, ReadonlyArray<string>>): Map<string, string>;
+interface BundleBuildInput {
+    dossier: ContextDossier;
+    target: GraphNode;
+    kind: "file" | "symbol";
+    /** Weighted `references` edges (srcId = importing file → dstId = symbol id). */
+    refEdges: readonly GraphEdge[];
+    /** Weighted `imports` edges (file → file/external). */
+    importEdges: readonly GraphEdge[];
+    /** Git toplevel to resolve the source path, or null (read relative to cwd). */
+    repoRoot: string | null;
+    /** `coverage_pct` for the target node, or null when the overlay is absent. */
+    coveragePct: number | null;
+    /** File id → seeded-relevance score (C-89); absent/empty ⇒ weight-ordered cold path. */
+    relevanceByFile?: ReadonlyMap<string, number>;
+    /** The target's declaring file id, for locating each edge's neighbour (C-89). */
+    targetFileId?: string;
+}
+declare function buildContextBundle(input: BundleBuildInput): ContextBundle;
+/** Concatenated text projection — hand this straight to an embedder/LLM. */
+declare function renderBundleText(bundle: ContextBundle): string;
 
 /**
  * PageRank over one snapshot's file-level graph (symbol nodes and `references`
@@ -1156,111 +1257,6 @@ declare function describeMetrics(names: Iterable<string>): {
     unknown: string[];
 };
 
-type Severity = "error" | "warning";
-interface MetricMaxRule {
-    type: "metric-max";
-    id: string;
-    metric: string;
-    max: number;
-    kind?: NodeKind;
-    severity?: Severity;
-    exclude?: string[];
-    excludeRoles?: NodeRole[];
-}
-interface MetricMinRule {
-    type: "metric-min";
-    id: string;
-    metric: string;
-    min: number;
-    kind?: NodeKind;
-    severity?: Severity;
-    exclude?: string[];
-    excludeRoles?: NodeRole[];
-}
-interface MetricProductMaxRule {
-    type: "metric-product-max";
-    id: string;
-    metrics: string[];
-    max: number;
-    kind?: NodeKind;
-    severity?: Severity;
-    exclude?: string[];
-    excludeRoles?: NodeRole[];
-}
-/** Flags nodes whose value sits strictly above the given percentile of the metric over every node of the kind. */
-interface MetricOutlierRule {
-    type: "metric-outlier";
-    id: string;
-    metric: string;
-    kind: NodeKind;
-    /** 50 to 100; the threshold interpolates linearly between the two nearest ranked values. */
-    percentile: number;
-    /** Fewest nodes that must carry the metric before any is judged; defaults to 20. */
-    minSample?: number;
-    /** A node is flagged only if its value also exceeds this absolute floor, guarding sparse metrics whose percentile sits at or near zero. */
-    floor?: number;
-    /** When true, rank and gate on the pool of carriers with a non-zero value only; zero-valued nodes are never flagged. */
-    rankNonZero?: boolean;
-    severity?: Severity;
-}
-interface ForbidImportRule {
-    type: "forbid-import";
-    id: string;
-    from: string;
-    to: string;
-    severity?: Severity;
-}
-interface LayeredDepsRule {
-    type: "layered-deps";
-    id: string;
-    layers: string[][];
-    severity?: Severity;
-}
-interface NoInternalOnlyBarrelsRule {
-    type: "no-internal-only-barrels";
-    id: string;
-    /** Path prefixes marking package roots; node ids carry no intrinsic package membership. */
-    packageRoots: string[];
-    severity?: Severity;
-    /** Globs or substrings to skip, such as CLI bin entries the role classifier calls barrels. */
-    exclude?: string[];
-}
-type CheckRule = MetricMaxRule | MetricMinRule | MetricProductMaxRule | MetricOutlierRule | ForbidImportRule | LayeredDepsRule | NoInternalOnlyBarrelsRule;
-interface CheckRulesFile {
-    rules: CheckRule[];
-}
-interface CheckViolation {
-    ruleId: string;
-    severity: Severity;
-    nodeId: string;
-    message: string;
-    metric?: string;
-    value?: number;
-    threshold?: number;
-    destinationId?: string;
-    isCarryover?: boolean;
-    /** Repo-relative file the violation sits in; a symbol's parent file. */
-    path?: string;
-    lineStart?: number;
-    lineEnd?: number;
-    symbol?: string;
-    /** One line a reader can check without re-running the rule, such as `loc=412 (max 350)`. */
-    evidence?: string;
-    tool?: string;
-}
-interface CheckResult {
-    snapshotId: number;
-    baselineSnapshotId?: number;
-    rulesEvaluated: number;
-    nodesEvaluated: number;
-    violations: CheckViolation[];
-    newErrors: number;
-    newWarnings: number;
-    carryoverErrors: number;
-    carryoverWarnings: number;
-    passed: boolean;
-}
-
 /** The three whole-snapshot reads rule evaluation needs; any store with them can be checked. */
 type RuleStore = Pick<CodeGraphStore, "listNodes" | "listEdges" | "listMetrics">;
 
@@ -1272,10 +1268,6 @@ interface RunChecksOptions {
 declare function runChecks(store: CodeGraphStore, options: RunChecksOptions): CheckResult;
 /** Every rule's violations in one snapshot with no baseline; needs only the three whole-snapshot reads. */
 declare function snapshotViolations(store: RuleStore, snapshotId: number, rules: readonly CheckRule[]): CheckViolation[];
-/** Identity of a violation across snapshots: severity, value and message may change, the key does not. */
-declare function violationKey(v: CheckViolation): string;
-/** {@link violationKey} with both node ids carried into another snapshot's id space; unmoved ids key as before. */
-declare function rebasedViolationKey(v: CheckViolation, resolve: (id: string) => string): string;
 
 /** One tool-neutral audit finding; every finding cites a path so a citation checker can verify it. */
 interface Finding {
@@ -1423,6 +1415,27 @@ interface GraphDiffSummary {
     removedEdges: number;
     metricChanges: number;
 }
+/** Why a symbol present in both snapshots changed; `renamed` alone means its footprint held. */
+type FootprintChangeReason = "signature" | "consumers" | "coupling" | "renamed";
+interface FootprintChange {
+    /** The to-snapshot id; a removed symbol keeps its from-snapshot id. */
+    symbolId: string;
+    /** The from-snapshot id, set only when it differs from `symbolId`. */
+    previousId?: string;
+    status: "added" | "removed" | "changed";
+    /** Empty for an added or removed symbol. */
+    reasons: FootprintChangeReason[];
+    /** The declaring file, in the to-snapshot's id space where it still exists there. */
+    fileId: string;
+}
+interface FootprintDiff {
+    fromSnapshotId: number;
+    toSnapshotId: number;
+    /** Sorted by `symbolId`; an unchanged symbol is absent. */
+    changes: FootprintChange[];
+    /** Sorted distinct declaring files of `changes`; consumer files never appear here. */
+    files: string[];
+}
 interface GraphDiff {
     summary: GraphDiffSummary;
     addedNodes: GraphNode[];
@@ -1443,20 +1456,10 @@ interface DiffSnapshotsOptions {
  */
 declare function diffSnapshots(store: CodeGraphStore, options: DiffSnapshotsOptions): GraphDiff;
 
-interface UnchangedViolation {
-    from: CheckViolation;
-    to: CheckViolation;
-    delta: number | null;
-}
-interface CheckDiff {
+interface CheckDiff extends ViolationBuckets {
     fromSnapshotId: number;
     toSnapshotId: number;
     rulesEvaluated: number;
-    newViolations: CheckViolation[];
-    resolvedViolations: CheckViolation[];
-    unchanged: UnchangedViolation[];
-    worsened: UnchangedViolation[];
-    improved: UnchangedViolation[];
 }
 interface DiffCheckResultsOptions {
     fromSnapshotId: number;
@@ -1511,6 +1514,56 @@ declare function computeFootprints(graph: FootprintGraph, options?: FootprintOpt
  */
 declare function symbolSetHash(unit: FootprintUnit, footprints: ReadonlyMap<string, SymbolFootprint>): string;
 
+interface DiffFootprintsOptions extends FootprintOptions {
+    fromSnapshotId: number;
+    toSnapshotId: number;
+}
+/**
+ * Symbols whose documentable footprint differs between two snapshots. From-snapshot ids
+ * follow the alias chain first, so a moved file reads as `renamed`, not a remove plus an add.
+ */
+declare function diffFootprints(store: CodeGraphStore, options: DiffFootprintsOptions): FootprintDiff;
+
+/**
+ * What a consumer generated a unit's doc from. Provenance lives with the consumer, not the
+ * store, so it survives snapshot prune.
+ */
+interface UnitProvenance {
+    unitId: string;
+    /** The to-snapshot's commit hash; null for a working-tree snapshot. */
+    commit: string | null;
+    symbolSetHash: string;
+    /** The generator the consumer used; the gate records it but never calls one. */
+    model: string | null;
+}
+interface UnitProvenanceInput {
+    unit: FootprintUnit;
+    footprints: ReadonlyMap<string, SymbolFootprint>;
+    snapshot: Pick<SnapshotRow, "commitHash">;
+    model?: string | null;
+}
+type RegenerateReason = "new" | "changed";
+interface UnitRegeneration {
+    unitId: string;
+    reason: RegenerateReason;
+}
+interface GateUnitsInput {
+    prior: readonly UnitProvenance[];
+    units: readonly FootprintUnit[];
+    footprints: ReadonlyMap<string, SymbolFootprint>;
+}
+/** An empty `regenerate` means the caller makes no LLM call. */
+interface GateResult {
+    regenerate: UnitRegeneration[];
+    skip: string[];
+    /** Prior units that no longer exist. */
+    orphaned: string[];
+}
+/** A fresh provenance record for one unit at the given snapshot. */
+declare function unitProvenance(input: UnitProvenanceInput): UnitProvenance;
+/** Splits units into those whose symbol-set hash moved since the prior record and those that did not. */
+declare function gateUnits(input: GateUnitsInput): GateResult;
+
 interface EmbeddableSymbol {
     id: string;
     name: string;
@@ -1727,4 +1780,4 @@ declare function getConventionMap(store: CodeGraphStore, snapshotId: number, mod
  */
 declare function findConventions(store: CodeGraphStore, snapshotId: number, query: string, embedder: Embedder, model: string, opts?: FindConventionsOptions): Promise<ConventionQueryResult>;
 
-export { ALIAS_BASE_ATTR, ALL_ROLES, type AliasChain, type AliasChainInput, type AliasChainOptions, type AliasLoader, type AliasResolution, COMMUNITY_SUMMARY_NAMESPACE, COVERAGE_METRIC_NAME, type CachedEmbedResult, type CheckDiff, type CheckResult, type CheckRule, type CheckRulesFile, type CheckSnapshotOptions, type CheckSnapshotResult, type CheckViolation, CodeGraphStore, type ConventionArea, type ConventionCorpus, type ConventionCoverage, type ConventionMap, type ConventionMatch, type ConventionOptions, type ConventionQueryResult, type ConventionSymbol, DEAD_CODE_METRIC_NAMES, DEFAULT_CHURN_WINDOWS, DEFAULT_OUTLIER_MIN_SAMPLE, DOMAIN_DDL, type DeepAst, type DeepAstInput, type DiffCheckResultsOptions, type DiffSnapshotsOptions, EXCEPTION_METRIC_NAMES, type EdgeKind, type EmbedAttempt, type EmbedCoverage, type EmbedSnapshotResult, type EmbeddableSymbol, type ExternalDiagnostic, FINDING_DDL, type FileFingerprint, type FindConventionsOptions, type FindSimilarOptions, type Finding, type FindingKeyInput, type FootprintGraph, type FootprintOptions, type FootprintParts, type FootprintUnit, type ForbidImportRule, GROWTH_RISK_METRIC_NAMES, type GraphDiff, type GraphDiffSummary, type GraphEdge, type GraphFragment, type GraphMetric, type GraphNode, type HistoryMetricsOptions, INDEX_VERSION, type IdAlias, type IdAliasReason, type IndexOptions, type IndexResult, type IstanbulCoverage, KIT, LanguageExtractor, type LanguageExtractorOptions, type LayeredDepsRule, type LineSpan, type Lineage, type LineageSnapshot, type LineageStep, type LinkMethod, type LinkTestsOptions, type LoadedHistory, METRIC_CATALOGUE, MIGRATIONS, type MemberInfo, type MetricAbsence, type MetricAggregate, type MetricDelta, type MetricDescriptor, type MetricDirection, type MetricMaxRule, type MetricMinRule, type MetricOutlierRule, type MetricProductMaxRule, type MetricRollup, type MetricSource, type MetricUnit, type NoInternalOnlyBarrelsRule, type NodeKind, type NodeRename, type NodeRole, type PackageFlag, type PackageLayer, type PackageStats, type PageRankOptions, type PageRankResult, type PageRankRow, type PairCoupling, type PairFlag, type ParamInfo, type PartitionQualityInput, type PartitionQualityResult, type PriorSnapshotOptions, type PruneOptions, type PrunePlan, type PruneResult, PythonGraphExtractor, type ReadFile, type ReferenceEdgeLite, type RelevanceOptions, type ResolveAliasOptions, type ReuseBasis, type RuleStore, type RunChecksOptions, SCHEMA_VERSION, SNAPSHOT_SCOPED_TABLES, SOURCE_METRIC_NAMES, SYMBOL_EMBEDDING_NAMESPACE, SYMBOL_ID_SEP, SYMBOL_METRIC_NAMES, type Severity, type SimilarCandidate, type SimilarResult, type SnapshotInsert, type SnapshotRow, type SnapshotSpec, type SourceLanguage, type StoredFinding, type StoredVerdict, type SummarizeConventionsResult, type Summarizer, type SymbolConsumers, type SymbolCouplingOptions, type SymbolCouplingPair, type SymbolFootprint, type SymbolSpan, type TestCoverageOwnershipOptions, type TestSourceLink, type TopMetricRow, TsMorphGraphExtractor, type TsMorphGraphExtractorOptions, type UnchangedViolation, type ValidateRulesOptions, type VerdictCitation, type VerdictLabel, aggregateMetrics, aliasChain, annotateRoles, attributeCoverage, buildAliases, buildConventionAreas, buildEmbedText, buildFileModuleNodes, buildIndexerMetrics, buildLineage, canonicalEdgeKind, canonicalMetricName, canonicalRole, carryForwardVerdicts, checkSnapshot, classifyRole, collectDeclaredNames, collectDeclaredSpans, compilePatterns, computeDeadCodeMetrics, computeDeepAst, computeFootprints, computeGrowthRiskMetrics, computeMetrics, computePageRank, computePartitionQuality, computeRecencyWindows, computeRelevance, computeRoleHints, computeSourceMetrics, computeSymbolConsumers, computeSymbolCoupling, computeTestCoverageOwnership, createAliasChain, defaultTargetCount, describeMetric, describeMetrics, detectCommunities, detectGitHead, detectGitToplevel, detectRenames, diffCheckResults, diffSnapshots, edgeWeight, embedSnapshot, embedTextsCached, externalId, externalToFinding, fileId, findConventions, findSimilarCapability, findingKey, getConventionMap, getEdgeWeight, groupTestsBySource, hashContent, hashEmbedText, hashText, indexPaths, invertBuckets, isGeneratedByHeuristic, isGeneratedFile, isInsideGitRepo, keyFindings, lineagePath, linkTestsToSources, listEdges, listEdgesTouching, listEmbeddableSymbols, listFindings, listMetrics, listMetricsForNode, listNodes, listVerdicts, loadCheckRules, loadGeneratedPatterns, loadHistoryMetrics, loadLineage, matchesAny, moduleId, normalizeFlaggedText, openCodeGraph, packageId, parentModuleId, parseSymbolId, patternToRegex, percentileOf, planPrune, priorSnapshotForRef, pruneDanglingReferences, readSourceFiles, rebasedViolationKey, resolveAlias, resolveBarrelEdges, resolveChurnWindows, resolveGitRef, resolveSnapshot, runChecks, runPrune, saveFindings, saveVerdicts, snapshotPageRank, snapshotReferenceEdges, snapshotRelevance, snapshotSymbolConsumers, snapshotSymbolCoupling, snapshotViolations, structuralSignature, summarizeConventions, symbolId, symbolSetHash, testCoverageCountMetrics, toFindings, tryEmbedSnapshot, validateRules, violationKey, walkSourceFiles, windowSuffix };
+export { ALIAS_BASE_ATTR, ALL_ROLES, type AliasChain, type AliasChainInput, type AliasChainOptions, type AliasLoader, type AliasResolution, type AnnotateRolesOptions, BUNDLE_SCHEMA_VERSION, BlastRadiusEntry, type BundleBuildInput, type BundleEdge, type BundleEdges, COMMUNITY_SUMMARY_NAMESPACE, SCHEMA_VERSION as CONTEXT_SCHEMA_VERSION, COVERAGE_METRIC_NAME, type CachedEmbedResult, type CheckDiff, CheckResult, CheckRule, type CheckSnapshotOptions, type CheckSnapshotResult, CheckViolation, CodeGraphStore, type Consumers, type ContextBuildInput, type ContextBundle, type ContextDossier, type ConventionArea, type ConventionCorpus, type ConventionCoverage, type ConventionMap, type ConventionMatch, type ConventionOptions, type ConventionQueryResult, type ConventionSymbol, type Coverage, DEAD_CODE_METRIC_NAMES, DEFAULT_CHURN_WINDOWS, DEFAULT_MAX_LINE_CHARS, DEFAULT_OUTLIER_MIN_SAMPLE, DOMAIN_DDL, type DeepAst, type DeepAstInput, type DiffCheckResultsOptions, type DiffFootprintsOptions, type DiffSnapshotsOptions, ELISION_MARKER, EXCEPTION_METRIC_NAMES, EdgeKind, type EmbedAttempt, type EmbedCoverage, type EmbedSnapshotResult, type EmbeddableSymbol, type ExternalDiagnostic, FINDING_DDL, type FileDossier, FileFingerprint, type FileOwnership, type FindConventionsOptions, type FindSimilarOptions, type Finding, type FindingKeyInput, type FootprintChange, type FootprintChangeReason, type FootprintDiff, type FootprintGraph, type FootprintOptions, type FootprintParts, type FootprintUnit, GROWTH_RISK_METRIC_NAMES, type GateResult, type GateUnitsInput, type GraphDiff, type GraphDiffSummary, GraphEdge, GraphFragment, GraphMetric, GraphNode, type HistoryMetricsOptions, INDEX_VERSION, IdAlias, IdAliasReason, type IndexOptions, type IndexResult, type IndexSource, type IstanbulCoverage, KIT, LanguageExtractor, type LanguageExtractorOptions, type LineSpan, type Lineage, type LineageSnapshot, type LineageStep, type LoadedHistory, METRIC_CATALOGUE, MIGRATIONS, type MemberInfo, type MetricAbsence, type MetricAggregate, type MetricDelta, type MetricDescriptor, type MetricDirection, type MetricRollup, type MetricSource, type MetricUnit, type MinifiedSource, type MinifyLanguage, NodeKind, NodeMetrics, type NodeRename, NodeRole, type PageRankOptions, type PageRankResult, type PageRankRow, type ParamInfo, type PriorSnapshotOptions, type Provenance, type PruneOptions, type PrunePlan, type PruneResult, PythonGraphExtractor, type ReadFile, ReferenceEdgeLite, type RegenerateReason, type RelevanceOptions, type ResolveAliasOptions, type ReuseBasis, type RoleGlobs, type RoleHints, type RuleStore, type RunChecksOptions, SCHEMA_VERSION$1 as SCHEMA_VERSION, SNAPSHOT_SCOPED_TABLES, SOURCE_METRIC_NAMES, SYMBOL_EMBEDDING_NAMESPACE, SYMBOL_ID_SEP, SYMBOL_METRIC_NAMES, Severity, type SignatureTreeOptions, type SimilarCandidate, type SimilarResult, type SnapshotInsert, SnapshotRow, type SnapshotSpec, type SourceChunk, type SourceLanguage, type StoredFinding, type StoredVerdict, type SummarizeConventionsResult, type Summarizer, SymbolConsumers, SymbolCouplingOptions, SymbolCouplingPair, type SymbolDossier, type SymbolFootprint, type SymbolLine, type SymbolSpan, TRUNCATION_SUFFIX, type TestCoverageOwnershipOptions, TestSourceLink, type TopMetricRow, TsMorphGraphExtractor, type TsMorphGraphExtractorOptions, UNIMPORTED_ROLES, type UnitProvenance, type UnitProvenanceInput, type UnitRegeneration, type ValidateRulesOptions, type VerdictCitation, type VerdictLabel, ViolationBuckets, aggregateMetrics, aliasChain, annotateRoles, attributeCoverage, buildAliases, buildContextBundle, buildContextDossier, buildConventionAreas, buildEmbedText, buildFileModuleNodes, buildIndexerMetrics, buildLineage, canonicalEdgeKind, canonicalMetricName, canonicalRole, carryForwardVerdicts, checkSnapshot, classifyRole, collectDeclaredNames, collectDeclaredSpans, compilePatterns, computeDeadCodeMetrics, computeDeepAst, computeFootprints, computeGrowthRiskMetrics, computeMetrics, computePageRank, computeRecencyWindows, computeRelevance, computeRoleHints, computeSourceMetrics, computeTestCoverageOwnership, createAliasChain, defaultTargetCount, describeMetric, describeMetrics, detectCommunities, detectGitHead, detectGitToplevel, detectRenames, diffCheckResults, diffFootprints, diffSnapshots, edgeWeight, embedSnapshot, embedTextsCached, externalId, externalToFinding, fileId, findConventions, findSimilarCapability, findingKey, gateUnits, getConventionMap, getEdgeWeight, gitTreeSource, hashContent, hashEmbedText, hashText, importMarker, indexPaths, isGeneratedByHeuristic, isGeneratedFile, isInsideGitRepo, isMinifyLanguage, keyFindings, lineagePath, listEdges, listEdgesTouching, listEmbeddableSymbols, listFindings, listMetrics, listMetricsForNode, listNodes, listVerdicts, loadCheckRules, loadGeneratedPatterns, loadHistoryMetrics, loadLineage, loadRoleGlobs, matchesAny, minifySource, moduleId, normalizeFlaggedText, openCodeGraph, originalLine, packageId, parentModuleId, parseSymbolId, patternToRegex, percentileOf, planPrune, priorSnapshotForRef, pruneDanglingReferences, readSourceFiles, renderBundleText, renderContextMarkdown, renderSignatureTree, resolveAlias, resolveBarrelEdges, resolveChurnWindows, resolveGitRef, resolveSnapshot, runChecks, runPrune, saveFindings, saveVerdicts, snapshotPageRank, snapshotReferenceEdges, snapshotRelevance, snapshotSymbolConsumers, snapshotSymbolCoupling, snapshotViolations, structuralSignature, summarizeConventions, symbolId, symbolSetHash, toFindings, tryEmbedSnapshot, unitProvenance, validateRules, walkSourceFiles, windowSuffix, workingTreeSource };