@nudojs/service 5.0.0-beta.0 → 5.0.0-beta.1

package/dist/evaluator/evaluator-api.d.ts

@@ -1,7 +1,7 @@
 export { C as CallRecord } from '../call-record-CkyCFkT9.js';
 import { Abs } from '@nudojs/core';
 export { L as LoadedEnv, l as loadEnvs, a as loadEnvsAsync, p as preloadPathEnvs } from '../env-loader-fj0TSCcA.js';
-export { A as AnalysisConfig, a as AnalysisMode, C as CheckConfig, D as DiagnosticsLevel, I as InterfaceConfig, N as NudoConfig, b as analysisConfig, c as checkConfig, d as diskCacheRoot, f as findProjectConfig, i as interfaceConfig } from '../config-DDB588oA.js';
+export { A as AnalysisConfig, a as AnalysisMode, C as CheckConfig, D as DiagnosticsLevel, I as InterfaceConfig, N as NudoConfig, b as analysisConfig, c as checkConfig, d as diskCacheRoot, f as findProjectConfig, i as interfaceConfig, m as matchesEmitAllowlist } from '../config-DDB588oA.js';
 
 /**
  * 内置类原型成员近似表（Abs 声明）。

package/dist/evaluator/evaluator-api.js

@@ -8,13 +8,12 @@ import {
   diskCacheRoot,
   findProjectConfig,
   interfaceConfig,
-  resolveNpmNudo
-} from "../chunk-YLALZXTZ.js";
-import {
   loadEnvs,
   loadEnvsAsync,
-  preloadPathEnvs
-} from "../chunk-PVJIMQRI.js";
+  matchesEmitAllowlist,
+  preloadPathEnvs,
+  resolveNpmNudo
+} from "../chunk-ZXVAX7DE.js";
 export {
   BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
   analysisConfig,
@@ -27,6 +26,7 @@ export {
   interfaceConfig,
   loadEnvs,
   loadEnvsAsync,
+  matchesEmitAllowlist,
   preloadPathEnvs,
   resolveNpmNudo
 };

package/dist/index.d.ts

@@ -1,21 +1,16 @@
-import { A as AnalyzeLoadModule, D as DirectiveCaseMode, a as AnalysisResult } from './analyzer-types-JyJiCt8w.js';
-export { B as BindingInfo, C as CaseHint, b as CaseResult, c as CompletionItem, d as Diagnostic, e as DiagnosticSeverity, f as DiagnosticTag, 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, E as EnvHarvestConflict, M as MergeHarvestOptions, d as ModuleGraphCache, e as analyzeFile, f as analyzeFileAsync, g as buildModuleGraph, h as clearAbsModuleCache, i as clearBPathCache, j as collectAbsBindingsFromGraph, k as collectBPathReplacements, l as collectCallRecords, m as collectEnvGlobals, n as collectEnvModules, 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, x as getEnvHarvestConflictCollector, y as isBPathCapable, z as mergeHarvestUnderEnv, C as setEnvHarvestConflictCollector, 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';
+import { a as AnalyzeLoadModule, D as DirectiveCaseMode, A as AnalysisResult } from './analyzer-types-CfBrPK9L.js';
+export { B as BindingInfo, C as CaseHint, b as CaseResult, c as CompletionItem, d as Diagnostic, e as DiagnosticSeverity, f as DiagnosticTag, F as FunctionAnalysis, R as ReferenceInfo, S as SourceLocation, g as SymbolInfo, h as SymbolTable } from './analyzer-types-CfBrPK9L.js';
+export { A as AbsGraphOptions, a as AbsModuleCacheEntry, b as AbsModuleGraphResult, c as AbsModuleLoadIssue, B as BPathRunResult, E as EnvHarvestConflict, M as MergeHarvestOptions, d as ModuleGraphCache, e as analyzeFile, f as analyzeFileAsync, g as buildModuleGraph, h as clearAbsModuleCache, i as clearBPathCache, j as collectAbsBindingsFromGraph, k as collectBPathReplacements, l as collectCallRecords, m as collectEnvGlobals, n as collectEnvModules, o as collectEnvNames, p as computeDirtySet, q as defaultAbsLoadModule, r as diagnosticsLevelForFile, s as evalAbsModuleGraph, t as evictAbsModuleCacheFiles, u as evictBPathCacheForFiles, v as filterDiagnosticsByLevel, w as getAbsModuleCacheSize, x as getBPathCacheSize, y as getEnvHarvestConflictCollector, z as isBPathCapable, C as locFromNode, D as mergeHarvestUnderEnv, F as resolveModule, G as setEnvHarvestConflictCollector, H as shouldAnalyzeFile, I as sourceHasNudoDirectives, J as topoSortDirty, K as trimBPathCache, L as tryBPathCall, N as tryBPathCallFull, O as tryRunBPath } from './analysis-_DlXLC-L.js';
 import { C as CallRecord } from './call-record-CkyCFkT9.js';
 export { c as clearPathEnvCaches, g as getPathEnvCacheSizes } from './env-loader-fj0TSCcA.js';
 import { N as NudoConfig } from './config-DDB588oA.js';
 export { A as AnalysisConfig, a as AnalysisMode, C as CheckConfig, e as DEFAULT_ANALYSIS_MODE, D as DiagnosticsLevel, I as InterfaceConfig, b as analysisConfig, g as applyBForkBudgetFromConfig, c as checkConfig, h as currentBForkBudgetLimit, d as diskCacheRoot, f as findProjectConfig, i as interfaceConfig, m as matchesEmitAllowlist } from './config-DDB588oA.js';
 import { File, Node } from '@babel/types';
 import { PolyFn, Abs, AbsModuleExports } from '@nudojs/core';
-import { L as LoadModule } from './interface-BGlP7aIk.js';
-export { C as ConstraintSourceExpr, D as DerivedExport, a as DerivedParam, b as DraftEvidence, E as EmitDerivedResult, c as EmitInterfaceOpts, d as EmitInterfaceResult, e as EmitInterfaceSkipReason, I as InterfaceDraftEntry, f as InterfaceDraftOpts, g as InterfaceDraftResult, h as InterfaceSurfaceEntry, i as InterfaceSurfaceOpts, R as RootDeriveOpts, j as RootDeriveResult, T as TypeBinding, W as WriteDraftResult, k as collectParamBodyAccesses, l as defaultLoadModule, m as deriveFromRoot, n as draftInterface, o as emitDerivedFromRoot, p as emitInterface, q as extractFnConstraintSources, r as formatDerivedSection, s as formatDraftModule, t as formatDraftSummary, u as formatEmitSummary, v as formatInterfaceSurfaceLine, w as injectBindings, x as interfaceSurface, y as isDraftableEntry, z as sidecarDraftPath, A as typeExprToDirective, B as writeInterfaceDraft } from './interface-BGlP7aIk.js';
+import { L as LoadModule } from './what-if-mIo7I5Ii.js';
+export { T as TypeBinding, d as defaultLoadModule, i as injectBindings, t as typeExprToDirective } from './what-if-mIo7I5Ii.js';
 import { FunctionWithDirectives, FileDirective } from '@nudojs/parser';
-export { SchemaDialect, SchemaNode, SchemaProjection, SchemaRefinement, StandardSchemaIssue, StandardSchemaModuleProjection, StandardSchemaResult, absToSchemaNode, absToSchemaSource, absToStandardSchema, absToStandardSchemaModule, absToTSType, constraintToSchemaNode, generateDts, generateFunctionDtsLines, generateGuardFunction, generateGuardFunctionFromAbs, projectAbsToSchema, schemaNodeToZod, validateSchemaNode } from './dts.js';
-export { CaseJson, CaseJsonCase, CaseJsonFunction, EmitResult, EmitSkipReason, buildCaseDirective, insertGeneratedCaseDirectives, serializeCaseArg, serializeCaseJson, stripGeneratedCaseDirectives, unifiedDiff } from './case.js';
-export { BuildSemanticTokensOpts, CaseInfo, HoverInfo, SEMANTIC_TOKEN_MODIFIERS, SEMANTIC_TOKEN_TYPES, SemanticToken, buildSemanticTokens, encodeSemanticTokens, getAbsAtPosition, getAbsAtPositionAsync, getCasesForFile, getCompletionsAtPosition, getHoverAtPosition, getTypeAtPosition, getTypeAtPositionAsync, interfaceTierModifierBit } from './lsp.js';
-export { AbsInlay, BMemberDiag, collectAbsInlays } from '@nudojs/core/internal';
-export { HARVEST_NODE_DEFAULT_MAX_FILES, HARVEST_NODE_DEFAULT_MAX_MS, HarvestJson, HarvestNodeStats, HarvestSig, NodeEnvResult, PackageHarvest, absToHarvestSig, autoHarvestModules, barePackageName, bareSpecToAbsModules, clearHarvestCache, clearNodeHarvestCache, collectBarePackages, collectDtsFromEntry, depsCacheRoot, dtsClosureHash, formatHarvestSummary, getHarvestCacheSize, getNodeHarvestCacheSize, handwrittenNodeEnv, harvestCacheKey, harvestNodeTypes, harvestPackage, harvestPackageCached, harvestPackageWithDisk, harvestSigToAbs, harvestToAbsModules, harvestedValueToAbs, isHarvestNodeDisabled, loadHarvestEnvFromDisk, lookupHarvested, materializeHarvestJson, packageHarvestToAbsModules, readHarvestDisk, resolvePackageRoot, serializeHarvestJson, summarizeNodeEnv, writeHarvestDisk } from './harvest.js';
-import '@nudojs/harvester';
+import '@nudojs/core/internal';
 
 declare function analysisFileCacheKey(filePath: string, source: string, activeCases?: Map<string, number>, externalCallRecords?: CallRecord[], analysisCfg?: {
     mode: string;
@@ -76,7 +71,10 @@ declare function analyzeExportsFromSource(filePath: string, source: string): Mod
 declare function collectStaticImports(entryFile: string, maxDepth?: number): Map<string, ModuleExports>;
 
 /**
- * Dual-entry (browser / node) observation signal.
+ * Entry-variant (browser / node) observation signal.
+ *
+ * (Module named entry-variants to avoid "dual engine" confusion; the
+ * product diagnostic code remains `nudo:dual-entry`.)
  *
  * Call-site records are file-scoped: when a package ships separate browser and
  * node entrypoints, records collected against one variant do **not** inject
@@ -90,7 +88,7 @@ declare function collectStaticImports(entryFile: string, maxDepth?: number): Map
  * being analyzed is one of those entry targets. Single-entry packages never
  * fire.
  */
-type DualEntryInfo = {
+type EntryVariantInfo = {
     pkgPath: string;
     pkgDir: string;
     pkgName?: string;
@@ -105,7 +103,7 @@ type DualEntryInfo = {
     browserTargets: string[];
     nodeTargets: string[];
 };
-type DualFaces = {
+type EntryVariantFaces = {
     kind: "exports-conditions" | "browser-field";
     browser: string[];
     node: string[];
@@ -114,7 +112,7 @@ type DualFaces = {
  * Detect browser/node dual faces in a parsed package.json.
  * Returns null unless both faces exist and differ (zero-FP on single-entry).
  */
-declare function detectDualEntryFromPackageJson(pkg: unknown): DualFaces | null;
+declare function detectEntryVariantsFromPackageJson(pkg: unknown): EntryVariantFaces | null;
 /** Nearest package.json walking up from the file's directory. */
 declare function findOwningPackage(fromFile: string): {
     path: string;
@@ -126,9 +124,9 @@ declare function findOwningPackage(fromFile: string): {
  * differing faces **and** this file must be one of the entry targets.
  * Returns null otherwise (single-entry packages, shared helpers, …).
  */
-declare function dualEntryForFile(filePath: string): DualEntryInfo | null;
+declare function entryVariantForFile(filePath: string): EntryVariantInfo | null;
 /** Host-facing info issue (CLI check / JSON) for one analyzed entry variant. */
-type DualEntryIssue = {
+type EntryVariantIssue = {
     severity: "info";
     code: "nudo:dual-entry";
     message: string;
@@ -136,7 +134,7 @@ type DualEntryIssue = {
     line: number;
     column: number;
 };
-declare function dualEntryIssueForFile(filePath: string): DualEntryIssue | null;
+declare function entryVariantIssueForFile(filePath: string): EntryVariantIssue | null;
 
 /**
  * `@nudo:skip [returnsExpr]` 采集（host 侧）。
@@ -484,4 +482,4 @@ declare function clearEnvPathDeps(): void;
 /** watch 门禁：env 模板变更必须可被接收（即便扩展名不进 isNudoTargetPath） */
 declare function isEnvTemplatePath(path: string): boolean;
 
-export { ANALYSIS_ABI, type AbsMockSeeds, AnalysisResult, type AnalysisSession, type BPathBuiltinUnknown, type BPathDiagnostics, type BPathUnreachable, CallRecord, DEFAULT_SESSION_CACHE_LIMITS, type DepContent, DirectiveCaseMode, DiskCache, type DiskCacheOptions, type DualEntryInfo, type DualEntryIssue, LoadModule, type MockModuleApplyResult, type ModuleExports, NudoConfig, type SessionCacheLimits, ambientSourcesOfSidecar, analysisFileCacheKey, analyzeExportsFromSource, applyMockModuleDirectives, applyMockModuleDirectivesFromSource, applySessionCacheConfig, checkCacheKey, clearAnalysisFileCache, clearAnalysisSessionCaches, clearEnvPathDeps, clearFnAnalysisCache, collectBPathDiagnostics, collectDependencySpecs, collectLoadDepContents, collectSkipReturns, collectStaticImports, detectDualEntryFromPackageJson, dualEntryForFile, dualEntryIssueForFile, envPathDependents, evictAnalysisCachesForFiles, evictAnalysisFileCacheForFiles, evictFnAnalysisCacheForFiles, extractNudoImportSpecs, findOwningPackage, getAnalysisFileCacheSize, getAnalysisSession, getEnvPathDepsSize, getFnAnalysisCacheSize, getSessionCacheLimits, ifaceCacheKey, isEnvTemplatePath, isNudoTargetPath, isProjectConfigPath, isSidecarPath, isWatchRelevantPath, mockDirectivesToAbsSeeds, mockSeedsForSource, mockSeedsToAbsMocks, noteEnvPathDeps, relativizePath, resetAllAnalysisCaches, resetSessionCacheLimitState, setAnalysisSession, setSessionCacheFromProject, setSessionCacheLimits, sha256Hex, trimAnalysisFileCache, trimFnAnalysisCache };
+export { ANALYSIS_ABI, type AbsMockSeeds, AnalysisResult, type AnalysisSession, type BPathBuiltinUnknown, type BPathDiagnostics, type BPathUnreachable, CallRecord, DEFAULT_SESSION_CACHE_LIMITS, type DepContent, DirectiveCaseMode, DiskCache, type DiskCacheOptions, type EntryVariantInfo, type EntryVariantIssue, LoadModule, type MockModuleApplyResult, type ModuleExports, NudoConfig, type SessionCacheLimits, ambientSourcesOfSidecar, analysisFileCacheKey, analyzeExportsFromSource, applyMockModuleDirectives, applyMockModuleDirectivesFromSource, applySessionCacheConfig, checkCacheKey, clearAnalysisFileCache, clearAnalysisSessionCaches, clearEnvPathDeps, clearFnAnalysisCache, collectBPathDiagnostics, collectDependencySpecs, collectLoadDepContents, collectSkipReturns, collectStaticImports, detectEntryVariantsFromPackageJson, entryVariantForFile, entryVariantIssueForFile, envPathDependents, evictAnalysisCachesForFiles, evictAnalysisFileCacheForFiles, evictFnAnalysisCacheForFiles, extractNudoImportSpecs, findOwningPackage, getAnalysisFileCacheSize, getAnalysisSession, getEnvPathDepsSize, getFnAnalysisCacheSize, getSessionCacheLimits, ifaceCacheKey, isEnvTemplatePath, isNudoTargetPath, isProjectConfigPath, isSidecarPath, isWatchRelevantPath, mockDirectivesToAbsSeeds, mockSeedsForSource, mockSeedsToAbsMocks, noteEnvPathDeps, relativizePath, resetAllAnalysisCaches, resetSessionCacheLimitState, setAnalysisSession, setSessionCacheFromProject, setSessionCacheLimits, sha256Hex, trimAnalysisFileCache, trimFnAnalysisCache };

package/dist/index.js

@@ -4,83 +4,19 @@ import {
   hasNudoDirectives,
   isNudoTargetPath,
   shouldAnalyzeFile
-} from "./chunk-LFZRUXGK.js";
-import {
-  serializeCaseJson
-} from "./chunk-QYRH7Z2Q.js";
-import {
-  absToSchemaNode,
-  absToSchemaSource,
-  absToStandardSchema,
-  absToStandardSchemaModule,
-  absToTSType,
-  constraintToSchemaNode,
-  generateDts,
-  generateFunctionDtsLines,
-  generateGuardFunction,
-  generateGuardFunctionFromAbs,
-  projectAbsToSchema,
-  schemaNodeToZod,
-  validateSchemaNode
-} from "./chunk-6IZR4ZYJ.js";
-import {
-  HARVEST_NODE_DEFAULT_MAX_FILES,
-  HARVEST_NODE_DEFAULT_MAX_MS,
-  clearNodeHarvestCache,
-  getNodeHarvestCacheSize,
-  handwrittenNodeEnv,
-  harvestNodeTypes,
-  isHarvestNodeDisabled,
-  summarizeNodeEnv
-} from "./chunk-K3ZPOTP2.js";
+} from "./chunk-EG6FYQLI.js";
 import {
   ANALYSIS_ABI,
   DiskCache,
   checkCacheKey,
   collectLoadDepContents,
-  collectParamBodyAccesses,
-  deriveFromRoot,
-  draftInterface,
-  emitDerivedFromRoot,
-  emitInterface,
-  extractFnConstraintSources,
   extractNudoImportSpecs,
-  formatDerivedSection,
-  formatDraftModule,
-  formatDraftSummary,
-  formatEmitSummary,
-  formatInterfaceSurfaceLine,
   ifaceCacheKey,
   injectBindings,
-  interfaceSurface,
-  isDraftableEntry,
   relativizePath,
   sha256Hex,
-  sidecarDraftPath,
-  typeExprToDirective,
-  writeInterfaceDraft
-} from "./chunk-HEU4WON5.js";
-import {
-  buildCaseDirective,
-  insertGeneratedCaseDirectives,
-  serializeCaseArg,
-  stripGeneratedCaseDirectives,
-  unifiedDiff
-} from "./chunk-YLVZMHWC.js";
-import {
-  SEMANTIC_TOKEN_MODIFIERS,
-  SEMANTIC_TOKEN_TYPES,
-  buildSemanticTokens,
-  encodeSemanticTokens,
-  getAbsAtPosition,
-  getAbsAtPositionAsync,
-  getCasesForFile,
-  getCompletionsAtPosition,
-  getHoverAtPosition,
-  getTypeAtPosition,
-  getTypeAtPositionAsync,
-  interfaceTierModifierBit
-} from "./chunk-E4N4A4JV.js";
+  typeExprToDirective
+} from "./chunk-J2PUE4NV.js";
 import {
   analysisFileCacheKey,
   analyzeFile,
@@ -99,12 +35,13 @@ import {
   collectCallRecords,
   collectEnvGlobals,
   collectEnvModules,
+  collectEnvNames,
   computeDirtySet,
   defaultAbsLoadModule,
   defaultLoadModule,
-  detectDualEntryFromPackageJson,
-  dualEntryForFile,
-  dualEntryIssueForFile,
+  detectEntryVariantsFromPackageJson,
+  entryVariantForFile,
+  entryVariantIssueForFile,
   envPathDependents,
   evalAbsModuleGraph,
   evictAbsModuleCacheFiles,
@@ -120,11 +57,13 @@ import {
   getFnAnalysisCacheSize,
   isBPathCapable,
   isEnvTemplatePath,
+  locFromNode,
   mergeHarvestUnderEnv,
   mockDirectivesToAbsSeeds,
   mockSeedsForSource,
   mockSeedsToAbsMocks,
   noteEnvPathDeps,
+  resolveModule,
   setEnvHarvestConflictCollector,
   topoSortDirty,
   trimAnalysisFileCache,
@@ -133,66 +72,199 @@ import {
   tryBPathCall,
   tryBPathCallFull,
   tryRunBPath
-} from "./chunk-QAFMPM2E.js";
-import {
-  absToHarvestSig,
-  analyzeExportsFromSource,
-  autoHarvestModules,
-  barePackageName,
-  bareSpecToAbsModules,
-  clearHarvestCache,
-  collectBarePackages,
-  collectDependencySpecs,
-  collectDtsFromEntry,
-  collectStaticImports,
-  depsCacheRoot,
-  dtsClosureHash,
-  formatHarvestSummary,
-  getHarvestCacheSize,
-  harvestCacheKey,
-  harvestPackage,
-  harvestPackageCached,
-  harvestPackageWithDisk,
-  harvestSigToAbs,
-  harvestToAbsModules,
-  harvestedValueToAbs,
-  loadHarvestEnvFromDisk,
-  lookupHarvested,
-  materializeHarvestJson,
-  packageHarvestToAbsModules,
-  readHarvestDisk,
-  resolvePackageRoot,
-  serializeHarvestJson,
-  writeHarvestDisk
-} from "./chunk-U7JYTRIB.js";
+} from "./chunk-NQXAF4LJ.js";
 import {
   DEFAULT_ANALYSIS_MODE,
   DEFAULT_SESSION_CACHE_LIMITS,
   analysisConfig,
   applyBForkBudgetFromConfig,
   checkConfig,
+  clearPathEnvCaches,
   currentBForkBudgetLimit,
   diskCacheRoot,
   findProjectConfig,
+  getPathEnvCacheSizes,
   getSessionCacheLimits,
   interfaceConfig,
   matchesEmitAllowlist,
   resetSessionCacheLimitState,
   setSessionCacheFromProject,
   setSessionCacheLimits
-} from "./chunk-YLALZXTZ.js";
-import {
-  clearPathEnvCaches,
-  getPathEnvCacheSizes
-} from "./chunk-PVJIMQRI.js";
+} from "./chunk-ZXVAX7DE.js";
+
+// src/static-imports.ts
+import { parse } from "@nudojs/parser";
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { generalizeFromAst, foldStaticStringExpr } from "@nudojs/core";
+function resolveRelative(fromFile, spec) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  const base = resolve(dirname(fromFile), spec);
+  for (const cand of [
+    base,
+    base + ".js",
+    base + ".cjs",
+    base + ".mjs",
+    base + ".ts",
+    base + ".mts",
+    base + ".cts",
+    join(base, "index.js"),
+    join(base, "index.cjs"),
+    join(base, "index.mjs"),
+    join(base, "index.ts")
+  ]) {
+    if (existsSync(cand)) return cand;
+  }
+  return void 0;
+}
+function collectDependencySpecs(ast) {
+  const specs = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportAllDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    collectRequires(stmt, specs);
+  }
+  return specs;
+}
+function collectRequires(node, out) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type === "CallExpression" && obj.callee) {
+      const c = obj.callee;
+      let spec;
+      if (c.type === "Identifier" && c.name === "require") {
+        spec = foldStaticStringExpr(obj.arguments?.[0]);
+      } else if (c.type === "MemberExpression" && !c.computed && c.object?.type === "Identifier" && c.object.name === "require" && c.property?.type === "Identifier" && c.property.name === "resolve") {
+        spec = foldStaticStringExpr(obj.arguments?.[0]);
+      }
+      if (spec !== void 0) out.push(spec);
+    }
+    for (const key of Object.keys(obj)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const v = obj[key];
+      if (Array.isArray(v)) v.forEach(visit);
+      else if (v && typeof v === "object") visit(v);
+    }
+  };
+  visit(node);
+}
+function analyzeExportsFromSource(filePath, source) {
+  const file = parse(source);
+  const named = /* @__PURE__ */ new Map();
+  let defaultExport;
+  const poly = /* @__PURE__ */ new Map();
+  for (const stmt of file.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      named.set(decl.id.name, decl.id.name);
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier") named.set(d.id.name, d.id.name);
+      }
+    }
+    if (decl.type === "ClassDeclaration" && decl.id) {
+      named.set(decl.id.name, decl.id.name);
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      if (d.type === "FunctionDeclaration" && d.id) defaultExport = d.id.name;
+      if (d.type === "Identifier") defaultExport = d.name;
+    }
+    collectCjsExports(stmt, named, (n) => {
+      defaultExport = n;
+    });
+  }
+  for (const name of named.values()) {
+    const g = generalizeFromAst(name, source);
+    if (g) poly.set(name, g);
+  }
+  if (defaultExport) {
+    const g = generalizeFromAst(defaultExport, source);
+    if (g) poly.set("default", g);
+  }
+  return { path: filePath, named, defaultExport, source, poly };
+}
+function collectCjsExports(stmt, named, setDefault) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type !== "AssignmentExpression") {
+      for (const key of Object.keys(obj)) {
+        if (key === "loc" || key === "start" || key === "end") continue;
+        const v = obj[key];
+        if (Array.isArray(v)) v.forEach(visit);
+        else if (v && typeof v === "object") visit(v);
+      }
+      return;
+    }
+    const left = obj.left;
+    const right = obj.right;
+    if (left?.type === "MemberExpression" && left.object?.type === "Identifier" && left.object.name === "exports" && left.property?.type === "Identifier" && left.property.name) {
+      named.set(left.property.name, left.property.name);
+    }
+    if (left?.type === "MemberExpression" && left.object?.type === "Identifier" && left.object.name === "module" && left.property?.type === "Identifier" && left.property.name === "exports") {
+      if (right?.type === "Identifier" && typeof right.name === "string") {
+        named.set(right.name, right.name);
+        setDefault(right.name);
+      }
+      if (right?.type === "ObjectExpression") {
+        const props = right.properties;
+        for (const p of props) {
+          if (p.type !== "ObjectProperty") continue;
+          const key = p.key;
+          const val = p.value;
+          const exportName = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? key.value : void 0;
+          if (exportName) named.set(exportName, exportName);
+          if (val?.type === "Identifier" && val.name && exportName) {
+          }
+        }
+      }
+    }
+  };
+  visit(stmt);
+}
+function collectStaticImports(entryFile, maxDepth = 8) {
+  const graph = /* @__PURE__ */ new Map();
+  const queue = [
+    { file: resolve(entryFile), depth: 0 }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const { file, depth } = queue.shift();
+    if (seen.has(file) || depth > maxDepth) continue;
+    seen.add(file);
+    if (!existsSync(file)) continue;
+    const source = readFileSync(file, "utf8");
+    const mod = analyzeExportsFromSource(file, source);
+    graph.set(file, mod);
+    const ast = parse(source);
+    for (const spec of collectDependencySpecs(ast)) {
+      const resolved = resolveRelative(file, spec);
+      if (resolved) queue.push({ file: resolved, depth: depth + 1 });
+    }
+  }
+  return graph;
+}
 
 // src/skip-directives.ts
-import { extractDirectives, parse } from "@nudojs/parser";
+import { extractDirectives, parse as parse2 } from "@nudojs/parser";
 function collectSkipReturns(source) {
   const out = /* @__PURE__ */ new Map();
   let ast;
   try {
-    ast = parse(source);
+    ast = parse2(source);
   } catch {
     return out;
   }
@@ -203,9 +275,6 @@ function collectSkipReturns(source) {
   return out;
 }
 
-// src/index.ts
-import { collectAbsInlays } from "@nudojs/core/internal";
-
 // src/session-cache.ts
 import {
   resetGeneralizeMemo,
@@ -312,16 +381,6 @@ export {
   DEFAULT_ANALYSIS_MODE,
   DEFAULT_SESSION_CACHE_LIMITS,
   DiskCache,
-  HARVEST_NODE_DEFAULT_MAX_FILES,
-  HARVEST_NODE_DEFAULT_MAX_MS,
-  SEMANTIC_TOKEN_MODIFIERS,
-  SEMANTIC_TOKEN_TYPES,
-  absToHarvestSig,
-  absToSchemaNode,
-  absToSchemaSource,
-  absToStandardSchema,
-  absToStandardSchemaModule,
-  absToTSType,
   ambientSourcesOfSidecar,
   analysisConfig,
   analysisFileCacheKey,
@@ -332,12 +391,7 @@ export {
   applyMockModuleDirectives,
   applyMockModuleDirectivesFromSource,
   applySessionCacheConfig,
-  autoHarvestModules,
-  barePackageName,
-  bareSpecToAbsModules,
-  buildCaseDirective,
   buildModuleGraph,
-  buildSemanticTokens,
   checkCacheKey,
   checkConfig,
   clearAbsModuleCache,
@@ -346,40 +400,27 @@ export {
   clearBPathCache,
   clearEnvPathDeps,
   clearFnAnalysisCache,
-  clearHarvestCache,
-  clearNodeHarvestCache,
   clearPathEnvCaches,
   collectAbsBindingsFromGraph,
-  collectAbsInlays,
   collectBPathDiagnostics,
   collectBPathReplacements,
-  collectBarePackages,
   collectCallRecords,
   collectDependencySpecs,
-  collectDtsFromEntry,
   collectEnvGlobals,
   collectEnvModules,
+  collectEnvNames,
   collectLoadDepContents,
-  collectParamBodyAccesses,
   collectSkipReturns,
   collectStaticImports,
   computeDirtySet,
-  constraintToSchemaNode,
   currentBForkBudgetLimit,
   defaultAbsLoadModule,
   defaultLoadModule,
-  depsCacheRoot,
-  deriveFromRoot,
-  detectDualEntryFromPackageJson,
+  detectEntryVariantsFromPackageJson,
   diagnosticsLevelForFile,
   diskCacheRoot,
-  draftInterface,
-  dtsClosureHash,
-  dualEntryForFile,
-  dualEntryIssueForFile,
-  emitDerivedFromRoot,
-  emitInterface,
-  encodeSemanticTokens,
+  entryVariantForFile,
+  entryVariantIssueForFile,
   envPathDependents,
   evalAbsModuleGraph,
   evictAbsModuleCacheFiles,
@@ -387,92 +428,46 @@ export {
   evictAnalysisFileCacheForFiles,
   evictBPathCacheForFiles,
   evictFnAnalysisCacheForFiles,
-  extractFnConstraintSources,
   extractNudoImportSpecs,
   filterDiagnosticsByLevel,
   findOwningPackage,
   findProjectConfig,
-  formatDerivedSection,
-  formatDraftModule,
-  formatDraftSummary,
-  formatEmitSummary,
-  formatHarvestSummary,
-  formatInterfaceSurfaceLine,
-  generateDts,
-  generateFunctionDtsLines,
-  generateGuardFunction,
-  generateGuardFunctionFromAbs,
-  getAbsAtPosition,
-  getAbsAtPositionAsync,
   getAbsModuleCacheSize,
   getAnalysisFileCacheSize,
   getAnalysisSession,
   getBPathCacheSize,
-  getCasesForFile,
-  getCompletionsAtPosition,
   getEnvHarvestConflictCollector,
   getEnvPathDepsSize,
   getFnAnalysisCacheSize,
-  getHarvestCacheSize,
-  getHoverAtPosition,
-  getNodeHarvestCacheSize,
   getPathEnvCacheSizes,
   getSessionCacheLimits,
-  getTypeAtPosition,
-  getTypeAtPositionAsync,
-  handwrittenNodeEnv,
-  harvestCacheKey,
-  harvestNodeTypes,
-  harvestPackage,
-  harvestPackageCached,
-  harvestPackageWithDisk,
-  harvestSigToAbs,
-  harvestToAbsModules,
-  harvestedValueToAbs,
   ifaceCacheKey,
   injectBindings,
-  insertGeneratedCaseDirectives,
   interfaceConfig,
-  interfaceSurface,
-  interfaceTierModifierBit,
   isBPathCapable,
-  isDraftableEntry,
   isEnvTemplatePath,
-  isHarvestNodeDisabled,
   isNudoTargetPath,
   isProjectConfigPath,
   isSidecarPath,
   isWatchRelevantPath,
-  loadHarvestEnvFromDisk,
-  lookupHarvested,
+  locFromNode,
   matchesEmitAllowlist,
-  materializeHarvestJson,
   mergeHarvestUnderEnv,
   mockDirectivesToAbsSeeds,
   mockSeedsForSource,
   mockSeedsToAbsMocks,
   noteEnvPathDeps,
-  packageHarvestToAbsModules,
-  projectAbsToSchema,
-  readHarvestDisk,
   relativizePath,
   resetAllAnalysisCaches,
   resetSessionCacheLimitState,
-  resolvePackageRoot,
-  schemaNodeToZod,
-  serializeCaseArg,
-  serializeCaseJson,
-  serializeHarvestJson,
+  resolveModule,
   setAnalysisSession,
   setEnvHarvestConflictCollector,
   setSessionCacheFromProject,
   setSessionCacheLimits,
   sha256Hex,
   shouldAnalyzeFile,
-  sidecarDraftPath,
   hasNudoDirectives as sourceHasNudoDirectives,
-  stripGeneratedCaseDirectives,
-  summarizeNodeEnv,
   topoSortDirty,
   trimAnalysisFileCache,
   trimBPathCache,
@@ -480,9 +475,5 @@ export {
   tryBPathCall,
   tryBPathCallFull,
   tryRunBPath,
-  typeExprToDirective,
-  unifiedDiff,
-  validateSchemaNode,
-  writeHarvestDisk,
-  writeInterfaceDraft
+  typeExprToDirective
 };