effect-analyzer 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1895 @@
+import { S as StaticEffectIR, P as ProjectServiceMap, A as AnalyzerOptions, a as AnalysisError, M as MermaidOptions, E as EffectPath, D as DiagramQualityWithFile, b as DiagramTopOffendersReport, c as DiagramQuality, J as JSONRenderOptions, d as ShowcaseEntry, e as ServiceRequirement, f as SourceLocation, g as StaticEffectNode, C as ComplexityThresholds, h as ComplexityMetrics, T as TestMatrix, i as StaticFiberNode, j as CauseTypeSignature, k as EffectTypeSignature, L as LayerTypeSignature, l as ScheduleTypeSignature, m as StreamTypeSignature } from './analyze-a8PswlPG.cjs';
+export { n as AnalysisStats, o as AnalysisWarning, p as AnalyzeResult, q as DependencyInfo, r as DiagramQualityMetrics, s as DiagramReadabilityBand, t as DiagramTopOffenderEntry, u as JSDocTags, v as LayerImplementation, w as MermaidDetailLevel, x as MermaidStyles, y as PathCondition, z as PathStepRef, B as ScheduleInfo, F as SemanticRole, G as ServiceArtifact, G as ServiceArtifactType, H as ServiceConsumerRef, I as ServiceDefinition, K as ShowcaseStepDetail, N as StaticAnalysisMetadata, O as StaticBaseNode, Q as StaticCauseNode, R as StaticConcurrencyPrimitiveNode, U as StaticConditionalNode, V as StaticEffectProgram, W as StaticErrorHandlerNode, X as StaticExitNode, Y as StaticFlowNode, Z as StaticGeneratorNode, _ as StaticLayerNode, $ as StaticLoopNode, a0 as StaticMatchNode, a1 as StaticParallelNode, a2 as StaticPipeNode, a3 as StaticRaceNode, a4 as StaticResourceNode, a5 as StaticRetryNode, a6 as StaticScheduleNode, a7 as StaticStreamNode, a8 as StaticTimeoutNode, a9 as StaticTransformNode, aa as StaticUnknownNode, ab as StreamOperatorInfo, ac as TestCondition, ad as TestMatrixSummary, ae as TestPath, af as analyze, ag as getStaticChildren, ah as isStaticCauseNode, ai as isStaticConcurrencyPrimitiveNode, aj as isStaticConditionalNode, ak as isStaticEffectNode, al as isStaticErrorHandlerNode, am as isStaticExitNode, an as isStaticFiberNode, ao as isStaticGeneratorNode, ap as isStaticLayerNode, aq as isStaticLoopNode, ar as isStaticMatchNode, as as isStaticParallelNode, at as isStaticPipeNode, au as isStaticRaceNode, av as isStaticResourceNode, aw as isStaticRetryNode, ax as isStaticScheduleNode, ay as isStaticStreamNode, az as isStaticTimeoutNode, aA as isStaticTransformNode, aB as isStaticUnknownNode } from './analyze-a8PswlPG.cjs';
+import { Effect } from 'effect';
+import { Node, SourceFile, Project, TypeChecker, Type } from 'ts-morph';
+
+/**
+ * Project-wide / Cross-file Analysis (GAP 17)
+ *
+ * Analyzes a directory of TypeScript files and aggregates results.
+ */
+
+/** Per-file failure for project analysis (Gap 3: no silent drops). */
+interface ProjectFileFailure {
+    readonly file: string;
+    readonly error: string;
+}
+interface ProjectAnalysisResult {
+    /** File path -> list of program IRs in that file */
+    readonly byFile: Map<string, readonly StaticEffectIR[]>;
+    /** All programs across the project */
+    readonly allPrograms: readonly StaticEffectIR[];
+    /** Entry points (files that run Effect.runPromise / runSync / NodeRuntime.runMain) - heuristic + package.json */
+    readonly entryPointFiles: string[];
+    /** Total file count discovered */
+    readonly fileCount: number;
+    /** Files that failed to analyze (error message included) - Gap 3 */
+    readonly failedFiles: readonly ProjectFileFailure[];
+    /** Files that were analyzed but had zero Effect programs */
+    readonly zeroProgramFiles: readonly string[];
+    /** Project-level deduplicated service map (when --service-map is enabled) */
+    readonly serviceMap?: ProjectServiceMap | undefined;
+}
+interface AnalyzeProjectOptions {
+    readonly tsconfig?: string | undefined;
+    /** File extensions to discover; default ['.ts', '.tsx']. Include '.js'/.jsx' for best-effort JS (Gap 6). */
+    readonly extensions?: readonly string[] | undefined;
+    readonly maxDepth?: number | undefined;
+    /** When true, include per-file durationMs in outcomes (improve.md §7 optional timing). */
+    readonly includePerFileTiming?: boolean | undefined;
+    /** Optional false-positive review: paths matching any of these (substring or path segment) are excluded from suspiciousZeros (improve.md §5). */
+    readonly excludeFromSuspiciousZeros?: readonly string[] | undefined;
+    /** Optional path to known Effect internals root for per-file analysis (improve.md §1). */
+    readonly knownEffectInternalsRoot?: string | undefined;
+    /** When true, build the deduplicated project-level service map (--service-map). */
+    readonly buildServiceMap?: boolean | undefined;
+}
+/** Per-file outcome for coverage audit. */
+interface FileOutcome {
+    readonly file: string;
+    readonly status: 'ok' | 'fail' | 'zero';
+    readonly programCount?: number;
+    readonly error?: string;
+    /** When includePerFileTiming: analysis time in ms (improve.md §7). */
+    readonly durationMs?: number;
+}
+type ZeroProgramCategory = 'barrel_or_index' | 'config_or_build' | 'test_or_dtslint' | 'type_only' | 'suspicious' | 'other';
+interface ZeroProgramClassification {
+    readonly file: string;
+    readonly category: ZeroProgramCategory;
+    readonly importsEffect: boolean;
+}
+/** Coverage audit: discovered vs analyzed vs failed/zero, with per-file outcomes. */
+interface CoverageAuditResult {
+    readonly discovered: number;
+    readonly analyzed: number;
+    readonly zeroPrograms: number;
+    readonly failed: number;
+    readonly outcomes: readonly FileOutcome[];
+    readonly percentage: number;
+    /** analyzed / (analyzed + failed) * 100 — excludes zero-program files (correct classification). */
+    readonly analyzableCoverage: number;
+    /** unknownCount / totalNodes across all analyzed files (0–1). */
+    readonly unknownNodeRate: number;
+    /** Repo-level aggregate: total node count across all analyzed programs (improve.md §5). */
+    readonly totalNodes: number;
+    /** Repo-level aggregate: unknown node count across all analyzed programs (improve.md §5). */
+    readonly unknownNodes: number;
+    /** Files that import from effect/@effect but produced zero programs. */
+    readonly suspiciousZeros: readonly string[];
+    /** Per-category zero-program counts for triage. */
+    readonly zeroProgramCategoryCounts: Readonly<Record<ZeroProgramCategory, number>>;
+    /** Per-file category for zero-program outcomes. */
+    readonly zeroProgramClassifications: readonly ZeroProgramClassification[];
+    /** Top N files by unknown node rate (highest first), for --show-top-unknown. */
+    readonly topUnknownFiles?: readonly string[];
+    /** Unknown node counts by reason. */
+    readonly unknownReasonCounts?: Readonly<Record<string, number>>;
+    /** Top unknown reasons by count (highest first), for --show-top-unknown-reasons. */
+    readonly topUnknownReasons?: readonly {
+        reason: string;
+        count: number;
+    }[];
+    /** Audit execution time in ms (improve.md §7 performance validation). */
+    readonly durationMs?: number;
+}
+/**
+ * Analyze all TypeScript files in a directory and return aggregated IRs.
+ */
+declare function analyzeProject(dirPath: string, options?: AnalyzeProjectOptions): Effect.Effect<ProjectAnalysisResult>;
+/**
+ * Run a coverage audit over a directory: discover all .ts/.tsx files, analyze each,
+ * and return counts plus per-file outcomes (ok / zero programs / failed with reason).
+ * Does not swallow failures; every file gets an outcome.
+ */
+declare function runCoverageAudit(dirPath: string, options?: AnalyzeProjectOptions): Effect.Effect<CoverageAuditResult>;
+
+/**
+ * Migration Assistant (GAP 29)
+ *
+ * Detects patterns that could be migrated to Effect (try/catch, Promise.all, etc.).
+ */
+interface MigrationOpportunity {
+    readonly filePath: string;
+    readonly line: number;
+    readonly column: number;
+    readonly pattern: string;
+    readonly suggestion: string;
+    readonly codeSnippet?: string | undefined;
+}
+interface MigrationReport {
+    readonly opportunities: readonly MigrationOpportunity[];
+    readonly fileCount: number;
+}
+/**
+ * Scan a file for migration opportunities.
+ */
+declare function findMigrationOpportunities(filePath: string, source?: string): MigrationOpportunity[];
+/**
+ * Scan a directory for migration opportunities.
+ */
+declare function findMigrationOpportunitiesInProject(dirPath: string, options?: {
+    extensions?: readonly string[];
+}): Promise<MigrationReport>;
+/**
+ * Format migration report as text.
+ */
+declare function formatMigrationReport(report: MigrationReport): string;
+
+/**
+ * Shared utilities for static Effect analysis: options, ID generation,
+ * location/JSDoc extraction, dependency/error aggregation, program naming.
+ */
+
+declare const resetIdCounter: () => void;
+
+/**
+ * Static Effect Analyzer
+ *
+ * Uses ts-morph to walk the TypeScript AST and extract Effect structure
+ * without executing the code. Built entirely with Effect for composability.
+ *
+ * Public API: analyzeEffectFile, analyzeEffectSource, resetIdCounter.
+ * Implementation is split across analysis-utils, analysis-patterns, alias-resolution,
+ * program-discovery, effect-analysis, and core-analysis.
+ */
+
+declare const analyzeEffectFile: (filePath: string, options?: AnalyzerOptions) => Effect.Effect<readonly StaticEffectIR[], AnalysisError>;
+declare const analyzeEffectSource: (code: string, filePath?: string, options?: AnalyzerOptions) => Effect.Effect<readonly StaticEffectIR[], AnalysisError>;
+
+/**
+ * Mermaid diagram generation for Effect IR
+ *
+ * Aligned with awaitly-analyze: Start/End nodes, explicit edges,
+ * optional subgraphs for parallel/race, sequential flow for pipe/generator.
+ */
+
+/**
+ * Generate a Mermaid flowchart from static Effect IR (sync).
+ * Includes Start/End nodes, optional subgraphs, sequential flow.
+ */
+declare function renderStaticMermaid(ir: StaticEffectIR, options?: Partial<MermaidOptions>): string;
+/**
+ * Render Effect IR as Mermaid flowchart (Effect).
+ * Same as renderStaticMermaid but returns Effect.Effect<string>.
+ */
+declare const renderMermaid: (ir: StaticEffectIR, options?: Partial<MermaidOptions>) => Effect.Effect<string>;
+interface PathsMermaidOptions {
+    direction?: 'TB' | 'LR' | 'BT' | 'RL';
+    /** Collapse consecutive log-like steps into one summary node (default: true). */
+    collapseRepeatedLogs?: boolean;
+    /** Collapse consecutive pure-transform-like steps into one summary node (default: true). */
+    collapsePureTransforms?: boolean;
+    /** Collapse consecutive environment-acquisition-like steps (default: false, true in style-guide mode). */
+    collapseEnvironmentRuns?: boolean;
+    /** Apply summary-only readability heuristics (environment grouping + service boundary prefixes). */
+    styleGuide?: boolean;
+    /** Prefix the first service-like calls with "svc:" (default: false, true in style-guide mode). */
+    prefixServiceBoundaries?: boolean;
+}
+interface DisplayPathStep {
+    key: string;
+    name: string;
+}
+interface PathSummaryResult {
+    steps: readonly DisplayPathStep[];
+    collapsedGroups: number;
+}
+declare function summarizePathSteps(path: EffectPath, options: PathsMermaidOptions): PathSummaryResult;
+/**
+ * Generate a simplified Mermaid diagram from execution paths.
+ * Start -> step1 -> step2 -> ... -> End; nodes merged by nodeId.
+ */
+declare function renderPathsMermaid(paths: readonly EffectPath[], options?: PathsMermaidOptions): string;
+interface EnhancedMermaidOptions extends Partial<MermaidOptions> {
+    showTypeSignatures?: boolean;
+    showRequiredServices?: boolean;
+    showErrorNodes?: boolean;
+}
+/**
+ * Generate enhanced Mermaid with type signatures and/or required services on nodes.
+ */
+declare function renderEnhancedMermaid(ir: StaticEffectIR, options?: EnhancedMermaidOptions): string;
+/**
+ * Render enhanced Mermaid as Effect.
+ */
+declare const renderEnhancedMermaidEffect: (ir: StaticEffectIR, options?: EnhancedMermaidOptions) => Effect.Effect<string>;
+/**
+ * Generate a Mermaid sequence diagram for fiber fork/join (GAP 21).
+ */
+declare function renderSequenceMermaid(ir: StaticEffectIR): string;
+/**
+ * Generate a Mermaid Gantt diagram for retry schedules (GAP 21).
+ */
+declare function renderRetryGanttMermaid(ir: StaticEffectIR): string;
+/**
+ * Render a project-level service dependency graph as a Mermaid flowchart.
+ * Services are hexagon-shaped nodes, with edges showing layer requirements.
+ */
+declare function renderServiceGraphMermaid(serviceMap: ProjectServiceMap, options?: {
+    direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}): string;
+
+interface RailwayOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a railway-oriented Mermaid flowchart from an Effect IR.
+ *
+ * Happy path flows left-to-right with `-->|ok|` edges.
+ * Steps with typed errors get `-->|err|` branches to error nodes.
+ */
+declare function renderRailwayMermaid(ir: StaticEffectIR, options?: RailwayOptions): string;
+
+/**
+ * Mermaid renderer for the R channel (service/dependency) graph.
+ *
+ * Two modes:
+ * - Single-file: `renderServicesMermaid(ir)` — shows required vs provided services for one program.
+ * - Project-wide: `renderServicesMermaidFromMap(serviceMap)` — shows the full service dependency graph.
+ */
+
+interface ServicesOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a Mermaid flowchart showing the R channel for a single IR.
+ *
+ * - Program node as a rectangle
+ * - Required services as blue hexagons with `requires` edges
+ * - Provided services as green hexagons with `provides` edges
+ */
+declare function renderServicesMermaid(ir: StaticEffectIR, options?: ServicesOptions): string;
+/**
+ * Render a Mermaid flowchart for a project-wide service dependency graph.
+ *
+ * - Each service is a hexagon node
+ * - Edges show layer dependencies
+ * - Unresolved services are dashed
+ */
+declare function renderServicesMermaidFromMap(serviceMap: ProjectServiceMap, options?: ServicesOptions): string;
+
+interface MermaidErrorsOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a Mermaid flowchart showing error propagation:
+ * - Steps (left): which steps produce errors
+ * - Error types (middle): the error type nodes
+ * - Handlers (right): which handlers catch which errors
+ * - Unhandled: errors that are never caught
+ */
+declare function renderErrorsMermaid(ir: StaticEffectIR, options?: MermaidErrorsOptions): string;
+
+interface DecisionsOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a decision-tree Mermaid flowchart from an Effect IR.
+ *
+ * Decision nodes (conditional, decision, switch, match) are rendered as
+ * diamond-shaped nodes with labeled edges to their branches.
+ */
+declare function renderDecisionsMermaid(ir: StaticEffectIR, options?: DecisionsOptions): string;
+
+interface CausesOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a Cause-tree Mermaid flowchart from an Effect IR.
+ *
+ * Shows how errors compose: parallel failures, sequential failures,
+ * defects vs expected errors.
+ */
+declare function renderCausesMermaid(ir: StaticEffectIR, options?: CausesOptions): string;
+
+interface ConcurrencyOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a concurrency-focused Mermaid flowchart from an Effect IR.
+ *
+ * Shows parallel execution, races, fiber forks/joins, and concurrency primitives.
+ */
+declare function renderConcurrencyMermaid(ir: StaticEffectIR, options?: ConcurrencyOptions): string;
+
+/**
+ * Render a Mermaid sequence diagram from an Effect IR showing
+ * execution order with service calls and timing info.
+ */
+declare function renderTimelineMermaid(ir: StaticEffectIR): string;
+
+interface LayersOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a layered architecture Mermaid flowchart from an Effect IR.
+ *
+ * Shows which layers provide which services and their dependencies.
+ * - Layer nodes are rectangles with name and lifecycle info.
+ * - Service nodes are hexagons.
+ * - Provides edges are solid green arrows.
+ * - Requires edges are dashed blue arrows.
+ * - Merge edges are gray arrows.
+ */
+declare function renderLayersMermaid(ir: StaticEffectIR, options?: LayersOptions): string;
+
+interface RetryOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a Mermaid flowchart showing retry and timeout resilience patterns.
+ */
+declare function renderRetryMermaid(ir: StaticEffectIR, options?: RetryOptions): string;
+
+interface TestabilityOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a testability-focused Mermaid flowchart from an Effect IR.
+ *
+ * Shows what needs mocking for testing: required services, isolation boundaries,
+ * and mock complexity (easy leaf services vs hard infrastructure/layer services).
+ */
+declare function renderTestabilityMermaid(ir: StaticEffectIR, options?: TestabilityOptions): string;
+
+interface DataflowOptions {
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+}
+/**
+ * Render a dataflow Mermaid flowchart from an Effect IR.
+ *
+ * Shows data transformation pipelines: how types evolve through pipe chains
+ * and generator yield sequences.
+ */
+declare function renderDataflowMermaid(ir: StaticEffectIR, options?: DataflowOptions): string;
+
+type DiagramType = 'mermaid' | 'railway';
+/**
+ * Infer the best diagram type for an Effect program.
+ *
+ * Decision order:
+ * 1. Hard rules: parallel/race/switch/loop/conditional/decision → mermaid
+ * 2. Soft heuristics: low complexity → railway, otherwise mermaid
+ */
+declare function inferBestDiagramType(ir: StaticEffectIR): DiagramType;
+
+interface DiagramQualityHintInput {
+    readonly reasons?: readonly string[] | undefined;
+    readonly tips?: readonly string[] | undefined;
+}
+interface DiagramQualityOptions {
+    readonly styleGuideSummary?: boolean | undefined;
+    readonly hints?: DiagramQualityHintInput | undefined;
+}
+declare function computeProgramDiagramQuality(ir: StaticEffectIR, options?: DiagramQualityOptions): DiagramQuality;
+declare function computeFileDiagramQuality(filePath: string, programs: readonly StaticEffectIR[], options?: DiagramQualityOptions): DiagramQualityWithFile;
+declare function buildTopOffendersReport(fileQualities: readonly DiagramQualityWithFile[], topN?: number): DiagramTopOffendersReport;
+
+declare function loadDiagramQualityHintsFromEslintJson(jsonPath: string): Promise<Map<string, DiagramQualityHintInput>>;
+
+/**
+ * Plain-English explanation renderer for Effect IR trees.
+ *
+ * Walks the static IR and produces a human-readable narrative
+ * describing what an Effect program does.
+ */
+
+/**
+ * Renders a full plain-English explanation for a single Effect IR program.
+ */
+declare function renderExplanation(ir: StaticEffectIR): string;
+/**
+ * Renders explanations for multiple programs, separated by `---`.
+ */
+declare function renderMultipleExplanations(irs: readonly StaticEffectIR[]): string;
+
+/**
+ * Summary Output Module
+ *
+ * Produces ultra-compact one-liner-per-program output for quick overview
+ * of Effect program characteristics.
+ */
+
+/**
+ * Render a one-line summary for a single Effect program IR.
+ *
+ * Format:
+ *   programName | gen | 6 steps | 2 services | 0 errors | 1 handler | complexity: 2
+ */
+declare function renderSummary(ir: StaticEffectIR): string;
+/**
+ * Render a formatted, column-aligned table summarizing multiple Effect program IRs.
+ *
+ * Example output:
+ *   Program          | Kind | Steps | Services | Errors | Handlers | Complexity
+ *   -----------------+------+-------+----------+--------+----------+-----------
+ *   serviceProgram   | gen  |     6 |        2 |      0 |        0 |          2
+ *   databaseProgram  | gen  |     5 |        2 |      1 |        1 |          3
+ */
+declare function renderMultipleSummaries(irs: readonly StaticEffectIR[]): string;
+
+/**
+ * Build a program x service dependency matrix as a markdown table from IR dependencies.
+ */
+declare function renderDependencyMatrix(irs: readonly StaticEffectIR[]): string;
+/**
+ * Build a program x service dependency matrix as a markdown table from the
+ * project-level service map (more accurate than IR-based).
+ */
+declare function renderDependencyMatrixFromServiceMap(serviceMap: ProjectServiceMap): string;
+
+/**
+ * JSON output generation for Effect IR
+ */
+
+/**
+ * Render Effect IR as JSON string
+ */
+declare const renderJSON: (ir: StaticEffectIR, options?: Partial<JSONRenderOptions>) => Effect.Effect<string>;
+/**
+ * Render multiple Effect IRs as JSON array
+ */
+declare const renderMultipleJSON: (irs: readonly StaticEffectIR[], options?: Partial<JSONRenderOptions>) => Effect.Effect<string>;
+
+/**
+ * Interactive HTML Output (GAP 22 v2)
+ *
+ * Generates a self-contained HTML file with:
+ * - Embedded IR and Mermaid diagram
+ * - Search/filter nodes by type, name, complexity
+ * - Click-to-navigate: click node to see source location, IR details
+ * - Path explorer: select a path and highlight it
+ * - Complexity heatmap: color nodes by complexity contribution
+ * - Error/data flow toggles
+ * - 6-theme system with system preference detection and localStorage persistence
+ */
+
+type HtmlTheme = 'midnight' | 'ocean' | 'ember' | 'forest' | 'daylight' | 'paper';
+interface HtmlOutputOptions {
+    readonly title?: string | undefined;
+    /** Named theme, or legacy 'light'/'dark' aliases (mapped to daylight/midnight). */
+    readonly theme?: HtmlTheme | 'light' | 'dark' | undefined;
+}
+/**
+ * Render IR as a self-contained HTML page with interactive features.
+ */
+declare function renderInteractiveHTML(ir: StaticEffectIR, options?: HtmlOutputOptions): string;
+
+/**
+ * Documentation Generation for Effect IR
+ *
+ * Generates comprehensive markdown documentation from analyzed Effect programs:
+ * workflow steps, service dependencies, complexity metrics, and embedded diagrams.
+ */
+
+interface DocSection {
+    title: string;
+    content: string;
+}
+interface DocumentationOptions {
+    /** Include Mermaid diagram in documentation */
+    includeDiagram?: boolean | undefined;
+    /** Include complexity metrics */
+    includeComplexity?: boolean | undefined;
+    /** Include service dependency table */
+    includeServiceDeps?: boolean | undefined;
+    /** Include error type documentation */
+    includeErrors?: boolean | undefined;
+    /** Include data flow information */
+    includeDataFlow?: boolean | undefined;
+}
+/**
+ * Generate comprehensive markdown documentation from an analyzed Effect IR.
+ */
+declare function renderDocumentation(ir: StaticEffectIR, options?: Partial<DocumentationOptions>): string;
+/**
+ * Generate documentation for multiple programs.
+ */
+declare function renderMultiProgramDocs(irs: readonly StaticEffectIR[], options?: Partial<DocumentationOptions>): string;
+
+/**
+ * Showcase Output Generator
+ *
+ * Produces rich per-step detail from the Effect IR, matching the structure
+ * of awaitly-analyze's analyzer-showcase.data.json format.
+ */
+
+interface ShowcaseOptions {
+    /** Mermaid diagram direction */
+    readonly direction?: 'TB' | 'LR' | 'BT' | 'RL' | undefined;
+}
+/**
+ * Generate a showcase entry from an analyzed Effect IR.
+ */
+declare function generateShowcase(ir: StaticEffectIR, options?: ShowcaseOptions, sourceCode?: string): ShowcaseEntry;
+/**
+ * Generate showcase entries for multiple programs.
+ */
+declare function generateMultipleShowcase(irs: readonly StaticEffectIR[], options?: ShowcaseOptions, sourceCode?: string): ShowcaseEntry[];
+
+/**
+ * Cross-Program Composition Resolver for Effect IR
+ *
+ * Builds a graph of Effect programs that reference other programs
+ * (e.g. via identifier effects that match another program name).
+ */
+
+interface ProgramGraphNode {
+    name: string;
+    filePath: string;
+    ir: StaticEffectIR;
+    calls: ProgramCallEdge[];
+    calledBy: string[];
+}
+interface ProgramCallEdge {
+    targetProgram: string;
+    callSite?: {
+        line: number;
+        column: number;
+    };
+    resolved: boolean;
+}
+interface ProgramGraph {
+    programs: Map<string, ProgramGraphNode>;
+    entryProgram: string;
+    circularDependencies: string[][];
+    unresolvedReferences: UnresolvedProgramRef[];
+}
+interface UnresolvedProgramRef {
+    programName: string;
+    referencedFrom: string;
+    reason: string;
+}
+interface CompositionResolverOptions {
+    /** Entry program name when building from multiple IRs */
+    entryProgramName?: string | undefined;
+}
+interface YieldStarCall {
+    callee: string;
+    location?: {
+        line: number;
+        column: number;
+    } | undefined;
+    isYieldStar: boolean;
+}
+/**
+ * Build a program composition graph from a list of analyzed IRs (e.g. from one file).
+ */
+declare function analyzeProgramGraph(irs: readonly StaticEffectIR[], filePath: string, options?: CompositionResolverOptions): ProgramGraph;
+declare function getTopologicalOrder(graph: ProgramGraph): string[];
+declare function getDependencies(graph: ProgramGraph, programName: string): string[];
+declare function getDependents(graph: ProgramGraph, programName: string): string[];
+declare function calculateGraphComplexity(graph: ProgramGraph): {
+    totalCyclomaticComplexity: number;
+    totalPrograms: number;
+    maxDepth: number;
+    hasCircularDependencies: boolean;
+};
+declare function renderGraphMermaid(graph: ProgramGraph): string;
+/**
+ * Render a composition Mermaid diagram showing generator call relationships
+ * with subgraphs grouping by file and yield* edge labels.
+ */
+declare function renderCompositionMermaid(graph: ProgramGraph): string;
+interface ProjectCompositionOptions {
+    /** Entry program name */
+    entryProgramName?: string | undefined;
+}
+/**
+ * Build a composition graph from a project-wide analysis result (multi-file).
+ * Merges IRs across files into a unified program graph with cross-file edges.
+ */
+declare function analyzeProjectComposition(byFile: ReadonlyMap<string, readonly StaticEffectIR[]>, options?: ProjectCompositionOptions, serviceMap?: ProjectServiceMap): ProgramGraph;
+/**
+ * Render a composition Mermaid diagram that includes service nodes from the service map.
+ * Programs are rectangular, services are hexagonal.
+ */
+declare function renderCompositionWithServicesMermaid(graph: ProgramGraph, projectServiceMap: ProjectServiceMap): string;
+
+/**
+ * Data Flow Analysis for Effect IR
+ *
+ * Builds a graph of value and service dependencies between effect nodes:
+ * - Value flow: sequential edges from one effect to the next in execution order
+ * - Service reads: effect nodes that require services from Context
+ */
+
+interface DataFlowNode {
+    id: string;
+    name?: string | undefined;
+    /** Success type this effect produces (writes) */
+    writes?: string | undefined;
+    /** Service IDs this effect reads from Context */
+    reads: string[];
+    location?: {
+        line: number;
+        column: number;
+    } | undefined;
+}
+interface DataFlowEdge {
+    from: string;
+    to: string;
+    key: string;
+}
+interface DataFlowGraph {
+    nodes: DataFlowNode[];
+    edges: DataFlowEdge[];
+    producedKeys: Set<string>;
+    undefinedReads: UndefinedRead[];
+    duplicateWrites: DuplicateWrite[];
+}
+interface UndefinedRead {
+    key: string;
+    readerId: string;
+    readerName?: string | undefined;
+}
+interface DuplicateWrite {
+    key: string;
+    writerIds: string[];
+}
+declare function buildDataFlowGraph(ir: StaticEffectIR): DataFlowGraph;
+declare function getDataFlowOrder(graph: DataFlowGraph): string[] | undefined;
+declare function getProducers(graph: DataFlowGraph, stepId: string): DataFlowNode[];
+declare function getConsumers(graph: DataFlowGraph, stepId: string): DataFlowNode[];
+declare function getTransitiveDependencies(graph: DataFlowGraph, stepId: string): string[];
+declare function findCycles(graph: DataFlowGraph): string[][];
+interface DataFlowValidation {
+    valid: boolean;
+    issues: DataFlowIssue[];
+}
+interface DataFlowIssue {
+    severity: 'error' | 'warning';
+    type: 'undefined-read' | 'duplicate-write' | 'cycle';
+    message: string;
+    stepIds: string[];
+    key?: string;
+}
+declare function validateDataFlow(graph: DataFlowGraph): DataFlowValidation;
+declare function renderDataFlowMermaid(graph: DataFlowGraph): string;
+
+/**
+ * Error Flow Analysis for Effect IR
+ *
+ * Aggregates error types from effect nodes (typeSignature.errorType) and
+ * error-handler nodes (catchTag, etc.) to build an error propagation view.
+ */
+
+interface StepErrorInfo {
+    stepId: string;
+    stepName?: string | undefined;
+    errors: string[];
+    location?: {
+        line: number;
+        column: number;
+    } | undefined;
+}
+/** Per-node error propagation: errors at this point and how handlers narrow (GAP 4) */
+interface ErrorPropagation {
+    atNode: string;
+    possibleErrors: string[];
+    narrowedBy?: {
+        handler: string;
+        removedErrors: string[];
+        addedErrors: string[];
+    };
+    defects: string[];
+    interruptible: boolean;
+}
+interface ErrorPropagationAnalysis {
+    propagation: ErrorPropagation[];
+    byNodeId: Map<string, ErrorPropagation>;
+}
+interface ErrorFlowAnalysis {
+    allErrors: string[];
+    stepErrors: StepErrorInfo[];
+    errorToSteps: Map<string, string[]>;
+    stepsWithoutErrors: string[];
+    allStepsDeclareErrors: boolean;
+}
+interface ErrorFlowEdge {
+    stepId: string;
+    error: string;
+}
+interface ErrorValidation {
+    valid: boolean;
+    unusedDeclared: string[];
+    undeclaredErrors: string[];
+    computedErrors: string[];
+}
+declare function analyzeErrorFlow(ir: StaticEffectIR): ErrorFlowAnalysis;
+declare function analyzeErrorPropagation(ir: StaticEffectIR): ErrorPropagationAnalysis;
+declare function getErrorsAtPoint(analysis: ErrorFlowAnalysis, afterStepId: string): string[];
+declare function getErrorProducers(analysis: ErrorFlowAnalysis, errorTag: string): StepErrorInfo[];
+declare function validateWorkflowErrors(analysis: ErrorFlowAnalysis, declaredErrors: string[]): ErrorValidation;
+declare function renderErrorFlowMermaid(analysis: ErrorFlowAnalysis): string;
+declare function formatErrorSummary(analysis: ErrorFlowAnalysis): string;
+
+/**
+ * Layer Dependency Graph (GAP 2)
+ *
+ * Collects StaticLayerNode from IR and builds a dependency graph
+ * (provides, requires, merge/provide edges) for visualization.
+ */
+
+interface LayerNodeInfo {
+    id: string;
+    name?: string;
+    provides: string[];
+    requires: string[];
+    lifecycle: string;
+    isMerged: boolean;
+    operationLayerIds: string[];
+}
+interface LayerGraphEdge {
+    from: string;
+    to: string;
+    kind: 'provides' | 'requires' | 'merge';
+}
+interface LayerDependencyGraph {
+    layers: LayerNodeInfo[];
+    edges: LayerGraphEdge[];
+    serviceToLayers: Map<string, string[]>;
+}
+declare function buildLayerDependencyGraph(ir: StaticEffectIR): LayerDependencyGraph;
+interface LayerCycle {
+    /** Layer IDs forming the cycle (first == last to close the loop) */
+    path: string[];
+}
+/**
+ * Detect cycles in the layer provides→requires graph.
+ * Returns all unique cycles found with the full cycle path.
+ */
+declare function detectLayerCycles(graph: LayerDependencyGraph): LayerCycle[];
+interface DiamondDependency {
+    serviceId: string;
+    providers: string[];
+}
+/**
+ * Detect diamond dependencies: services reachable through multiple provide paths.
+ */
+declare function detectDiamondDependencies(graph: LayerDependencyGraph): DiamondDependency[];
+interface UnsatisfiedService$1 {
+    serviceId: string;
+    requiredBy: string[];
+}
+/**
+ * Find services required by layers but not provided by any layer.
+ */
+declare function findUnsatisfiedServices(graph: LayerDependencyGraph): UnsatisfiedService$1[];
+declare function renderLayerGraphMermaid(graph: LayerDependencyGraph): string;
+
+/**
+ * Service (R) Flow Analysis (GAP 3)
+ *
+ * Tracks which services each effect requires, where they are provided,
+ * and where R is still unsatisfied.
+ */
+
+interface ServiceProvision {
+    nodeId: string;
+    serviceId: string;
+    location?: SourceLocation;
+}
+interface UnsatisfiedService {
+    nodeId: string;
+    serviceId: string;
+    serviceType?: string;
+    location?: SourceLocation;
+}
+interface ServiceLifecycleEntry {
+    createdAt: string;
+    consumedAt: string[];
+    releasedAt?: string;
+}
+interface ServiceFlowAnalysis {
+    requiredServices: ServiceRequirement[];
+    providedServices: ServiceProvision[];
+    unsatisfiedAt: UnsatisfiedService[];
+    serviceLifecycle: Map<string, ServiceLifecycleEntry>;
+}
+/**
+ * Build service flow analysis from IR.
+ * Tracks required vs provided services and unsatisfied requirements at each node.
+ */
+declare function analyzeServiceFlow(ir: StaticEffectIR, options?: {
+    /** Optional: resolve effect node to its AST to read first arg (for provideService). */
+    getFirstArgText?: (effectNode: StaticEffectNode) => string | undefined;
+}): ServiceFlowAnalysis;
+
+/**
+ * Service Registry - builds a deduplicated service map for whole-codebase analysis.
+ *
+ * When the analyzer encounters `yield* SomeService`, this module creates a
+ * first-class ServiceArtifact for that service, including its tag definition,
+ * interface shape, layer implementations, consumers, and transitive dependencies.
+ */
+
+/**
+ * Build a deduplicated project-level service map from analyzed program IRs.
+ *
+ * @param byFile Map of file path to analyzed programs in that file
+ * @param sourceFiles Optional map of file path to ts-morph SourceFile for AST-level extraction.
+ *   When not provided, only IR-level data (requiredServices, StaticLayerNode) is used.
+ */
+declare function buildProjectServiceMap(byFile: ReadonlyMap<string, readonly StaticEffectIR[]>, sourceFiles?: ReadonlyMap<string, any>): ProjectServiceMap;
+
+/**
+ * Ref / State Management Analysis (GAP 7)
+ *
+ * Detects Ref, FiberRef, SynchronizedRef usage and potential race conditions.
+ */
+
+interface RefInfo {
+    refId: string;
+    operation: 'make' | 'get' | 'set' | 'update' | 'modify' | 'getAndSet' | 'getAndUpdate';
+    nodeId: string;
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+interface RefMutation {
+    refId: string;
+    nodeId: string;
+    operation: 'set' | 'update' | 'modify' | 'getAndSet' | 'getAndUpdate';
+}
+interface RaceCondition {
+    refId: string;
+    readerIds: string[];
+    writerIds: string[];
+    message: string;
+}
+interface StateFlowAnalysis {
+    refs: RefInfo[];
+    mutations: RefMutation[];
+    potentialRaces: RaceCondition[];
+    stateGraph: {
+        refId: string;
+        readers: string[];
+        writers: string[];
+    }[];
+}
+declare function analyzeStateFlow(ir: StaticEffectIR): StateFlowAnalysis;
+
+/**
+ * Scope & Resource Lifecycle Analysis (GAP 10)
+ *
+ * Detects acquireRelease, Scope.*, Pool.*, Effect.scoped and tracks
+ * resource ordering and potential leaks.
+ */
+
+interface ResourceAcquisition {
+    nodeId: string;
+    type: 'acquireRelease' | 'acquireUseRelease' | 'scoped' | 'pool' | 'keyedPool';
+    acquireNodeId?: string;
+    releaseNodeId?: string;
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+interface ScopeBoundary {
+    nodeId: string;
+    type: 'scoped' | 'scopeMake' | 'scopeUse' | 'scopeFork' | 'scopeAddFinalizer' | 'scopeExtend';
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+interface ScopeResourceAnalysis {
+    acquisitions: ResourceAcquisition[];
+    scopeBoundaries: ScopeBoundary[];
+    poolCreations: string[];
+    potentialLeaks: string[];
+}
+declare function analyzeScopeResource(ir: StaticEffectIR): ScopeResourceAnalysis;
+
+/**
+ * Observability Analysis (GAP 11)
+ *
+ * Detects Effect.withSpan, Effect.log*, Metric.*, Logger usage.
+ */
+
+interface SpanInfo {
+    nodeId: string;
+    name?: string;
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+interface LogPointInfo {
+    nodeId: string;
+    level: 'debug' | 'info' | 'warning' | 'error';
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+interface MetricInfo {
+    nodeId: string;
+    type: 'counter' | 'gauge' | 'histogram' | 'summary' | 'timer';
+    /** Whether this metric uses Metric.tagged / taggedWithLabels */
+    isTagged?: boolean;
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+interface ObservabilityAnalysis {
+    spans: SpanInfo[];
+    logPoints: LogPointInfo[];
+    metrics: MetricInfo[];
+    coverage: {
+        effectCount: number;
+        effectsWithSpans: number;
+        effectsWithMetrics: number;
+        errorHandlersWithLogging: number;
+        errorHandlerCount: number;
+    };
+}
+declare function analyzeObservability(ir: StaticEffectIR): ObservabilityAnalysis;
+
+interface ServiceCompletenessEntry {
+    serviceId: string;
+    status: 'ok' | 'missing' | 'missing-dependency';
+    providedBy?: string;
+    message: string;
+}
+interface DICompletenessReport {
+    programName: string;
+    requiredServices: string[];
+    providedByLayer: Map<string, string>;
+    entries: ServiceCompletenessEntry[];
+    layerGraphAcyclic: boolean;
+    valid: boolean;
+    readonly layerConflicts?: {
+        serviceId: string;
+        providers: SourceLocation[];
+    }[];
+}
+/**
+ * Check DI completeness for a single program IR: required services vs what layers provide.
+ */
+declare function checkDICompleteness(ir: StaticEffectIR): DICompletenessReport;
+/**
+ * Format a DI completeness report as text.
+ */
+declare function formatDICompletenessReport(report: DICompletenessReport): string;
+
+/**
+ * Strict Mode Diagnostics for Effect IR
+ *
+ * Validates Effect programs against strict rules: error type declarations,
+ * parallel/race error handling, and optional labelling.
+ */
+
+interface StrictDiagnostic {
+    rule: StrictRule;
+    severity: 'error' | 'warning';
+    message: string;
+    fix?: string | undefined;
+    location?: SourceLocation | undefined;
+    nodeId?: string | undefined;
+}
+type StrictRule = 'missing-error-type' | 'unknown-error-type' | 'parallel-missing-errors' | 'race-missing-errors' | 'effect-without-handler' | 'fiber-potential-leak' | 'resource-missing-scope' | 'unbounded-concurrency' | 'unused-service' | 'dead-code-path';
+interface StrictValidationResult {
+    valid: boolean;
+    diagnostics: StrictDiagnostic[];
+    errors: StrictDiagnostic[];
+    warnings: StrictDiagnostic[];
+}
+interface StrictValidationOptions {
+    /** Require effect nodes to have a declared error type (not unknown/never when they can fail) */
+    requireErrors?: boolean | undefined;
+    /** Require effects in parallel/race to have error type */
+    requireParallelErrors?: boolean | undefined;
+    warningsAsErrors?: boolean | undefined;
+}
+declare function validateStrict(ir: StaticEffectIR, options?: StrictValidationOptions): StrictValidationResult;
+declare function formatDiagnostics(result: StrictValidationResult): string;
+declare function formatDiagnosticsJSON(result: StrictValidationResult): string;
+declare function getSummary(result: StrictValidationResult): string;
+
+/**
+ * Path Generator
+ *
+ * Generates all possible execution paths through an Effect program based on
+ * static analysis. Each path represents a unique sequence of steps that could
+ * execute given certain conditions.
+ */
+
+interface PathGeneratorOptions {
+    /** Maximum paths to generate (default: 1000) */
+    maxPaths?: number;
+    /** Whether to include loop iterations as separate paths (default: false) */
+    expandLoops?: boolean;
+    /** Maximum loop iterations to expand if expandLoops is true (default: 3) */
+    maxLoopIterations?: number;
+}
+interface PathGenerationResult {
+    /** Generated effect paths */
+    paths: EffectPath[];
+    /** Whether the maxPaths limit was hit (truncation occurred) */
+    limitHit: boolean;
+}
+/**
+ * Generate all possible execution paths through an Effect program.
+ */
+declare function generatePaths(ir: StaticEffectIR, options?: PathGeneratorOptions): EffectPath[];
+/**
+ * Generate all possible execution paths with metadata.
+ */
+declare function generatePathsWithMetadata(ir: StaticEffectIR, options?: PathGeneratorOptions): PathGenerationResult;
+interface PathStatistics {
+    totalPaths: number;
+    pathLimitHit: boolean;
+    pathsWithLoops: number;
+    pathsWithUnresolvedRefs: number;
+    uniqueConditions: string[];
+    maxPathLength: number;
+    minPathLength: number;
+    avgPathLength: number;
+}
+interface PathStatisticsOptions {
+    limitHit?: boolean;
+}
+declare function calculatePathStatistics(paths: EffectPath[], options?: PathStatisticsOptions): PathStatistics;
+declare function filterPaths(paths: EffectPath[], filter: {
+    mustIncludeStep?: string;
+    mustExcludeStep?: string;
+    conditionTrue?: string;
+    conditionFalse?: string;
+    noLoops?: boolean;
+    maxLength?: number;
+}): EffectPath[];
+
+/**
+ * Complexity Metrics Calculator
+ *
+ * Calculates complexity metrics for Effect programs including:
+ * - Cyclomatic complexity (McCabe)
+ * - Cognitive complexity (Sonar-style)
+ * - Path count (bounded or unbounded)
+ * - Depth and breadth metrics
+ */
+
+declare const DEFAULT_THRESHOLDS: ComplexityThresholds;
+declare function calculateComplexity(ir: StaticEffectIR): ComplexityMetrics;
+interface ComplexityAssessment {
+    level: 'low' | 'medium' | 'high' | 'very-high';
+    warnings: ComplexityWarning[];
+    recommendations: string[];
+}
+interface ComplexityWarning {
+    type: 'cyclomatic' | 'cognitive' | 'paths' | 'depth' | 'breadth';
+    message: string;
+    severity: 'warning' | 'error';
+}
+declare function assessComplexity(metrics: ComplexityMetrics, thresholds?: ComplexityThresholds): ComplexityAssessment;
+declare function formatComplexitySummary(metrics: ComplexityMetrics, assessment: ComplexityAssessment): string;
+
+/**
+ * Test Coverage Matrix Generator
+ *
+ * Generates a test coverage matrix from Effect paths, helping developers
+ * ensure all paths through an Effect program are tested.
+ */
+
+interface TestMatrixOptions {
+    /** Prefix for generated test names */
+    testNamePrefix?: string;
+    /** Function to customize test name generation */
+    testNameGenerator?: (path: EffectPath) => string;
+    /** Whether to include paths with loops (they may need special handling) */
+    includeLoopPaths?: boolean;
+}
+declare function generateTestMatrix(paths: EffectPath[], options?: TestMatrixOptions): TestMatrix;
+declare function formatTestMatrixMarkdown(matrix: TestMatrix): string;
+declare function formatTestMatrixAsCode(matrix: TestMatrix, options?: {
+    testRunner?: 'vitest' | 'jest' | 'mocha';
+    programName?: string;
+}): string;
+declare function formatTestChecklist(matrix: TestMatrix): string;
+
+/**
+ * Config Module Analysis (GAP 9)
+ *
+ * Detects Effect Config / ConfigProvider usage.
+ */
+
+interface ConfigItem {
+    readonly key: string;
+    readonly type: 'string' | 'number' | 'integer' | 'boolean' | 'date' | 'duration' | 'url' | 'port' | 'logLevel' | 'literal' | 'array' | 'map' | 'nested' | 'secret' | 'unknown';
+    readonly required: boolean;
+    readonly hasDefault: boolean;
+    readonly location?: SourceLocation;
+}
+interface ConfigCombinator {
+    readonly kind: 'map' | 'mapAttempt' | 'mapOrFail' | 'orElse' | 'orElseIf' | 'withDefault' | 'withDescription' | 'validate' | 'repeat' | 'option';
+    readonly location?: SourceLocation;
+}
+interface ConfigAnalysis {
+    readonly requiredConfigs: ConfigItem[];
+    readonly optionalConfigs: ConfigItem[];
+    readonly secretConfigs: ConfigItem[];
+    readonly providerOverrides: string[];
+    readonly envVarHints: Map<string, string>;
+    readonly combinators: ConfigCombinator[];
+}
+/**
+ * Analyze a TypeScript file for Effect Config usage.
+ */
+declare function analyzeConfig(filePath: string, source?: string): ConfigAnalysis;
+/**
+ * Format config analysis as a markdown table.
+ */
+declare function formatConfigReport(analysis: ConfigAnalysis): string;
+
+/**
+ * Pattern Matching (Match) Analysis (GAP 12)
+ *
+ * Detects Effect Match module usage and non-exhaustive matches.
+ */
+
+interface MatchArmInfo {
+    readonly kind: 'tag' | 'when' | 'not' | 'orElse' | 'exhaustive';
+    readonly tag?: string;
+    readonly location?: SourceLocation;
+}
+interface MatchAnalysis {
+    readonly matchSites: MatchSiteInfo[];
+    readonly nonExhaustive: MatchSiteInfo[];
+}
+interface MatchSiteInfo {
+    readonly location?: SourceLocation;
+    readonly arms: MatchArmInfo[];
+    readonly hasExhaustive: boolean;
+    readonly hasOrElse: boolean;
+}
+/**
+ * Analyze a file for Effect Match usage.
+ */
+declare function analyzeMatch(filePath: string, source?: string): MatchAnalysis;
+
+/**
+ * Platform Integration Detection (GAP 14)
+ *
+ * Detects which Effect platform modules are in use (HTTP, FileSystem, etc.).
+ */
+
+interface PlatformUsageAnalysis {
+    readonly platforms: ('node' | 'bun' | 'browser')[];
+    readonly modules: {
+        readonly http: {
+            client: boolean;
+            server: boolean;
+            routes: string[];
+            api: boolean;
+            apiBuilder: boolean;
+            endpoint: boolean;
+            security: boolean;
+            middleware: boolean;
+        };
+        readonly filesystem: {
+            reads: string[];
+            writes: string[];
+        };
+        readonly sockets: boolean;
+        readonly terminal: boolean;
+        readonly workers: boolean;
+        readonly commands: string[];
+        readonly keyValueStore: boolean;
+        readonly multipart: boolean;
+        readonly codecs: string[];
+        readonly openApi: boolean;
+    };
+    readonly locations: Map<string, SourceLocation>;
+    readonly fileSystemOps?: {
+        op: string;
+        location: SourceLocation;
+    }[];
+    readonly commandOps?: {
+        op: string;
+        location: SourceLocation;
+    }[];
+    readonly routeDefinitions?: {
+        readonly method: string;
+        readonly name: string;
+        readonly path: string;
+        readonly location: SourceLocation;
+        readonly apiId?: string;
+        readonly groupName?: string;
+    }[];
+    readonly middlewareChain?: {
+        name: string;
+        location: SourceLocation;
+    }[];
+    readonly cliCommands?: {
+        name: string;
+        hasSchema: boolean;
+        location: SourceLocation;
+    }[];
+}
+/**
+ * Analyze a file for Effect platform usage.
+ */
+declare function analyzePlatformUsage(filePath: string, source?: string): PlatformUsageAnalysis;
+
+/**
+ * Effect Schema AST → OpenAPI JSON Schema
+ *
+ * Walks Effect Schema expressions in the AST and produces OpenAPI-compatible
+ * JSON Schema (no $schema, suitable for OpenAPI components.schemas).
+ */
+
+type JsonSchemaObject = Record<string, unknown>;
+/**
+ * Extract OpenAPI JSON Schema from an Effect Schema AST node.
+ */
+declare function schemaToJsonSchema(node: Node, sf: SourceFile, project: Project, defs?: Map<string, JsonSchemaObject>): JsonSchemaObject | undefined;
+
+/**
+ * HttpApi Structure Extractor
+ *
+ * Extracts HttpApi, HttpApiGroup, and HttpApiEndpoint structure from @effect/platform
+ * source code for API documentation generation.
+ */
+
+interface HttpApiEndpointInfo {
+    readonly name: string;
+    readonly method: string;
+    readonly path: string;
+    readonly location: SourceLocation;
+    readonly description?: string;
+    readonly summary?: string;
+    readonly deprecated?: boolean;
+    readonly excluded?: boolean;
+    /** Request body schema (from .setPayload) as OpenAPI JSON Schema */
+    readonly requestSchema?: JsonSchemaObject;
+    /** Success response schema (from .addSuccess) as OpenAPI JSON Schema */
+    readonly responseSchema?: JsonSchemaObject;
+    /** URL/query params schema (from .setUrlParams) as OpenAPI JSON Schema */
+    readonly urlParamsSchema?: JsonSchemaObject;
+}
+interface HttpApiGroupInfo {
+    readonly name: string;
+    readonly endpoints: readonly HttpApiEndpointInfo[];
+    readonly description?: string;
+    readonly topLevel?: boolean;
+    readonly prefix?: string;
+}
+interface HttpApiStructure {
+    readonly apiId: string;
+    readonly filePath: string;
+    readonly groups: readonly HttpApiGroupInfo[];
+    readonly prefix?: string;
+}
+/**
+ * Extract HttpApi structure from a source file.
+ * Returns all HttpApi.make(...) declarations with their groups and endpoints.
+ */
+declare function extractHttpApiStructure(sourceFile: SourceFile, filePath: string): HttpApiStructure[];
+
+/**
+ * API Documentation Output
+ *
+ * Renders HttpApi structure as markdown and OpenAPI paths.
+ */
+
+/**
+ * Render API docs as markdown with H1 per API, H2 per group, and endpoint table.
+ */
+declare function renderApiDocsMarkdown(structures: readonly HttpApiStructure[]): string;
+/**
+ * Render API structure as Mermaid flowchart (API -> groups -> endpoints).
+ */
+declare function renderApiDocsMermaid(structures: readonly HttpApiStructure[]): string;
+/**
+ * Render minimal OpenAPI paths object for merging into full spec.
+ * Includes request/response schemas when extracted from Effect Schema.
+ */
+declare function renderOpenApiPaths(structures: readonly HttpApiStructure[]): {
+    paths: Record<string, Record<string, {
+        operationId: string;
+        summary?: string;
+        deprecated?: boolean;
+        requestBody?: {
+            content: {
+                'application/json': {
+                    schema: unknown;
+                };
+            };
+        };
+        responses?: Record<string, {
+            content?: {
+                'application/json': {
+                    schema: unknown;
+                };
+            };
+            description?: string;
+        }>;
+        parameters?: {
+            name: string;
+            in: string;
+            schema: unknown;
+        }[];
+    }>>;
+};
+
+/**
+ * Testing Pattern Analysis (GAP 16)
+ *
+ * Detects TestClock, TestContext, mock layers, and test entry points.
+ */
+
+interface TestingPatternAnalysis {
+    readonly testClockUsed: boolean;
+    readonly testContextUsed: boolean;
+    readonly mockLayers: string[];
+    readonly runInTests: boolean;
+    readonly effectVitestUsed: boolean;
+    readonly effectVitestImported: boolean;
+    readonly sharedLayerUsed: boolean;
+    readonly testAnnotationsUsed: boolean;
+    readonly flakyTestUsed: boolean;
+    readonly exitAssertionsUsed: boolean;
+    readonly testServicesUsed: boolean;
+    readonly fastCheckUsed: boolean;
+    readonly propertyTestUsed: boolean;
+    readonly locations: Map<string, SourceLocation>;
+}
+/**
+ * Analyze a file for Effect testing patterns.
+ */
+declare function analyzeTestingPatterns(filePath: string, source?: string): TestingPatternAnalysis;
+
+/**
+ * Effect Version Compatibility (GAP 25)
+ *
+ * Reads package.json for Effect version and flags deprecated API usage.
+ */
+interface EffectVersionInfo {
+    readonly version: string;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly isPrerelease: boolean;
+}
+interface VersionCompatReport {
+    readonly effectVersion: EffectVersionInfo | null;
+    readonly deprecationWarnings: string[];
+    readonly suggestion: string | null;
+}
+/**
+ * Read Effect version from package.json at dir (or cwd).
+ */
+declare function getEffectVersion(dir?: string): Promise<EffectVersionInfo | null>;
+/**
+ * Produce a minimal compatibility report (version + any known deprecations).
+ */
+declare function checkVersionCompat(projectRoot?: string): Promise<VersionCompatReport>;
+
+/**
+ * Effect.gen Yield Analysis Enhancement (GAP 28)
+ *
+ * Tracks variable bindings from yields and data flow through generator.
+ */
+
+interface YieldBinding {
+    readonly yieldIndex: number;
+    readonly variableName?: string;
+    readonly effectCallee?: string;
+    readonly nodeId: string;
+}
+interface GenYieldAnalysis {
+    readonly bindings: YieldBinding[];
+    readonly unusedYieldIndices: number[];
+    readonly serviceYields: string[];
+}
+/**
+ * Analyze yield bindings and service usage in a generator program.
+ */
+declare function analyzeGenYields(ir: StaticEffectIR): GenYieldAnalysis;
+
+/**
+ * SQL / Database Pattern Detection (GAP 15)
+ *
+ * Detects SqlClient, SqlSchema, transactions, and N+1 patterns.
+ */
+
+interface SqlPatternAnalysis {
+    readonly sqlClientUsed: boolean;
+    readonly withTransaction: boolean;
+    readonly schemaDefs: string[];
+    readonly queryInLoop: boolean;
+    readonly locations: Map<string, SourceLocation>;
+    readonly resolvers?: {
+        name: string;
+        table?: string;
+        location: SourceLocation;
+    }[];
+    readonly migrations?: {
+        name: string;
+        location: SourceLocation;
+    }[];
+    readonly queriesInLoops?: {
+        query: string;
+        location: SourceLocation;
+    }[];
+}
+/**
+ * Analyze a file for Effect SQL/database patterns.
+ */
+declare function analyzeSqlPatterns(filePath: string, source?: string): SqlPatternAnalysis;
+
+/**
+ * RPC Pattern Detection (GAP 20)
+ *
+ * Detects @effect/rpc usage: Rpc.make, routers, client calls.
+ */
+
+interface RpcPatternAnalysis {
+    readonly rpcDefined: boolean;
+    readonly routers: string[];
+    readonly clientCalls: string[];
+    readonly locations: Map<string, SourceLocation>;
+    readonly rpcDefinitions?: {
+        name: string;
+        isStreaming: boolean;
+        location: SourceLocation;
+    }[];
+}
+/**
+ * Analyze a file for Effect RPC patterns.
+ */
+declare function analyzeRpcPatterns(filePath: string, source?: string): RpcPatternAnalysis;
+
+/**
+ * Request Batching / DataLoader Pattern (GAP 19)
+ *
+ * Detects RequestResolver, Request.tagged, Effect.withRequestBatching.
+ */
+
+interface RequestBatchingAnalysis {
+    readonly requestTagged: boolean;
+    readonly resolverBatched: boolean;
+    readonly withBatching: boolean;
+    readonly withCaching: boolean;
+    readonly locations: Map<string, SourceLocation>;
+}
+/**
+ * Analyze a file for Effect request batching patterns.
+ */
+declare function analyzeRequestBatching(filePath: string, source?: string): RequestBatchingAnalysis;
+
+/**
+ * STM (Software Transactional Memory) Analysis (GAP 13)
+ *
+ * Detects STM.commit, TRef, TMap, TQueue, transactional refs.
+ */
+
+interface StmAnalysis {
+    readonly commitSites: SourceLocation[];
+    readonly tRefs: string[];
+    readonly tMaps: string[];
+    readonly tQueues: string[];
+    readonly retryUsed: boolean;
+    readonly locations: Map<string, SourceLocation>;
+}
+/**
+ * Analyze a file for Effect STM usage.
+ */
+declare function analyzeStm(filePath: string, source?: string): StmAnalysis;
+
+/**
+ * Effect Playground / REPL Integration (GAP 30 - minimal)
+ *
+ * Serializes IR + metadata for shareable or client-side exploration.
+ */
+
+interface PlaygroundPayload {
+    readonly version: 1;
+    readonly ir: StaticEffectIR;
+    readonly mermaid: string;
+    readonly programName: string;
+    readonly exportedAt: string;
+}
+/**
+ * Export IR and Mermaid as a JSON payload for sharing or embedding.
+ */
+declare function exportForPlayground(ir: StaticEffectIR): PlaygroundPayload;
+/**
+ * Encode payload as a base64 JSON string (for URL-safe sharing).
+ */
+declare function encodePlaygroundPayload(payload: PlaygroundPayload): string;
+/**
+ * Decode a base64url string back to PlaygroundPayload.
+ */
+declare function decodePlaygroundPayload(encoded: string): PlaygroundPayload;
+
+/**
+ * Disk cache for analysis results.
+ * When --cache is used, IR is stored by file path + content hash for reuse.
+ */
+
+/**
+ * Read cached IRs if valid (same content hash and mtime).
+ */
+declare function getCached(filePath: string, content: string, baseDir?: string): Promise<readonly StaticEffectIR[] | null>;
+/**
+ * Write IRs to cache.
+ */
+declare function setCached(filePath: string, content: string, irs: readonly StaticEffectIR[], baseDir?: string): Promise<void>;
+
+/**
+ * Const Inliner
+ *
+ * Resolves same-module const references for static analysis.
+ * Handles patterns like:
+ *   const myErrors = tags('A', 'B');
+ *   await step('x', fn, { errors: myErrors });
+ *
+ * This is used by the analyzer to inline const values for full static extraction.
+ */
+
+/**
+ * Result of resolving a const reference.
+ */
+interface ConstResolution {
+    /** Whether the resolution was successful */
+    resolved: boolean;
+    /** The resolved value (if successful) */
+    value?: ConstValue;
+    /** Reason for failure (if not resolved) */
+    reason?: string;
+}
+/**
+ * A resolved const value.
+ */
+type ConstValue = {
+    type: "string";
+    value: string;
+} | {
+    type: "number";
+    value: number;
+} | {
+    type: "boolean";
+    value: boolean;
+} | {
+    type: "array";
+    value: ConstValue[];
+} | {
+    type: "object";
+    value: Record<string, ConstValue>;
+} | {
+    type: "null";
+    value: null;
+} | {
+    type: "undefined";
+    value: undefined;
+};
+/**
+ * Cache for resolved const declarations in a source file.
+ */
+interface ConstCache {
+    /** Map of variable name to its resolved value */
+    values: Map<string, ConstResolution>;
+    /** Source file this cache is for */
+    sourceFile: SourceFile;
+}
+/**
+ * Create a const cache for a source file.
+ */
+declare function createConstCache(sourceFile: SourceFile): ConstCache;
+/**
+ * Resolve a const reference by name.
+ */
+declare function resolveConst(name: string, cache: ConstCache): ConstResolution;
+/**
+ * Resolve a node to a const value.
+ */
+declare function resolveNode(node: Node, cache: ConstCache): ConstResolution;
+/**
+ * Convert a ConstValue to a plain JavaScript value.
+ */
+declare function constValueToJS(value: ConstValue): unknown;
+/**
+ * Extract string array from a ConstValue.
+ * Returns undefined if the value is not a string array.
+ */
+declare function extractStringArray(value: ConstValue): string[] | undefined;
+/**
+ * Extract a string from a ConstValue.
+ * Returns undefined if the value is not a string.
+ */
+declare function extractString(value: ConstValue): string | undefined;
+
+type StepChangeKind = "added" | "removed" | "unchanged" | "renamed" | "moved";
+interface StepDiffEntry {
+    kind: StepChangeKind;
+    stepId: string;
+    previousStepId?: string;
+    callee?: string;
+    containerBefore?: string;
+    containerAfter?: string;
+}
+interface StructuralChange {
+    kind: "added" | "removed";
+    nodeType: string;
+    description: string;
+}
+interface DiffSummary {
+    stepsAdded: number;
+    stepsRemoved: number;
+    stepsRenamed: number;
+    stepsMoved: number;
+    stepsUnchanged: number;
+    structuralChanges: number;
+    hasRegressions: boolean;
+}
+interface ProgramDiff {
+    beforeName: string;
+    afterName: string;
+    diffedAt: number;
+    steps: StepDiffEntry[];
+    structuralChanges: StructuralChange[];
+    summary: DiffSummary;
+}
+interface DiffOptions {
+    detectRenames?: boolean;
+    regressionMode?: boolean;
+}
+interface DiffMarkdownOptions {
+    showUnchanged?: boolean;
+    title?: string;
+}
+interface DiffMermaidOptions {
+    showRemovedSteps?: boolean;
+    direction?: "TB" | "LR" | "BT" | "RL";
+}
+
+declare function diffPrograms(before: StaticEffectIR, after: StaticEffectIR, options?: DiffOptions): ProgramDiff;
+
+declare function renderDiffMarkdown(diff: ProgramDiff, options?: DiffMarkdownOptions): string;
+
+declare function renderDiffJSON(diff: ProgramDiff, options?: {
+    pretty?: boolean;
+}): string;
+
+/**
+ * Render a mermaid diagram of the "after" IR with diff annotations overlaid
+ * (style classes for added, removed, moved, renamed steps).
+ */
+declare function renderDiffMermaid(after: StaticEffectIR, diff: ProgramDiff, options?: DiffMermaidOptions): string;
+
+/**
+ * Parse a source argument that can be:
+ * - A file path (./src/foo.ts)
+ * - A git ref:path combo (HEAD~1:src/foo.ts or main:src/foo.ts)
+ * - A PR URL (https://github.com/org/repo/pull/123)
+ */
+declare function parseSourceArg(arg: string): {
+    kind: 'file' | 'git-ref' | 'github-pr';
+    filePath?: string;
+    ref?: string;
+    prUrl?: string;
+};
+/**
+ * Resolve a git ref:path to the file contents from that commit.
+ * Returns the source text of the file at the given ref.
+ */
+declare function resolveGitSource(ref: string, filePath: string, cwd?: string): string;
+
+type AutoFormat = 'mermaid' | 'mermaid-railway' | 'mermaid-services' | 'mermaid-errors' | 'mermaid-concurrency' | 'mermaid-decisions' | 'mermaid-layers' | 'mermaid-retry' | 'mermaid-testability' | 'mermaid-dataflow' | 'mermaid-causes' | 'mermaid-timeline';
+/**
+ * Analyzes the IR and returns the most relevant format names to render.
+ * Includes `mermaid-railway` or `mermaid` as baseline (auto-detected),
+ * plus up to 2 specialized formats based on what's interesting in the program.
+ */
+declare function selectFormats(ir: StaticEffectIR): AutoFormat[];
+
+/**
+ * Fiber Lifecycle Analysis
+ *
+ * Detects fiber fork patterns and potential leaks:
+ * - Unscoped forks (Effect.fork) without a corresponding join/await/interrupt
+ * - Daemon forks (fire-and-forget) flagged as intentional
+ * - Scoped forks (forkScoped) always safe within scope
+ */
+
+type FiberRisk = 'safe' | 'daemon' | 'potential-leak' | 'uncertain';
+interface FiberForkInfo {
+    /** Node ID of the fork */
+    nodeId: string;
+    /** Fork variant */
+    operation: StaticFiberNode['operation'];
+    /** Whether this fork is scoped (forkScoped) */
+    isScoped: boolean;
+    /** Whether this fork is daemon (forkDaemon) — fire-and-forget intentional */
+    isDaemon: boolean;
+    /** Whether a join/await/interrupt is found in the same program tree */
+    hasJoin: boolean;
+    /** Risk classification */
+    risk: FiberRisk;
+    location?: {
+        filePath: string;
+        line: number;
+        column: number;
+    };
+}
+interface FiberLeakAnalysis {
+    /** All fork operations found */
+    forks: FiberForkInfo[];
+    /** Forks classified as potential leaks (unscoped, non-daemon, no join) */
+    potentialLeaks: FiberForkInfo[];
+    /** Daemon (fire-and-forget) forks */
+    daemonForks: FiberForkInfo[];
+    /** Safely scoped forks */
+    safeForks: FiberForkInfo[];
+    /** Summary counts */
+    summary: {
+        total: number;
+        safe: number;
+        daemon: number;
+        potentialLeaks: number;
+        uncertain: number;
+    };
+}
+declare function analyzeFiberLeaks(ir: StaticEffectIR): FiberLeakAnalysis;
+declare function formatFiberLeakReport(analysis: FiberLeakAnalysis): string;
+
+/**
+ * Type Signature Extractor
+ *
+ * Uses ts-morph's TypeChecker to extract Effect type parameters:
+ * - A (Success type)
+ * - E (Error type)
+ * - R (Requirements/Context type)
+ */
+
+/**
+ * Extract Effect type signature from a node
+ */
+declare const extractEffectTypeSignature: (node: Node, _typeChecker: TypeChecker) => EffectTypeSignature | undefined;
+/**
+ * Extract service requirements from a Context type
+ */
+declare const extractServiceRequirements: (node: Node, _typeChecker: TypeChecker) => ServiceRequirement[];
+/**
+ * Track how an Effect type transforms through a pipe operation
+ */
+declare const trackTypeTransformation: (inputType: EffectTypeSignature, operation: string, outputType: EffectTypeSignature) => {
+    operation: string;
+    typeChange: string;
+};
+/**
+ * Format type signature for display
+ */
+declare const formatTypeSignature: (sig: EffectTypeSignature) => string;
+/**
+ * Extract Stream<A, E, R> type args from a node's type (regex fallback).
+ */
+declare function extractStreamTypeSignature(node: Node): StreamTypeSignature | undefined;
+/**
+ * Extract Layer<ROut, E, RIn> type args from a node's type (regex fallback).
+ */
+declare function extractLayerTypeSignature(node: Node): LayerTypeSignature | undefined;
+/**
+ * Extract Schedule<Out, In, R> type args from a node's type (regex fallback).
+ */
+declare function extractScheduleTypeSignature(node: Node): ScheduleTypeSignature | undefined;
+/**
+ * Extract Cause<E> type arg from a node's type (regex fallback).
+ */
+declare function extractCauseTypeSignature(node: Node): CauseTypeSignature | undefined;
+/**
+ * Check if a type is a Schema type
+ */
+declare const isSchemaType: (type: Type) => boolean;
+/**
+ * Extract Schema validation information
+ */
+declare const extractSchemaInfo: (type: Type) => {
+    encoded: string;
+    decoded: string;
+} | undefined;
+
+/**
+ * Effect-Specific Linter
+ *
+ * Detects common issues and anti-patterns in Effect code:
+ * - Untagged yields (potential bugs)
+ * - Missing error handlers
+ * - Unhandled error types
+ * - Complex Layer compositions that could be simplified
+ * - Dead code (unused yields)
+ */
+
+interface LintRule {
+    readonly name: string;
+    readonly description: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly check: (ir: StaticEffectIR) => readonly LintIssue[];
+}
+interface LintIssue {
+    readonly rule: string;
+    readonly message: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly location?: SourceLocation | undefined;
+    readonly nodeId?: string | undefined;
+    /** Human-readable suggestion (shown in diagnostics) */
+    readonly suggestion?: string | undefined;
+    /** Optional code replacement for quick-fix (must be valid replacement text) */
+    readonly fix?: string | undefined;
+}
+/**
+ * Detect untagged yields in Effect.gen
+ * A yield without storing the result is often a bug
+ */
+declare const untaggedYieldRule: LintRule;
+/**
+ * Detect missing error handlers on Effects that can fail
+ */
+declare const missingErrorHandlerRule: LintRule;
+/**
+ * Detect dead code - yields whose results are never used in later yields or return
+ */
+declare const deadCodeRule: LintRule;
+/**
+ * Detect complex Layer compositions that could be simplified
+ */
+declare const complexLayerRule: LintRule;
+/**
+ * Detect catchAll when catchTag would be more appropriate
+ */
+declare const catchAllVsCatchTagRule: LintRule;
+/** Error channel is unknown or Error instead of tagged errors */
+declare const errorTypeTooWideRule: LintRule;
+/** Effect.all with concurrency "unbounded" on potentially large collections */
+declare const unboundedParallelismRule: LintRule;
+/** .pipe() with only one transformation */
+declare const redundantPipeRule: LintRule;
+/** orDie used - may convert recoverable errors to defects */
+declare const orDieWarningRule: LintRule;
+declare const DEFAULT_LINT_RULES: readonly LintRule[];
+interface LintResult {
+    readonly issues: readonly LintIssue[];
+    readonly summary: {
+        readonly errors: number;
+        readonly warnings: number;
+        readonly infos: number;
+        readonly total: number;
+    };
+}
+/**
+ * Run all lint rules on an Effect IR
+ */
+declare const lintEffectProgram: (ir: StaticEffectIR, rules?: readonly LintRule[]) => LintResult;
+/**
+ * Format lint issues as a readable report
+ */
+declare const formatLintReport: (result: LintResult, programName: string) => string;
+
+export { AnalysisError, type AnalyzeProjectOptions, AnalyzerOptions, CauseTypeSignature, type ComplexityAssessment, ComplexityMetrics, ComplexityThresholds, type ComplexityWarning, type CompositionResolverOptions, type ConfigAnalysis, type ConfigItem, type ConstCache, type ConstResolution, type ConstValue, type CoverageAuditResult, DEFAULT_LINT_RULES, DEFAULT_THRESHOLDS, type DICompletenessReport, type DataFlowEdge, type DataFlowGraph, type DataFlowIssue, type DataFlowNode, type DataFlowValidation, DiagramQuality, DiagramQualityWithFile, DiagramTopOffendersReport, type DiagramType, type DiamondDependency, type DisplayPathStep, type DocSection, type DocumentationOptions, type DuplicateWrite, EffectPath, EffectTypeSignature, type EffectVersionInfo, type EnhancedMermaidOptions, type ErrorFlowAnalysis, type ErrorFlowEdge, type ErrorPropagation, type ErrorPropagationAnalysis, type ErrorValidation, type FiberForkInfo, type FiberLeakAnalysis, type FileOutcome, type GenYieldAnalysis, type HtmlOutputOptions, type HttpApiEndpointInfo, type HttpApiGroupInfo, type HttpApiStructure, JSONRenderOptions, type JsonSchemaObject, type LayerCycle, type LayerDependencyGraph, type LayerGraphEdge, type LayerNodeInfo, LayerTypeSignature, type LintIssue, type LintResult, type LintRule, type LogPointInfo, type MatchAnalysis, type MatchArmInfo, type MatchSiteInfo, MermaidOptions, type MetricInfo, type MigrationOpportunity, type MigrationReport, type ObservabilityAnalysis, type PathGenerationResult, type PathGeneratorOptions, type PathStatistics, type PathStatisticsOptions, type PathSummaryResult, type PathsMermaidOptions, type PlatformUsageAnalysis, type PlaygroundPayload, type ProgramCallEdge, type ProgramGraph, type ProgramGraphNode, type ProjectAnalysisResult, type ProjectCompositionOptions, type ProjectFileFailure, ProjectServiceMap, ProjectServiceMap as ProjectServiceMapType, type RaceCondition, type RefInfo, type RefMutation, type RequestBatchingAnalysis, type ResourceAcquisition, type RpcPatternAnalysis, ScheduleTypeSignature, type ScopeBoundary, type ScopeResourceAnalysis, type ServiceCompletenessEntry, type ServiceFlowAnalysis, type ServiceLifecycleEntry, type ServiceProvision, ServiceRequirement, ShowcaseEntry, type ShowcaseOptions, SourceLocation, type SpanInfo, type SqlPatternAnalysis, type StateFlowAnalysis, StaticEffectIR, StaticEffectNode, StaticFiberNode, type StepErrorInfo, type StmAnalysis, StreamTypeSignature, type StrictDiagnostic, type StrictRule, type StrictValidationOptions, type StrictValidationResult, TestMatrix, type TestMatrixOptions, type TestingPatternAnalysis, type UndefinedRead, type UnresolvedProgramRef, type UnsatisfiedService, type VersionCompatReport, type YieldBinding, type YieldStarCall, analyzeConfig, analyzeEffectFile, analyzeEffectSource, analyzeErrorFlow, analyzeErrorPropagation, analyzeFiberLeaks, analyzeGenYields, analyzeMatch, analyzeObservability, analyzePlatformUsage, analyzeProgramGraph, analyzeProject, analyzeProjectComposition, analyzeRequestBatching, analyzeRpcPatterns, analyzeScopeResource, analyzeServiceFlow, analyzeSqlPatterns, analyzeStateFlow, analyzeStm, analyzeTestingPatterns, assessComplexity, buildDataFlowGraph, buildLayerDependencyGraph, buildProjectServiceMap, buildTopOffendersReport, calculateComplexity, calculateGraphComplexity, calculatePathStatistics, catchAllVsCatchTagRule, checkDICompleteness, checkVersionCompat, complexLayerRule, computeFileDiagramQuality, computeProgramDiagramQuality, constValueToJS, createConstCache, deadCodeRule, decodePlaygroundPayload, detectDiamondDependencies, detectLayerCycles, diffPrograms, encodePlaygroundPayload, errorTypeTooWideRule, exportForPlayground, extractCauseTypeSignature, extractEffectTypeSignature, extractHttpApiStructure, extractLayerTypeSignature, extractScheduleTypeSignature, extractSchemaInfo, extractServiceRequirements, extractStreamTypeSignature, extractString, extractStringArray, filterPaths, findCycles, findMigrationOpportunities, findMigrationOpportunitiesInProject, findUnsatisfiedServices, formatComplexitySummary, formatConfigReport, formatDICompletenessReport, formatDiagnostics, formatDiagnosticsJSON, formatErrorSummary, formatFiberLeakReport, formatLintReport, formatMigrationReport, formatTestChecklist, formatTestMatrixAsCode, formatTestMatrixMarkdown, formatTypeSignature, generateMultipleShowcase, generatePaths, generatePathsWithMetadata, generateShowcase, generateTestMatrix, getCached, getConsumers, getDataFlowOrder, getDependencies, getDependents, getEffectVersion, getErrorProducers, getErrorsAtPoint, getProducers, getSummary, getTopologicalOrder, getTransitiveDependencies, inferBestDiagramType, isSchemaType, lintEffectProgram, loadDiagramQualityHintsFromEslintJson, missingErrorHandlerRule, orDieWarningRule, parseSourceArg, redundantPipeRule, renderApiDocsMarkdown, renderApiDocsMermaid, renderCausesMermaid, renderCompositionMermaid, renderCompositionWithServicesMermaid, renderConcurrencyMermaid, renderDataFlowMermaid, renderDataflowMermaid, renderDecisionsMermaid, renderDependencyMatrix, renderDependencyMatrixFromServiceMap, renderDiffJSON, renderDiffMarkdown, renderDiffMermaid, renderDocumentation, renderEnhancedMermaid, renderEnhancedMermaidEffect, renderErrorFlowMermaid, renderErrorsMermaid, renderExplanation, renderGraphMermaid, renderInteractiveHTML, renderJSON, renderLayerGraphMermaid, renderLayersMermaid, renderMermaid, renderMultiProgramDocs, renderMultipleExplanations, renderMultipleJSON, renderMultipleSummaries, renderOpenApiPaths, renderPathsMermaid, renderRailwayMermaid, renderRetryGanttMermaid, renderRetryMermaid, renderSequenceMermaid, renderServiceGraphMermaid, renderServicesMermaid, renderServicesMermaidFromMap, renderStaticMermaid, renderSummary, renderTestabilityMermaid, renderTimelineMermaid, resetIdCounter, resolveConst, resolveGitSource, resolveNode, runCoverageAudit, schemaToJsonSchema, selectFormats, setCached, summarizePathSteps, trackTypeTransformation, unboundedParallelismRule, untaggedYieldRule, validateDataFlow, validateStrict, validateWorkflowErrors };