@nudojs/core 0.3.0 → 0.3.1

package/src/algebra/__tests__/leq.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { leqAbs } from "../leq.ts";
-import { abs, numLit, strLit, boolLit, num, str, unknown, never } from "../abs.ts";
-import { v, lit } from "../term.ts";
-import { gt, ge, pTrue } from "../pred.ts";
-
-function numWithPred(n: number, op: "gt" | "ge" = "gt") {
-  return abs(num().shape, v("x"), op === "gt" ? gt(v("x"), lit(n)) : ge(v("x"), lit(n)), "path");
-}
-
-describe("leqAbs structural assignability", () => {
-  it("never and unknown poles", () => {
-    expect(leqAbs(never, num()).ok).toBe(true);
-    expect(leqAbs(numLit(1), unknown).ok).toBe(true);
-  });
-
-  it("prim and literal", () => {
-    expect(leqAbs(numLit(1), num()).ok).toBe(true);
-    expect(leqAbs(strLit("a"), str()).ok).toBe(true);
-    expect(leqAbs(numLit(1), str()).ok).toBe(false);
-  });
-
-  it("object width and depth", () => {
-    const src = abs(
-      {
-        k: "obj",
-        slots: { a: { value: numLit(1) }, b: { value: strLit("x") } },
-      },
-      undefined,
-      undefined,
-      "exact",
-    );
-    const tgt = abs({ k: "obj", slots: { a: { value: num() } } }, undefined, undefined, "exact");
-    expect(leqAbs(src, tgt).ok).toBe(true);
-
-    const missing = abs({ k: "obj", slots: { z: { value: num() } } }, undefined, undefined, "exact");
-    expect(leqAbs(src, missing).ok).toBe(false);
-  });
-
-  it("optional slot may be missing", () => {
-    const src = abs({ k: "obj", slots: { a: { value: numLit(1) } } }, undefined, undefined, "exact");
-    const tgt = abs(
-      { k: "obj", slots: { a: { value: num() }, b: { value: str(), optional: true } } },
-      undefined,
-      undefined,
-      "exact",
-    );
-    expect(leqAbs(src, tgt).ok).toBe(true);
-  });
-
-  it("arr and tuple", () => {
-    const tup = abs({ k: "tuple", elements: [numLit(1), numLit(2)] }, undefined, undefined, "exact");
-    const arr = abs({ k: "arr", element: num() }, undefined, undefined, "exact");
-    expect(leqAbs(tup, arr).ok).toBe(true);
-    expect(leqAbs(arr, tup).ok).toBe(false);
-  });
-
-  it("brand is nominal", () => {
-    const a = abs(
-      { k: "brand", name: "A", shape: abs({ k: "obj", slots: {} }, undefined, undefined, "exact") },
-      undefined,
-      undefined,
-      "exact",
-    );
-    const b = abs(
-      { k: "brand", name: "B", shape: abs({ k: "obj", slots: {} }, undefined, undefined, "exact") },
-      undefined,
-      undefined,
-      "exact",
-    );
-    expect(leqAbs(a, a).ok).toBe(true);
-    expect(leqAbs(a, b).ok).toBe(false);
-  });
-
-  it("numeric pred: stricter source is assignable to wider target", () => {
-    const x5 = numWithPred(5, "gt");
-    const x0 = numWithPred(0, "gt");
-    expect(leqAbs(x5, x0).ok).toBe(true);
-    expect(leqAbs(x0, x5).ok).toBe(false);
-  });
-
-  it("eff promise inner", () => {
-    const p1 = abs(
-      { k: "eff", eff: "promise", inner: numLit(1) },
-      undefined,
-      undefined,
-      "exact",
-    );
-    const p2 = abs({ k: "eff", eff: "promise", inner: num() }, undefined, undefined, "exact");
-    expect(leqAbs(p1, p2).ok).toBe(true);
-  });
-
-  it("sum source requires all members assignable", () => {
-    const sum = abs(
-      { k: "sum", members: [numLit(1), numLit(2)] },
-      undefined,
-      undefined,
-      "exact",
-    );
-    expect(leqAbs(sum, num()).ok).toBe(true);
-    expect(leqAbs(sum, str()).ok).toBe(false);
-  });
-
-  it("fail reason is nudo-style", () => {
-    const r = leqAbs(numLit(1), str());
-    expect(r.ok).toBe(false);
-    expect(r.reason).toContain("prim");
-  });
-});

package/src/algebra/__tests__/load-deps-fp-memo.test.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  checkSource,
-  generalizeFromAst,
-  resetCheckSourceMemo,
-  resetGeneralizeMemo,
-  getCheckSourceMemoSize,
-  getGeneralizeMemoSize,
-  pTrue,
-} from "../index.ts";
-
-beforeEach(() => {
-  resetCheckSourceMemo();
-  resetGeneralizeMemo();
-});
-
-/** 生成 >64 个可达 require 依赖的源码 */
-function manyDepsSource(n: number): { src: string; deps: Record<string, string> } {
-  const deps: Record<string, string> = {};
-  let src = "";
-  for (let i = 0; i < n; i++) {
-    const name = `./d${i}.js`;
-    deps[`/t/d${i}.js`] = `module.exports = { n: ${i} };\n`;
-    src += `const m${i} = require("${name}");\n`;
-  }
-  src += `function id(x) { return x; }\nid(m0.n);\n`;
-  return { src, deps };
-}
-
-function makeLoad(deps: Record<string, string>) {
-  return (spec: string, fromFile: string) => {
-    const i = fromFile.lastIndexOf("/");
-    const base = i >= 0 ? fromFile.slice(0, i) : "";
-    const joined = spec.startsWith(".")
-      ? `${base}/${spec.replace(/^\.\//, "")}`
-      : spec;
-    return deps[joined];
-  };
-}
-
-describe("check memo fail-open on truncated dep fingerprint", () => {
-  it("does not memoize when loadable deps exceed the node cap", () => {
-    const { src, deps } = manyDepsSource(70);
-    const loadModule = makeLoad(deps);
-    const opts = { loadModule, fromFile: "/t/a.js" };
-    const r1 = checkSource("/t/a.js", src, pTrue, opts);
-    expect(r1).toBeDefined();
-    // 截断指纹不可信 → 不得写入整文件 memo
-    expect(getCheckSourceMemoSize()).toBe(0);
-  });
-
-  it("still re-checks after an uncached dep changes (no stale hit)", () => {
-    const { src, deps } = manyDepsSource(70);
-    // 假设 64 节点 cap 后 d69 可能未进指纹；改它再 check 必须重算
-    deps["/t/d69.js"] = `module.exports = { n: 999 };\n`;
-    const loadModule = makeLoad(deps);
-    const opts = { loadModule, fromFile: "/t/a.js" };
-    const r = checkSource("/t/a.js", src, pTrue, opts);
-    expect(r).toBeDefined();
-    expect(getCheckSourceMemoSize()).toBe(0);
-  });
-
-  it("memoizes normally under the node cap", () => {
-    const { src, deps } = manyDepsSource(3);
-    const loadModule = makeLoad(deps);
-    const opts = { loadModule, fromFile: "/t/a.js" };
-    checkSource("/t/a.js", src, pTrue, opts);
-    expect(getCheckSourceMemoSize()).toBe(1);
-  });
-});
-
-describe("generalize L0 fingerprints ordinary require deps", () => {
-  it("misses L0 when a plain require target changes (parent source unchanged)", () => {
-    let dep = `module.exports = { add1: (x) => x + 1 };\n`;
-    const loadModule = (spec: string) =>
-      spec === "./util.js" ? dep : undefined;
-    const src = `
-const util = require("./util.js");
-function go(x) {
-  return util.add1(x);
-}
-`;
-    const opts = {
-      refine: { loadModule, fromFile: "/t/a.js" },
-    };
-    const g0 = generalizeFromAst("go", src, opts);
-    expect(g0).toBeDefined();
-    expect(getGeneralizeMemoSize()).toBe(1);
-
-    dep = `module.exports = { add1: (x) => x + 10 };\n`;
-    const g1 = generalizeFromAst("go", src, opts);
-    expect(g1).toBeDefined();
-    // dep 内容变了 → L0 不得复用旧 PolyFn
-    expect(g1).not.toBe(g0);
-    expect(getGeneralizeMemoSize()).toBe(2);
-  });
-
-  it("still hits L0 when require target is unchanged", () => {
-    const dep = `module.exports = { add1: (x) => x + 1 };\n`;
-    const loadModule = (spec: string) =>
-      spec === "./util.js" ? dep : undefined;
-    const src = `
-const util = require("./util.js");
-function go(x) {
-  return util.add1(x);
-}
-`;
-    const opts = {
-      refine: { loadModule, fromFile: "/t/a.js" },
-    };
-    const g0 = generalizeFromAst("go", src, opts);
-    const g1 = generalizeFromAst("go", src, opts);
-    expect(g1).toBe(g0);
-    expect(getGeneralizeMemoSize()).toBe(1);
-  });
-
-  it("does not write L0 when deps fingerprint is truncated", () => {
-    const deps: Record<string, string> = {};
-    let src = "";
-    for (let i = 0; i < 70; i++) {
-      deps[`/t/d${i}.js`] = `module.exports = { n: ${i} };\n`;
-      src += `const m${i} = require("./d${i}.js");\n`;
-    }
-    src += `function id(x) { return x; }\nid(m0.n);\n`;
-    const loadModule = makeLoad(deps);
-    const g0 = generalizeFromAst("id", src, {
-      refine: { loadModule, fromFile: "/t/a.js" },
-    });
-    expect(g0).toBeDefined();
-    expect(getGeneralizeMemoSize()).toBe(0);
-  });
-});

package/src/algebra/__tests__/methods.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { callAbsMethod, getAbsProperty } from "../methods.ts";
-import { createTemplateAbs } from "../template.ts";
-import { strLit, numLit, abs } from "../abs.ts";
-import { typeValueToString } from "../../type-value.ts";
-import { absToTypeValue } from "../bridge.ts";
-import { analyzeFn } from "../ast-eval.ts";
-
-describe("Abs method table", () => {
-  it("template startsWith with known prefix", () => {
-    // `xy${string}`
-    const tmpl = createTemplateAbs([strLit("xy"), abs({ k: "prim", type: "string" }, undefined, undefined, "exact")]);
-    const r = callAbsMethod(tmpl, "startsWith", [strLit("x")]);
-    expect(r && typeValueToString(absToTypeValue(r))).toBe("true");
-    const r2 = callAbsMethod(tmpl, "startsWith", [strLit("a")]);
-    expect(r2 && typeValueToString(absToTypeValue(r2))).toBe("false");
-  });
-
-  it("template length with all-literal parts", () => {
-    // createTemplateAbs with two lits folds to single lit; use mixed
-    const tmpl = createTemplateAbs([strLit("ab"), abs({ k: "prim", type: "string" }, undefined, undefined, "exact")]);
-    const len = getAbsProperty(tmpl, "length");
-    expect(len).toBeDefined();
-    expect(len!.shape.k).toBe("prim");
-  });
-
-  it("analyzeFn uses method table", () => {
-    const src = `
-      function f(x) {
-        const s = "xy" + x;
-        return s.startsWith("x");
-      }
-    `;
-    const r = analyzeFn(src, "f", [abs({ k: "prim", type: "string" }, undefined, undefined, "exact")]);
-    expect(typeValueToString(absToTypeValue(r))).toBe("true");
-  });
-});

package/src/algebra/__tests__/node-types.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { collectAbsNodeTypes, findAbsAtPosition } from "../ast-eval.ts";
-import { formatAbs } from "../format.ts";
-
-describe("Abs node type map", () => {
-  it("collects node → Abs for expressions", () => {
-    const source = `const x = 1 + 2;\nconst y = x * 3;\n`;
-    const map = collectAbsNodeTypes(source);
-    expect(map.size).toBeGreaterThan(0);
-    const values = [...map.values()].map((a) => formatAbs(a));
-    expect(values.some((s) => s.includes("3"))).toBe(true);
-  });
-
-  it("findAbsAtPosition picks tightest node", () => {
-    // `const x = 1 + 2;`
-    //  col 10 = `1`, col 14 = `2` (0-based)
-    const source = `const x = 1 + 2;\n`;
-    const map = collectAbsNodeTypes(source);
-    const at1 = findAbsAtPosition(map, 1, 10);
-    expect(at1).toBeDefined();
-    expect(formatAbs(at1!)).toContain("1");
-    const at2 = findAbsAtPosition(map, 1, 14);
-    expect(at2).toBeDefined();
-    expect(formatAbs(at2!)).toContain("2");
-  });
-});

package/src/algebra/__tests__/nudo-constraints.ts

@@ -1,46 +0,0 @@
-/**
- * 测试用标准约束库（*.nudo.js 形态）。
- * 金标统一：@nudo:refine <param> <name>
- */
-export const STD_NUDO_SRC = `
-export const positive = number().gt(0);
-export const delay = number().gt(0);
-export const nonNeg = number().ge(0);
-export const percent = number().ge(0).le(100);
-export const port = number().ge(1).le(65535);
-export const small = number().lt(10);
-export const atLeast1 = number().ge(1);
-export const max100 = number().le(100);
-export const intId = number().int().gt(0);
-export const shortName = string().min(1).max(20);
-export const positives = array(number().gt(0));
-export const userShape = shape({
-  id: number().gt(0),
-  name: string(),
-});
-export const configShape = shape({
-  retries: number().ge(0).le(5),
-  label: string().optional(),
-});
-export const orderShape = shape({
-  user: shape({ id: number().gt(0), name: string() }),
-  tags: array(string().min(1)),
-});
-`;
-
-/** 给无 import 的测试源补上标准 import 行 */
-export function withStdImport(source: string): string {
-  if (source.includes("@nudo:import")) return source;
-  return `/// @nudo:import { positive, delay, nonNeg, percent, port, small, atLeast1, max100, intId, shortName, positives, userShape, configShape, orderShape } from "./std.nudo.js"\n${source}`;
-}
-
-/** checkSource 用的 loadModule */
-export function stdLoadModule(spec: string): string | undefined {
-  if (spec.includes("std.nudo") || spec.endsWith(".nudo.js")) return STD_NUDO_SRC;
-  return undefined;
-}
-
-export const stdOpts = {
-  loadModule: stdLoadModule,
-  fromFile: "/test/file.js",
-};

package/src/algebra/__tests__/objects.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  analyzeFn,
-  objOf,
-  spread,
-  joinAbs,
-  joinObjects,
-  collapseToOptional,
-  numLit,
-  strLit,
-  boolLit,
-  numVar,
-  gtNum,
-  v,
-  lit,
-  litValue,
-  formatAbs,
-  formatShape,
-  isObj,
-} from "../index.ts";
-
-describe("objects: spread", () => {
-  it("defaults ⊕ {port:3000} keeps host and overwrites port", () => {
-    const defaults = objOf({
-      host: { value: strLit("localhost") },
-      port: { value: numLit(8080) },
-      debug: { value: boolLit(false) },
-    });
-    const over = objOf({
-      port: { value: numLit(3000) },
-      debug: { value: boolLit(true) },
-    });
-    const r = spread(defaults, over);
-    expect(isObj(r)).toBe(true);
-    if (!isObj(r)) return;
-    expect(litValue(r.shape.slots.host!.value)).toBe("localhost");
-    expect(litValue(r.shape.slots.port!.value)).toBe(3000);
-    expect(litValue(r.shape.slots.debug!.value)).toBe(true);
-  });
-
-  it("createConfig from source keeps literal results per call site", () => {
-    const src = `
-      function createConfig(options) {
-        return {
-          host: "localhost",
-          port: 8080,
-          debug: false,
-          ...options,
-        };
-      }
-    `;
-    const r1 = analyzeFn(src, "createConfig", [
-      objOf({ port: { value: numLit(3000) }, debug: { value: boolLit(true) } }),
-    ]);
-    expect(isObj(r1)).toBe(true);
-    if (!isObj(r1)) return;
-    expect(litValue(r1.shape.slots.host!.value)).toBe("localhost");
-    expect(litValue(r1.shape.slots.port!.value)).toBe(3000);
-    expect(litValue(r1.shape.slots.debug!.value)).toBe(true);
-
-    const r2 = analyzeFn(src, "createConfig", [objOf({})]);
-    if (!isObj(r2)) return;
-    expect(litValue(r2.shape.slots.port!.value)).toBe(8080);
-  });
-});
-
-describe("objects: join", () => {
-  it("same keys, different literal values → join drops term, keeps prim", () => {
-    const a = objOf({ a: { value: numLit(1) } });
-    const b = objOf({ a: { value: numLit(2) } });
-    const r = joinObjects(a, b);
-    expect(isObj(r)).toBe(true);
-    if (!isObj(r)) return;
-    expect(r.shape.slots.a!.value.shape).toEqual({ k: "prim", type: "number" });
-    expect(r.shape.slots.a!.value.term).toBeUndefined();
-  });
-
-  it("different key sets → sum, NOT optional collapse", () => {
-    const a = objOf({ port: { value: numLit(3000) } });
-    const b = objOf({});
-    const r = joinAbs(a, b);
-    // 应是 sum 而不是 { port?: number }
-    expect(r.shape.k).toBe("sum");
-  });
-
-  it("collapseToOptional is explicit loss and #widened", () => {
-    const a = objOf({ port: { value: numLit(3000) }, debug: { value: boolLit(true) } });
-    const b = objOf({ host: { value: strLit("x") } });
-    const sum = joinAbs(a, b);
-    expect(sum.shape.k).toBe("sum");
-    const collapsed = collapseToOptional(sum);
-    expect(collapsed.conf).toBe("widened");
-    expect(collapsed.shape.k).toBe("obj");
-    if (collapsed.shape.k !== "obj") return;
-    expect(collapsed.shape.slots.port!.optional).toBe(true);
-    expect(collapsed.shape.slots.host!.optional).toBe(true);
-    expect(collapsed.shape.slots.debug!.optional).toBe(true);
-  });
-});
-
-describe("format", () => {
-  it("formats literal number", () => {
-    expect(formatShape(numLit(4))).toBe("4");
-  });
-  it("formats with term and pred", () => {
-    const phi = gtNum(v("x"), 0);
-    const src = `
-      const add = (a, b) => a + b;
-      function scale(x) { return add(x, 1); }
-    `;
-    const r = analyzeFn(src, "scale", [numVar("x", gtNum(v("x"), 0))], phi);
-    const s = formatAbs(r);
-    expect(s).toContain("number");
-    expect(s).toContain("(x + 1)");
-    expect(s).toContain(">");
-  });
-});

package/src/algebra/__tests__/parse-source-cache.test.ts

@@ -1,42 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  parseSource,
-  resetParseSourceCache,
-  getParseSourceCacheSize,
-} from "../index.ts";
-
-const SRC = "function add(a, b) { return a + b; }\n";
-
-beforeEach(() => {
-  resetParseSourceCache();
-});
-
-describe("parseSource AST LRU", () => {
-  it("returns same File for identical source", () => {
-    const a = parseSource(SRC);
-    const b = parseSource(SRC);
-    expect(b).toBe(a);
-    expect(getParseSourceCacheSize()).toBe(1);
-  });
-
-  it("misses when source changes", () => {
-    const a = parseSource(SRC);
-    const b = parseSource(SRC + "\n// t\n");
-    expect(b).not.toBe(a);
-    expect(getParseSourceCacheSize()).toBe(2);
-  });
-
-  it("does not cache errorRecovery parses", () => {
-    parseSource(SRC, { errorRecovery: true });
-    expect(getParseSourceCacheSize()).toBe(0);
-    parseSource(SRC);
-    expect(getParseSourceCacheSize()).toBe(1);
-  });
-
-  it("LRU evicts oldest beyond cap", () => {
-    for (let i = 0; i < 20; i++) {
-      parseSource(`${SRC}// ${i}\n`);
-    }
-    expect(getParseSourceCacheSize()).toBeLessThanOrEqual(16);
-  });
-});

package/src/algebra/__tests__/refine-import.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  number,
-  instantiateConstraint,
-  isNudoConstraint,
-} from "../constraint.ts";
-import {
-  execNudoModule,
-  extractNudoImports,
-  extractRefinesFromSource,
-  refineToIndexedFull,
-} from "../refine.ts";
-import { checkSource, pTrue } from "../index.ts";
-import { predToString } from "../pred.ts";
-
-const intf = `
-export const delay = number().gt(0);
-export const percent = number().ge(0).le(100);
-`;
-
-const loadModule = (spec: string): string | undefined => {
-  if (spec.includes("nudo")) return intf;
-  return undefined;
-};
-
-describe("@nudo:refine <param> <constraint>", () => {
-  it("number().gt(0) instantiates to param > 0", () => {
-    const c = number().gt(0);
-    expect(isNudoConstraint(c)).toBe(true);
-    expect(predToString(instantiateConstraint(c, "ms"))).toBe("ms > 0");
-  });
-
-  it("chains bounds", () => {
-    const c = number().ge(0).le(100);
-    expect(predToString(instantiateConstraint(c, "n"))).toContain("0");
-    expect(predToString(instantiateConstraint(c, "n"))).toContain("100");
-  });
-
-  it("executes .nudo.js module", () => {
-    const exp = execNudoModule(intf);
-    expect(Object.keys(exp).sort()).toEqual(["delay", "percent"]);
-    expect(isNudoConstraint(exp.delay)).toBe(true);
-  });
-
-  it("parses named @nudo:import", () => {
-    const src = `/// @nudo:import { delay, percent } from "./x.nudo.js"\n`;
-    expect(extractNudoImports(src)).toEqual([
-      { names: ["delay", "percent"], spec: "./x.nudo.js" },
-    ]);
-  });
-
-  it("resolves ms delay to Pred", () => {
-    const src = `
-/// @nudo:import { delay } from "./x.nudo.js"
-/**
- * @nudo:refine ms delay
- */
-function setDelay(ms) {
-  if (ms > 0) return ms;
-  return 0;
-}
-`;
-    const reqs = extractRefinesFromSource(src, "setDelay", {
-      loadModule,
-      fromFile: "/t/demo.js",
-    });
-    expect(reqs.length).toBe(1);
-    expect(reqs[0]!.param).toBe("ms");
-    expect(predToString(reqs[0]!.pred)).toBe("ms > 0");
-  });
-
-  it("check catches violation from template", () => {
-    const src = `
-/// @nudo:import { delay } from "./x.nudo.js"
-/**
- * @nudo:refine ms delay
- */
-function setDelay(ms) {
-  if (ms > 0) return ms;
-  return 0;
-}
-setDelay(0);
-`;
-    const r = checkSource("/t/demo.js", src, pTrue, {
-      loadModule,
-      fromFile: "/t/demo.js",
-    });
-    expect(r.ok).toBe(false);
-    expect(r.issues.some((i) => i.code === "nudo:constraint-violated")).toBe(true);
-  });
-
-  it("refineToIndexedFull maps param names", () => {
-    const src = `
-/// @nudo:import { delay, percent } from "./x.nudo.js"
-/**
- * @nudo:refine ms delay
- * @nudo:refine n percent
- */
-function f(ms, n) {
-  return ms + n;
-}
-`;
-    const idx = refineToIndexedFull(src, "f", ["ms", "n"], {
-      loadModule,
-      fromFile: "/t/f.js",
-    });
-    expect(idx.length).toBe(2);
-  });
-});

package/src/algebra/__tests__/stable-source-key-block.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { stableAnalyzeKeySource } from "../stable-source-key.ts";
-
-describe("stableAnalyzeKeySource trailing block comments", () => {
-  it("strips trailing non-nudo block comments", () => {
-    const a = "function f() { return 1; }\n";
-    const b = "function f() { return 1; }\n/* trailing note */\n";
-    const c = "function f() { return 1; }\n/*\n * multi\n * line\n */\n";
-    expect(stableAnalyzeKeySource(b)).toBe(stableAnalyzeKeySource(a));
-    expect(stableAnalyzeKeySource(c)).toBe(stableAnalyzeKeySource(a));
-  });
-
-  it("keeps trailing block comments that carry @nudo", () => {
-    const a = "function f() { return 1; }\n";
-    const b = 'function f() { return 1; }\n/* @nudo:case "x" (1) */\n';
-    expect(stableAnalyzeKeySource(b)).not.toBe(stableAnalyzeKeySource(a));
-  });
-
-  it("does not strip block-comment markers inside code lines", () => {
-    const src = 'const s = "/* not a comment */";\n';
-    expect(stableAnalyzeKeySource(src).trimEnd()).toBe(src.trimEnd());
-  });
-});

package/src/algebra/__tests__/stable-source-key.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { stableAnalyzeKeySource } from "../stable-source-key.ts";
-
-describe("stableAnalyzeKeySource", () => {
-  it("strips trailing non-nudo line comments", () => {
-    const a = "function f() { return 1; }\n";
-    const b = "function f() { return 1; }\n// hello\n";
-    const c = "function f() { return 1; }\n\n// t0\n// t1\n";
-    expect(stableAnalyzeKeySource(b)).toBe(stableAnalyzeKeySource(a));
-    expect(stableAnalyzeKeySource(c)).toBe(stableAnalyzeKeySource(a));
-  });
-
-  it("keeps trailing @nudo comments", () => {
-    const a = "function f() { return 1; }\n";
-    const b = "function f() { return 1; }\n// @nudo:case \"x\" (1)\n";
-    expect(stableAnalyzeKeySource(b)).not.toBe(stableAnalyzeKeySource(a));
-  });
-
-  it("keeps JSDoc nudo blocks", () => {
-    const a = "/**\n * @nudo:case \"c\" (1)\n */\nfunction f(x) { return x; }\n";
-    const b = a + "// trailing\n";
-    expect(stableAnalyzeKeySource(b)).toBe(stableAnalyzeKeySource(a));
-    expect(stableAnalyzeKeySource(a)).toContain("@nudo:case");
-  });
-
-  it("normalizes trailing blank lines", () => {
-    const a = "let x = 1;\n";
-    const b = "let x = 1;\n\n\n";
-    expect(stableAnalyzeKeySource(b)).toBe(stableAnalyzeKeySource(a));
-  });
-});