@nudojs/service 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/service",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Shared inference service for Nudo IDE integrations — file analysis, completions, and .d.ts generation",
   "type": "module",
   "license": "MIT",
@@ -28,9 +28,10 @@
   "dependencies": {
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@nudojs/core": "0.2.0",
-    "@nudojs/parser": "0.2.0",
-    "@nudojs/cli": "0.2.1"
+    "@nudojs/core": "0.3.0",
+    "@nudojs/parser": "0.3.0",
+    "@nudojs/cli": "0.3.0",
+    "@nudojs/harvester": "0.2.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"

package/src/__tests__/abs-bindings.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { collectAbsBindingsFromGraph, analyzeFile, getHoverAtPosition } from "@nudojs/service";
+import { formatAbs, absToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("Abs bindings from module graph", () => {
+  it("includes local functions and imported names", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-abs-bind-"));
+    dirs.push(dir);
+    writeFileSync(join(dir, "math.js"), `export function double(x) { return x * 2; }\n`);
+    const main = `import { double } from "./math.js";
+export function run(n) { return double(n); }
+const k = 1;
+`;
+    const mainPath = join(dir, "main.js");
+    writeFileSync(mainPath, main, "utf-8");
+    const binds = collectAbsBindingsFromGraph(main, mainPath);
+    expect(binds.has("run")).toBe(true);
+    expect(binds.has("double")).toBe(true);
+    expect(binds.has("k")).toBe(true);
+    expect(formatAbs(binds.get("k")!)).toContain("1");
+  });
+
+  it("analyzeFile bindings prefer Abs projection for capable files", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-abs-bind2-"));
+    dirs.push(dir);
+    writeFileSync(join(dir, "math.js"), `export function double(x) { return x * 2; }\n`);
+    const main = `import { double } from "./math.js";
+export function run(n) { return double(n); }
+`;
+    const mainPath = join(dir, "main.js");
+    writeFileSync(mainPath, main, "utf-8");
+    const result = analyzeFile(mainPath, main);
+    expect(result.bindings.has("run")).toBe(true);
+    // imported binding should exist
+    expect(result.bindings.has("double")).toBe(true);
+  });
+
+  it("hover on local function returns abs", () => {
+    const src = `export function add(a, b) { return a + b; }
+`;
+    const h = getHoverAtPosition("/tmp/hover-abs.js", src, 1, 16);
+    // 不要求精确命中，但不应抛错
+    expect(h === null || typeof h.typeText === "string").toBe(true);
+  });
+});

package/src/__tests__/abs-call-records.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { analyzeFile } from "@nudojs/service";
+import { typeValueToString } from "@nudojs/core";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("Abs call records with relative import", () => {
+  it("tags imported calls with targetModule and feeds externalFunctions", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nudo-abs-call-"));
+    dirs.push(dir);
+    const bSrc = `export function triple(x) { return x * 3; }\n`;
+    const aSrc = `import { triple } from "./b.js";\nfunction caller(n) { return triple(n); }\nconst r = caller(4);\n`;
+    writeFileSync(join(dir, "b.js"), bSrc);
+    const aPath = resolve(dir, "a.js");
+    writeFileSync(aPath, aSrc);
+
+    const result = analyzeFile(aPath, aSrc);
+
+    expect(result.externalFunctions).toBeDefined();
+    expect(result.externalFunctions).toHaveLength(1);
+    const triple = result.externalFunctions![0];
+    expect(triple.name).toBe("triple");
+    expect(triple.fromModule).toContain("b.js");
+    expect(triple.cases).toHaveLength(1);
+    expect(typeValueToString(triple.cases[0].result)).toBe("12");
+  });
+});

package/src/__tests__/abs-calls.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "../analyzer.ts";
+import { typeValueToString } from "@nudojs/core";
+
+describe("self-contained Abs call records", () => {
+  it("collects call sites from Abs program eval", () => {
+    const source = `
+      function add(a, b) { return a + b; }
+      const r = add(2, 3);
+    `;
+    const result = analyzeFile("/t/abs-call.js", source);
+    const add = result.functions.find((f) => f.name === "add");
+    expect(add).toBeDefined();
+    expect(add!.cases.length).toBeGreaterThan(0);
+    expect(add!.cases[0]!.source).toBe("callsite");
+    expect(typeValueToString(add!.cases[0]!.result)).toBe("5");
+  });
+
+  it("self-contained entry still works", () => {
+    const source = `function scale(x) { return x + 1; }`;
+    const result = analyzeFile("/t/abs-entry.js", source);
+    const scale = result.functions.find((f) => f.name === "scale");
+    expect(scale!.entryOnly).toBe(true);
+    expect(scale!.cases[0]!.intension).toBeDefined();
+  });
+
+  it("mock seeds feed Abs path (call@ stays exact)", () => {
+    const source = `
+      // @nudo:mock parse = stub().returns(42)
+      function run() {
+        return parse();
+      }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/abs-mock.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    expect(run).toBeDefined();
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(call).toBeDefined();
+    expect(typeValueToString(call!.result)).toBe("42");
+  });
+
+  it("directive expected is carried on CaseResult", () => {
+    const source = `
+      /**
+       * @nudo:case "ok" (1) => T.number
+       * @nudo:case "bad" (1) => T.string
+       */
+      function id(x) { return x; }
+    `;
+    const result = analyzeFile("/t/abs-expected.js", source);
+    const id = result.functions.find((f) => f.name === "id");
+    const ok = id!.cases.find((c) => c.name === "ok");
+    const bad = id!.cases.find((c) => c.name === "bad");
+    expect(ok!.expected).toBeDefined();
+    expect(bad!.expected).toBeDefined();
+    expect(result.diagnostics.some((d) => d.code === "nudo:case-expected")).toBe(true);
+  });
+});

package/src/__tests__/abs-module-cache.test.ts

@@ -0,0 +1,121 @@
+import { it, expect, describe, afterAll, beforeEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  evalAbsModuleGraph,
+  defaultAbsLoadModule,
+  clearAbsModuleCache,
+  evictAbsModuleCacheFiles,
+} from "@nudojs/service";
+
+const dirs: string[] = [];
+
+function setup(files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-modcache-"));
+  dirs.push(dir);
+  for (const [f, src] of Object.entries(files)) {
+    writeFileSync(join(dir, f), src, "utf-8");
+  }
+  return dir;
+}
+
+beforeEach(() => clearAbsModuleCache());
+afterAll(() => {
+  clearAbsModuleCache();
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+describe("abs module session cache", () => {
+  it("reuses evaluated dependency exports across entries (skips re-read/re-eval)", () => {
+    const dir = setup({
+      "util.js": `export function inc(x) { return x + 1; }\n`,
+    });
+    let loads = 0;
+    const loadModule = (spec: string, fromFile: string): string | undefined => {
+      loads++;
+      return defaultAbsLoadModule(spec, fromFile);
+    };
+    const entry = (f: string) => `import { inc } from "./util.js";\nexport function go(x) { return inc(x); }`;
+
+    const g1 = evalAbsModuleGraph(entry("a.js"), join(dir, "a.js"), { loadModule });
+    expect(g1.modules["./util.js"]).toBeDefined();
+    const loadsAfterFirst = loads;
+
+    const g2 = evalAbsModuleGraph(entry("b.js"), join(dir, "b.js"), { loadModule });
+    expect(g2.modules["./util.js"]).toBeDefined();
+    // 缓存命中：第二个入口不再读盘重载 util.js
+    expect(loads).toBe(loadsAfterFirst);
+    // 同一条导出（引用同一对象）
+    expect(g2.modules["./util.js"]).toBe(g1.modules["./util.js"]);
+  });
+
+  it("invalidates by stat fingerprint when dependency content changes", () => {
+    const dir = setup({
+      "util.js": `export function inc(x) { return x + 1; }\n`,
+    });
+    const entry = `import { inc } from "./util.js";\nexport function go(x) { return inc(x); }`;
+    const entryFile = join(dir, "main.js");
+
+    const g1 = evalAbsModuleGraph(entry, entryFile);
+    expect(g1.modules["./util.js"]!.named.inc).toBeDefined();
+    expect(g1.modules["./util.js"]!.named.ver).toBeUndefined();
+
+    // 变更内容（size 必变 → 指纹必失效，与 mtime 精度无关）
+    writeFileSync(join(dir, "util.js"), `export function inc(x) { return x + 1; }\nexport const ver = 2;\n`, "utf-8");
+    const g2 = evalAbsModuleGraph(entry, entryFile);
+    expect(g2.modules["./util.js"]!.named.ver).toBeDefined();
+  });
+
+  it("clear and evict drop cached entries", () => {
+    const dir = setup({
+      "util.js": `export const n = 1;\n`,
+    });
+    let loads = 0;
+    const loadModule = (spec: string, fromFile: string): string | undefined => {
+      loads++;
+      return defaultAbsLoadModule(spec, fromFile);
+    };
+    const entry = `import { n } from "./util.js";\nexport function go() { return n; }`;
+    const entryFile = join(dir, "main.js");
+
+    evalAbsModuleGraph(entry, entryFile, { loadModule });
+    const loadsAfterFirst = loads;
+
+    clearAbsModuleCache();
+    evalAbsModuleGraph(entry, entryFile, { loadModule });
+    expect(loads).toBeGreaterThan(loadsAfterFirst);
+
+    const loadsAfterSecond = loads;
+    evictAbsModuleCacheFiles([join(dir, "util.js")]);
+    evalAbsModuleGraph(entry, entryFile, { loadModule });
+    expect(loads).toBeGreaterThan(loadsAfterSecond);
+  });
+
+  it("replays subtree load issues (missing) on cache hit", () => {
+    const dir = setup({
+      "util.js": `import { gone } from "./gone.js";\nexport const y = gone;\n`,
+    });
+    const entry = (f: string) => `import { y } from "./util.js";\nexport function go() { return y; }`;
+
+    const g1 = evalAbsModuleGraph(entry("a.js"), join(dir, "a.js"));
+    expect(g1.issues.some((i) => i.kind === "missing" && i.label === "./gone.js")).toBe(true);
+
+    const g2 = evalAbsModuleGraph(entry("b.js"), join(dir, "b.js"));
+    expect(g2.issues.some((i) => i.kind === "missing" && i.label === "./gone.js")).toBe(true);
+  });
+
+  it("replays cycle issues on cache hit", () => {
+    const dir = setup({
+      "a.js": `import { b } from "./b.js";\nexport const a = 1;\n`,
+      "b.js": `import { a } from "./a.js";\nexport const b = 2;\n`,
+    });
+    const entry = (f: string) => `import { a } from "./a.js";\nexport function go() { return a; }`;
+
+    const g1 = evalAbsModuleGraph(entry("e1.js"), join(dir, "e1.js"));
+    expect(g1.issues.some((i) => i.kind === "cycle")).toBe(true);
+
+    const g2 = evalAbsModuleGraph(entry("e2.js"), join(dir, "e2.js"));
+    expect(g2.issues.some((i) => i.kind === "cycle")).toBe(true);
+  });
+});

package/src/__tests__/abs-modules-graph.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { evalAbsModuleGraph } from "@nudojs/service";
+import { analyzeFn, litValue, numLit } from "@nudojs/core";
+
+const dirs: string[] = [];
+
+afterAll(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+});
+
+function tmpProject(files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-abs-mod-"));
+  dirs.push(dir);
+  for (const [rel, src] of Object.entries(files)) {
+    const p = join(dir, rel);
+    mkdirSync(join(p, ".."), { recursive: true });
+    writeFileSync(p, src, "utf-8");
+  }
+  return dir;
+}
+
+describe("Abs module graph", () => {
+  it("evaluates a relative import and binds named exports", () => {
+    const dir = tmpProject({
+      "math.js": `
+export function double(x) { return x * 2; }
+export const answer = 42;
+`,
+      "main.js": `
+import { double, answer } from "./math.js";
+export function run(n) { return double(n); }
+`,
+    });
+    const mainSrc = `import { double, answer } from "./math.js";
+export function run(n) { return double(n); }
+`;
+    const { modules } = evalAbsModuleGraph(mainSrc, join(dir, "main.js"));
+    expect(modules["./math.js"]).toBeDefined();
+    expect(modules["./math.js"]!.named.double).toBeDefined();
+    expect(litValue(modules["./math.js"]!.named.answer!)).toBe(42);
+
+    const r = analyzeFn(
+      mainSrc,
+      "run",
+      [numLit(21)],
+      undefined,
+      undefined,
+      undefined,
+      modules,
+    );
+    expect(litValue(r)).toBe(42);
+  });
+
+  it("chained relative imports resolve", () => {
+    const dir = tmpProject({
+      "a.js": `export function inc(x) { return x + 1; }`,
+      "b.js": `
+import { inc } from "./a.js";
+export function twice(x) { return inc(inc(x)); }
+`,
+      "main.js": `
+import { twice } from "./b.js";
+export function go(x) { return twice(x); }
+`,
+    });
+    const mainSrc = `import { twice } from "./b.js";
+export function go(x) { return twice(x); }
+`;
+    const { modules } = evalAbsModuleGraph(mainSrc, join(dir, "main.js"));
+    const result = analyzeFn(
+      mainSrc,
+      "go",
+      [numLit(0)],
+      undefined,
+      undefined,
+      undefined,
+      modules,
+    );
+    expect(litValue(result)).toBe(2);
+  });
+
+  it("cycle does not hang", () => {
+    const dir = tmpProject({
+      "a.js": `
+import { b } from "./b.js";
+export function a(x) { return b(x); }
+`,
+      "b.js": `
+import { a } from "./a.js";
+export function b(x) { return x; }
+`,
+    });
+    const mainSrc = `import { a } from "./a.js"; export function go(x) { return a(x); }`;
+    const { modules } = evalAbsModuleGraph(mainSrc, join(dir, "main.js"));
+    expect(modules["./a.js"]).toBeDefined();
+  });
+});

package/src/__tests__/abs-typevalue-diff.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFile } from "../analyzer.ts";
+import { typeValueToString } from "@nudojs/core";
+
+/**
+ * Service 层 Abs ↔ TypeValue 差分门禁。
+ * 自包含源码：call@ 结果必须与 TypeValue 路径投影一致
+ * （Abs 成功时 callRecords 被 Abs 覆盖；此处验证覆盖后的结果合理）。
+ */
+describe("Abs vs TypeValue service differential", () => {
+  const samples: Array<{ name: string; source: string; fn: string; expect: string }> = [
+    {
+      name: "literal add",
+      source: `function add(a, b) { return a + b; }\nconst r = add(2, 3);`,
+      fn: "add",
+      expect: "5",
+    },
+    {
+      name: "string concat",
+      source: `function cat(a, b) { return a + b; }\nconst r = cat("x", "y");`,
+      fn: "cat",
+      expect: '"xy"',
+    },
+    {
+      name: "branch join",
+      source: `function f(n) { if (n > 0) return 1; return 0; }\nconst r = f(3);`,
+      fn: "f",
+      expect: "1",
+    },
+    {
+      name: "object field",
+      source: `function get(o) { return o.id; }\nconst r = get({ id: 7 });`,
+      fn: "get",
+      expect: "7",
+    },
+  ];
+
+  for (const s of samples) {
+    it(s.name, () => {
+      const result = analyzeFile(`/t/diff-${s.fn}.js`, s.source);
+      const fn = result.functions.find((f) => f.name === s.fn);
+      const call = fn!.cases.find((c) => c.source === "callsite");
+      expect(call, `no call@ for ${s.fn}`).toBeDefined();
+      expect(typeValueToString(call!.result)).toBe(s.expect);
+      // Abs 路径应填充 intension
+      expect(call!.intension).toBeDefined();
+    });
+  }
+
+  it("mock + call does not degrade to unknown", () => {
+    const source = `
+      // @nudo:mock handler = stub().returns("ok")
+      function run() { return handler(); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-mock.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).not.toBe("unknown");
+    expect(typeValueToString(call!.result)).toBe('"ok"');
+  });
+
+  it("mock withArgs dispatches on Abs path (literal hit)", () => {
+    const source = `
+      // @nudo:mock id = stub().withArgs(21).returns("hit")
+      function run() { return id(21); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-withargs.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).toBe('"hit"');
+  });
+
+  it("mock withArgs miss falls back to unknown", () => {
+    const source = `
+      // @nudo:mock id = stub().withArgs(21).returns("hit")
+      function run() { return id(99); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-withargs-miss.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).toBe("unknown");
+  });
+
+  it("mock onFirstCall without returns is default value", () => {
+    const source = `
+      // @nudo:mock getPort = stub().onFirstCall(8080)
+      function run() { return getPort(); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-onfirst.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).toBe("8080");
+  });
+
+  it("mock sinon.stub().onFirstCall().returns() matches Abs path", () => {
+    const source = `
+      // @nudo:mock fetch = sinon.stub().onFirstCall().returns({ data: "first" })
+      function run() { return fetch(); }
+      const r = run();
+    `;
+    const result = analyzeFile("/t/diff-onfirst-sinon.js", source);
+    const run = result.functions.find((f) => f.name === "run");
+    const call = run!.cases.find((c) => c.source === "callsite");
+    expect(typeValueToString(call!.result)).not.toBe("unknown");
+    expect(typeValueToString(call!.result)).toContain("first");
+  });
+});

package/src/__tests__/analyzer.test.ts

@@ -188,7 +188,7 @@ function lonely(x) {
     const addFn = result.functions.find((f) => f.name === "add");
     expect(addFn!.cases).toHaveLength(2);
     expect(addFn!.cases[0].name).toBe("concrete");
-    expect(addFn!.cases[0].source).toBeUndefined();
+    expect(addFn!.cases[0].source).toBe("directive");
     expect(addFn!.entryOnly).toBeUndefined();
     expect(typeValueToString(addFn!.cases[0].result)).toBe("3");
     // 行为已修复：吸收律生效，combined 的字面量 3 被共存的 number 吸收（原期望 "3 | number"）
@@ -289,8 +289,12 @@ function lonely(u) {
       expect(triple.cases[0].name).toMatch(/^call@L\d+$/);
       expect(triple.cases[0].source).toBe("callsite");
       expect(triple.cases[0].args.map(typeValueToString)).toEqual(["4"]);
-      expect(typeValueToString(triple.cases[0].result)).toBe("12");
-      expect(typeValueToString(triple.combined)).toBe("12");
+      const caseResult = triple.cases[0].result;
+      if (caseResult === undefined) throw new Error("expected case result");
+      expect(typeValueToString(caseResult)).toBe("12");
+      const combined = triple.combined;
+      if (combined === undefined) throw new Error("expected combined result");
+      expect(typeValueToString(combined)).toBe("12");
       // imported function must not leak into this file's local functions
       expect(result.functions.map((f) => f.name)).toEqual(["caller"]);
     } finally {
@@ -647,6 +651,70 @@ describe("getCompletionsAtPosition", () => {
     expect(names).toContain("reduce");
     expect(names).toContain("length");
   });
+
+  // 来源：IDE 深度批次——union 接收者的 dot 补全不再返回空
+  it("completes only members common to every union member, with per-member type detail", () => {
+    const source = [
+      `const a = { x: 1, m() { return 1; } };`,
+      `const b = { x: 2 };`,
+      `const u = Math.random() > 0.5 ? a : b;`,
+      `u.x;`,
+    ].join("\n");
+    const completions = getCompletionsAtPosition("/test/union.js", source, 4, 2);
+    const names = completions.map((c) => c.label);
+    expect(names).toContain("x");
+    // m 只存在于一个成员：非公共成员不得出现在补全里
+    expect(names).not.toContain("m");
+    // detail 是各成员上该成员类型的并集渲染
+    const x = completions.find((c) => c.label === "x");
+    expect(x?.kind).toBe("property");
+    expect(x?.detail).toBe("1 | 2");
+  });
+
+  it("returns empty completions for a union with no common members", () => {
+    const source = [
+      `const c1 = { p: 1 };`,
+      `const c2 = { q: 2 };`,
+      `const u = Math.random() > 0.5 ? c1 : c2;`,
+      `u.a;`,
+    ].join("\n");
+    const completions = getCompletionsAtPosition("/test/union-empty.js", source, 4, 2);
+    expect(completions).toEqual([]);
+  });
+
+  // 来源：IDE 深度批次——内置方法 detail 不再硬编码，取 evaluator 真实 fnSig
+  it("derives array method detail from the evaluator instead of hardcoding", () => {
+    const source = `const arr = [1, 2, 3];\narr.map;\n`;
+    const completions = getCompletionsAtPosition("/test/arr-sig.js", source, 2, 4);
+    // Array.prototype.map 的近似签名：(_arg0: unknown) => unknown[]
+    expect(completions.find((c) => c.label === "map")?.detail).toBe("(_arg0: unknown) => unknown[]");
+    expect(completions.find((c) => c.label === "join")?.detail).toBe("(_arg0: string) => string");
+    // 字面量 [1,2,3] 求值为 tuple：length 是精确字面量
+    expect(completions.find((c) => c.label === "length")?.detail).toBe("3");
+    // 抽象 array（filter 结果）的 length 回到 number
+    const widened = getCompletionsAtPosition(
+      "/test/arr-wide.js",
+      `const arr = [1, "a"].filter(() => Math.random() > 0.5);\narr.m;\n`,
+      2,
+      4,
+    );
+    expect(widened.find((c) => c.label === "length")?.detail).toBe("number");
+  });
+
+  it("derives tuple length and string/promise method detail from the evaluator", () => {
+    const tuple = getCompletionsAtPosition("/test/tuple.js", `const pair = [1, "a"];\npair.x;\n`, 2, 5);
+    expect(tuple.find((c) => c.label === "length")?.detail).toBe("2");
+
+    // [1,2].join("-") 推断出 primitive string（字面量接收者不走 string 分支）
+    const str = getCompletionsAtPosition("/test/str.js", `const s = [1, 2].join("-");\ns.to;\n`, 2, 2);
+    expect(str.find((c) => c.label === "toUpperCase")?.detail).toBe("() => string");
+    expect(str.find((c) => c.label === "slice")?.detail).toBe("(_arg0: number, _arg1: number) => string");
+
+    const promise = getCompletionsAtPosition("/test/promise.js", `const p = Promise.resolve(1);\np.then;\n`, 2, 2);
+    expect(promise.find((c) => c.label === "then")?.detail).toBe("(_arg0: unknown) => Promise<unknown>");
+    // 派生自求值器原型近似表：含建模过的 Object.prototype 继承方法 toString
+    expect(promise.map((c) => c.label).sort()).toEqual(["catch", "finally", "then", "toString"]);
+  });
 });
 
 describe("buildModuleGraph / computeDirtySet / topoSortDirty", () => {