@nudojs/service 0.2.1 → 0.3.0

package/src/__tests__/fn-cache-evict.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  evictFnAnalysisCacheForFiles,
+  clearFnAnalysisCache,
+  fnAnalysisCacheSet,
+  fnAnalysisCacheGet,
+  type CachedFnAnalysis,
+} from "../fn-analysis-cache.ts";
+
+function entry(name: string): CachedFnAnalysis {
+  return {
+    analysis: {
+      name,
+      loc: {
+        start: { line: 1, column: 0 },
+        end: { line: 1, column: 10 },
+      },
+      paramNames: [],
+      cases: [],
+    },
+    diagnostics: [],
+    caseHints: [],
+    callRecords: [],
+  };
+}
+
+const SEP = "\0";
+
+describe("evictFnAnalysisCacheForFiles", () => {
+  beforeEach(() => {
+    clearFnAnalysisCache();
+  });
+
+  it("drops every fn entry for the given entry file", () => {
+    const keyA1 = `/t/a.js${SEP}own1${SEP}deps1${SEP}0`;
+    const keyA2 = `/t/a.js${SEP}own2${SEP}deps2${SEP}0`;
+    const keyB = `/t/b.js${SEP}own1${SEP}deps1${SEP}0`;
+    fnAnalysisCacheSet(keyA1, entry("a"));
+    fnAnalysisCacheSet(keyA2, entry("b"));
+    fnAnalysisCacheSet(keyB, entry("c"));
+    const n = evictFnAnalysisCacheForFiles(["/t/a.js"]);
+    expect(n).toBe(2);
+    expect(fnAnalysisCacheGet(keyA1)).toBeUndefined();
+    expect(fnAnalysisCacheGet(keyB)).toBeDefined();
+  });
+
+  it("does not drop a different file with a shared path prefix", () => {
+    const keyA = `/t/a.js${SEP}x${SEP}y${SEP}0`;
+    const keyBak = `/t/a.js.bak${SEP}x${SEP}y${SEP}0`;
+    fnAnalysisCacheSet(keyA, entry("a"));
+    fnAnalysisCacheSet(keyBak, entry("bak"));
+    evictFnAnalysisCacheForFiles(["/t/a.js"]);
+    expect(fnAnalysisCacheGet(keyA)).toBeUndefined();
+    expect(fnAnalysisCacheGet(keyBak)).toBeDefined();
+  });
+});

package/src/__tests__/harvest-auto.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { barePackageName, collectBarePackages } from "../harvest-auto.ts";
+
+describe("barePackageName", () => {
+  it("keeps simple package names", () => {
+    expect(barePackageName("ms")).toBe("ms");
+    expect(barePackageName("lodash/fp")).toBe("lodash");
+  });
+
+  it("keeps scoped packages", () => {
+    expect(barePackageName("@types/node")).toBe("@types/node");
+    expect(barePackageName("@babel/parser")).toBe("@babel/parser");
+  });
+
+  it("rejects relative / absolute / node builtins", () => {
+    expect(barePackageName("./a.js")).toBeUndefined();
+    expect(barePackageName("../b")).toBeUndefined();
+    expect(barePackageName("/abs/path")).toBeUndefined();
+    expect(barePackageName("node:fs")).toBeUndefined();
+  });
+});
+
+describe("collectBarePackages", () => {
+  it("extracts import and require specs", () => {
+    const src = `
+import ms from "ms";
+import { join } from "path";
+const x = require("lodash/fp");
+import fs from "node:fs";
+import local from "./local.js";
+`;
+    const pkgs = collectBarePackages(src);
+    expect(pkgs).toContain("ms");
+    expect(pkgs).toContain("path");
+    expect(pkgs).toContain("lodash");
+    expect(pkgs).not.toContain("node:fs");
+    expect(pkgs).not.toContain("./local.js");
+  });
+
+  it("returns empty for unparsable source", () => {
+    expect(collectBarePackages("function (")).toEqual([]);
+  });
+});

package/src/__tests__/harvest-node.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { harvestNodeTypes, summarizeNodeEnv } from "../harvest-node.ts";
+import { resolve } from "node:path";
+
+describe("harvest @types/node", () => {
+  it("harvests @types/node when installed", () => {
+    const root = resolve(process.cwd(), "../..");
+    const r = harvestNodeTypes(root, 6);
+    if (!r.ok) {
+      // env may not have @types/node in some CI — soft skip
+      expect(r.error).toBeTruthy();
+      return;
+    }
+    expect(r.files).toBeGreaterThan(0);
+    expect(r.env.stats.symbols).toBeGreaterThan(0);
+    const s = summarizeNodeEnv(r.env);
+    expect(s.symbolCount).toBeGreaterThan(0);
+    // Node env 通常含 process / Buffer 等全局
+    const hasUseful =
+      s.globals.some((g) => /process|Buffer|console/i.test(g)) ||
+      s.modules.length > 0;
+    expect(hasUseful).toBe(true);
+  });
+});

package/src/__tests__/harvest-package.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { harvestPackage, formatHarvestSummary, resolvePackageRoot } from "../harvest-package.ts";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+describe("harvest npm package", () => {
+  const root = resolve(process.cwd(), "../..");
+  // monorepo root may vary; try a few
+  const cwdHasTs = existsSync(resolve(root, "node_modules/typescript/package.json"));
+
+  it("resolvePackageRoot finds workspace packages", () => {
+    // typescript is a root devDep of the monorepo
+    const r = resolvePackageRoot("typescript", root);
+    if (r) {
+      expect(existsSync(r)).toBe(true);
+    } else {
+      // environment without typescript installed — skip soft
+      expect(r).toBeUndefined();
+    }
+  });
+
+  it("harvestPackage on typescript if available", () => {
+    const r = resolvePackageRoot("typescript", root);
+    if (!r) {
+      expect(true).toBe(true);
+      return;
+    }
+    const h = harvestPackage("typescript", root);
+    if ("error" in h) {
+      // no d.ts collected — still ok in constrained env
+      expect(h.error).toBeTruthy();
+      return;
+    }
+    expect(h.dtsFiles.length).toBeGreaterThan(0);
+    expect(h.env.stats.symbols).toBeGreaterThan(0);
+    expect(formatHarvestSummary(h)).toContain("typescript");
+  });
+});

package/src/__tests__/harvest-to-abs.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { writeFileSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { harvestedValueToAbs, bareSpecToAbsModules, evalAbsModuleGraph } from "@nudojs/service";
+import { T, analyzeFn, numLit, absToString, getFnImpl } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("harvest → Abs", () => {
+  it("fnSig becomes callable absFunction with declared return", () => {
+    const tv = T.fnSig([T.number], T.string);
+    const a = harvestedValueToAbs(tv);
+    expect(a.shape.k).toBe("fn");
+    expect(a.conf).toBe("mock");
+    expect(getFnImpl(a)?.apply).toBeTypeOf("function");
+    const r = getFnImpl(a)!.apply!([numLit(1)]);
+    expect(absToString(r)).toContain("string");
+  });
+
+  it("bareSpecToAbsModules finds lodash from monorepo root", () => {
+    const file = join(process.cwd(), "packages/service/src/__probe.js");
+    const mods = bareSpecToAbsModules("lodash", file);
+    expect(mods).toBeDefined();
+    expect(Object.keys(mods!.named).length).toBeGreaterThan(0);
+  });
+
+  it("module graph injects bare import into analyzeFn", () => {
+    // 放在 monorepo 内，harvest 才能找到 node_modules/@types/lodash
+    const dir = join(process.cwd(), "packages/service/src/__tmp-bare-mod");
+    mkdirSync(dir, { recursive: true });
+    dirs.push(dir);
+    const main = `import { chunk } from "lodash";
+export function go(x) { return chunk(x, 2); }
+`;
+    const mainPath = join(dir, "main.js");
+    writeFileSync(mainPath, main, "utf-8");
+    const { modules } = evalAbsModuleGraph(main, mainPath);
+    expect(modules["lodash"]).toBeDefined();
+    const r = analyzeFn(main, "go", [numLit(4)], undefined, undefined, undefined, modules);
+    expect(r).toBeDefined();
+    expect(["mock", "partial", "path", "exact", "widened", "opaque"]).toContain(r.conf);
+  });
+});

package/src/__tests__/hover-intension.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { getHoverAtPosition } from "../analyzer.ts";
+
+describe("getHoverAtPosition lossless Abs", () => {
+  it("hover on function name shows Abs + intension", () => {
+    const source = `function scale(x) { return x + 1; }\nscale(2);\n`;
+    const hover = getHoverAtPosition("/t/hover.js", source, 1, 9);
+    expect(hover).not.toBeNull();
+    expect(hover!.intension ?? hover!.typeText).toContain("scale");
+    expect(hover!.intension ?? "").toContain("+");
+    // 无损 Abs：含 conf 标记
+    expect(hover!.abs).toBeDefined();
+    expect(hover!.abs).toContain("#");
+    expect(hover!.absMultiline).toBeDefined();
+  });
+
+  it("hover on binding shows Abs from evalProgramAbs", () => {
+    const source = `const x = 1 + 2;\n`;
+    const hover = getHoverAtPosition("/t/h3.js", source, 1, 7);
+    if (hover?.abs) {
+      expect(hover.abs).toContain("3");
+    }
+  });
+
+  it("hover on expression uses Abs node table (lossless)", () => {
+    const source = `const n = 1 + 2;\n`;
+    // column of `2` is 14 (0-based)
+    const hover = getHoverAtPosition("/t/h4.js", source, 1, 14);
+    expect(hover).not.toBeNull();
+    expect(hover!.abs).toBeDefined();
+    expect(hover!.abs).toContain("2");
+  });
+
+  it("hover on non-function still returns type", () => {
+    const source = `const n = 1;\n`;
+    const hover = getHoverAtPosition("/t/h2.js", source, 1, 7);
+    if (hover) expect(typeof hover.typeText).toBe("string");
+  });
+});

package/src/__tests__/infer-json.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile, serializeInferJson } from "../index.ts";
+
+describe("InferJson contract v1", () => {
+  it("self-contained function has abs in intension", () => {
+    const src = `function scale(x) { return x + 1; }\n`;
+    const result = analyzeFile("/t/scale.js", src);
+    const json = serializeInferJson(result, "/t/scale.js");
+    expect(json.version).toBe(1);
+    expect(json.file).toBe("/t/scale.js");
+    expect(json.summary.functions).toBeGreaterThan(0);
+    const fn = json.functions.find((f) => f.name === "scale");
+    expect(fn).toBeDefined();
+    expect(fn!.entryOnly).toBe(true);
+    const entry = fn!.cases.find((c) => c.name.startsWith("entry@"));
+    expect(entry).toBeDefined();
+    expect(entry!.intension?.abs).toContain("#");
+    expect(entry!.intension?.display).toContain("scale");
+    // 外延仍有 TypeValue 字符串
+    expect(typeof entry!.result).toBe("string");
+  });
+
+  it("call site cases include args/result strings", () => {
+    const src = `
+function add(a, b) { return a + b; }
+const r = add(2, 3);
+`;
+    const result = analyzeFile("/t/add.js", src);
+    const json = serializeInferJson(result, "/t/add.js");
+    const add = json.functions.find((f) => f.name === "add");
+    expect(add!.cases.length).toBeGreaterThan(0);
+    expect(add!.cases[0]!.args.length).toBe(2);
+    expect(add!.cases[0]!.result).toBe("5");
+  });
+});

package/src/__tests__/integration.test.ts

@@ -330,3 +330,92 @@ function alwaysFails(x) {
     expect(throwDiags[0].message).toContain("alwaysFails");
   });
 });
+
+// ---------------------------------------------------------------------------
+// .ts 输入支持：analyzeFile/analyzeFileAsync 走统一剥除后的 parse()，
+// 推断结果与等价 .js 一致，且 TS 语法（interface/import type/enum/断言）
+// 不产生 unknown-global 等假诊断。
+// ---------------------------------------------------------------------------
+
+import { isNudoTargetPath } from "../target-path.ts";
+
+describe("integration: .ts source through the full pipeline", () => {
+  const tsSource = `
+interface Point { x: number; y: number }
+import type { Gone } from "./no-such-module";
+
+/**
+ * @nudo:case "nums" (1, 2)
+ * @nudo:case "syms" (T.number, T.number)
+ */
+function add(a: number, b: number): number {
+  return a + b;
+}
+
+/** @nudo:case "cast" (T.string) */
+function cast(s: string) {
+  const v = s as unknown as { n: number };
+  const w = v!;
+  return s.length + 1;
+}
+
+export { add, cast };
+`;
+
+  it("infers .ts functions identically to equivalent .js", () => {
+    const jsSource = `
+/**
+ * @nudo:case "nums" (1, 2)
+ * @nudo:case "syms" (T.number, T.number)
+ */
+function add(a, b) {
+  return a + b;
+}
+
+/** @nudo:case "cast" (T.string) */
+function cast(s) {
+  const v = s;
+  const w = v;
+  return s.length + 1;
+}
+
+export { add, cast };
+`;
+    const ts = analyzeFile("/test.ts", tsSource);
+    const js = analyzeFile("/test.js", jsSource);
+    expect(ts.functions.map((f) => f.name)).toEqual(js.functions.map((f) => f.name));
+    expect(ts.functions).toHaveLength(2);
+    const tsAdd = ts.functions[0];
+    const jsAdd = js.functions[0];
+    expect(tsAdd.cases).toHaveLength(jsAdd.cases.length);
+    for (let i = 0; i < tsAdd.cases.length; i++) {
+      expect(typeValueToString(tsAdd.cases[i].result)).toBe(typeValueToString(jsAdd.cases[i].result));
+    }
+    expect(typeValueToString(tsAdd.cases[0].result)).toBe("3");
+  });
+
+  it("TS-only syntax produces no false diagnostics", () => {
+    const result = analyzeFile("/test.ts", tsSource);
+    const falseDiagnostics = result.diagnostics.filter(
+      (d) => d.code === "nudo:unknown-global" || d.code === "nudo:builtin-unknown",
+    );
+    expect(falseDiagnostics).toHaveLength(0);
+  });
+
+  it("case-emitter round-trip works on stripped .ts source (call@ directives reinsertable)", () => {
+    const source = `function scale(n) { return n * 2; }\nconst out = scale(21);\n`;
+    const result = analyzeFile("/test.ts", source);
+    // 全程序推断：无指令函数从调用点合成 case
+    const scale = result.functions.find((f) => f.name === "scale");
+    expect(scale).toBeDefined();
+    expect(scale!.cases.length).toBeGreaterThan(0);
+    expect(scale!.cases[0].source).toBe("callsite");
+    expect(typeValueToString(scale!.cases[0].result)).toBe("42");
+  });
+
+  it("isNudoTargetPath is exported from the service surface", () => {
+    expect(isNudoTargetPath("a.ts")).toBe(true);
+    expect(isNudoTargetPath("a.d.ts")).toBe(false);
+    expect(isNudoTargetPath("a.tsx")).toBe(false);
+  });
+});

package/src/__tests__/m3-intension.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "../index.ts";
+
+describe("analyzer intension (always on)", () => {
+  it("entry@ gets intension display", () => {
+    const source = `function scale(x) { return x + 1; }\n`;
+    const result = analyzeFile("f.js", source);
+    const fn = result.functions.find((f) => f.name === "scale");
+    expect(fn).toBeDefined();
+    const entry = fn!.cases.find((c) => c.name.startsWith("entry@"));
+    expect(entry).toBeDefined();
+    expect(entry!.intension).toBeDefined();
+    expect(entry!.intension!.display).toContain("scale");
+    expect(entry!.intension!.display).toContain("+");
+    // 无损 Abs（不经 bridge）
+    expect(entry!.intension!.abs).toBeDefined();
+    expect(entry!.intension!.abs).toContain("#");
+  });
+
+  it("add generalizes to A1+A2", () => {
+    const source = `function add(a, b) { return a + b; }\n`;
+    const result = analyzeFile("f.js", source);
+    const fn = result.functions.find((f) => f.name === "add");
+    const entry = fn!.cases.find((c) => c.name.startsWith("entry@"));
+    expect(entry!.intension!.display).toContain("A1");
+    expect(entry!.intension!.display).toContain("+");
+  });
+});

package/src/__tests__/mock-seed-fingerprint.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import { numLit, unknown } from "@nudojs/core";
+import { parseTypeValueExpr } from "@nudojs/parser";
+import { mockSeedFingerprint } from "../bpath-run.ts";
+import { mockDirectivesToAbsSeeds } from "../mock-abs.ts";
+
+describe("mockSeedFingerprint", () => {
+  it("misses when mock values change under the same names", () => {
+    const a = mockSeedFingerprint({ fetch: numLit(1) });
+    const b = mockSeedFingerprint({ fetch: numLit(2) });
+    expect(a).not.toBe(b);
+  });
+
+  it("hits for identical name+value sets regardless of key order", () => {
+    const a = mockSeedFingerprint({ x: numLit(1), y: unknown });
+    const b = mockSeedFingerprint({ y: unknown, x: numLit(1) });
+    expect(a).toBe(b);
+  });
+
+  it("empty and missing mocks share the dash key", () => {
+    expect(mockSeedFingerprint(undefined)).toBe("-");
+    expect(mockSeedFingerprint({})).toBe("-");
+  });
+
+  it("misses when real sinon.stub().returns value changes", () => {
+    const seeds1 = mockDirectivesToAbsSeeds([
+      {
+        directives: [
+          {
+            kind: "mock",
+            name: "fetch",
+            sinonExpr: { type: "sinon.stub", returnValue: parseTypeValueExpr("1") },
+          } as never,
+        ],
+      },
+    ]);
+    const seeds2 = mockDirectivesToAbsSeeds([
+      {
+        directives: [
+          {
+            kind: "mock",
+            name: "fetch",
+            sinonExpr: { type: "sinon.stub", returnValue: parseTypeValueExpr("2") },
+          } as never,
+        ],
+      },
+    ]);
+    const a = mockSeedFingerprint(seeds1.seedVars, seeds1.seedFns);
+    const b = mockSeedFingerprint(seeds2.seedVars, seeds2.seedFns);
+    expect(a).not.toBe(b);
+  });
+
+  it("includes seedFns in the fingerprint", () => {
+    const a = mockSeedFingerprint(
+      {},
+      { load: { params: ["x"], body: { type: "Identifier", name: "x" } as never } },
+    );
+    const b = mockSeedFingerprint(
+      {},
+      { load: { params: ["y"], body: { type: "Identifier", name: "y" } as never } },
+    );
+    expect(a).not.toBe(b);
+  });
+});

package/src/__tests__/session-cache-evict.test.ts

@@ -0,0 +1,90 @@
+/**
+ * 宿主契约回归：入口 source 未变、依赖模块内容变了时，
+ * 必须 evictAnalysisCachesForFiles（CLI watch / vite-plugin），
+ * 否则 AnalysisResult / B-path / fn-cache 会命中陈旧结果。
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  analyzeFile,
+  clearAnalysisSessionCaches,
+  evictAnalysisCachesForFiles,
+} from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterEach(() => {
+  clearAnalysisSessionCaches();
+  for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
+});
+
+function caseResultOf(result: ReturnType<typeof analyzeFile>, fnName: string, caseName: string): string {
+  const fn = result.functions.find((f) => f.name === fnName);
+  const c = fn?.cases.find((x) => x.name === caseName);
+  if (!c) throw new Error(`missing case ${fnName}/${caseName}`);
+  return typeValueToString(c.result);
+}
+
+describe("dep-change host eviction contract", () => {
+  const MAIN = `
+const util = require("./util.js");
+/**
+ * @nudo:case "t" (1)
+ */
+function go(n) {
+  return util.inc(n);
+}
+`;
+
+  it("without eviction, parent analysis hits stale result after dep change", () => {
+    clearAnalysisSessionCaches();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-stale-"));
+    dirs.push(dir);
+    const depPath = join(dir, "util.js");
+    const mainPath = join(dir, "main.js");
+    writeFileSync(depPath, `export function inc(x) { return x + 1; }\n`);
+    writeFileSync(mainPath, MAIN);
+
+    const r1 = analyzeFile(mainPath, MAIN);
+    expect(caseResultOf(r1, "go", "t")).toBe("2");
+
+    // dep 变了，parent source 不变；不逐出 → 整文件缓存命中
+    writeFileSync(depPath, `export function inc(x) { return x + 99; }\n`);
+    const r2 = analyzeFile(mainPath, MAIN);
+    expect(caseResultOf(r2, "go", "t")).toBe("2"); // 陈旧——正是契约要防的
+  });
+
+  it("evictAnalysisCachesForFiles makes parent see dep change", () => {
+    clearAnalysisSessionCaches();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-evict-"));
+    dirs.push(dir);
+    const depPath = join(dir, "util.js");
+    const mainPath = join(dir, "main.js");
+    writeFileSync(depPath, `export function inc(x) { return x + 1; }\n`);
+    writeFileSync(mainPath, MAIN);
+
+    expect(caseResultOf(analyzeFile(mainPath, MAIN), "go", "t")).toBe("2");
+
+    writeFileSync(depPath, `export function inc(x) { return x + 99; }\n`);
+    // 模拟 CLI watch：脏集入口文件定向逐出
+    evictAnalysisCachesForFiles([mainPath]);
+    expect(caseResultOf(analyzeFile(mainPath, MAIN), "go", "t")).toBe("100");
+  });
+
+  it("clearAnalysisSessionCaches is a full reset", () => {
+    clearAnalysisSessionCaches();
+    const dir = mkdtempSync(join(tmpdir(), "nudo-clear-"));
+    dirs.push(dir);
+    const depPath = join(dir, "util.js");
+    const mainPath = join(dir, "main.js");
+    writeFileSync(depPath, `export function inc(x) { return x + 1; }\n`);
+    writeFileSync(mainPath, MAIN);
+
+    expect(caseResultOf(analyzeFile(mainPath, MAIN), "go", "t")).toBe("2");
+    writeFileSync(depPath, `export function inc(x) { return x + 5; }\n`);
+    clearAnalysisSessionCaches();
+    expect(caseResultOf(analyzeFile(mainPath, MAIN), "go", "t")).toBe("6");
+  });
+});

package/src/__tests__/static-imports.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { collectStaticImports } from "../static-imports.ts";
+
+describe("host static imports (not a bundler)", () => {
+  it("collects relative imports for type facts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-imp-"));
+    try {
+      writeFileSync(
+        join(dir, "math.js"),
+        `export function add(a, b) { return a + b; }\nexport function scale(x) { return add(x, 1); }\n`,
+      );
+      writeFileSync(
+        join(dir, "index.js"),
+        `import { add, scale } from "./math.js";\nexport function double(x) { return scale(x) + x; }\n`,
+      );
+      const graph = collectStaticImports(join(dir, "index.js"));
+      expect(graph.size).toBe(2);
+      const index = graph.get(join(dir, "index.js"))!;
+      expect(index.named.has("double")).toBe(true);
+      expect(index.poly.get("double")?.display).toContain("double");
+      const math = graph.get(join(dir, "math.js"))!;
+      expect(math.poly.get("add")?.display).toContain("A1");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("skips bare specifiers (npm packages)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-bare-"));
+    try {
+      writeFileSync(
+        join(dir, "app.js"),
+        `import lodash from "lodash";\nexport function f(x) { return x + 1; }\n`,
+      );
+      const graph = collectStaticImports(join(dir, "app.js"));
+      expect(graph.size).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});