@nudojs/service 3.0.0 → 5.0.0-beta.0

package/README.md

@@ -4,16 +4,31 @@ Shared inference service for [Nudo](https://github.com/nudojs/nudo) IDE integrat
 
 ## What is Nudo?
 
-Nudo is a type inference engine for JavaScript. Instead of a separate type system, it runs your code with symbolic type values via abstract interpretation — no TypeScript, no build step.
+Nudo is a type inference engine for JavaScript. The type system is Abs (`shape × term × pred × conf`); production analysis is Abs-native via abstract interpretation — no TypeScript, no build step.
 
 ## This package
 
-`@nudojs/service` provides the high-level analysis API used by editor extensions and build tools:
+`@nudojs/service` provides the high-level analysis API used by editor extensions and build tools.
+
+Production evaluation is **Abs-native B-path** (`evalAbsModuleGraph` + `runTranspiled`); the TypeValue AST interpreter is gone. Prefer a focused subpath over the full barrel:
+
+| Subpath | Face |
+|---|---|
+| `@nudojs/service/analysis` | File analysis, diagnostics, call records, Abs module-graph eval |
+| `@nudojs/service/interface` | Interface / contract product (surface, emit, draft, derive) |
+| `@nudojs/service/dts` | Extensional projections: dts / schema / standard / guard |
+| `@nudojs/service/case` | Debug case reports + case directive emit (`nudo test`) |
+| `@nudojs/service/lsp` | IDE surface (hover, completions, semantic tokens, inlays) |
+| `@nudojs/service/harvest` | `@types` → Abs env harvesting |
+| `@nudojs/service/evaluator` | Host API surface (env/config/CallRecord) — not the eval engine |
+| `@nudojs/service` | Full barrel (stable; all of the above) |
+
+Highlights:
 
 - **File analysis** — `analyzeFile` returns diagnostics, function analyses, and case results
 - **IDE features** — `getTypeAtPosition`, `getCompletionsAtPosition`, `getCasesForFile`
-- **DTS generation** — `generateDts` and `typeValueToTSType` for producing `.d.ts` output
-- **Zod schema generation** — `typeValueToZodSchema` converts inferred types to Zod schema strings
+- **DTS generation** — `generateDts` / `absToTSType` for producing `.d.ts` output from Abs
+- **Schema projection** — `absToSchemaSource` / `projectAbsToSchema` produce dialect schema source
 - **Guard generation** — `generateGuardFunction` produces zero-dependency runtime type guards
 
 ## Install

package/dist/analysis-CSXrOVlg.d.ts

@@ -0,0 +1,267 @@
+import { A as AnalyzeLoadModule, D as DirectiveCaseMode, a as AnalysisResult } from './analyzer-types-JyJiCt8w.js';
+import { C as CallRecord } from './call-record-CkyCFkT9.js';
+import { Abs, AbsModuleExports, BCallRecord, Phi, TranspiledCallResult } from '@nudojs/core';
+import { Node } from '@babel/types';
+import { BMemberDiag } from '@nudojs/core/internal';
+import { D as DiagnosticsLevel, A as AnalysisConfig } from './config-DDB588oA.js';
+
+/** mtime 边缓存：key 为文件路径，edges 为已抽取的相对 import 边（与 buildModuleGraph 返回语义一致）。 */
+type ModuleGraphCache = Map<string, {
+    mtimeMs: number;
+    size: number;
+    edges: string[];
+}>;
+/** Statically extract each file's relative import edges (extension resolution identical to CLI resolveModule: ''/'.js'/'.ts'/'.mjs'; bare npm specifiers skipped). */
+declare function buildModuleGraph(files: string[], cache?: ModuleGraphCache): {
+    imports: Map<string, Set<string>>;
+    dependents: Map<string, Set<string>>;
+};
+/** changed plus its transitive dependents (reverse-edge BFS); cycle-safe via visited. */
+declare function computeDirtySet(dependents: Map<string, Set<string>>, changedFile: string): string[];
+/** Topological order with dependencies before dependents (only imports edges internal to dirty; cycles tolerated — remaining files appended in arbitrary order). */
+declare function topoSortDirty(imports: Map<string, Set<string>>, dirty: string[]): string[];
+
+/**
+ * 调用点发现（阶段一）：在"使用现场"文件（测试 / 上层应用）中求值
+ * 顶层代码，收集它对（外部模块导出的）函数的调用记录。每条记录带
+ * 真实的实参类型与结果类型——后续 analyzeFile 将其注入合成 case，
+ * 使被使用方从 entry-only（参数全 unknown）升级为真实调用形态。
+ *
+ * Abs 路径（TypeValue evaluateProgram 已删）：evalAbsModuleGraph + AbsCallRecord。
+ * 只做求值与记录，不产出诊断；求值异常不抛出（使用现场文件可能
+ * 依赖未 mock 的全局，收集不到就收集不到，不能拖垮主分析）。
+ */
+declare function collectCallRecords(filePath: string, source: string): CallRecord[];
+
+/**
+ * Async entry to analyzeFile: preloads path-based env files
+ * (`/// @nudo:env ./nudo-harvest-node.ts`) via dynamic import — impossible
+ * synchronously in ESM — then runs the sync analysis, which picks the
+ * preloaded factories up from the env-loader cache.
+ * `loadModule` is optional; when provided it is used for relative imports /
+ * sidecar ambient bindings (LSP buffer-aware path). Default remains
+ * `defaultLoadModule` (disk).
+ */
+declare function analyzeFileAsync(filePath: string, source: string, activeCases?: Map<string, number>, externalCallRecords?: CallRecord[], loadModule?: AnalyzeLoadModule, 
+/** 默认 all（库/测试兼容）；check/IDE 宿主应传 none（惰性 case） */
+caseMode?: DirectiveCaseMode): Promise<AnalysisResult>;
+/**
+ * 整文件分析。同 (path, source, cases, external) 命中 memo → O(1)。
+ * 不再每次 clearBPathCache：B 路径按本文件 source 键控。
+ *
+ * `loadModule`：可选；提供时用于相对 import / 侧车 ambient（LSP
+ * buffer-aware）。未提供时走 defaultLoadModule（磁盘）。
+ *
+ * 宿主契约：入口 source 未变但依赖模块内容变了时，必须调用
+ * `evictBPathCacheForFiles` / `evictAnalysisFileCacheForFiles` /
+ * `evictFnAnalysisCacheForFiles`（LSP 已接好）。非 LSP 宿主
+ * （CLI watch / vite-plugin）在 dep 变更时应 `clearBPathCache()` 或上述逐出。
+ */
+declare function analyzeFile(filePath: string, source: string, activeCases?: Map<string, number>, externalCallRecords?: CallRecord[], loadModule?: AnalyzeLoadModule, caseMode?: DirectiveCaseMode): AnalysisResult;
+
+/**
+ * Host：import 图（相对 + 裸包 harvest）→ Abs 导出表 → 注入入口。
+ * 读 fs / 解析路径 / harvest 在这里；core 只收 modules 表。
+ */
+
+type AbsLoadModule = (spec: string, fromFile: string) => string | undefined;
+/** 相对说明符 → 源码 */
+declare function defaultAbsLoadModule(spec: string, fromFile: string): string | undefined;
+/** 模块加载守卫：与 TypeValue loadModuleEnv 口径对齐，供 analyzer 映射诊断 */
+type AbsModuleLoadIssue = {
+    kind: "cycle" | "depth" | "missing";
+    /** 诊断定位用标签（文件 basename 或 require/import 说明符） */
+    label: string;
+    reason: string;
+};
+type AbsModuleGraphResult = {
+    /** 入口 import 说明符 → 依赖导出表 */
+    modules: Record<string, AbsModuleExports>;
+    /** 绝对路径 → 导出表（含依赖；循环时占位为空） */
+    byPath: Map<string, AbsModuleExports>;
+    /** cycle / depth / missing（B 路径权威，避免 TypeValue 叠报） */
+    issues: AbsModuleLoadIssue[];
+};
+type AbsGraphOptions = {
+    loadModule?: AbsLoadModule;
+    seedVars?: Record<string, Abs>;
+    seedFns?: Record<string, {
+        params: string[];
+        body: Node;
+        async?: boolean;
+    }>;
+    maxDepth?: number;
+};
+/** 会话级依赖模块缓存条目：stat 指纹 + 导出 + 子树装载 issue。 */
+type AbsModuleCacheEntry = {
+    mtimeMs: number;
+    size: number;
+    exports: AbsModuleExports;
+    /** 该模块子树首次求值时记录的 cycle/depth/missing；命中时重放。 */
+    issues: AbsModuleLoadIssue[];
+};
+/** 测试/诊断：当前条目数（≤ ABS_MODULE_CACHE_MAX） */
+declare function getAbsModuleCacheSize(): number;
+declare function clearAbsModuleCache(): void;
+declare function evictAbsModuleCacheFiles(paths: string[]): void;
+/**
+ * 递归求值相对依赖 + 裸包 harvest，产出入口可用的 modules 表。
+ * 循环依赖：先放空表再回填（与 TypeValue 路径 partial 口径一致），
+ * 并记录 cycle/depth/missing 供诊断。
+ */
+declare function evalAbsModuleGraph(entrySource: string, entryFile: string, opts?: AbsGraphOptions): AbsModuleGraphResult;
+/**
+ * 收集顶层绑定名 → Abs（含相对 import / 裸包 harvest 注入）。
+ * 供 bindings / hover 从 Abs 投影，不必走 TypeValue evaluator。
+ *
+ * B-path fail-closed：绑定 = B run 绑定表（$recordBinding：顶层 const/let，
+ * arrow/function 表达式经 $fnVal 已是 Abs fn）+ 导出表桥接（export
+ * function/const）+ import 本地名（模块图解析）；B 失败 → 空 Map
+ * （显式无信息，不回落解释求值）。
+ */
+declare function collectAbsBindingsFromGraph(source: string, filePath: string, opts?: AbsGraphOptions): Map<string, Abs>;
+
+/** @nudo:env → Abs 全局表（env 模块 Abs 原生） */
+declare function collectEnvGlobals(envNames: string[]): Record<string, Abs>;
+/** @nudo:env modules（path / node:path / fs…）→ AbsModuleExports */
+declare function collectEnvModules(envNames: string[]): Record<string, AbsModuleExports>;
+/** Conflict when handwritten env overwrote a harvest module/export (B8). */
+type EnvHarvestConflict = {
+    module: string;
+    /** export names where env replaced a harvest binding (empty + defaulted = default only) */
+    exports: string[];
+    defaultOverwritten: boolean;
+};
+/**
+ * Install conflict collector; returns the previous one so nested/concurrent
+ * analyzeFile callers can save/restore (module-global is not re-entrant).
+ */
+declare function setEnvHarvestConflictCollector(collector: ((c: EnvHarvestConflict) => void) | null): ((c: EnvHarvestConflict) => void) | null;
+/** Read-only peek for tests / nested restore. */
+declare function getEnvHarvestConflictCollector(): ((c: EnvHarvestConflict) => void) | null;
+type MergeHarvestOptions = {
+    /**
+     * Per-call conflict sink. Takes precedence over the module-global collector
+     * installed via `setEnvHarvestConflictCollector`.
+     */
+    onConflict?: (c: EnvHarvestConflict) => void;
+};
+/**
+ * Handwritten `@nudojs/env` wins over harvest / graph modules on overlapping
+ * module keys and overlapping export names (docs/versioning.md B8 + website
+ * harvester API). Harvest-only modules/exports are kept as fill-in.
+ * Overwrites notify `opts.onConflict` or the global collector.
+ */
+declare function mergeHarvestUnderEnv(harvestModules: Record<string, AbsModuleExports>, envModules: Record<string, AbsModuleExports>, opts?: MergeHarvestOptions): Record<string, AbsModuleExports>;
+/** 收集 @nudo:replace + @nudo:as → transpile 注入表 */
+declare function collectBPathReplacements(source: string): {
+    targets: Array<{
+        target: string;
+        varName: string;
+        stmtStart?: number;
+        stmtEnd?: number;
+    }>;
+    values: Record<string, Abs>;
+    asTargets: Array<{
+        varName: string;
+        stmtStart: number;
+        stmtEnd: number;
+    }>;
+    asValues: Record<string, Abs>;
+};
+/**
+ * 可走 transpile+exec 的快速预判（env 经 loadEnvs 内置 + 已 preload 的路径型）。
+ * 注意：正确性不依赖本函数——未 lowering 的构造在转译点 fail-closed
+ * （unknown / 空导出），tryRunTranspiled 捕获后记录；本函数仅是廉价前置闸。
+ * 顶层 this 已按 ESM 托管，不再关 B 路径。
+ */
+declare function isBPathCapable(source: string, envNames?: string[]): boolean;
+type BPathRunResult = {
+    exports: Record<string, unknown>;
+    modules: Record<string, AbsModuleExports>;
+    /** 顶层执行期 method-missing */
+    memberDiags?: BMemberDiag[];
+    /** 模块图 cycle/depth/missing（B 权威） */
+    moduleIssues?: AbsModuleLoadIssue[];
+    /** Abs 求值递归截断的函数标签 */
+    truncatedFns?: string[];
+    /** 顶层 $callNamed 调用点（call@ 合成；不经 TypeValue collector） */
+    calls?: BCallRecord[];
+};
+declare function clearBPathCache(): void;
+/** 测试/诊断：当前 B-path run 缓存条目数（≤ getSessionCacheLimits().maxBRuns） */
+declare function getBPathCacheSize(): number;
+/** 依赖文件变更后：逐出以这些文件为入口的 B-path 缓存 */
+declare function evictBPathCacheForFiles(files: string[]): number;
+/** 立刻压到当前 maxBRuns（调低上限时收内存） */
+declare function trimBPathCache(): void;
+/** 模块图 + runTranspiled（默认 analyze 模式） */
+declare function tryRunBPath(source: string, filePath: string, opts?: {
+    maxLoopIters?: number;
+    mode?: "exec" | "analyze";
+    envNames?: string[];
+    /** @nudo:mock → Abs，注入为全局绑定（防止顶层调用真 fetch 等） */
+    mocks?: Record<string, Abs>;
+    /** 宽松全局（调用点发现 exec 采集） */
+    lenientGlobals?: boolean;
+}): BPathRunResult | undefined;
+/**
+ * B 路径求值具名导出（结果 + throws）；opts.collectCalls 时附带调用点记录。
+ *
+ * `calls` 只含**本次具名调用期间**（callTranspiledExportFull 内）发生的
+ * 调用点——不含模块级顶层调用（run.calls）。模块级记录由主分析流程
+ * 另行收集（analyzer 的 bTopCallRecords / absCallRecords）；在此重复返回
+ * 会把 B 路径结果（常为 unknown）当第二组记录推给 analyzer，dedupe 因
+ * 结果形态不同而保留，污染被调函数的 case 列表（多余 call@L 重复 +
+ * call@symbolic 聚合 case，见 analyzer directive-case 分支）。
+ */
+declare function tryBPathCallFull(source: string, filePath: string, fnName: string, args: Abs[], opts?: {
+    collectCalls?: boolean;
+    collectMemberDiags?: boolean;
+    envNames?: string[];
+    mocks?: Record<string, Abs>;
+    /** 入口 Φ 种子（assume 约束——B 侧路径条件收窄） */
+    phi?: Phi;
+}): (TranspiledCallResult & {
+    calls?: BCallRecord[];
+    memberDiags?: BMemberDiag[];
+    moduleIssues?: AbsModuleLoadIssue[];
+    truncatedFns?: string[];
+}) | undefined;
+/** B 路径求值具名导出（仅成功结果） */
+declare function tryBPathCall(source: string, filePath: string, fnName: string, args: Abs[], opts?: {
+    envNames?: string[];
+    mocks?: Record<string, Abs>;
+    phi?: Phi;
+}): Abs | undefined;
+
+/**
+ * 分析范围判定（design-cli-semantics.md §7）。
+ * CLI 显式路径不受 mode 限制；本模块供 LSP/watch 自动验证使用。
+ */
+
+/**
+ * 按 analysis.diagnostics 档过滤 evaluator/check **显示路径**诊断。
+ * - off：显示层全静音（与 errors 档区分）。check 门禁（CLI `nudo check` /
+ *   checkSource）独立于本过滤，不受 off 影响。
+ * - errors：只发 severity=error
+ * - default：error + warning（静音 NOISY_WARNING_CODES）
+ * - verbose：全量
+ */
+declare function filterDiagnosticsByLevel<T extends {
+    severity: string;
+    code?: string;
+}>(diags: T[], level: DiagnosticsLevel): T[];
+declare function diagnosticsLevelForFile(filePath: string): DiagnosticsLevel;
+declare function hasNudoDirectives(source: string): boolean;
+/**
+ * 是否应对该文件跑分析（自动路径，如 LSP validate）。
+ * - 非 target 路径 → false
+ * - exclude 命中 / include 未命中 → false
+ * - mode=directives → 仅有指令
+ * - mode=exports → 指令 | export | 同名侧车
+ * - mode=all → true
+ */
+declare function shouldAnalyzeFile(filePath: string, source: string | undefined, config?: AnalysisConfig): boolean;
+
+export { type AbsGraphOptions as A, type BPathRunResult as B, setEnvHarvestConflictCollector as C, shouldAnalyzeFile as D, type EnvHarvestConflict as E, hasNudoDirectives as F, topoSortDirty as G, trimBPathCache as H, tryBPathCall as I, tryBPathCallFull as J, tryRunBPath as K, type MergeHarvestOptions as M, type AbsModuleCacheEntry as a, type AbsModuleGraphResult as b, type AbsModuleLoadIssue as c, type ModuleGraphCache as d, analyzeFile as e, analyzeFileAsync as f, buildModuleGraph as g, clearAbsModuleCache as h, clearBPathCache as i, collectAbsBindingsFromGraph as j, collectBPathReplacements as k, collectCallRecords as l, collectEnvGlobals as m, collectEnvModules as n, computeDirtySet as o, defaultAbsLoadModule as p, diagnosticsLevelForFile as q, evalAbsModuleGraph as r, evictAbsModuleCacheFiles as s, evictBPathCacheForFiles as t, filterDiagnosticsByLevel as u, getAbsModuleCacheSize as v, getBPathCacheSize as w, getEnvHarvestConflictCollector as x, isBPathCapable as y, mergeHarvestUnderEnv as z };

package/dist/analysis.d.ts

@@ -0,0 +1,7 @@
+export { a as AnalysisResult, B as BindingInfo, C as CaseHint, b as CaseResult, c as CompletionItem, d as Diagnostic, e as DiagnosticSeverity, f as DiagnosticTag, D as DirectiveCaseMode, F as FunctionAnalysis, R as ReferenceInfo, S as SourceLocation, g as SymbolInfo, h as SymbolTable } from './analyzer-types-JyJiCt8w.js';
+export { A as AbsGraphOptions, a as AbsModuleCacheEntry, b as AbsModuleGraphResult, c as AbsModuleLoadIssue, B as BPathRunResult, d as ModuleGraphCache, e as analyzeFile, f as analyzeFileAsync, g as buildModuleGraph, h as clearAbsModuleCache, i as clearBPathCache, j as collectAbsBindingsFromGraph, l as collectCallRecords, o as computeDirtySet, p as defaultAbsLoadModule, q as diagnosticsLevelForFile, r as evalAbsModuleGraph, s as evictAbsModuleCacheFiles, t as evictBPathCacheForFiles, u as filterDiagnosticsByLevel, v as getAbsModuleCacheSize, w as getBPathCacheSize, y as isBPathCapable, D as shouldAnalyzeFile, F as sourceHasNudoDirectives, G as topoSortDirty, H as trimBPathCache, I as tryBPathCall, J as tryBPathCallFull, K as tryRunBPath } from './analysis-CSXrOVlg.js';
+export { C as CallRecord } from './call-record-CkyCFkT9.js';
+import '@babel/types';
+import '@nudojs/core';
+import '@nudojs/core/internal';
+import './config-DDB588oA.js';

package/dist/analysis.js

@@ -0,0 +1,57 @@
+import {
+  diagnosticsLevelForFile,
+  filterDiagnosticsByLevel,
+  hasNudoDirectives,
+  shouldAnalyzeFile
+} from "./chunk-LFZRUXGK.js";
+import {
+  analyzeFile,
+  analyzeFileAsync,
+  buildModuleGraph,
+  clearAbsModuleCache,
+  clearBPathCache,
+  collectAbsBindingsFromGraph,
+  collectCallRecords,
+  computeDirtySet,
+  defaultAbsLoadModule,
+  evalAbsModuleGraph,
+  evictAbsModuleCacheFiles,
+  evictBPathCacheForFiles,
+  getAbsModuleCacheSize,
+  getBPathCacheSize,
+  isBPathCapable,
+  topoSortDirty,
+  trimBPathCache,
+  tryBPathCall,
+  tryBPathCallFull,
+  tryRunBPath
+} from "./chunk-QAFMPM2E.js";
+import "./chunk-U7JYTRIB.js";
+import "./chunk-YLALZXTZ.js";
+import "./chunk-PVJIMQRI.js";
+export {
+  analyzeFile,
+  analyzeFileAsync,
+  buildModuleGraph,
+  clearAbsModuleCache,
+  clearBPathCache,
+  collectAbsBindingsFromGraph,
+  collectCallRecords,
+  computeDirtySet,
+  defaultAbsLoadModule,
+  diagnosticsLevelForFile,
+  evalAbsModuleGraph,
+  evictAbsModuleCacheFiles,
+  evictBPathCacheForFiles,
+  filterDiagnosticsByLevel,
+  getAbsModuleCacheSize,
+  getBPathCacheSize,
+  isBPathCapable,
+  shouldAnalyzeFile,
+  hasNudoDirectives as sourceHasNudoDirectives,
+  topoSortDirty,
+  trimBPathCache,
+  tryBPathCall,
+  tryBPathCallFull,
+  tryRunBPath
+};

package/dist/analyzer-types-JyJiCt8w.d.ts

@@ -0,0 +1,158 @@
+import { Node } from '@babel/types';
+import { FormalParam, Abs } from '@nudojs/core';
+
+/**
+ * analyzer 共享类型（自 analyzer.ts god-file 机械拆出）。
+ * 只含类型，无运行时逻辑——供 module-load / diagnose / cache / orchestrate 共用。
+ */
+
+type SourceLocation = {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+};
+type DiagnosticSeverity = "error" | "warning" | "info";
+type DiagnosticTag = "unnecessary";
+type Diagnostic = {
+    range: SourceLocation;
+    severity: DiagnosticSeverity;
+    message: string;
+    tags?: DiagnosticTag[];
+    code?: string;
+    suggestions?: string[];
+    data?: unknown;
+    /** provenance of the receiver value (callsite argument that flowed into the error) */
+    origin?: {
+        line: number;
+        column: number;
+    };
+};
+type CaseResult = {
+    name: string;
+    /** 无损参数 Abs */
+    argAbs: Abs[];
+    /** 无损结果 Abs */
+    abs: Abs;
+    /** 无损抛出 Abs（未抛为 never） */
+    throwsAbs: Abs;
+    throwLoc?: SourceLocation;
+    source?: "directive" | "callsite";
+    /** `@nudo:case "name" (…) => expected` — presence means the case is a test assertion */
+    expected?: Abs;
+    /** number of additional call sites folded into a symbolic case */
+    aggregatedFrom?: number;
+    /**
+     * 内涵摘要（代数 generalize）：无损 Abs + term/pred/conf。
+     */
+    intension?: {
+        display?: string;
+        term?: string;
+        pred?: string;
+        conf?: string;
+        /** 无损 Abs 单行（formatAbs） */
+        abs?: string;
+        /** 无损 Abs 多行（formatAbsMultiline） */
+        absMultiline?: string;
+    };
+};
+type FunctionAnalysis = {
+    name: string;
+    loc: SourceLocation;
+    paramNames: string[];
+    /** C4.1 形参表面：draft/契约对齐（解构 placeholder + bound 名） */
+    formals?: FormalParam[];
+    cases: CaseResult[];
+    /** cases 结果 Abs 的 join；dts 返回位源 */
+    combinedAbs?: Abs;
+    entryOnly?: boolean;
+    skipped?: boolean;
+    /**
+     * True for functions collected from CJS-style bindings/assignments
+     * (`exports.X = fn`, `module.exports = fn`, `const f = fn`): their name has
+     * no declaration-level stability, so .d.ts generation skips them while
+     * infer/JSON output still reports them.
+     */
+    noDeclaration?: boolean;
+    /** absolute path of the module this function is imported from (externalFunctions only) */
+    fromModule?: string;
+    /**
+     * HOF / entry shape 关系快照（generalizeFromAst），供 dts 泛型投影（C3.3）。
+     * 只存投影所需的 Abs，不挂 PolyFn 本体（缓存可克隆）。
+     */
+    hof?: {
+        /** 函数形参：外延关系 Abs（fn 形状，paramTypes/returnType） */
+        fnRels?: Array<{
+            param: string;
+            abs: Abs;
+        }>;
+        /** 值形参提升快照（如 items → arr(A1)） */
+        entryShapes?: Array<{
+            param: string;
+            abs: Abs;
+        }>;
+        /** 符号返回 Abs（含自由 α / B:param） */
+        symbolic?: Abs;
+    };
+};
+type BindingInfo = {
+    /** 无损 Abs */
+    abs: Abs;
+    loc?: SourceLocation;
+};
+type CaseHint = {
+    line: number;
+    label: string;
+    ok: boolean;
+};
+type AnalysisResult = {
+    functions: FunctionAnalysis[];
+    diagnostics: Diagnostic[];
+    bindings: Map<string, BindingInfo>;
+    /**
+     * Node identity is from the analysis-time parse. A later re-parse of the
+     * same source returns a *different* File (new Nodes) if the AST LRU evicted
+     * the original — lookups must use the File that produced this result, not a
+     * freshly parsed one. getTypeAtPosition rebuilds its own map and is unaffected.
+     */
+    /** 无损节点 Abs */
+    nodeAbsMap: Map<Node, Abs>;
+    caseHints: CaseHint[];
+    /** functions imported from other modules, synthesized from cross-file call sites observed while analyzing this file */
+    externalFunctions?: FunctionAnalysis[];
+};
+type CompletionItem = {
+    label: string;
+    kind: "property" | "method" | "variable";
+    detail?: string;
+};
+type SymbolInfo = {
+    name: string;
+    kind: "function" | "variable" | "class" | "parameter";
+    loc: SourceLocation;
+    uri?: string;
+};
+type ReferenceInfo = {
+    name: string;
+    loc: SourceLocation;
+    uri?: string;
+};
+type SymbolTable = {
+    definitions: Map<string, SymbolInfo>;
+    references: ReferenceInfo[];
+};
+/** Optional module loader for analysis (sidecar / relative imports). */
+type AnalyzeLoadModule = (spec: string, fromFile: string) => string | undefined;
+/**
+ * `@nudo:case` 求值档：
+ * - `none`（默认）：不跑 case；有 case 的函数也走 entry@ 出签名（check / IDE）
+ * - `all`：逐 case 真跑（`nudo test` / CaseJson / freeze）
+ * - `selected`：只跑 `activeCases` 选中的那条（LSP selectCase）
+ */
+type DirectiveCaseMode = "none" | "all" | "selected";
+
+export type { AnalyzeLoadModule as A, BindingInfo as B, CaseHint as C, DirectiveCaseMode as D, FunctionAnalysis as F, ReferenceInfo as R, SourceLocation as S, AnalysisResult as a, CaseResult as b, CompletionItem as c, Diagnostic as d, DiagnosticSeverity as e, DiagnosticTag as f, SymbolInfo as g, SymbolTable as h };

package/dist/call-record-CkyCFkT9.d.ts

@@ -0,0 +1,33 @@
+import { Abs } from '@nudojs/core';
+
+/**
+ * 调用点记录（CallRecord）。Abs 唯一真理源。
+ * argAbs/resultAbs/throwsAbs 必填；展示/外延在 CaseResult 边界再桥。
+ */
+
+type CallRecord = {
+    fnName: string;
+    /** 无损参数 Abs */
+    argAbs: Abs[];
+    /** 无损结果 Abs（threw 时为 never） */
+    resultAbs: Abs;
+    /** 无损抛出值 Abs（未抛为 never） */
+    throwsAbs: Abs;
+    /** Line-relative. Per-fn cache replay shifts this by lineDelta — if you
+     *  add another position field (callee loc, arg loc), extend
+     *  shiftCallRecordLines in analyzer.ts in the same change. */
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    targetModule?: string;
+    targetExport?: string;
+    /** export names the same function value was re-exported under after its
+     * defining module (barrel `index.js`, CJS forwarding shims); usage-site
+     * records stay name-matchable against them */
+    targetAliases?: string[];
+    /** module whose evaluation created the function value (definition site). */
+    fnModule?: string;
+};
+
+export type { CallRecord as C };