codebaseiq 0.1.0

package/dist/health-DJaZXg8I.d.ts

@@ -0,0 +1,340 @@
+import { S as ScipDatabase } from './db-D7sauVFH.js';
+import { stats } from './queries/stats.js';
+import { ComplexityHotspotCoverage } from './queries/complexity-hotspots.js';
+
+/**
+ * Structural copy of analysis/git-history's ChangeAmplification — defined
+ * here so the report envelope consumed by runtime/ does not pull analysis/
+ * types across the layer boundary.
+ */
+interface ChangeAmplificationSummary {
+    medianFilesPerCommit: number;
+    p90FilesPerCommit: number;
+    commitsAnalyzed: number;
+}
+interface CountLocSummary {
+    /** Raw finding count reported to users. */
+    count: number;
+    /** Score-pressure count; lower than count when findings are broad discovery leads. */
+    scoreCount?: number;
+    loc: number;
+    /** Files contributing findings — feeds fix-density validation. */
+    files?: string[];
+}
+interface StaleSummary extends CountLocSummary {
+    unused: number;
+    singleUse: number;
+}
+interface DriftSummary {
+    count: number;
+    unusedImports: number;
+    architectureViolations: number;
+    /** @deprecated Use `architectureViolations`. */
+    layerViolations: number;
+    direct: number;
+    signal: number;
+}
+interface ComplexitySummary {
+    top: Array<{
+        symbol: string;
+        score: number;
+        file?: string;
+    }>;
+    extremeCount: number;
+    coverage: ComplexityHotspotCoverage;
+}
+type HealthSemanticEvidenceStatus = 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable' | 'disabled';
+interface HealthSemanticEvidenceCoverage {
+    enabled: boolean;
+    status: HealthSemanticEvidenceStatus;
+    incompleteSymbolCount: number;
+    unavailableSymbolCount: number;
+}
+interface HealthPhaseEvidenceCoverage {
+    phase: string;
+    semanticEvidence: HealthSemanticEvidenceCoverage;
+}
+interface GitEvidenceSummary {
+    amplification: ChangeAmplificationSummary | null;
+    hiddenCoupling: {
+        pairCount: number;
+        scoreCount: number;
+        top: Array<{
+            fileA: string;
+            fileB: string;
+            together: number;
+            confidence: number;
+            focusedTogether: number;
+            broadTogether: number;
+            broadCommitRatio: number;
+            lastTogetherAt: number;
+            recentTogether: number;
+            commitScope: 'focused' | 'mixed' | 'broad-sweep';
+            recency: 'recent' | 'stale';
+            scoreWeight: number;
+            subjectContext: {
+                subjectLabels: string[];
+                issueRefs: string[];
+                sampleSubjects: string[];
+                externalIssueLabelStatus: 'unavailable';
+            };
+        }>;
+    };
+    /** Per-file change counts over the analyzed window (tracked files only). */
+    fileStats: Record<string, {
+        changes: number;
+        fixChanges: number;
+    }>;
+    commitsScanned: number;
+}
+interface SuppressionSummary {
+    total: number;
+    byCategory: Record<string, number>;
+}
+
+type FindingEvidence = 'graph-fact' | 'heuristic' | 'change-graph';
+interface HealthAction {
+    category: string;
+    description: string;
+    effort: 'low' | 'medium' | 'high';
+    impact: 'low' | 'medium' | 'high';
+    count: number;
+    locRecoverable: number;
+    /** What kind of evidence backs this action — agents should trust accordingly. */
+    evidence: FindingEvidence;
+}
+/** One deduction line — the score is the sum of these, so it is auditable. */
+interface ScoreDeduction {
+    axis: string;
+    points: number;
+    detail: string;
+    /** Risk deductions use graph/change evidence; hygiene deductions use candidate signals. */
+    kind: 'risk' | 'hygiene';
+}
+interface HealthPressure {
+    axis: string;
+    category: string;
+    kind: ScoreDeduction['kind'];
+    count: number;
+    threshold: number;
+    ratio: number;
+    extraPenalty: number;
+}
+interface HealthAxes {
+    /** LOC in indexed zero-reference or disconnected candidates (legacy field name: deletable). */
+    deletable: {
+        loc: number;
+        symbols: number;
+    };
+    cycles: {
+        count: number;
+    };
+    /** Files touched per commit — the measured cost of one conceptual change. */
+    changeAmplification: ChangeAmplificationSummary | null;
+    /** File pairs that co-change without a structural link — concepts the visible graph can't see. */
+    hiddenCoupling: {
+        pairCount: number;
+        scoreCount: number;
+        top: Array<{
+            fileA: string;
+            fileB: string;
+            together: number;
+            confidence: number;
+            scoreWeight?: number;
+        }>;
+    } | null;
+    /** Complexity hotspots weighted by churn — complex code nobody touches costs nothing. */
+    churnWeightedComplexity: Array<{
+        symbol: string;
+        file?: string;
+        score: number;
+        changes: number;
+        weighted: number;
+    }> | null;
+    /** What fraction of findings rest on graph facts vs heuristics, and how many the user has rejected. */
+    evidenceQuality: {
+        graphFindings: number;
+        heuristicFindings: number;
+        userSuppressed: number;
+    };
+}
+/** Do flagged files attract more fix commits than the rest? The falsifiability check. */
+interface HealthValidation {
+    flaggedFiles: number;
+    flaggedFixDensity: number;
+    baselineFixDensity: number;
+    /** > 1 means findings concentrate where fixes happen — predictive signal. */
+    ratio: number | null;
+    /** Per-detector lift — which detectors actually predict fixes, auditable. */
+    byCategory: Record<string, {
+        flaggedFiles: number;
+        fixDensity: number;
+        lift: number | null;
+    }>;
+    validationBasis: {
+        method: 'subject-regex';
+        commitsScanned: number;
+    };
+}
+interface HealthReport {
+    /** Headline = min(riskScore, hygieneScore); kept for compatibility. */
+    score: number;
+    /** Risk-oriented graph facts and change-graph signals; the composite remains experimental. */
+    riskScore: number;
+    /** Tidiness signals (candidate detectors) — real but not fix-predictive. */
+    hygieneScore: number;
+    scoreBreakdown: ScoreDeduction[];
+    overview: {
+        documents: number;
+        symbols: number;
+        indexSizeBytes: number;
+    };
+    findings: {
+        deadSymbols: number;
+        deadLoc: number;
+        isolatedSymbols: number;
+        isolatedLoc: number;
+        cycles: number;
+        similarPairs: number;
+        duplicateBodyGroups: number;
+        duplicateBodyLoc: number;
+        twinDriftGroups: number;
+        twinDriftLoc: number;
+        reactComponentDuplicatePairs: number;
+        reactHookCandidatePairs: number;
+        reactHookCandidateScoreCount: number;
+        reactLargeComponentPressureFiles: number;
+        vueComponentDuplicatePairs: number;
+        vueComposableCandidatePairs: number;
+        vueComposableCandidateScoreCount: number;
+        vueLargeViewPressureFiles: number;
+        extractionCandidates: number;
+        wrappers: number;
+        wrapperScoreCount: number;
+        passthroughs: number;
+        staleTypes: number;
+        driftedFiles: number;
+        complexityHotspotCount: number;
+        hiddenCouplingPairs: number | null;
+        hiddenCouplingScoreCount: number | null;
+        coverageContractViolations: number;
+    };
+    axes: HealthAxes;
+    validation: HealthValidation | null;
+    suppressions: {
+        total: number;
+        byCategory: Record<string, number>;
+    } | null;
+    actions: HealthAction[];
+    pressure: HealthPressure[];
+    topComplexity: Array<{
+        symbol: string;
+        score: number;
+        file?: string;
+    }>;
+    coverage: {
+        status: 'complete' | 'incomplete' | 'semantic-disabled';
+        complexity: ComplexitySummary['coverage'];
+        phases: HealthPhaseEvidenceCoverage[];
+    };
+    warnings?: string[];
+}
+
+declare const HEALTH_PHASES: readonly ["overview", "dead", "isolated", "cycles", "similar", "duplicate-bodies", "twin-drift", "react-component-duplicates", "react-hook-candidates", "react-large-component-pressure", "vue-component-duplicates", "vue-composable-candidates", "vue-large-view-pressure", "extract-candidates", "wrapper-candidates", "passthrough-candidates", "stale-abstractions", "drift", "complexity-hotspots", "git-evidence", "suppressions", "coverage-contracts"];
+type HealthPhaseName = (typeof HEALTH_PHASES)[number];
+type HealthPhasePayload = {
+    phase: 'overview';
+    statsResult: ReturnType<typeof stats>;
+    warnings: string[];
+} | {
+    phase: 'dead';
+    dead: CountLocSummary;
+} | {
+    phase: 'isolated';
+    isolated: CountLocSummary;
+} | {
+    phase: 'cycles';
+    realCycleCount: number;
+} | {
+    phase: 'similar';
+    similarCount: number;
+} | {
+    phase: 'duplicate-bodies';
+    duplicateBodies: CountLocSummary;
+} | {
+    phase: 'twin-drift';
+    twinDrift: CountLocSummary;
+} | {
+    phase: 'react-component-duplicates';
+    reactComponentDuplicates: CountLocSummary;
+} | {
+    phase: 'react-hook-candidates';
+    reactHookCandidates: CountLocSummary;
+} | {
+    phase: 'react-large-component-pressure';
+    reactLargeComponentPressure: CountLocSummary;
+} | {
+    phase: 'vue-component-duplicates';
+    vueComponentDuplicates: CountLocSummary;
+} | {
+    phase: 'vue-composable-candidates';
+    vueComposableCandidates: CountLocSummary;
+} | {
+    phase: 'vue-large-view-pressure';
+    vueLargeViewPressure: CountLocSummary;
+} | {
+    phase: 'extract-candidates';
+    extractCount: number;
+} | {
+    phase: 'wrapper-candidates';
+    wrappers: CountLocSummary;
+} | {
+    phase: 'passthrough-candidates';
+    passthroughs: CountLocSummary;
+} | {
+    phase: 'stale-abstractions';
+    stale: StaleSummary;
+} | {
+    phase: 'drift';
+    drift: DriftSummary;
+} | {
+    phase: 'complexity-hotspots';
+    complexity: ComplexitySummary;
+} | {
+    phase: 'git-evidence';
+    gitEvidence: GitEvidenceSummary | null;
+} | {
+    phase: 'suppressions';
+    suppressions: SuppressionSummary;
+} | {
+    phase: 'coverage-contracts';
+    coverageContracts: CountLocSummary;
+};
+type HealthPhaseResult = HealthPhasePayload & {
+    evidenceCoverage: HealthSemanticEvidenceCoverage;
+};
+/**
+ * Single composite health report that runs all de-bloat analyses
+ * and produces a prioritized action list.
+ *
+ * The scoring formula accounts for common false positives:
+ * - Entry points (CLI, workers, barrels) appearing as "dead code"
+ * - Typed result interfaces with 1 consumer (normal for APIs)
+ * - Consistent import patterns across sibling modules (not duplication)
+ * - Barrel and orchestrator files deviating from sibling patterns (expected)
+ */
+declare function health(db: ScipDatabase, opts?: {
+    scope?: string;
+    full?: boolean;
+}): HealthReport;
+declare function healthPhase(db: ScipDatabase, phase: HealthPhaseName, opts?: {
+    scope?: string;
+    full?: boolean;
+}): HealthPhaseResult;
+declare function healthPhases(db: ScipDatabase, phases: readonly HealthPhaseName[], opts?: {
+    scope?: string;
+    full?: boolean;
+}): HealthPhaseResult[];
+declare function healthReportFromPhases(phaseResults: HealthPhaseResult[]): HealthReport;
+
+export { HEALTH_PHASES as H, type HealthAction as a, type HealthReport as b, healthPhase as c, healthReportFromPhases as d, type HealthPhaseName as e, healthPhases as f, health as h };

package/dist/index.d.ts

@@ -0,0 +1,183 @@
+import { S as ScipDatabase } from './db-D7sauVFH.js';
+import { I as IndexedDefinition, S as SymbolMatch, a as ScipSymbol, b as ScipLocalSymbol } from './symbol-types-BIQwfoAx.js';
+import { c as classifyFile } from './file-kind-BKCVMNUf.js';
+import { C as CalleeRow, G as GraphRowsMapEvidence } from './call-graph-evidence-gNsxjCW8.js';
+export { C as CodeBaseIQConfig } from './config-types-BNoC96J3.js';
+import 'better-sqlite3';
+
+declare function sourceFallbackCallerEvidenceMap(db: ScipDatabase, definitions: ReadonlyArray<IndexedDefinition>, opts?: {
+    skipPath?: (relativePath: string) => boolean;
+}): Map<number, Set<string>>;
+
+type FrameworkSourceReferenceKind = 'cross-language-dispatch' | 'rust-attribute';
+
+/**
+ * Identifier-attribution module — one owner of "given a textual identifier
+ * hit in file F, which SCIP symbol(s) does it refer to?"
+ *
+ * Pre-this-module the same logic lived in four places (sourceCandidateLines,
+ * importAttributedCandidateLines, findCallerFiles inner loop,
+ * dead.ts:resolveLeaf) with subtle drift. Bug fixes in one site silently
+ * coexisted with the bug in the others. The Vue support and interface-
+ * dispatch fixes from earlier had to touch all four sites separately.
+ *
+ * The forward call (`attributeIdentifier`) is the core. The inverse views
+ * (`findReferences`, `findCallerFiles`) build on it.
+ *
+ * The disambiguation policy — same-file > direct import > interface-dispatch
+ * (all candidates in same imported file) > empty — is owned here. Callers
+ * receive the answer, not raw candidates.
+ */
+
+interface SymbolRef {
+    symbolId: number;
+    symbol: string;
+    /** Defining file of the symbol. */
+    relativePath: string;
+}
+/**
+ * What symbol(s) does identifier `name` in file `file` refer to?
+ *
+ * Returns the symbols this textual hit reasonably resolves to. May
+ * return >1 entry when an interface and one or more impls all live
+ * in the same imported file (runtime dispatch could land on any).
+ * Returns [] when the leaf is ambiguous and no disambiguation
+ * signal applies.
+ */
+declare function attributeIdentifier(db: ScipDatabase, file: string, identifier: string): SymbolRef[];
+
+type SourceReferenceKind = 'identifier' | FrameworkSourceReferenceKind;
+type DefaultSourceReferenceTarget = ReturnType<typeof attributeIdentifier>[number];
+interface SourceReferenceTarget {
+    symbolId: number;
+    relativePath: string;
+}
+interface SourceReferenceHit {
+    sourceFile: string;
+    name: string;
+    target: SourceReferenceTarget;
+    occurrences: number;
+    kind: SourceReferenceKind;
+}
+interface ScanSourceReferencesOptions {
+    paths: Iterable<string>;
+    includeVueSfc?: boolean;
+    includeCrossLanguageDispatchNames?: boolean;
+    includeRustAttributeNames?: boolean;
+    identifierResolution?: 'strict' | 'permissive';
+    candidateNames?: ReadonlySet<string>;
+    skipPath?: (relativePath: string) => boolean;
+    resolveTargets?: (ctx: SourceReferenceResolveContext) => Iterable<SourceReferenceTarget>;
+    afterPath?: (relativePath: string) => void;
+}
+interface SourceReferenceResolveContext {
+    sourceFile: string;
+    name: string;
+    kind: SourceReferenceKind;
+    defaultTargets: () => readonly DefaultSourceReferenceTarget[];
+}
+declare function scanSourceReferences(db: ScipDatabase, opts: ScanSourceReferencesOptions, visit: (hit: SourceReferenceHit) => void): void;
+
+declare function productionCallableDefinitions(db: ScipDatabase, opts?: {
+    scope?: string;
+    files?: readonly string[];
+    minLoc?: number;
+    maxLoc?: number;
+    excludeSymbol?: string;
+    excludeEntrySurfaces?: boolean;
+    excludeTypesFiles?: boolean;
+    /**
+     * Skip externally-live symbols (package surface / entryRoots config).
+     * For detectors whose advice is "inline or delete this" — published API
+     * has consumers the index cannot see, so that advice would be wrong.
+     */
+    excludeRootedSymbols?: boolean;
+    excludeRustTraitImplMembers?: boolean;
+    includeSuppressed?: boolean;
+    requireFunctionLikeSymbol?: boolean;
+    requireCallableSymbol?: boolean;
+    sortByLocDesc?: boolean;
+}): IndexedDefinition[];
+
+declare class ProjectIndex {
+    private readonly db;
+    constructor(db: ScipDatabase);
+    scopedDefinitions(scope?: string): IndexedDefinition[];
+    definitionsForFile(relativePath: string): IndexedDefinition[];
+    productionCallableDefinitions(opts?: NonNullable<Parameters<typeof productionCallableDefinitions>[1]>): IndexedDefinition[];
+    calleeMap(definitions: ReadonlyArray<SymbolMatch>, opts?: {
+        additive?: boolean;
+        semantic?: boolean;
+    }): Map<number, CalleeRow[]>;
+    calleeEvidenceMap(definitions: ReadonlyArray<SymbolMatch>, opts?: {
+        additive?: boolean;
+        semantic?: boolean;
+    }): GraphRowsMapEvidence<CalleeRow>;
+    crossFileCallerMap(definitions?: ReadonlyArray<SymbolMatch>, opts?: {
+        semantic?: boolean;
+    }): Map<number, Set<string>>;
+    sourceFallbackCallerFiles(definitions: ReadonlyArray<IndexedDefinition>, opts?: {
+        skipPath?: (relativePath: string) => boolean;
+    }): ReturnType<typeof sourceFallbackCallerEvidenceMap>;
+    callerFileMap(definitions: ReadonlyArray<IndexedDefinition>, opts?: {
+        semantic?: boolean;
+        sourceFallback?: boolean;
+    }): Map<number, Set<string>>;
+    frameworkReferencedSymbolIds(definitions: ReadonlyArray<IndexedDefinition>): Set<number>;
+    symbolsWithNonSelfCallees(definitions: ReadonlyArray<IndexedDefinition>, opts?: {
+        additive?: boolean;
+        semantic?: boolean;
+    }): Set<number>;
+    fileDependencyGraph(scope?: string): Map<string, Set<string>>;
+    fileKind(relativePath: string): ReturnType<typeof classifyFile>;
+    hasSuppressionComment(definition: Pick<IndexedDefinition, 'relativePath' | 'startLine'>): boolean;
+    sourceFiles(): string[];
+    scanSourceReferences(opts: Parameters<typeof scanSourceReferences>[1], visit: Parameters<typeof scanSourceReferences>[2]): void;
+    callableSignature(definition: Pick<IndexedDefinition, 'relativePath' | 'startLine' | 'endLine'>): {
+        paramCount: number;
+    } | null;
+}
+
+/**
+ * Builds a gitignore-based path filter from .gitignore files found
+ * in the project directory tree. This replaces hardcoded path exclusions
+ * like "node_modules/", "dist/", "target/", "__pycache__/" — instead,
+ * we respect whatever the project already ignores.
+ *
+ * Falls back to sensible defaults if no .gitignore is found.
+ */
+declare function createGitignoreFilter(projectRoot: string): PathFilter;
+interface PathFilter {
+    /** Returns true if this path should be excluded from results */
+    isIgnored: (relativePath: string) => boolean;
+    /** Filter an array of paths, keeping only non-ignored ones */
+    filter: (paths: string[]) => string[];
+}
+
+/**
+ * Parse a SCIP symbol string into its structured components.
+ * Works for any SCIP-indexed language (TypeScript, Java, Rust, Python, etc.)
+ */
+declare function parseSymbol(raw: string): ScipSymbol | ScipLocalSymbol;
+/**
+ * Convert a parsed SCIP symbol to a short, human-readable name.
+ * Language-agnostic: works for any SCIP-indexed language.
+ *
+ * Examples:
+ *   "scip-typescript npm @vega/api 0.1.3 src/modules/auth/auth.service.ts/AuthService#login()."
+ *   → "auth.service:AuthService:login()"
+ *
+ *   "scip-java maven com.example/mylib 1.0.0 com/example/MyClass#doStuff()."
+ *   → "MyClass:doStuff()"
+ *
+ *   "rust-analyzer cargo my-crate 0.1.0 src/lib.rs/MyStruct#new()."
+ *   → "lib:MyStruct:new()"
+ */
+declare function shortenSymbol(raw: string): string;
+/**
+ * Extract just the leaf name from a SCIP symbol.
+ * Useful when you only need the function/class/variable name without path context.
+ */
+declare function leafName(raw: string): string;
+
+export { ProjectIndex, ScipDatabase, createGitignoreFilter, leafName, parseSymbol, shortenSymbol };

package/dist/index.js

@@ -0,0 +1,2 @@
+import{a as e}from"./chunk-DDZ7VHWV.js";import{a as m}from"./chunk-NEDP5RFQ.js";import{c as a}from"./chunk-7FND7D7N.js";import"./chunk-BGBBVSH4.js";import"./chunk-JOIRNPPY.js";import"./chunk-6CS3UQTN.js";import"./chunk-P5XHIJHI.js";import"./chunk-J77SU6VA.js";import"./chunk-UCD3H3UZ.js";import"./chunk-CVYSU6BX.js";import"./chunk-ELNRLMC5.js";import"./chunk-UZGZB3VB.js";import"./chunk-ZKX2FRS6.js";import"./chunk-C7QOQX32.js";import"./chunk-TIIC3ZE7.js";import"./chunk-YUKYB54I.js";import"./chunk-OANDYLJQ.js";import"./chunk-NNOKTMZT.js";import"./chunk-SGX43S2L.js";import{b as o,d as r,e as t}from"./chunk-FETNQCFO.js";import"./chunk-O6QTXQPJ.js";import"./chunk-ADTBPVUZ.js";import"./chunk-BMYOV5GP.js";import"./chunk-CWONGW6P.js";import"./chunk-3LCDIREB.js";import"./chunk-NNJ2KZZG.js";export{a as ProjectIndex,e as ScipDatabase,m as createGitignoreFilter,t as leafName,o as parseSymbol,r as shortenSymbol};
+//# sourceMappingURL=index.js.map

package/dist/invocation-command-descriptors-QT2JMY5J.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{a,b,c}from"./chunk-C74PPYLA.js";export{b as directNavigationCommandEligible,c as loadInvocationCommandDescriptors,a as normalizeLegacyEvidenceInvocation};
+//# sourceMappingURL=invocation-command-descriptors-QT2JMY5J.js.map

package/dist/invocation-command-descriptors-YN4QJEAX.js

@@ -0,0 +1,2 @@
+import{a,b,c}from"./chunk-Q5ELPRKQ.js";export{b as directNavigationCommandEligible,c as loadInvocationCommandDescriptors,a as normalizeLegacyEvidenceInvocation};
+//# sourceMappingURL=invocation-command-descriptors-YN4QJEAX.js.map

package/dist/next-anchor-candidates-BwMczMvX.d.ts

@@ -0,0 +1,90 @@
+import { a as ExplorationEvidenceStrength, c as ExplorationEvidenceSource } from './exploration-topology-BG4v30HZ.js';
+
+/** Compatibility projection used by current renderers while evidence axes remain independent. */
+type BoundaryEvidenceStrength = 'exact' | 'derived' | 'candidate';
+type BoundaryResolutionState = 'locally-linked' | 'external' | 'unresolved' | 'ambiguous';
+type BoundarySourceScope = 'production' | 'test' | 'fixture' | 'example' | 'generated' | 'script' | 'unknown';
+
+type BehaviorSignal = 'anchor' | 'signature' | 'binding' | 'branch' | 'loop' | 'call' | 'await' | 'return' | 'throw' | 'mutation' | 'shape' | 'spread' | 'catch' | 'finally';
+interface BehaviorSkeletonLine {
+    line: number;
+    endLine: number;
+    depth: number;
+    signals: BehaviorSignal[];
+    text: string;
+    copied: boolean;
+}
+interface BehaviorSkeleton {
+    callable?: {
+        name: string;
+        startLine: number;
+        endLine: number;
+    };
+    representation: 'outline';
+    constructKind: string;
+    signature: string;
+    lines: BehaviorSkeletonLine[];
+    signals: BehaviorSignal[];
+    testCases: string[];
+    coverage: {
+        sourceStatements: number;
+        representedStatements: number;
+        copiedStatements: number;
+        omittedStatements: 0;
+    };
+    rawCharacters: number;
+    outlineCharacters: number;
+    /** @deprecated Prefer coverage.sourceStatements. */
+    candidateLines: number;
+    /** @deprecated Behavioral outlines never silently omit statements. */
+    omittedLines: number;
+}
+
+interface SystemMapNextAnchorAlternative {
+    symbol: string | null;
+    label: string;
+    file: string;
+    line: number;
+    endLine: number | null;
+}
+interface SystemMapNextAnchor {
+    id: string;
+    status: ExplorationEvidenceStrength | 'ambiguous';
+    source: 'graph-call' | 'graph-relation' | 'leaf-identity-candidate';
+    /** Optional on legacy call candidates; populated for newly rendered causal targets. */
+    direction?: 'upstream' | 'downstream' | 'connector';
+    causalRole?: 'caller' | 'callee' | 'result-callback' | 'callable-reference' | 'runtime-producer' | 'runtime-consumer';
+    relationKind?: string;
+    fromStepId: string;
+    fromLabel: string;
+    callsite: {
+        file: string;
+        line: number;
+        endLine: number;
+        text: string;
+        signals: BehaviorSignal[];
+        calleeLeaf: string;
+    };
+    alternatives: SystemMapNextAnchorAlternative[];
+    alternativeCount: number;
+    evidence: ExplorationEvidenceSource[];
+}
+interface SystemMapNextAnchorPacket {
+    anchors: SystemMapNextAnchor[];
+    withheldAnchors: SystemMapNextAnchor[];
+    candidateAnchors: number;
+    omittedAnchors: number;
+    scannedBehaviorSteps: number;
+    visibleCallsites: number;
+    graphEvidencedCallsites: number;
+    identityCandidateCallsites: number;
+    ambiguousCallsites: number;
+    unresolvedCallsites: number;
+    upstreamCandidates?: number;
+    resultCandidates?: number;
+    runtimeCandidates?: number;
+    inspectCommand: string | null;
+    remainingInspectCommands: string[];
+}
+
+export type { BehaviorSignal as B, SystemMapNextAnchorPacket as S, BoundarySourceScope as a, SystemMapNextAnchor as b, SystemMapNextAnchorAlternative as c, BehaviorSkeleton as d, BoundaryEvidenceStrength as e, BoundaryResolutionState as f };

package/dist/output-continuation-command-2V2SL4TD.js

@@ -0,0 +1,2 @@
+import{a}from"./chunk-476NR5B7.js";import"./chunk-GTIYTDRE.js";import"./chunk-ZZ3MWF33.js";import"./chunk-NCZUNH3E.js";import"./chunk-YUKYB54I.js";import"./chunk-NNO6A2PO.js";import"./chunk-P5XHIJHI.js";import"./chunk-KUW32IRO.js";import"./chunk-5VKBFZZU.js";import"./chunk-7MGU3HPH.js";import"./chunk-FAJQ7LWY.js";import"./chunk-Z54RD7VL.js";import"./chunk-RU65DDUP.js";import"./chunk-QW7EP6WI.js";import"./chunk-3IER7Q6H.js";import"./chunk-FM5BPL4V.js";import"./chunk-DRENNWRG.js";import"./chunk-RDBI2RXU.js";import"./chunk-R2NOK63J.js";import"./chunk-EF2R3WNQ.js";import"./chunk-WE5RZHZ7.js";import"./chunk-2Q2LW5JW.js";export{a as outputContinuationCommandDescriptor};
+//# sourceMappingURL=output-continuation-command-2V2SL4TD.js.map

package/dist/output-continuation-command-65J5IP3O.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{a}from"./chunk-JSOYNVWH.js";import"./chunk-ECQBG7PW.js";import"./chunk-XZEE23VG.js";import"./chunk-G6XFR4ZL.js";import"./chunk-3JSXXYTZ.js";import"./chunk-DO6WQD2T.js";import"./chunk-2X7V4HS4.js";import"./chunk-SNNWPCN7.js";import"./chunk-B2OB55RR.js";export{a as outputContinuationCommandDescriptor};
+//# sourceMappingURL=output-continuation-command-65J5IP3O.js.map

package/dist/postinstall.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{d as n}from"./chunk-YMGZZEW4.js";import"./chunk-6OAHRI2D.js";import"./chunk-2Q2LW5JW.js";n();
+//# sourceMappingURL=postinstall.js.map

package/dist/project-reindex-5JOKXAXT.js

@@ -0,0 +1,2 @@
+import{a}from"./chunk-ZMI2JSX2.js";import"./chunk-TFZB6XTM.js";import"./chunk-VFY6Y2H6.js";import"./chunk-ILMHV3KM.js";import"./chunk-PYAB5SM6.js";import"./chunk-NCZUNH3E.js";import"./chunk-YUKYB54I.js";import"./chunk-KUW32IRO.js";import"./chunk-7MGU3HPH.js";import"./chunk-FDGD5AB5.js";import"./chunk-RU65DDUP.js";import"./chunk-QW7EP6WI.js";import"./chunk-3IER7Q6H.js";import"./chunk-FM5BPL4V.js";import"./chunk-DRENNWRG.js";import"./chunk-RDBI2RXU.js";import"./chunk-R2NOK63J.js";import"./chunk-EF2R3WNQ.js";import"./chunk-WE5RZHZ7.js";import"./chunk-6OAHRI2D.js";import"./chunk-2Q2LW5JW.js";export{a as reindexConfiguredProject};
+//# sourceMappingURL=project-reindex-5JOKXAXT.js.map

package/dist/project-reindex-UQBIKO4M.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{m as a}from"./chunk-Q72QSKXC.js";import"./chunk-3JSXXYTZ.js";import"./chunk-DO6WQD2T.js";import"./chunk-2X7V4HS4.js";import"./chunk-SNNWPCN7.js";export{a as reindexConfiguredProject};
+//# sourceMappingURL=project-reindex-UQBIKO4M.js.map