@nudojs/service 0.3.0 → 0.3.1

package/src/__tests__/integration.test.ts

@@ -1,421 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { typeValueToString } from "@nudojs/core";
-import {
-  analyzeFile,
-  typeValueToZodSchema,
-  generateGuardFunction,
-  generateDts,
-  typeValueToTSType,
-} from "../index.ts";
-
-describe("integration: full pipeline", () => {
-  it("infers types through the complete analyze → generate pipeline", () => {
-    const source = `
-/**
- * @nudo:case "strings" (T.string)
- * @nudo:case "numbers" (T.number)
- */
-function process(x) {
-  if (typeof x === "string") return x.toUpperCase();
-  return x + 1;
-}
-`;
-    const result = analyzeFile("/test.js", source);
-
-    // Verify inference
-    expect(result.functions).toHaveLength(1);
-    expect(result.functions[0].name).toBe("process");
-    expect(result.functions[0].cases).toHaveLength(2);
-    expect(result.functions[0].combined).toBeDefined();
-
-    // Verify Zod generation for each case result
-    const zodSchema0 = typeValueToZodSchema(result.functions[0].cases[0].result);
-    expect(zodSchema0).toBeTruthy();
-    expect(typeof zodSchema0).toBe("string");
-
-    const zodSchema1 = typeValueToZodSchema(result.functions[0].cases[1].result);
-    expect(zodSchema1).toBeTruthy();
-
-    // Verify guard generation
-    const guard = generateGuardFunction("isProcessOutput", result.functions[0].cases[0].result);
-    expect(guard).toContain("function isProcessOutput");
-    expect(guard).toContain("export function");
-
-    // Verify DTS generation
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function process");
-    expect(dts).toContain("strings");
-    expect(dts).toContain("numbers");
-  });
-
-  it("handles a single-case function end-to-end", () => {
-    const source = `
-/**
- * @nudo:case "test" (T.number)
- */
-function double(x) {
-  return x * 2;
-}
-`;
-    const result = analyzeFile("/test/double.js", source);
-
-    expect(result.functions).toHaveLength(1);
-    const fn = result.functions[0];
-    expect(fn.name).toBe("double");
-    expect(fn.cases).toHaveLength(1);
-    expect(typeValueToString(fn.cases[0].result)).toBe("number");
-
-    // Zod schema should produce a valid z.number() call
-    const zod = typeValueToZodSchema(fn.cases[0].result);
-    expect(zod).toBe("z.number()");
-
-    // Guard should check typeof
-    const guard = generateGuardFunction("isDoubleOutput", fn.cases[0].result);
-    expect(guard).toContain("typeof data === 'number'");
-
-    // DTS should have a single declaration line
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function double(x: number): number;");
-  });
-});
-
-describe("integration: Zod schema generation", () => {
-  it("generates Zod schemas from inferred object types", () => {
-    const source = `
-/**
- * @nudo:case "test" ({ name: "Alice", age: 30 })
- */
-function getUser(config) {
-  return config;
-}
-`;
-    const result = analyzeFile("/test/user.js", source);
-    const fn = result.functions[0];
-    const zod = typeValueToZodSchema(fn.cases[0].result);
-
-    expect(zod).toContain("z.object");
-    expect(zod).toContain("name");
-    expect(zod).toContain("age");
-  });
-
-  it("generates Zod schemas for union return types", () => {
-    const source = `
-/**
- * @nudo:case "string" (T.string)
- * @nudo:case "number" (T.number)
- */
-function parse(x) {
-  if (typeof x === "string") return x;
-  return x;
-}
-`;
-    const result = analyzeFile("/test/parse.js", source);
-    const fn = result.functions[0];
-
-    // Each case should produce a valid Zod schema
-    expect(typeValueToZodSchema(fn.cases[0].result)).toBe("z.string()");
-    expect(typeValueToZodSchema(fn.cases[1].result)).toBe("z.number()");
-
-    // Combined type should produce a union schema
-    const combined = fn.combined!;
-    const combinedZod = typeValueToZodSchema(combined);
-    expect(combinedZod).toContain("z.union");
-  });
-});
-
-describe("integration: guard generation", () => {
-  it("generates guards for complex inferred types", () => {
-    const source = `
-/**
- * @nudo:case "test" ([1, "two", true])
- */
-function identity(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("/test/tuple.js", source);
-    const fn = result.functions[0];
-    const guard = generateGuardFunction("isTuple", fn.cases[0].result);
-
-    expect(guard).toContain("export function isTuple");
-    expect(guard).toContain("Array.isArray");
-    expect(guard).toContain("data.length === 3");
-    // Literal values produce equality checks, not typeof checks
-    expect(guard).toContain("data[0] === 1");
-    expect(guard).toContain('data[1] === "two"');
-    expect(guard).toContain("data[2] === true");
-  });
-
-  it("generates guards for object return types", () => {
-    const source = `
-/**
- * @nudo:case "test" ({ id: 1, active: true })
- */
-function getRecord(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("/test/record.js", source);
-    const fn = result.functions[0];
-    const guard = generateGuardFunction("isRecord", fn.cases[0].result);
-
-    expect(guard).toContain("export function isRecord");
-    expect(guard).toContain("typeof data === 'object'");
-    expect(guard).toContain("data !== null");
-    expect(guard).toContain("data.id");
-    expect(guard).toContain("data.active");
-  });
-});
-
-describe("integration: DTS generation", () => {
-  it("generates declarations for functions returning inferred object types", () => {
-    const source = `
-/**
- * @nudo:case "test" ({ x: 1, y: "hello" })
- */
-function makePoint(config) {
-  return config;
-}
-`;
-    const result = analyzeFile("/test/point.js", source);
-    const dts = generateDts(result);
-
-    expect(dts).toContain("export declare function makePoint");
-    expect(dts).toContain("x:");
-    expect(dts).toContain("y:");
-  });
-
-  it("generates TS type strings from inferred values", () => {
-    const source = `
-/**
- * @nudo:case "concrete" (1, 2)
- * @nudo:case "symbolic" (T.number, T.number)
- */
-function add(a, b) {
-  return a + b;
-}
-`;
-    const result = analyzeFile("/test/add.js", source);
-    const fn = result.functions[0];
-
-    expect(typeValueToTSType(fn.cases[0].result)).toBe("3");
-    expect(typeValueToTSType(fn.cases[1].result)).toBe("number");
-
-    // 行为已修复：多 case 不再逐 case 生成字面量重载（`): 3;` 拦截合法调用），
-    // 改为单一 widen 主签名 + JSDoc 保留字面量精度
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function add(a: number, b: number): number;");
-    expect(dts).toContain("Case: concrete (1, 2) => 3");
-  });
-});
-
-describe("integration: multiple cases", () => {
-  it("resolves combined type from multiple @nudo:case directives", () => {
-    const source = `
-/**
- * @nudo:case "string-input" (T.string)
- * @nudo:case "number-input" (T.number)
- * @nudo:case "boolean-input" (T.boolean)
- */
-function stringify(x) {
-  if (typeof x === "string") return x;
-  if (typeof x === "number") return String(x);
-  return String(x);
-}
-`;
-    const result = analyzeFile("/test/stringify.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(3);
-    expect(fn.cases[0].name).toBe("string-input");
-    expect(fn.cases[1].name).toBe("number-input");
-    expect(fn.cases[2].name).toBe("boolean-input");
-
-    // Combined type should be a union of the three return types
-    expect(fn.combined).toBeDefined();
-    const combinedStr = typeValueToString(fn.combined!);
-    expect(combinedStr).toBeTruthy();
-
-    // DTS should contain overloads for all three cases
-    const dts = generateDts(result);
-    expect(dts).toContain("string-input");
-    expect(dts).toContain("number-input");
-    expect(dts).toContain("boolean-input");
-  });
-
-  it("handles mixed literal and symbolic cases", () => {
-    const source = `
-/**
- * @nudo:case "literal" (42)
- * @nudo:case "symbolic" (T.number)
- */
-function passThrough(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("/test/mixed.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(2);
-    expect(typeValueToString(fn.cases[0].result)).toBe("42");
-    expect(typeValueToString(fn.cases[1].result)).toBe("number");
-
-    // Zod should produce valid schemas for both
-    expect(typeValueToZodSchema(fn.cases[0].result)).toBe("z.literal(42)");
-    expect(typeValueToZodSchema(fn.cases[1].result)).toBe("z.number()");
-  });
-});
-
-describe("integration: error cases", () => {
-  it("detects throw paths and reports diagnostics", () => {
-    const source = `
-/**
- * @nudo:case "valid" (10)
- * @nudo:case "negative" (-1)
- */
-function safeSqrt(x) {
-  if (x < 0) {
-    throw new RangeError("negative input");
-  }
-  return x;
-}
-`;
-    const result = analyzeFile("/test/sqrt.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(2);
-
-    // The valid case should not throw
-    expect(fn.cases[0].throws.kind).toBe("never");
-
-    // The negative case should throw
-    expect(fn.cases[1].throws.kind).not.toBe("never");
-
-    // Diagnostics should contain a may-throw warning for the active (first) case
-    // if its branch can throw, or for the negative case
-    const throwDiags = result.diagnostics.filter(
-      (d) => d.code === "nudo-may-throw",
-    );
-    // At least one throw diagnostic should exist since the function has a throw path
-    expect(throwDiags.length).toBeGreaterThanOrEqual(0);
-
-    // The result should still be analysable and produce valid outputs
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function safeSqrt");
-  });
-
-  it("handles a function that always throws", () => {
-    const source = `
-/**
- * @nudo:case "test" (T.string)
- */
-function alwaysFails(x) {
-  throw new Error("always fails");
-}
-`;
-    const result = analyzeFile("/test/fail.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(1);
-    // Result type should be never since the function always throws
-    expect(fn.cases[0].result.kind).toBe("never");
-    // Throws type should not be never
-    expect(fn.cases[0].throws.kind).not.toBe("never");
-
-    // A throw diagnostic should be generated
-    const throwDiags = result.diagnostics.filter(
-      (d) => d.code === "nudo-may-throw",
-    );
-    expect(throwDiags.length).toBeGreaterThanOrEqual(1);
-    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

@@ -1,28 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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__/schema-generator.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T } from "@nudojs/core";
-import { typeValueToZodSchema } from "../schema-generator.ts";
-
-describe("schema-generator", () => {
-  it("generates z.string() for string type", () => {
-    expect(typeValueToZodSchema(T.string)).toBe("z.string()");
-  });
-
-  it("generates z.number() for number type", () => {
-    expect(typeValueToZodSchema(T.number)).toBe("z.number()");
-  });
-
-  it("generates z.literal() for literal types", () => {
-    expect(typeValueToZodSchema(T.literal("hello"))).toBe('z.literal("hello")');
-    expect(typeValueToZodSchema(T.literal(42))).toBe("z.literal(42)");
-    expect(typeValueToZodSchema(T.literal(true))).toBe("z.literal(true)");
-  });
-
-  it("generates z.object() for object types", () => {
-    const obj = T.object({ name: T.string, age: T.number });
-    expect(typeValueToZodSchema(obj)).toBe("z.object({ name: z.string(), age: z.number() })");
-  });
-
-  it("generates z.array() for array types", () => {
-    expect(typeValueToZodSchema(T.array(T.string))).toBe("z.array(z.string())");
-  });
-
-  it("generates z.union() for union types", () => {
-    const union = T.union(T.string, T.number);
-    expect(typeValueToZodSchema(union)).toBe("z.union([z.string(), z.number()])");
-  });
-
-  it("generates z.null() and z.undefined()", () => {
-    expect(typeValueToZodSchema(T.null)).toBe("z.null()");
-    expect(typeValueToZodSchema(T.undefined)).toBe("z.undefined()");
-  });
-});

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

@@ -1,90 +0,0 @@
-/**
- * 宿主契约回归：入口 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

@@ -1,44 +0,0 @@
-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 });
-    }
-  });
-});