@opensip-cli/graph 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,642 @@
+import type { Signal } from '@opensip-cli/core';
+/**
+ * `RuleHints` — adapter-supplied per-language rule input. Historically
+ * declared in `lang-adapter/types.ts` and re-exported here so rule
+ * modules under `rules/` could consult hints without importing from
+ * `lang-adapter/`. Keeping the type in the engine's shared type layer preserves
+ * that direction after the old in-package `lang-*` directory rules were retired.
+ *
+ * The original re-export created a `types.ts ↔ lang-adapter/types.ts`
+ * file-level cycle reported by `circular-import-detection`. The fix is
+ * to host the canonical declaration here in `types.ts` (which sits at
+ * the bottom of the engine's type layer) and have `lang-adapter/types.ts`
+ * import it from here — inverting the dependency so the cycle is gone.
+ */
+export interface RuleHints {
+    /** Predicate: is this file a test? Path is project-relative. */
+    readonly isTestFile?: (filePathProjectRel: string) => boolean;
+    /** Globs treated as generated code. */
+    readonly generatedFilePatterns?: readonly string[];
+    /** Side-effect primitives — fully-qualified names (e.g. 'fs.writeFileSync'). */
+    readonly sideEffectPrimitives?: readonly string[];
+    /** Throw-statement detection regex for `always-throws-branch`. */
+    readonly throwSyntaxRegex?: RegExp;
+}
+/**
+ * @fileoverview Core type shapes for the graph tool's six-stage pipeline.
+ *
+ * Stage 1 (inventory) emits a Catalog of FunctionOccurrence entries with
+ * empty `calls`. Stage 2 (edges) populates `calls` with CallEdge entries
+ * that reference back into the catalog by bodyHash. Stage 3 (indexes)
+ * produces forward/reverse maps over the catalog.
+ *
+ * These types are immutable. Every consumer treats them as frozen data;
+ * the dep-cruiser and fitness checks (graph-stage-output-immutability)
+ * assert this at build time.
+ *
+ * Per spec §2.2 / §2.4. The catalog is the authority for ids: every
+ * CallEdge.to is a bodyHash that already exists in the catalog.
+ */
+export type FunctionKind = 'function-declaration' | 'function-expression' | 'arrow' | 'method' | 'constructor' | 'getter' | 'setter' | 'module-init';
+/**
+ * How a call edge was resolved (static dispatch, method dispatch, JSX, etc.).
+ *
+ * `'syntactic'` is the fast-mode tag: the edge was resolved from the callee's
+ * name plus the file's import graph WITHOUT the type checker. It is always
+ * approximate — fast-mode edges carry capped confidence (never `'high'`) so
+ * consumers can distinguish them from semantic (`exact`-mode) edges.
+ *
+ * `'semantic'` is the cross-shard linker tag: the edge was recovered by the
+ * Phase-2 boundary resolver, which links a bare/workspace import specifier +
+ * callee name to a UNIQUE exported occurrence in the imported package's export
+ * symbol table — exactly what the type checker would conclude. It is a resolved
+ * edge (high confidence) and is NOT import-constrained downstream (the linker
+ * already proved reachability by construction). The resolver declines (emits no
+ * edge) on any ambiguity, so a `'semantic'` edge is never a name-only guess.
+ */
+export type CallResolution = 'static' | 'method-dispatch' | 'jsx' | 'constructor' | 'unknown' | 'dynamic-string' | 'syntactic' | 'semantic';
+/** Resolver confidence in a call edge: high (one body), medium (few), low (many or partial). */
+export type CallConfidence = 'high' | 'medium' | 'low';
+/**
+ * Call-graph resolution tier. `exact` = semantic (type-checker-backed),
+ * the default that preserves historical behavior; `fast` = syntactic
+ * (name + import-graph), no type checker — bounded accuracy for a large
+ * cold-build speedup on monorepos.
+ */
+export type ResolutionMode = 'exact' | 'fast';
+/** Function visibility tier: exported from module, module-local, or class-private. */
+export type Visibility = 'exported' | 'module-local' | 'private';
+/** A function parameter descriptor: name, optionality, and rest-arg flag. */
+export interface Param {
+    readonly name: string;
+    readonly optional: boolean;
+    readonly rest: boolean;
+}
+/** A resolved call from one function to another. Populated by stage 2. */
+export interface CallEdge {
+    /** bodyHash[] — one for static, many for polymorphic, empty for unresolved. */
+    readonly to: readonly string[];
+    readonly line: number;
+    readonly column: number;
+    readonly resolution: CallResolution;
+    readonly confidence: CallConfidence;
+    /** Raw call expression text, truncated to ≤ 80 chars. */
+    readonly text: string;
+    /**
+     * True when the call expression appears as an ExpressionStatement
+     * (its return value is discarded). Used by `no-side-effect-path` to
+     * distinguish "pure helper called for its return value" (correct)
+     * from "pure helper called for nothing" (dead computation).
+     * Optional for forward-compatibility with pre-discard catalogs.
+     */
+    readonly discarded?: boolean;
+    /**
+     * True when this edge was recovered by the cross-shard boundary pass
+     * (a sharded build) rather than resolved within a single shard. A
+     * recovered `crossShard` edge is `resolution: 'semantic'` — the boundary
+     * linker proved the import specifier + callee name resolve to a UNIQUE
+     * exported occurrence in the imported package (the same conclusion the type
+     * checker reaches), so it is a high-confidence resolved edge. The linker
+     * DECLINES on ambiguity rather than guessing, so a `crossShard` edge is never
+     * a name-only match. Lets consumers reason about boundary edges (e.g. "the
+     * cross-package edges came from the linker, not a single shard").
+     * Omitted/false for intra-shard edges; optional for forward-compat.
+     */
+    readonly crossShard?: boolean;
+}
+/**
+ * A resolved module-level dependency edge — an `import` / `from … import` /
+ * `require` / `use` statement from one source file to another (or to an
+ * external package the catalog doesn't track). Attached to module-init
+ * occurrences only.
+ *
+ * Phase 4 of opensip's substrate consolidation (DEC-498) — preserves the
+ * `depends_on` edge kind required by opensip's
+ * `dependencyEdgesBetweenModules` query, which dispatch ticket grouping
+ * and review-panel blast-radius depend on.
+ *
+ * `to.length === 0` means the import target is outside the catalog
+ * (typically an external npm/PyPI/crates.io package). `specifier`
+ * preserves the raw import string so unresolved edges remain traceable.
+ */
+export interface DependencyEdge {
+    /** bodyHash[] of the target module-init occurrence(s). Empty when the
+     *  import resolves to a module outside the catalog (external package). */
+    readonly to: readonly string[];
+    /** 1-based line of the import / require / use statement. */
+    readonly line: number;
+    /** 0-based column. */
+    readonly column: number;
+    /** The raw import specifier — `'./foo'`, `'@opensip/core'`, `'os.path'`,
+     *  `'std::collections'`, etc. Preserved for unresolved-edge attribution. */
+    readonly specifier: string;
+}
+/** A single callable function or method, by simple name + per-occurrence record. */
+export interface FunctionOccurrence {
+    /** sha256(normalized body) — the primary identifier. */
+    readonly bodyHash: string;
+    /**
+     * Length of the normalized body in characters (comments stripped,
+     * whitespace collapsed). Used by `duplicated-function-body` to skip
+     * trivial wrapper bodies whose duplication is not actionable.
+     * Optional for forward-compatibility with pre-bodySize catalogs;
+     * absent values are treated as "passes the threshold."
+     */
+    readonly bodySize?: number;
+    /** "saveBaseline", "<arrow:gate.ts:42:7>", "<module-init:gate.ts>". */
+    readonly simpleName: string;
+    /** "fitness/engine/src/gate.saveBaseline" — for human display. */
+    readonly qualifiedName: string;
+    /** Project-relative path. */
+    readonly filePath: string;
+    /**
+     * The package this occurrence belongs to — the `name` of its nearest
+     * enclosing `package.json`, else the top-level path segment. Assigned by
+     * `assignPackages` at build time so consumers (coupling grid, edge
+     * constraint) bucket by real package boundary, not a path heuristic.
+     * Optional for forward-compat; absent ⇒ derive from `filePath`.
+     */
+    readonly package?: string;
+    /** 1-based line where the function declaration begins. */
+    readonly line: number;
+    /** 0-based column. */
+    readonly column: number;
+    readonly endLine: number;
+    readonly kind: FunctionKind;
+    readonly params: readonly Param[];
+    readonly returnType: string | null;
+    readonly enclosingClass: string | null;
+    readonly decorators: readonly string[];
+    readonly visibility: Visibility;
+    readonly inTestFile: boolean;
+    readonly definedInGenerated: boolean;
+    /** Populated by stage 2. Empty after stage 1. */
+    readonly calls: readonly CallEdge[];
+    /**
+     * Module-level depends-on edges. Only populated on `module-init`
+     * occurrences (one per file); absent on all other occurrence kinds.
+     * Optional for forward-compatibility with pre-Phase-4 catalogs on
+     * disk — absent values are treated as "no dependencies emitted by
+     * this adapter."
+     *
+     * Phase 4 of opensip's substrate consolidation (DEC-498). The opensip
+     * catalog-json renderer emits these as `edge_kind: 'depends_on'` rows
+     * for opensip's `dependencyEdgesBetweenModules` query.
+     */
+    readonly dependencies?: readonly DependencyEdge[];
+}
+/** Stage 1's parse-error record (e.g., file unparseable; reported but does not abort the run). */
+export interface ParseError {
+    readonly filePath: string;
+    readonly message: string;
+}
+/**
+ * A call site a shard worker could NOT resolve within its own files —
+ * the callee name is not among the shard's own occurrences. Plain,
+ * JSON-safe data (no AST): the cross-shard pass re-resolves these against
+ * the global merged catalog + import graph, syntactically.
+ *
+ * Emitted by an adapter's `resolveCallSites` when `emitBoundaryCalls` is
+ * set (only the adapter can extract a callee name from its AST), and
+ * carried across the worker boundary inside a `ShardBuildResult`.
+ */
+export interface CrossBoundaryCall {
+    /** bodyHash of the enclosing function (an occurrence in this shard's fragment). */
+    readonly ownerHash: string;
+    /**
+     * Project-relative file path of the owning occurrence — byte-identical to its
+     * `FunctionOccurrence.filePath` (posix-normalized, as the walk emits it). The
+     * cross-shard merge keys/stitches edges by `ownerEdgeKey(ownerHash, ownerFile)`
+     * — NOT by `ownerHash` alone — so body-twins (identical bodies in different
+     * files) never smear each other's edges (ADR-0003). It is ALSO the directory
+     * the cross-shard linker resolves a relative import specifier against (the
+     * owner's actual file, not a last-writer-wins `bodyHash→file` guess).
+     */
+    readonly ownerFile: string;
+    /** Syntactic callee simple name (`foo` in `foo()`, rightmost in `a.b.c()`). */
+    readonly calleeName: string;
+    /** The raw import specifier the name came from, if imported (`'./x.js'`, `'@scope/pkg'`). */
+    readonly importSpecifier?: string;
+    /**
+     * Type-attested target SOURCE file (project-relative) for a cross-package
+     * METHOD call `recv.m()` — the package's published `dist/*.d.ts` decl the
+     * checker resolved `m` to, mapped to its source. Set INSTEAD of
+     * `importSpecifier` (a method name is not an imported binding). The linker pins
+     * by (`targetFile` + `calleeName`) against the merged catalog, so cross-package
+     * methods resolve through the SAME post-merge linker as cross-package functions
+     * — identically in both engines (exact's inline pass declines them under the
+     * intra-package pin restriction, so both route here).
+     */
+    readonly targetFile?: string;
+    /** 1-based line of the call site. */
+    readonly line: number;
+    /** 0-based column. */
+    readonly column: number;
+    /** Truncated call-expression text for display (≤ 80 chars, the CallEdge.text contract). */
+    readonly text: string;
+    /**
+     * True when the call's return value is discarded (ExpressionStatement).
+     * Carried so the recovered cross-shard CallEdge preserves the `discarded`
+     * flag that `no-side-effect-path` relies on.
+     */
+    readonly discarded?: boolean;
+}
+/**
+ * A name one module re-exports from another, normalized to the data the
+ * cross-package export index needs to make a re-exported name resolvable under
+ * the RE-EXPORTING package (not just its defining package). Captured by the
+ * language adapter's walk (TS: `export … from 'spec'` and the import-then-
+ * re-export idiom `export { x }`), carried on the catalog so the engine's
+ * cross-shard linker — which builds its index from the MERGED catalog — can
+ * follow re-export chains. Pure data (no AST handles); round-trips cache + merge.
+ */
+export interface ReExportRecord {
+    /** Re-exporting file, project-relative POSIX (→ `packageOf` gives the group). */
+    readonly fromFile: string;
+    /** The name as exposed BY this module. `'*'` for `export * from`. */
+    readonly exportedName: string;
+    /** The name in the SOURCE module (== `exportedName` unless aliased; `'*'` for star). */
+    readonly sourceName: string;
+    /** The source module specifier — relative (`'./x'`) or workspace (`'@scope/pkg'`). */
+    readonly specifier: string;
+}
+/**
+ * The catalog: functions keyed by simple name. Multiple occurrences
+ * per name.
+ *
+ * v3 — generic over language. The language-pluggability work replaced
+ * the v2 fields `tsConfigPath` and `tsCompilerVersion` with adapter-supplied
+ * `language` (the registered adapter id) and `cacheKey` (an opaque
+ * per-adapter invalidation key). v2 catalogs on disk return
+ * `{ kind: 'invalid', reason: 'version-mismatch' }` from
+ * `classifyCatalog`, so users see exactly one cold rebuild.
+ */
+export interface Catalog {
+    readonly version: '3.0';
+    readonly tool: 'graph';
+    /** Adapter id — currently always 'typescript'; future adapters add their own. */
+    readonly language: string;
+    readonly builtAt: string;
+    /**
+     * Opaque per-adapter cache invalidation key. The TypeScript adapter
+     * sets `ts-${ts.version}-${tsconfigContentHash}`. Different adapters
+     * MUST emit different prefixes so cross-adapter accidents (e.g. a
+     * Python catalog read by the TS adapter) hash-mismatch immediately.
+     */
+    readonly cacheKey: string;
+    /**
+     * Concatenated fingerprint of the source files at build time
+     * (mtime + size per file). Used by cache invalidation; absence
+     * means "this catalog was built before fingerprinting landed,"
+     * which invalidates the catalog conservatively.
+     */
+    readonly filesFingerprint?: string;
+    /**
+     * The resolution tier that produced this catalog. `'exact'` =
+     * semantic (type-checker-backed); `'fast'` = syntactic (approximate).
+     * Optional for forward-compatibility: catalogs persisted before fast
+     * mode landed have no marker, and **absence is interpreted as
+     * `'exact'`** (the historical behavior). Consumers that need to know
+     * whether edges are approximate read this field.
+     */
+    readonly resolutionMode?: ResolutionMode;
+    readonly functions: Readonly<Record<string, readonly FunctionOccurrence[]>>;
+    /**
+     * Re-export facts captured at walk time (see {@link ReExportRecord}). Present
+     * when the adapter emits them; consumed by `buildExportIndex` to resolve a
+     * name imported from the package that RE-EXPORTS it (the re-export-chain
+     * class). Optional so pre-feature catalogs and non-emitting adapters
+     * typecheck; absence means "no re-export following for this catalog."
+     */
+    readonly reExports?: readonly ReExportRecord[];
+    /**
+     * Derived feature columns materialized for the decoupled dashboard
+     * (ADR-0006): present ONLY when the producing run requested columns via
+     * `emitFeatures`. A default run persists no features. Optional so pre-
+     * feature catalogs and external callers typecheck, and so the plain
+     * widening to `GraphCatalog` stays cast-free.
+     */
+    readonly features?: PersistedFeatures;
+}
+/** O(1) lookups derived from the catalog. Not persisted. */
+export interface Indexes {
+    readonly byBodyHash: ReadonlyMap<string, FunctionOccurrence>;
+    /**
+     * Per-occurrence id (`${filePath}:${line}:${column}`) → the occurrence at that
+     * source location. Unlike `byBodyHash` (a CONTENT hash that collapses
+     * body-twins across packages into one node), an occId is unique per
+     * occurrence, so the SCC/cycle feature can key its graph by occurrence and
+     * never collapse two distinct functions with identical bodies. Consumed by
+     * `computeSccs` (node identity) and `rules/cycle.ts` (member resolution).
+     */
+    readonly byOccId: ReadonlyMap<string, FunctionOccurrence>;
+    /**
+     * bodyHash → ALL occurrences sharing that body. Unlike `byBodyHash`
+     * (one occurrence per hash, content-dedup), this preserves every
+     * occurrence so a callee whose body is duplicated across packages can be
+     * disambiguated to the correct package. Consumed by `resolveCallee`.
+     */
+    readonly occurrencesByHash: ReadonlyMap<string, readonly FunctionOccurrence[]>;
+    /**
+     * Project-relative filePath → set of package groups that file's module
+     * imports (derived from the file's module-init `dependencies[]` resolved
+     * to packages). Empty for files with no resolved imports — and empty in
+     * `fast` mode, where `dependencies[]` is not populated. Lets
+     * `resolveCallee` constrain a duplicated-body callee to a package the
+     * caller actually depends on.
+     */
+    readonly importedPackagesByFile: ReadonlyMap<string, ReadonlySet<string>>;
+    readonly bySimpleName: ReadonlyMap<string, readonly string[]>;
+    /** bodyHash → bodyHash[] (forward). */
+    readonly callees: ReadonlyMap<string, readonly string[]>;
+    /** bodyHash → bodyHash[] (reverse). */
+    readonly callers: ReadonlyMap<string, readonly string[]>;
+}
+/**
+ * Blast radius for one function: how much of the graph a change here can
+ * ripple through, via a bounded reverse BFS over the callers adjacency.
+ * `direct` = the function's direct callers; `transitive` = set-deduped
+ * callers reached at depth 2..5; `score = direct + 0.5 × transitive`
+ * (verbatim from the dashboard's former `code-paths/indexes.ts`).
+ */
+export interface BlastScore {
+    readonly direct: number;
+    readonly transitive: number;
+    readonly score: number;
+}
+/**
+ * Per-function feature columns, keyed by `bodyHash`. `bodyLines` is always
+ * present when the `function` grain is computed; every other column is
+ * optional because it is populated only when its driving `FeatureColumn`
+ * was requested (lazy/needed-only).
+ */
+export interface FunctionFeatures {
+    /** `endLine − line + 1` of the `byBodyHash` winner occurrence. The
+     *  canonical home for the span formula the dup-body / no-side-effect
+     *  rules used to inline. */
+    readonly bodyLines: number;
+    /** Blast radius (depth-5 reverse BFS). Present only when `'blast'` was
+     *  requested. */
+    readonly blast?: BlastScore;
+    /** True when the function is reachable from an inferred entry point
+     *  (BFS over `callees` from `inferEntryPoints` + `config.entryPointHashes`).
+     *  Present only when `'reachableFromEntry'` was requested. */
+    readonly reachableFromEntry?: boolean;
+    /** True when the function is reachable from a NON-test (production) entry
+     *  point. The companion flag the `test-only-reachable` rule reads alongside
+     *  `reachableOnlyFromTests`. Present only when `'reachableOnlyFromTests'`
+     *  was requested. */
+    readonly testReachable?: boolean;
+    /** True when the function has callers, is NOT reachable from any production
+     *  entry point, and ALL of its callers live in test files (the
+     *  `test-only-reachable` rule's reachability predicate). Present only when
+     *  `'reachableOnlyFromTests'` was requested. */
+    readonly reachableOnlyFromTests?: boolean;
+}
+/**
+ * Per-package feature columns, keyed by package name. Both degrees count
+ * DISTINCT packages (self-edges included, matching the coupling matrix's
+ * diagonal). Populated only when `'packageCoupling'` was requested.
+ */
+export interface PackageFeatures {
+    /** Distinct callee packages this package calls into (incl. itself). */
+    readonly couplingOut: number;
+    /** Distinct caller packages that call into this package (incl. itself). */
+    readonly couplingIn: number;
+}
+/**
+ * One strongly-connected component of the call graph (Tarjan over an
+ * OCCURRENCE-level adjacency — nodes are occIds, edges `resolveCallee`-
+ * disambiguated). Singletons are included by the algorithm. `id` is
+ * member-derived and stable across runs so Plan D predicates and the dashboard
+ * cycle-grouping read a deterministic key. Populated only when `'scc'` was
+ * requested.
+ *
+ * Members are occIds (`${filePath}:${line}:${column}`), NOT bodyHashes:
+ * occurrence identity is package-unique, so two functions with identical bodies
+ * in different packages stay distinct nodes (no false cross-package phantom).
+ * Resolve a member to its occurrence via `Indexes.byOccId`.
+ */
+export interface SccFeatures {
+    /** `scc:${sortedMembers[0]}` — stable, member-derived (resolves the spec
+     *  Open Question on the SCC id scheme). */
+    readonly id: string;
+    /** Member occIds (`${filePath}:${line}:${column}`), sorted (determinism). */
+    readonly members: readonly string[];
+    /** `members.length`. */
+    readonly sccSize: number;
+    /** True when the component's members span more than one distinct package. */
+    readonly crossesPackages: boolean;
+}
+/**
+ * One directed package-coupling edge — `count` static call edges from
+ * `callerPackage` into `calleePackage` (via the canonical `resolveCallee`
+ * disambiguation). Populated only when `'packageCoupling'` was requested.
+ */
+export interface PackageEdgeFeature {
+    readonly callerPackage: string;
+    readonly calleePackage: string;
+    readonly count: number;
+}
+/**
+ * Lazy column request. `buildFeatures` computes the UNION of the enabled
+ * rule set's declared `featureDeps` plus the caller's `emitFeatures`, and
+ * NOTHING else. Each column maps to the entity rows it populates:
+ *  - `bodyLines` / `blast` / `reachableFromEntry` / `reachableOnlyFromTests`
+ *    → `function` rows;
+ *  - `packageCoupling` → `package` rows (`couplingOut`/`couplingIn`) AND
+ *    `edge` rows (`count`) — one column, one pass;
+ *  - `scc` → `scc` rows.
+ */
+export type FeatureColumn = 'bodyLines' | 'blast' | 'reachableFromEntry' | 'reachableOnlyFromTests' | 'packageCoupling' | 'scc';
+/**
+ * The multi-entity feature table — derived from `Catalog` + `Indexes`,
+ * computed in `pipeline/features.ts`. A *plain view* by default (ADR-0006):
+ * rules consume it directly; only the dashboard columns are ever persisted,
+ * and only when requested. Each entity is empty when none of its driving
+ * columns were requested.
+ */
+export interface FeatureTable {
+    readonly function: ReadonlyMap<string, FunctionFeatures>;
+    readonly package: ReadonlyMap<string, PackageFeatures>;
+    readonly scc: readonly SccFeatures[];
+    readonly edge: readonly PackageEdgeFeature[];
+}
+/** JSON-safe mirror of `FunctionFeatures` (identical fields). */
+export type PersistedFunctionFeatures = FunctionFeatures;
+/**
+ * The only-when-needed materialized form persisted into the catalog JSON for
+ * the decoupled dashboard (ADR-0006). Maps become records; arrays pass
+ * through. Every entity is optional — only requested entities are present, so
+ * an empty request projects to `{}` and a lean default-run persists no blob.
+ */
+export interface PersistedFeatures {
+    readonly function?: Readonly<Record<string, PersistedFunctionFeatures>>;
+    readonly package?: Readonly<Record<string, PackageFeatures>>;
+    readonly scc?: readonly SccFeatures[];
+    readonly edge?: readonly PackageEdgeFeature[];
+}
+/**
+ * Flat-monorepo synthetic-partition strategy (flat-monorepo-strategy.ts).
+ * (A fourth 'community' Louvain strategy was prototyped and discarded by
+ * measurement — ADR-0045 B2; recoverable at tag
+ * `prototype/louvain-partitioning`.)
+ */
+export type PartitionStrategy = 'directory-depth' | 'file-count-chunks' | 'hybrid';
+/** Per-rule and overall configuration knobs. */
+export interface GraphConfig {
+    /** Minimum lines for a duplicated-function-body match (defaults: 5). */
+    readonly minDuplicateBodyLines?: number;
+    /**
+     * Minimum normalized body size (in characters) for a duplicated-
+     * function-body match. Filters out trivial pass-through wrappers
+     * whose duplication is structural, not actionable. Default: 200.
+     */
+    readonly minDuplicateBodySize?: number;
+    /**
+     * Minimum number of DISTINCT packages a body hash must appear in to
+     * trigger the aggregate cross-package duplication signal for the
+     * duplicated-function-body rule. When a body hash qualifies here (and
+     * clears `minCrossPackageDuplicateBodySize`), the single aggregate signal
+     * is emitted and the per-instance signals for that hash are suppressed.
+     * Default: 3.
+     */
+    readonly minCrossPackageDuplicatePackages?: number;
+    /**
+     * Normalized-body-size floor (chars) for the aggregate cross-package
+     * duplication path. Deliberately LIGHTER than `minDuplicateBodySize` (the
+     * per-instance floor) so the aggregate path keeps catching genuinely-small
+     * shared utilities copied across packages — its original purpose — while
+     * still dropping trivial bodies (empty DI-constructor shims, one-line
+     * getters, thin delegators) that are not consolidation targets. Unlike the
+     * per-instance path there is NO line floor here. Occurrences whose catalog
+     * predates `bodySize` skip this check. Default: 80.
+     */
+    readonly minCrossPackageDuplicateBodySize?: number;
+    /**
+     * Default recipe for `graph` runs when no `--recipe` flag is given (ADR-0022).
+     * Tool-scoped: this is the graph tool's recipe namespace, distinct from
+     * `fit.recipe` / `sim.recipe`. An unknown name here falls back to the built-in
+     * `default` recipe with a warning (config-sourced names are tolerant); an
+     * explicit `--recipe` typo still hard-fails.
+     */
+    readonly recipe?: string;
+    /**
+     * Flat-large synthetic-partition strategy override. Absent → the
+     * layout-recommended default ('hybrid').
+     */
+    readonly partitionStrategy?: PartitionStrategy;
+    /** Override the inferred entry-point list. */
+    readonly entryPointHashes?: readonly string[];
+    /**
+     * `graph:orphan-subtree`: allow flagging exported, zero-caller functions
+     * as orphans. Default `false` — public surface is not "dead" merely
+     * because it lacks an in-project caller (it may be consumed across a
+     * package boundary the call graph cannot resolve). Enable only for repos
+     * with trustworthy cross-package call resolution.
+     */
+    readonly flagExportedOrphans?: boolean;
+    /**
+     * `graph:orphan-subtree`: allow flagging functions declared in test
+     * files as orphans. Default `false` — test-file reachability is the job
+     * of `graph:test-only-reachable`; flagging here would double-report and
+     * over-trigger on test-only helpers.
+     */
+    readonly flagTestOrphans?: boolean;
+    /**
+     * `graph:large-function` warn-band threshold (in body lines). A function
+     * whose `bodyLines` exceeds this (but not the error threshold) emits a
+     * `medium` signal. In-rule default: 80.
+     */
+    readonly largeFunctionWarnLines?: number;
+    /**
+     * `graph:large-function` error-band threshold (in body lines). A function
+     * whose `bodyLines` exceeds this emits a `high` signal. In-rule default: 150.
+     */
+    readonly largeFunctionErrorLines?: number;
+    /**
+     * `graph:wide-function` warn-band threshold (parameter count). A function
+     * with more than this many params (but not more than the error threshold)
+     * emits a `medium` signal. In-rule default: 4.
+     */
+    readonly wideFunctionWarnParams?: number;
+    /**
+     * `graph:wide-function` error-band threshold (parameter count). A function
+     * with more than this many params emits a `high` signal. In-rule default: 7.
+     */
+    readonly wideFunctionErrorParams?: number;
+    /**
+     * `graph:high-blast-untested` warn-band threshold — the minimum
+     * `blast.score` (an **ABSOLUTE** count, never a percentile — ADR-0001) for an
+     * untested function to emit a `medium` signal. In-rule default: 8.
+     */
+    readonly highBlastWarnThreshold?: number;
+    /**
+     * `graph:high-blast-untested` error-band threshold — the minimum
+     * `blast.score` (an **ABSOLUTE** count, never a percentile — ADR-0001) for an
+     * untested function to emit a `high` signal. In-rule default: 20.
+     */
+    readonly highBlastErrorThreshold?: number;
+    /**
+     * `graph:cycle` minimum SCC size that emits a `medium` signal. A
+     * strongly-connected component with `sccSize >= cycleMinSize` (and not
+     * crossing packages, which always wins `high`) emits `medium`. The size-2
+     * band is gated separately by `cycleSize2Severity`. In-rule default: 3.
+     */
+    readonly cycleMinSize?: number;
+    /**
+     * `graph:cycle` posture for the size-2 band (a 2-member cycle, often
+     * legitimate mutual recursion). `'off'` → no signal; `'low'` → a `low`
+     * signal. In-rule default: `'off'` (ADR-0001 / Open Question #6).
+     */
+    readonly cycleSize2Severity?: 'off' | 'low';
+    /** Per-rule severity overrides. */
+    readonly severityOverrides?: Readonly<Record<string, 'error' | 'warning'>>;
+}
+/** Resolution-stat counters returned alongside the catalog by stage 2. */
+export interface ResolutionStats {
+    readonly totalCallSites: number;
+    readonly resolvedHigh: number;
+    readonly resolvedMedium: number;
+    readonly resolvedLow: number;
+    readonly unresolved: number;
+}
+/** Verdict produced by an edge resolver — pre-CallEdge shape. */
+export interface ResolverVerdict {
+    readonly to: readonly string[];
+    readonly resolution: CallResolution;
+    readonly confidence: CallConfidence;
+}
+/**
+ * A rule consumes frozen catalog/indexes/config and returns Signals.
+ *
+ * The fourth parameter `hints` carries the active language adapter's
+ * `RuleHints` (side-effect primitives, throw-syntax regex, test-file
+ * predicate, generated-file globs). It is optional so test code may
+ * still invoke `rule.evaluate(catalog, indexes, config)` without
+ * threading hints through. Rules that don't need hints can ignore it;
+ * rules that do consult hints MUST also implement a TypeScript-shaped
+ * fallback so the rule degrades gracefully when an adapter does not
+ * supply the relevant hint (per the graph rules-and-gating fidelity
+ * matrix).
+ *
+ * The fifth parameter `features` (Plan C) carries the engine-computed
+ * `FeatureTable` — the columns a rule declares via `featureDeps`. Like
+ * `hints`, it is optional so test code may call `rule.evaluate(catalog,
+ * indexes, config)` (3-arg) or `(…, hints)` (4-arg) without threading
+ * features. A rule that reads a column MUST degrade gracefully (recompute
+ * locally) when `features` is absent.
+ */
+export interface Rule {
+    /** Rule slug, e.g. "graph:orphan-subtree". Must start with "graph:". */
+    readonly slug: string;
+    readonly defaultSeverity: 'error' | 'warning';
+    /**
+     * Feature columns this rule reads. The features stage computes the UNION
+     * of every enabled rule's deps (+ the caller's `emitFeatures`) and nothing
+     * else — lazy/needed-only. Absent ⇒ this rule reads no features.
+     */
+    readonly featureDeps?: readonly FeatureColumn[];
+    readonly evaluate: (catalog: Catalog, indexes: Indexes, config: GraphConfig, hints?: RuleHints, features?: FeatureTable) => readonly Signal[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}