ai-code-map 0.0.0-stage → 0.1.0-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,1178 @@
+import ts from 'typescript';
+import { z } from 'zod';
+
+declare const SCHEMA_VERSION: 4;
+declare const CONFIG_VERSION: 1;
+declare const ANALYZER_VERSION = "0.4.0";
+
+declare class CodeMapError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: ErrorOptions);
+}
+
+declare const JsonValueSchema: z.ZodJSONSchema;
+type JsonValue = z.infer<typeof JsonValueSchema>;
+type JsonPrimitive = Extract<JsonValue, string | number | boolean | null>;
+declare const LanguageSchema: z.ZodEnum<{
+    ts: "ts";
+    tsx: "tsx";
+    js: "js";
+    jsx: "jsx";
+    mts: "mts";
+    cts: "cts";
+    mjs: "mjs";
+    cjs: "cjs";
+}>;
+type Language = z.infer<typeof LanguageSchema>;
+declare const FrameworkSchema: z.ZodEnum<{
+    typescript: "typescript";
+    react: "react";
+    nextjs: "nextjs";
+    nestjs: "nestjs";
+    node: "node";
+}>;
+type Framework = z.infer<typeof FrameworkSchema>;
+declare const FrameworkSelectionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    typescript: "typescript";
+    react: "react";
+    nextjs: "nextjs";
+    nestjs: "nestjs";
+    node: "node";
+}>, z.ZodLiteral<"auto">]>;
+type FrameworkSelection = z.infer<typeof FrameworkSelectionSchema>;
+declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    root: z.ZodDefault<z.ZodString>;
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tsconfig: z.ZodOptional<z.ZodString>;
+    frameworks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        typescript: "typescript";
+        react: "react";
+        nextjs: "nextjs";
+        nestjs: "nestjs";
+        node: "node";
+    }>, z.ZodLiteral<"auto">]>>>;
+    output: z.ZodDefault<z.ZodString>;
+    includePrivateSymbols: z.ZodDefault<z.ZodBoolean>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type CodeMapConfig = z.infer<typeof ConfigSchema>;
+declare const SourceRangeSchema: z.ZodObject<{
+    startLine: z.ZodNumber;
+    startColumn: z.ZodNumber;
+    endLine: z.ZodNumber;
+    endColumn: z.ZodNumber;
+}, z.core.$strict>;
+type SourceRange = z.infer<typeof SourceRangeSchema>;
+declare const ImportSpecifierRecordSchema: z.ZodObject<{
+    imported: z.ZodString;
+    local: z.ZodString;
+    typeOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type ImportSpecifierRecord = z.infer<typeof ImportSpecifierRecordSchema>;
+declare const ImportRecordSchema: z.ZodObject<{
+    source: z.ZodString;
+    specifiers: z.ZodArray<z.ZodObject<{
+        imported: z.ZodString;
+        local: z.ZodString;
+        typeOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    resolved: z.ZodOptional<z.ZodString>;
+    external: z.ZodBoolean;
+    kind: z.ZodEnum<{
+        esm: "esm";
+        commonjs: "commonjs";
+    }>;
+    line: z.ZodNumber;
+}, z.core.$strict>;
+type ImportRecord = z.infer<typeof ImportRecordSchema>;
+declare const ExportRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    local: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    default: z.ZodBoolean;
+    typeOnly: z.ZodOptional<z.ZodBoolean>;
+    line: z.ZodNumber;
+}, z.core.$strict>;
+type ExportRecord = z.infer<typeof ExportRecordSchema>;
+declare const ExternalOperationKindSchema: z.ZodEnum<{
+    filesystem: "filesystem";
+    http: "http";
+    database: "database";
+    queue: "queue";
+}>;
+type ExternalOperationKind = z.infer<typeof ExternalOperationKindSchema>;
+declare const ExternalOperationSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        filesystem: "filesystem";
+        http: "http";
+        database: "database";
+        queue: "queue";
+    }>;
+    api: z.ZodString;
+    line: z.ZodNumber;
+}, z.core.$strict>;
+type ExternalOperation = z.infer<typeof ExternalOperationSchema>;
+declare const SyntaxSummarySchema: z.ZodObject<{
+    parser: z.ZodString;
+    factCount: z.ZodNumber;
+    hadErrors: z.ZodBoolean;
+    fallbackFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type SyntaxSummary = z.infer<typeof SyntaxSummarySchema>;
+declare const FileRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    id: z.ZodString;
+    compilerUnit: z.ZodString;
+    path: z.ZodString;
+    language: z.ZodEnum<{
+        ts: "ts";
+        tsx: "tsx";
+        js: "js";
+        jsx: "jsx";
+        mts: "mts";
+        cts: "cts";
+        mjs: "mjs";
+        cjs: "cjs";
+    }>;
+    frameworks: z.ZodArray<z.ZodEnum<{
+        typescript: "typescript";
+        react: "react";
+        nextjs: "nextjs";
+        nestjs: "nestjs";
+        node: "node";
+    }>>;
+    hash: z.ZodString;
+    lines: z.ZodNumber;
+    imports: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        specifiers: z.ZodArray<z.ZodObject<{
+            imported: z.ZodString;
+            local: z.ZodString;
+            typeOnly: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        resolved: z.ZodOptional<z.ZodString>;
+        external: z.ZodBoolean;
+        kind: z.ZodEnum<{
+            esm: "esm";
+            commonjs: "commonjs";
+        }>;
+        line: z.ZodNumber;
+    }, z.core.$strict>>;
+    exports: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        local: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        default: z.ZodBoolean;
+        typeOnly: z.ZodOptional<z.ZodBoolean>;
+        line: z.ZodNumber;
+    }, z.core.$strict>>;
+    symbolIds: z.ZodArray<z.ZodString>;
+    env: z.ZodArray<z.ZodString>;
+    operations: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            filesystem: "filesystem";
+            http: "http";
+            database: "database";
+            queue: "queue";
+        }>;
+        api: z.ZodString;
+        line: z.ZodNumber;
+    }, z.core.$strict>>;
+    syntax: z.ZodObject<{
+        parser: z.ZodString;
+        factCount: z.ZodNumber;
+        hadErrors: z.ZodBoolean;
+        fallbackFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type FileRecord = z.infer<typeof FileRecordSchema>;
+declare const CompilerUnitRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        configured: "configured";
+        fallback: "fallback";
+    }>;
+    root: z.ZodString;
+    config: z.ZodOptional<z.ZodString>;
+    references: z.ZodArray<z.ZodString>;
+    extends: z.ZodArray<z.ZodString>;
+    pathAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type CompilerUnitRecord = z.infer<typeof CompilerUnitRecordSchema>;
+declare const SymbolKindSchema: z.ZodEnum<{
+    function: "function";
+    class: "class";
+    method: "method";
+    interface: "interface";
+    "type-alias": "type-alias";
+    variable: "variable";
+    "react-component": "react-component";
+    "react-hook": "react-hook";
+    "react-context": "react-context";
+    "next-page": "next-page";
+    "next-layout": "next-layout";
+    "next-route-handler": "next-route-handler";
+    "next-special-file": "next-special-file";
+    "nest-module": "nest-module";
+    "nest-controller": "nest-controller";
+    "nest-provider": "nest-provider";
+    "nest-guard": "nest-guard";
+    "nest-interceptor": "nest-interceptor";
+    "nest-pipe": "nest-pipe";
+    "nest-filter": "nest-filter";
+    "nest-gateway": "nest-gateway";
+    dto: "dto";
+    route: "route";
+}>;
+type SymbolKind = z.infer<typeof SymbolKindSchema>;
+declare const SymbolRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        function: "function";
+        class: "class";
+        method: "method";
+        interface: "interface";
+        "type-alias": "type-alias";
+        variable: "variable";
+        "react-component": "react-component";
+        "react-hook": "react-hook";
+        "react-context": "react-context";
+        "next-page": "next-page";
+        "next-layout": "next-layout";
+        "next-route-handler": "next-route-handler";
+        "next-special-file": "next-special-file";
+        "nest-module": "nest-module";
+        "nest-controller": "nest-controller";
+        "nest-provider": "nest-provider";
+        "nest-guard": "nest-guard";
+        "nest-interceptor": "nest-interceptor";
+        "nest-pipe": "nest-pipe";
+        "nest-filter": "nest-filter";
+        "nest-gateway": "nest-gateway";
+        dto: "dto";
+        route: "route";
+    }>;
+    file: z.ZodString;
+    range: z.ZodObject<{
+        startLine: z.ZodNumber;
+        startColumn: z.ZodNumber;
+        endLine: z.ZodNumber;
+        endColumn: z.ZodNumber;
+    }, z.core.$strict>;
+    exported: z.ZodBoolean;
+    defaultExport: z.ZodOptional<z.ZodBoolean>;
+    signature: z.ZodOptional<z.ZodString>;
+    documentation: z.ZodOptional<z.ZodString>;
+    facts: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    sourceHash: z.ZodString;
+}, z.core.$strict>;
+type SymbolRecord = z.infer<typeof SymbolRecordSchema>;
+declare const RelationTypeSchema: z.ZodEnum<{
+    references: "references";
+    imports: "imports";
+    exports: "exports";
+    reexports: "reexports";
+    calls: "calls";
+    instantiates: "instantiates";
+    renders: "renders";
+    "uses-hook": "uses-hook";
+    "reads-state": "reads-state";
+    "depends-on": "depends-on";
+    "used-by": "used-by";
+    contains: "contains";
+    injects: "injects";
+    "handles-route": "handles-route";
+    "consumes-dto": "consumes-dto";
+    "belongs-to-module": "belongs-to-module";
+    "uses-layout": "uses-layout";
+}>;
+type RelationType = z.infer<typeof RelationTypeSchema>;
+declare const RelationEvidenceClassificationSchema: z.ZodEnum<{
+    exact: "exact";
+    "framework-derived": "framework-derived";
+    heuristic: "heuristic";
+    derived: "derived";
+}>;
+type RelationEvidenceClassification = z.infer<typeof RelationEvidenceClassificationSchema>;
+declare const RelationOriginSchema: z.ZodObject<{
+    file: z.ZodString;
+    line: z.ZodNumber;
+    range: z.ZodObject<{
+        startLine: z.ZodNumber;
+        startColumn: z.ZodNumber;
+        endLine: z.ZodNumber;
+        endColumn: z.ZodNumber;
+    }, z.core.$strict>;
+    explanation: z.ZodString;
+    classification: z.ZodEnum<{
+        exact: "exact";
+        "framework-derived": "framework-derived";
+        heuristic: "heuristic";
+        derived: "derived";
+    }>;
+    analyzer: z.ZodString;
+}, z.core.$strict>;
+type RelationOrigin = z.infer<typeof RelationOriginSchema>;
+declare const RelationRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    from: z.ZodString;
+    type: z.ZodEnum<{
+        references: "references";
+        imports: "imports";
+        exports: "exports";
+        reexports: "reexports";
+        calls: "calls";
+        instantiates: "instantiates";
+        renders: "renders";
+        "uses-hook": "uses-hook";
+        "reads-state": "reads-state";
+        "depends-on": "depends-on";
+        "used-by": "used-by";
+        contains: "contains";
+        injects: "injects";
+        "handles-route": "handles-route";
+        "consumes-dto": "consumes-dto";
+        "belongs-to-module": "belongs-to-module";
+        "uses-layout": "uses-layout";
+    }>;
+    to: z.ZodString;
+    confidence: z.ZodNumber;
+    origin: z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodNumber;
+        range: z.ZodObject<{
+            startLine: z.ZodNumber;
+            startColumn: z.ZodNumber;
+            endLine: z.ZodNumber;
+            endColumn: z.ZodNumber;
+        }, z.core.$strict>;
+        explanation: z.ZodString;
+        classification: z.ZodEnum<{
+            exact: "exact";
+            "framework-derived": "framework-derived";
+            heuristic: "heuristic";
+            derived: "derived";
+        }>;
+        analyzer: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type RelationRecord = z.infer<typeof RelationRecordSchema>;
+declare const DiagnosticSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+}>;
+type DiagnosticSeverity = z.infer<typeof DiagnosticSeveritySchema>;
+declare const DiagnosticCodeSchema: z.ZodEnum<{
+    "parse-error": "parse-error";
+    "unresolved-import": "unresolved-import";
+    "invalid-config": "invalid-config";
+    "unsupported-file": "unsupported-file";
+    "analysis-error": "analysis-error";
+    "parser-fallback": "parser-fallback";
+    "compiler-config": "compiler-config";
+}>;
+type DiagnosticCode = z.infer<typeof DiagnosticCodeSchema>;
+declare const DiagnosticRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    code: z.ZodEnum<{
+        "parse-error": "parse-error";
+        "unresolved-import": "unresolved-import";
+        "invalid-config": "invalid-config";
+        "unsupported-file": "unsupported-file";
+        "analysis-error": "analysis-error";
+        "parser-fallback": "parser-fallback";
+        "compiler-config": "compiler-config";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type DiagnosticRecord = z.infer<typeof DiagnosticRecordSchema>;
+declare const WorkspacePackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    entryPoints: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type WorkspacePackage = z.infer<typeof WorkspacePackageSchema>;
+declare const MapCountsSchema: z.ZodObject<{
+    files: z.ZodNumber;
+    symbols: z.ZodNumber;
+    relations: z.ZodNumber;
+    diagnostics: z.ZodNumber;
+}, z.core.$strict>;
+type MapCounts = z.infer<typeof MapCountsSchema>;
+declare const ProjectRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    name: z.ZodString;
+    packageManager: z.ZodOptional<z.ZodString>;
+    frameworks: z.ZodArray<z.ZodEnum<{
+        typescript: "typescript";
+        react: "react";
+        nextjs: "nextjs";
+        nestjs: "nestjs";
+        node: "node";
+    }>>;
+    compilerUnits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            configured: "configured";
+            fallback: "fallback";
+        }>;
+        root: z.ZodString;
+        config: z.ZodOptional<z.ZodString>;
+        references: z.ZodArray<z.ZodString>;
+        extends: z.ZodArray<z.ZodString>;
+        pathAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    tsconfig: z.ZodOptional<z.ZodString>;
+    pathAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    entryPoints: z.ZodArray<z.ZodString>;
+    workspaces: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        entryPoints: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    counts: z.ZodObject<{
+        files: z.ZodNumber;
+        symbols: z.ZodNumber;
+        relations: z.ZodNumber;
+        diagnostics: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ProjectRecord = z.infer<typeof ProjectRecordSchema>;
+declare const SemanticInputRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodLiteral<"file">;
+    hash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodLiteral<"resolution-probe">;
+    scope: z.ZodEnum<{
+        project: "project";
+        toolchain: "toolchain";
+    }>;
+    targetKind: z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+        "readable-file": "readable-file";
+    }>;
+    exists: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodLiteral<"directory-listing">;
+    scope: z.ZodEnum<{
+        project: "project";
+        toolchain: "toolchain";
+    }>;
+    hash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodLiteral<"symlink">;
+    scope: z.ZodEnum<{
+        project: "project";
+        toolchain: "toolchain";
+    }>;
+    target: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodLiteral<"toolchain-file">;
+    hash: z.ZodString;
+}, z.core.$strict>], "kind">;
+type SemanticInputRecord = z.infer<typeof SemanticInputRecordSchema>;
+declare const ArtifactIntegrityRecordSchema: z.ZodObject<{
+    path: z.ZodEnum<{
+        "overview.md": "overview.md";
+        "project.json": "project.json";
+        "files.jsonl": "files.jsonl";
+        "symbols.jsonl": "symbols.jsonl";
+        "relations.jsonl": "relations.jsonl";
+        "diagnostics.json": "diagnostics.json";
+    }>;
+    hash: z.ZodString;
+}, z.core.$strict>;
+type ArtifactIntegrityRecord = z.infer<typeof ArtifactIntegrityRecordSchema>;
+declare const ProducerRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        "built-in": "built-in";
+        custom: "custom";
+    }>;
+    fingerprint: z.ZodString;
+}, z.core.$strict>;
+type ProducerRecord = z.infer<typeof ProducerRecordSchema>;
+declare const ManifestRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    analyzerVersion: z.ZodString;
+    producer: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            "built-in": "built-in";
+            custom: "custom";
+        }>;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>;
+    semanticResolver: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    syntaxParser: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    analyzers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    configHash: z.ZodString;
+    sourceFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        hash: z.ZodString;
+        compilerUnit: z.ZodString;
+        lines: z.ZodNumber;
+    }, z.core.$strict>>;
+    semanticInputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodLiteral<"file">;
+        hash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodLiteral<"resolution-probe">;
+        scope: z.ZodEnum<{
+            project: "project";
+            toolchain: "toolchain";
+        }>;
+        targetKind: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+            "readable-file": "readable-file";
+        }>;
+        exists: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodLiteral<"directory-listing">;
+        scope: z.ZodEnum<{
+            project: "project";
+            toolchain: "toolchain";
+        }>;
+        hash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodLiteral<"symlink">;
+        scope: z.ZodEnum<{
+            project: "project";
+            toolchain: "toolchain";
+        }>;
+        target: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodLiteral<"toolchain-file">;
+        hash: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        path: z.ZodEnum<{
+            "overview.md": "overview.md";
+            "project.json": "project.json";
+            "files.jsonl": "files.jsonl";
+            "symbols.jsonl": "symbols.jsonl";
+            "relations.jsonl": "relations.jsonl";
+            "diagnostics.json": "diagnostics.json";
+        }>;
+        hash: z.ZodString;
+    }, z.core.$strict>>;
+    integrityHash: z.ZodString;
+}, z.core.$strict>;
+type ManifestRecord = z.infer<typeof ManifestRecordSchema>;
+declare const CodeMapSchema: z.ZodObject<{
+    manifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<4>;
+        analyzerVersion: z.ZodString;
+        producer: z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                "built-in": "built-in";
+                custom: "custom";
+            }>;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>;
+        semanticResolver: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        syntaxParser: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        analyzers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        configHash: z.ZodString;
+        sourceFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            hash: z.ZodString;
+            compilerUnit: z.ZodString;
+            lines: z.ZodNumber;
+        }, z.core.$strict>>;
+        semanticInputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodLiteral<"file">;
+            hash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodLiteral<"resolution-probe">;
+            scope: z.ZodEnum<{
+                project: "project";
+                toolchain: "toolchain";
+            }>;
+            targetKind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                "readable-file": "readable-file";
+            }>;
+            exists: z.ZodBoolean;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodLiteral<"directory-listing">;
+            scope: z.ZodEnum<{
+                project: "project";
+                toolchain: "toolchain";
+            }>;
+            hash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodLiteral<"symlink">;
+            scope: z.ZodEnum<{
+                project: "project";
+                toolchain: "toolchain";
+            }>;
+            target: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodLiteral<"toolchain-file">;
+            hash: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        artifacts: z.ZodArray<z.ZodObject<{
+            path: z.ZodEnum<{
+                "overview.md": "overview.md";
+                "project.json": "project.json";
+                "files.jsonl": "files.jsonl";
+                "symbols.jsonl": "symbols.jsonl";
+                "relations.jsonl": "relations.jsonl";
+                "diagnostics.json": "diagnostics.json";
+            }>;
+            hash: z.ZodString;
+        }, z.core.$strict>>;
+        integrityHash: z.ZodString;
+    }, z.core.$strict>;
+    project: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<4>;
+        name: z.ZodString;
+        packageManager: z.ZodOptional<z.ZodString>;
+        frameworks: z.ZodArray<z.ZodEnum<{
+            typescript: "typescript";
+            react: "react";
+            nextjs: "nextjs";
+            nestjs: "nestjs";
+            node: "node";
+        }>>;
+        compilerUnits: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                configured: "configured";
+                fallback: "fallback";
+            }>;
+            root: z.ZodString;
+            config: z.ZodOptional<z.ZodString>;
+            references: z.ZodArray<z.ZodString>;
+            extends: z.ZodArray<z.ZodString>;
+            pathAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        tsconfig: z.ZodOptional<z.ZodString>;
+        pathAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        entryPoints: z.ZodArray<z.ZodString>;
+        workspaces: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            entryPoints: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        counts: z.ZodObject<{
+            files: z.ZodNumber;
+            symbols: z.ZodNumber;
+            relations: z.ZodNumber;
+            diagnostics: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    files: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<4>;
+        id: z.ZodString;
+        compilerUnit: z.ZodString;
+        path: z.ZodString;
+        language: z.ZodEnum<{
+            ts: "ts";
+            tsx: "tsx";
+            js: "js";
+            jsx: "jsx";
+            mts: "mts";
+            cts: "cts";
+            mjs: "mjs";
+            cjs: "cjs";
+        }>;
+        frameworks: z.ZodArray<z.ZodEnum<{
+            typescript: "typescript";
+            react: "react";
+            nextjs: "nextjs";
+            nestjs: "nestjs";
+            node: "node";
+        }>>;
+        hash: z.ZodString;
+        lines: z.ZodNumber;
+        imports: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            specifiers: z.ZodArray<z.ZodObject<{
+                imported: z.ZodString;
+                local: z.ZodString;
+                typeOnly: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            resolved: z.ZodOptional<z.ZodString>;
+            external: z.ZodBoolean;
+            kind: z.ZodEnum<{
+                esm: "esm";
+                commonjs: "commonjs";
+            }>;
+            line: z.ZodNumber;
+        }, z.core.$strict>>;
+        exports: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            local: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodString>;
+            default: z.ZodBoolean;
+            typeOnly: z.ZodOptional<z.ZodBoolean>;
+            line: z.ZodNumber;
+        }, z.core.$strict>>;
+        symbolIds: z.ZodArray<z.ZodString>;
+        env: z.ZodArray<z.ZodString>;
+        operations: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                filesystem: "filesystem";
+                http: "http";
+                database: "database";
+                queue: "queue";
+            }>;
+            api: z.ZodString;
+            line: z.ZodNumber;
+        }, z.core.$strict>>;
+        syntax: z.ZodObject<{
+            parser: z.ZodString;
+            factCount: z.ZodNumber;
+            hadErrors: z.ZodBoolean;
+            fallbackFrom: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    symbols: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<4>;
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            class: "class";
+            method: "method";
+            interface: "interface";
+            "type-alias": "type-alias";
+            variable: "variable";
+            "react-component": "react-component";
+            "react-hook": "react-hook";
+            "react-context": "react-context";
+            "next-page": "next-page";
+            "next-layout": "next-layout";
+            "next-route-handler": "next-route-handler";
+            "next-special-file": "next-special-file";
+            "nest-module": "nest-module";
+            "nest-controller": "nest-controller";
+            "nest-provider": "nest-provider";
+            "nest-guard": "nest-guard";
+            "nest-interceptor": "nest-interceptor";
+            "nest-pipe": "nest-pipe";
+            "nest-filter": "nest-filter";
+            "nest-gateway": "nest-gateway";
+            dto: "dto";
+            route: "route";
+        }>;
+        file: z.ZodString;
+        range: z.ZodObject<{
+            startLine: z.ZodNumber;
+            startColumn: z.ZodNumber;
+            endLine: z.ZodNumber;
+            endColumn: z.ZodNumber;
+        }, z.core.$strict>;
+        exported: z.ZodBoolean;
+        defaultExport: z.ZodOptional<z.ZodBoolean>;
+        signature: z.ZodOptional<z.ZodString>;
+        documentation: z.ZodOptional<z.ZodString>;
+        facts: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        sourceHash: z.ZodString;
+    }, z.core.$strict>>;
+    relations: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<4>;
+        from: z.ZodString;
+        type: z.ZodEnum<{
+            references: "references";
+            imports: "imports";
+            exports: "exports";
+            reexports: "reexports";
+            calls: "calls";
+            instantiates: "instantiates";
+            renders: "renders";
+            "uses-hook": "uses-hook";
+            "reads-state": "reads-state";
+            "depends-on": "depends-on";
+            "used-by": "used-by";
+            contains: "contains";
+            injects: "injects";
+            "handles-route": "handles-route";
+            "consumes-dto": "consumes-dto";
+            "belongs-to-module": "belongs-to-module";
+            "uses-layout": "uses-layout";
+        }>;
+        to: z.ZodString;
+        confidence: z.ZodNumber;
+        origin: z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            range: z.ZodObject<{
+                startLine: z.ZodNumber;
+                startColumn: z.ZodNumber;
+                endLine: z.ZodNumber;
+                endColumn: z.ZodNumber;
+            }, z.core.$strict>;
+            explanation: z.ZodString;
+            classification: z.ZodEnum<{
+                exact: "exact";
+                "framework-derived": "framework-derived";
+                heuristic: "heuristic";
+                derived: "derived";
+            }>;
+            analyzer: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<4>;
+        code: z.ZodEnum<{
+            "parse-error": "parse-error";
+            "unresolved-import": "unresolved-import";
+            "invalid-config": "invalid-config";
+            "unsupported-file": "unsupported-file";
+            "analysis-error": "analysis-error";
+            "parser-fallback": "parser-fallback";
+            "compiler-config": "compiler-config";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type CodeMap = z.infer<typeof CodeMapSchema>;
+
+type SyntaxFactKind = "import" | "export" | "declaration" | "call" | "jsx-element" | "parse-error";
+interface SyntaxFact {
+    kind: SyntaxFactKind;
+    name?: string;
+    nodeType: string;
+    range: SourceRange;
+    evidence: {
+        parser: string;
+        exact: boolean;
+    };
+}
+interface SyntaxIssue {
+    message: string;
+    range?: SourceRange;
+    fatal?: boolean;
+}
+interface SyntaxParseInput {
+    path: string;
+    language: Language;
+    source: string;
+}
+interface SyntaxParseResult {
+    parser: string;
+    facts: SyntaxFact[];
+    issues: SyntaxIssue[];
+    hadErrors: boolean;
+    fallbackFrom?: string;
+}
+interface SyntaxParserAdapter {
+    readonly name: string;
+    readonly version?: string;
+    supports(language: Language): boolean | Promise<boolean>;
+    parse(input: SyntaxParseInput): SyntaxParseResult | Promise<SyntaxParseResult>;
+}
+interface WorkspaceDiscoveryResult {
+    tool: string;
+    packages: WorkspacePackage[];
+}
+interface WorkspaceDiscovery {
+    readonly name: string;
+    discover(root: string): Promise<WorkspaceDiscoveryResult>;
+}
+interface IgnoreAdapter {
+    readonly name: string;
+    filter(root: string, paths: readonly string[]): Promise<string[]>;
+}
+interface SemanticResolveInput {
+    root: string;
+    sourceFiles: string[];
+    tsconfig?: string;
+    /** Stable owning compiler-unit ID. Additive in schema v2; legacy resolvers may ignore it. */
+    compilerUnit?: string;
+}
+interface SemanticModuleResolution {
+    resolvedFileName: string;
+    isExternalLibraryImport: boolean;
+}
+interface SemanticResolution {
+    program: ts.Program;
+    checker: ts.TypeChecker;
+    pathAliases: Record<string, string[]>;
+    diagnostics: DiagnosticRecord[];
+    /** Unit-anchored resolution used by analyzers instead of the process-global ts.sys host. */
+    resolveModule?: (moduleName: string, containingFile: string) => SemanticModuleResolution | undefined;
+    /** Bounded compiler-consumed files, typed probes, directories, symlinks, and toolchain inputs. */
+    semanticInputs?: () => SemanticInputObservation[];
+}
+type SemanticInputObservation = {
+    path: string;
+    kind: "file";
+    hash: string;
+} | {
+    path: string;
+    kind: "resolution-probe";
+    /** Defaults to the selected project for third-party resolver compatibility. */
+    scope?: "project" | "toolchain";
+    targetKind: "file" | "directory" | "readable-file";
+    exists: boolean;
+} | {
+    path: string;
+    kind: "directory-listing";
+    /** Defaults to the selected project for third-party resolver compatibility. */
+    scope?: "project" | "toolchain";
+    hash: string;
+} | {
+    path: string;
+    kind: "symlink";
+    /** Defaults to the selected project for third-party resolver compatibility. */
+    scope?: "project" | "toolchain";
+    target: string;
+} | {
+    path: string;
+    kind: "toolchain-file";
+    hash: string;
+};
+interface SemanticResolver {
+    readonly name: string;
+    readonly version?: string;
+    resolve(input: SemanticResolveInput): SemanticResolution | Promise<SemanticResolution>;
+}
+interface ScanOptions {
+    root?: string;
+    config?: string;
+    output?: string;
+    strict?: boolean;
+    analyzers?: FrameworkAnalyzer[];
+    parser?: SyntaxParserAdapter;
+    semanticResolver?: SemanticResolver;
+}
+interface ScanChanges {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+    moved: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+interface ScanResult {
+    map: CodeMap;
+    root: string;
+    outputDir: string;
+    wrote: boolean;
+    changes: ScanChanges;
+    elapsedMs: number;
+    counts: MapCounts;
+    criticalParseErrors: boolean;
+}
+interface LoadCodeMapOptions {
+    root?: string;
+    config?: string;
+    output?: string;
+}
+type FreshnessStatus = "current" | "stale" | "missing";
+interface FreshnessResult {
+    status: FreshnessStatus;
+    current: boolean;
+    root: string;
+    outputDir: string;
+    reasons: string[];
+    changes: ScanChanges;
+}
+interface ShowResult {
+    selector: string;
+    matches: Array<{
+        symbol: SymbolRecord;
+        file: FileRecord;
+        inbound: RelationRecord[];
+        outbound: RelationRecord[];
+    }>;
+}
+interface AnalysisContext {
+    root: string;
+    relativePath: string;
+    sourceFile: ts.SourceFile;
+    program: ts.Program;
+    checker: ts.TypeChecker;
+    sourceHash: string;
+    file: FileRecord;
+    packageDependencies: Set<string>;
+    syntax: SyntaxParseResult;
+    includePrivateSymbols: boolean;
+    compilerUnit?: CompilerUnitRecord;
+    indexedSourcePaths?: ReadonlySet<string>;
+    resolveModule?: SemanticResolution["resolveModule"];
+}
+interface AnalysisContribution {
+    symbols?: SymbolRecord[];
+    relations?: RelationRecord[];
+    diagnostics?: DiagnosticRecord[];
+    frameworks?: Framework[];
+}
+interface FrameworkAnalyzer {
+    readonly name: string;
+    readonly version?: string;
+    supports(context: AnalysisContext): boolean;
+    analyze(context: AnalysisContext): AnalysisContribution | Promise<AnalysisContribution>;
+}
+interface Analyzer {
+    readonly analyzers: readonly FrameworkAnalyzer[];
+    readonly parser: SyntaxParserAdapter;
+    scan(options?: ScanOptions): Promise<ScanResult>;
+}
+
+interface InitOptions extends LoadCodeMapOptions {
+    force?: boolean;
+}
+interface InitResult {
+    root: string;
+    configPath: string;
+    created: boolean;
+}
+declare function createDefaultConfig(root: string, configPath: string, output?: string): CodeMapConfig;
+declare function findProjectRoot(start?: string): Promise<string>;
+declare function initProject(options?: InitOptions): Promise<InitResult>;
+
+declare class TypeScriptParserAdapter implements SyntaxParserAdapter {
+    readonly name = "typescript-compiler-syntax";
+    readonly version: string;
+    constructor();
+    supports(language: Language): boolean;
+    parse(input: SyntaxParseInput): SyntaxParseResult;
+}
+declare class FallbackParserAdapter implements SyntaxParserAdapter {
+    readonly primary: SyntaxParserAdapter;
+    readonly fallback: SyntaxParserAdapter;
+    readonly name: string;
+    constructor(primary: SyntaxParserAdapter, fallback?: SyntaxParserAdapter);
+    supports(language: Language): Promise<boolean>;
+    parse(input: SyntaxParseInput): Promise<SyntaxParseResult>;
+    private parseFallback;
+}
+declare function createTypeScriptParserAdapter(): SyntaxParserAdapter;
+
+declare function scanProject(options?: ScanOptions): Promise<ScanResult>;
+declare function createAnalyzer(options?: {
+    analyzers?: FrameworkAnalyzer[];
+    parser?: SyntaxParserAdapter;
+    semanticResolver?: SemanticResolver;
+}): {
+    analyzers: FrameworkAnalyzer[];
+    parser: TypeScriptParserAdapter | FallbackParserAdapter;
+    scan: (scanOptions?: ScanOptions) => Promise<ScanResult>;
+};
+
+declare function buildOverview(map: CodeMap): string;
+declare function loadCodeMap(options?: LoadCodeMapOptions): Promise<CodeMap>;
+declare function computeManifestIntegrityHash(manifest: ManifestRecord): string;
+
+declare function checkFreshness(options?: LoadCodeMapOptions): Promise<FreshnessResult>;
+
+declare function showSymbol(map: CodeMap, selector: string): ShowResult;
+declare function formatShowResult(result: ShowResult): string;
+
+declare class CoreAnalyzer implements FrameworkAnalyzer {
+    readonly name = "typescript-node";
+    readonly version = "0.4.0";
+    supports(): boolean;
+    analyze(context: AnalysisContext): AnalysisContribution;
+}
+
+declare class ReactAnalyzer implements FrameworkAnalyzer {
+    readonly name = "react";
+    readonly version = "0.4.0";
+    supports(context: AnalysisContext): boolean;
+    analyze(context: AnalysisContext): AnalysisContribution;
+}
+
+declare class NextJsAnalyzer implements FrameworkAnalyzer {
+    readonly name = "nextjs";
+    readonly version = "0.1.0-experimental";
+    constructor();
+    supports(context: AnalysisContext): boolean;
+    analyze(context: AnalysisContext): AnalysisContribution;
+}
+
+declare class NestJsAnalyzer implements FrameworkAnalyzer {
+    readonly name = "nestjs";
+    readonly version = "0.1.0-experimental";
+    constructor();
+    supports(context: AnalysisContext): boolean;
+    analyze(context: AnalysisContext): AnalysisContribution;
+}
+
+declare class ManypkgWorkspaceDiscovery implements WorkspaceDiscovery {
+    readonly name = "manypkg";
+    discover(root: string): Promise<WorkspaceDiscoveryResult>;
+}
+declare function createWorkspaceDiscovery(): WorkspaceDiscovery;
+
+declare class GitIgnoreAdapter implements IgnoreAdapter {
+    readonly name = "ignore";
+    filter(root: string, paths: readonly string[]): Promise<string[]>;
+}
+declare function createGitIgnoreAdapter(): IgnoreAdapter;
+
+/** TypeScript remains authoritative for all TypeScript/JavaScript semantic facts. */
+declare class TypeScriptSemanticResolver implements SemanticResolver {
+    private readonly jsDocParsingMode;
+    readonly name = "typescript-program";
+    readonly version: string;
+    constructor(jsDocParsingMode?: ts.JSDocParsingMode);
+    resolve(input: SemanticResolveInput): SemanticResolution;
+}
+declare function createTypeScriptSemanticResolver(): SemanticResolver;
+
+export { ANALYZER_VERSION, type AnalysisContext, type AnalysisContribution, type Analyzer, type ArtifactIntegrityRecord, ArtifactIntegrityRecordSchema, CONFIG_VERSION, type CodeMap, type CodeMapConfig, CodeMapError, CodeMapSchema, type CompilerUnitRecord, CompilerUnitRecordSchema, ConfigSchema, CoreAnalyzer, type DiagnosticCode, type DiagnosticRecord, DiagnosticRecordSchema, type DiagnosticSeverity, type ExportRecord, type ExternalOperation, type ExternalOperationKind, FallbackParserAdapter, type FileRecord, FileRecordSchema, type Framework, type FrameworkAnalyzer, type FrameworkSelection, type FreshnessResult, type FreshnessStatus, GitIgnoreAdapter, type IgnoreAdapter, type ImportRecord, type ImportSpecifierRecord, type InitOptions, type InitResult, type JsonPrimitive, type JsonValue, type Language, type LoadCodeMapOptions, type ManifestRecord, ManifestRecordSchema, ManypkgWorkspaceDiscovery, type MapCounts, NestJsAnalyzer, NextJsAnalyzer, type ProducerRecord, ProducerRecordSchema, type ProjectRecord, ProjectRecordSchema, ReactAnalyzer, type RelationEvidenceClassification, type RelationOrigin, type RelationRecord, RelationRecordSchema, type RelationType, SCHEMA_VERSION, type ScanChanges, type ScanOptions, type ScanResult, type SemanticInputObservation, type SemanticInputRecord, SemanticInputRecordSchema, type SemanticModuleResolution, type SemanticResolution, type SemanticResolveInput, type SemanticResolver, type ShowResult, type SourceRange, type SymbolKind, type SymbolRecord, SymbolRecordSchema, type SyntaxFact, type SyntaxFactKind, type SyntaxIssue, type SyntaxParseInput, type SyntaxParseResult, type SyntaxParserAdapter, type SyntaxSummary, TypeScriptParserAdapter, TypeScriptSemanticResolver, type WorkspaceDiscovery, type WorkspaceDiscoveryResult, type WorkspacePackage, buildOverview, checkFreshness, computeManifestIntegrityHash, createAnalyzer, createDefaultConfig, createGitIgnoreAdapter, createTypeScriptParserAdapter, createTypeScriptSemanticResolver, createWorkspaceDiscovery, findProjectRoot, formatShowResult, initProject, loadCodeMap, scanProject, showSymbol };