@modusensus/dsh-mneme 0.8.2 → 0.8.4

package/test/runtime-tarball.test.js

@@ -1,82 +1,82 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { gzipSync } from "node:zlib";
-import { sha512Base64, stripPackagePrefix, verifyIntegrity, walkTar, walkTgz } from "../src/runtime/tarball.js";
-import { tarFile, tarHeader, tarMeta, tarPax } from "./helpers/tar-builder.js";
-
-// PR-C 下载通道的归档读取层。这里是整条链里最该被单独守住的一块：它读的是别人产出的字节，
-// 一旦读错，我们就会把「缺文件/文件截断」的运行时当成完整的搬进 payload，而那种错误
-// 要到第一次 import 原生模块时才现形。
-//
-// 合成归档在测试里现造（不引 tar 库），另外单独用 npm pack 产出的真实 .tgz 做过一次交叉核对
-// （见 PR 描述里的验证记录）——合成归档只能证明读取器与规范一致，真实产物才能证明它与 npm 一致。
-
-const END = [Buffer.alloc(512), Buffer.alloc(512)];
-
-function collect(buffer) {
-  const seen = [];
-  const stats = walkTar(buffer, (entry) => seen.push([entry.path, entry.data.toString("utf8")]));
-  return { seen, stats };
-}
-
-test("walkTar：普通文件、目录、prefix 长路径、符号链接跳过、归档结束块都能处理", () => {
-  const archive = Buffer.concat([
-    ...tarFile("package/package.json", '{"name":"x"}\n'),
-    ...tarMeta("package/lib", "5"),
-    ...tarFile("api.js", "export const x = 1;\n", { prefix: "package/a/very/long/nested/path" }),
-    ...tarMeta("package/link", "2"),
-    ...END
-  ]);
-
-  const { seen, stats } = collect(archive);
-  assert.deepEqual(seen, [
-    ["package/package.json", '{"name":"x"}\n'],
-    ["package/a/very/long/nested/path/api.js", "export const x = 1;\n"]
-  ]);
-  assert.equal(stats.files, 2);
-  assert.equal(stats.bytes, Buffer.byteLength('{"name":"x"}\n') + Buffer.byteLength("export const x = 1;\n"));
-  // 符号链接不能假装搬过来了 —— 如实记下，让上层去判断要不要失败。
-  assert.equal(stats.skipped.length, 1);
-  assert.match(stats.skipped[0], /package\/link/);
-});
-
-test("walkTar：pax 的 path 覆盖下一条目（超过 ustar 字段长度的深层路径靠它）", () => {
-  const long = `package/${"d".repeat(120)}/${"e".repeat(120)}/file.js`;
-  const archive = Buffer.concat([...tarPax(long), ...tarFile("truncated-name", "ok\n"), ...END]);
-  const { seen } = collect(archive);
-  assert.deepEqual(seen.map(([p]) => p), [long]);
-});
-
-test("walkTar：没有结束块也能读完（registry 产物有，但别依赖它）", () => {
-  const { seen } = collect(Buffer.concat([...tarFile("package/a.txt", "a\n")]));
-  assert.deepEqual(seen, [["package/a.txt", "a\n"]]);
-});
-
-test("walkTgz：gzip 包装的归档走同一条路", () => {
-  const inner = Buffer.concat([...tarFile("package/package.json", "{}\n"), ...END]);
-  // 未压缩那份用 walkTar 读，压缩那份用 walkTgz 读，两者结论必须一致。
-  const plain = collect(inner).seen;
-  const viaGzip = [];
-  const stats = walkTgz(gzipSync(inner), (entry) => viaGzip.push([entry.path, entry.data.toString("utf8")]));
-  assert.deepEqual(viaGzip, plain);
-  assert.equal(stats.files, 1);
-});
-
-test("stripPackagePrefix：只去 npm 那一层前缀", () => {
-  assert.equal(stripPackagePrefix("package/lib/index.js"), "lib/index.js");
-  assert.equal(stripPackagePrefix("package"), "package");
-  assert.equal(stripPackagePrefix("lib/index.js"), "lib/index.js");
-});
-
-test("verifyIntegrity：只认 sha512，且不匹配就是不匹配", () => {
-  const good = Buffer.from("hello tarball");
-  const integrity = `sha512-${sha512Base64(good)}`;
-  assert.equal(verifyIntegrity(good, integrity), true);
-
-  const tampered = Buffer.from("hello tarbal!");
-  assert.equal(verifyIntegrity(tampered, integrity), false, "差一个字节也必须失败");
-  // 不认识的算法不能放行：那等于把「没校验」说成「校验通过」。
-  assert.equal(verifyIntegrity(good, "md5-YWJj"), false);
-  assert.equal(verifyIntegrity(good, ""), false);
-  assert.equal(verifyIntegrity(good, "sha512-"), false);
+import test from "node:test";
+import assert from "node:assert/strict";
+import { gzipSync } from "node:zlib";
+import { sha512Base64, stripPackagePrefix, verifyIntegrity, walkTar, walkTgz } from "../src/runtime/tarball.js";
+import { tarFile, tarHeader, tarMeta, tarPax } from "./helpers/tar-builder.js";
+
+// PR-C 下载通道的归档读取层。这里是整条链里最该被单独守住的一块：它读的是别人产出的字节，
+// 一旦读错，我们就会把「缺文件/文件截断」的运行时当成完整的搬进 payload，而那种错误
+// 要到第一次 import 原生模块时才现形。
+//
+// 合成归档在测试里现造（不引 tar 库），另外单独用 npm pack 产出的真实 .tgz 做过一次交叉核对
+// （见 PR 描述里的验证记录）——合成归档只能证明读取器与规范一致，真实产物才能证明它与 npm 一致。
+
+const END = [Buffer.alloc(512), Buffer.alloc(512)];
+
+function collect(buffer) {
+  const seen = [];
+  const stats = walkTar(buffer, (entry) => seen.push([entry.path, entry.data.toString("utf8")]));
+  return { seen, stats };
+}
+
+test("walkTar：普通文件、目录、prefix 长路径、符号链接跳过、归档结束块都能处理", () => {
+  const archive = Buffer.concat([
+    ...tarFile("package/package.json", '{"name":"x"}\n'),
+    ...tarMeta("package/lib", "5"),
+    ...tarFile("api.js", "export const x = 1;\n", { prefix: "package/a/very/long/nested/path" }),
+    ...tarMeta("package/link", "2"),
+    ...END
+  ]);
+
+  const { seen, stats } = collect(archive);
+  assert.deepEqual(seen, [
+    ["package/package.json", '{"name":"x"}\n'],
+    ["package/a/very/long/nested/path/api.js", "export const x = 1;\n"]
+  ]);
+  assert.equal(stats.files, 2);
+  assert.equal(stats.bytes, Buffer.byteLength('{"name":"x"}\n') + Buffer.byteLength("export const x = 1;\n"));
+  // 符号链接不能假装搬过来了 —— 如实记下，让上层去判断要不要失败。
+  assert.equal(stats.skipped.length, 1);
+  assert.match(stats.skipped[0], /package\/link/);
+});
+
+test("walkTar：pax 的 path 覆盖下一条目（超过 ustar 字段长度的深层路径靠它）", () => {
+  const long = `package/${"d".repeat(120)}/${"e".repeat(120)}/file.js`;
+  const archive = Buffer.concat([...tarPax(long), ...tarFile("truncated-name", "ok\n"), ...END]);
+  const { seen } = collect(archive);
+  assert.deepEqual(seen.map(([p]) => p), [long]);
+});
+
+test("walkTar：没有结束块也能读完（registry 产物有，但别依赖它）", () => {
+  const { seen } = collect(Buffer.concat([...tarFile("package/a.txt", "a\n")]));
+  assert.deepEqual(seen, [["package/a.txt", "a\n"]]);
+});
+
+test("walkTgz：gzip 包装的归档走同一条路", () => {
+  const inner = Buffer.concat([...tarFile("package/package.json", "{}\n"), ...END]);
+  // 未压缩那份用 walkTar 读，压缩那份用 walkTgz 读，两者结论必须一致。
+  const plain = collect(inner).seen;
+  const viaGzip = [];
+  const stats = walkTgz(gzipSync(inner), (entry) => viaGzip.push([entry.path, entry.data.toString("utf8")]));
+  assert.deepEqual(viaGzip, plain);
+  assert.equal(stats.files, 1);
+});
+
+test("stripPackagePrefix：只去 npm 那一层前缀", () => {
+  assert.equal(stripPackagePrefix("package/lib/index.js"), "lib/index.js");
+  assert.equal(stripPackagePrefix("package"), "package");
+  assert.equal(stripPackagePrefix("lib/index.js"), "lib/index.js");
+});
+
+test("verifyIntegrity：只认 sha512，且不匹配就是不匹配", () => {
+  const good = Buffer.from("hello tarball");
+  const integrity = `sha512-${sha512Base64(good)}`;
+  assert.equal(verifyIntegrity(good, integrity), true);
+
+  const tampered = Buffer.from("hello tarbal!");
+  assert.equal(verifyIntegrity(tampered, integrity), false, "差一个字节也必须失败");
+  // 不认识的算法不能放行：那等于把「没校验」说成「校验通过」。
+  assert.equal(verifyIntegrity(good, "md5-YWJj"), false);
+  assert.equal(verifyIntegrity(good, ""), false);
+  assert.equal(verifyIntegrity(good, "sha512-"), false);
 });

package/test/runtime-verify.test.js

@@ -1,214 +1,214 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { DEFAULT_PROBE_TEXTS, defaultEngine, verifyFunctional, verifyPayload } from "../src/runtime/verify.js";
-import { TRANSFORMERS_ENTRY } from "../src/runtime/layout.js";
-import { pathToFileURL } from "node:url";
-
-// 验证三件套（issue #131 / PR-A）。重点不是「能跑通」，而是「坏的那几种能被抓住」：
-// 结构对但原生二进制与本机不匹配、返回非归一化向量、向量退化、加载直接抛——
-// 这些都必须变成一条可读的失败结论，而不是让调用方拿到一个假的 ok。
-
-/** 造一个结构上合法的 payload（只有形状，没有真东西）。 */
-function makePayload({ platform = "win32", arch = "x64", withEntry = true } = {}) {
-  const dir = mkdtempSync(join(tmpdir(), "mneme-verify-"));
-  const write = (rel, body) => {
-    const full = join(dir, rel);
-    mkdirSync(join(full, ".."), { recursive: true });
-    writeFileSync(full, body);
-  };
-  for (const name of ["@huggingface/transformers", "onnxruntime-node", "sharp"]) {
-    write(join("node_modules", name, "package.json"), JSON.stringify({ name, version: name === "@huggingface/transformers" ? "4.2.0" : "1.0.0" }));
-  }
-  if (withEntry) write(TRANSFORMERS_ENTRY, "export const x = 1;\n");
-  mkdirSync(join(dir, "node_modules", "onnxruntime-node", "bin", "napi-v6", platform, arch), { recursive: true });
-  return dir;
-}
-
-/** 归一化的假向量：`rows` 行，每行 dim 维，方向由 seed 决定。 */
-function fakeRows(rows, dim, seed = 0) {
-  return Array.from({ length: rows }, (_, r) => {
-    const v = Array.from({ length: dim }, (_, i) => Math.sin((i + 1) * (r + 1 + seed)));
-    const length = Math.hypot(...v);
-    return v.map((x) => x / length);
-  });
-}
-
-/** 注入一个「什么都能返回」的 engine。 */
-function engineReturning(value) {
-  return async () => async () => value;
-}
-
-test("功能验证：正常的向量通过，并报出维度与耗时", async () => {
-  const result = await verifyFunctional("/whatever", { engine: engineReturning(fakeRows(2, 512)) });
-  assert.equal(result.ok, true, result.reason);
-  assert.equal(result.dim, 512);
-  assert.equal(result.rows, 2);
-  assert.ok(result.elapsedMs >= 0);
-});
-
-test("功能验证：行数不符要报出来（而不是只取第一行当作通过）", async () => {
-  const result = await verifyFunctional("/whatever", { engine: engineReturning(fakeRows(1, 512)) });
-  assert.equal(result.ok, false);
-  assert.match(result.reason, /返回行数不符/);
-});
-
-test("功能验证：非归一化向量要报出来（说明 normalize 没生效）", async () => {
-  const rows = fakeRows(2, 8).map((row) => row.map((x) => x * 3));
-  const result = await verifyFunctional("/whatever", { engine: engineReturning(rows) });
-  assert.equal(result.ok, false);
-  assert.match(result.reason, /不是 L2 归一化/);
-});
-
-test("功能验证：向量退化成同一方向要报出来", async () => {
-  const one = fakeRows(1, 16)[0];
-  const result = await verifyFunctional("/whatever", { engine: engineReturning([one, one]) });
-  assert.equal(result.ok, false);
-  assert.match(result.reason, /嵌入退化/);
-});
-
-test("功能验证：加载失败与推理失败分别给出不同措辞", async () => {
-  const loadFail = await verifyFunctional("/whatever", {
-    engine: async () => {
-      throw new Error("Cannot find package 'onnxruntime-node'");
-    }
-  });
-  assert.equal(loadFail.ok, false);
-  assert.match(loadFail.reason, /加载运行时失败/);
-  assert.match(loadFail.reason, /onnxruntime-node/);
-
-  const embedFail = await verifyFunctional("/whatever", {
-    engine: async () => async () => {
-      throw new Error("boom");
-    }
-  });
-  assert.equal(embedFail.ok, false);
-  assert.match(embedFail.reason, /推理失败/);
-});
-
-test("功能验证：返回空向量要报出来，而不是当成 dim=0 通过", async () => {
-  const result = await verifyFunctional("/whatever", { engine: engineReturning([[], []]) });
-  assert.equal(result.ok, false);
-  assert.match(result.reason, /空向量/);
-});
-
-test("三件套：结构不过就不再做功能验证（省掉一次无谓的加载）", async () => {
-  const dir = makePayload({ withEntry: false });
-  let engineCalled = false;
-  const result = await verifyPayload(dir, {
-    platform: "win32",
-    arch: "x64",
-    engine: async () => {
-      engineCalled = true;
-      return async () => fakeRows(2, 8);
-    }
-  });
-  assert.equal(result.ok, false);
-  assert.equal(result.functional.ok, false);
-  assert.match(result.functional.reason, /跳过功能验证/);
-  assert.equal(engineCalled, false);
-});
-
-test("三件套：结构 + 功能都过、完整性缺失时如实标 unverified 且不判定失败", async () => {
-  const dir = makePayload();
-  const result = await verifyPayload(dir, {
-    platform: "win32",
-    arch: "x64",
-    engine: engineReturning(fakeRows(2, 8))
-  });
-  assert.equal(result.ok, true);
-  assert.equal(result.integrity.status, "unverified");
-  assert.equal(result.integrity.ok, true);
-  assert.equal(result.version, "4.2.0");
-});
-
-test("三件套：--strict 场景下哈希不匹配即整体不通过", async () => {
-  const dir = makePayload();
-  const matched = await verifyPayload(dir, {
-    platform: "win32",
-    arch: "x64",
-    engine: engineReturning(fakeRows(2, 8)),
-    integrity: { status: "sha512-matched", detail: "tarball 比对通过" }
-  });
-  assert.equal(matched.ok, true);
-  assert.equal(matched.integrity.status, "sha512-matched");
-
-  const mismatch = await verifyPayload(dir, {
-    platform: "win32",
-    arch: "x64",
-    engine: engineReturning(fakeRows(2, 8)),
-    integrity: { status: "sha512-mismatch", detail: "与钉死的哈希不一致" }
-  });
-  assert.equal(mismatch.ok, false);
-  assert.equal(mismatch.structural.ok, true, "结构仍然是对的，失败来自完整性");
-  assert.equal(mismatch.functional.ok, true);
-});
-
-test("假通过防线 ①：行不是数组时返回失败，而不是抛异常", async () => {
-  // 契约是「任何失败都返回结果对象，不抛」；非数组行会让 .length/.some 直接抛。
-  const dir = makePayload();
-  const result = await verifyPayload(dir, {
-    platform: "win32",
-    arch: "x64",
-    engine: engineReturning([null, null])
-  });
-  assert.equal(result.ok, false);
-  assert.match(result.functional.reason, /不是数组/);
-});
-
-test("假通过防线 ②：非有限数值必须判失败（NaN 的比较恒为 false，会静默通过）", async () => {
-  const dir = makePayload();
-  for (const bad of [[NaN, 0], [Infinity, 0], ["0.5", "0.5"]]) {
-    const result = await verifyPayload(dir, {
-      platform: "win32",
-      arch: "x64",
-      engine: engineReturning([bad, [0, 0]])
-    });
-    assert.equal(result.ok, false, `含 ${JSON.stringify(bad)} 的向量不该被判通过`);
-    assert.match(result.functional.reason, /非有限数值/);
-  }
-});
-
-test("默认 engine 是导出的函数，且探针文本固定（改它等于改验收标准）", () => {
-  assert.equal(typeof defaultEngine, "function");
-  assert.deepEqual(DEFAULT_PROBE_TEXTS, ["猫咪喜欢晒太阳", "the quick brown fox"]);
-});
-
-// ── defaultEngine：注入假 transformers 模块，钉住「真 import + 行切分」的契约 ──
-
-/** 造一个假 transformers 入口：export env + pipeline，把收到的参数记到 globalThis。 */
-function fakeEntry(dims) {
-  const dir = mkdtempSync(join(tmpdir(), "mneme-engine-"));
-  const entry = join(dir, "entry.mjs");
-  writeFileSync(entry, `
-export const env = {};
-export async function pipeline(kind, model, opts) {
-  globalThis.__engineSeen = { kind, model, opts, cacheDir: env.cacheDir, remote: env.allowRemoteModels };
-  const d = ${JSON.stringify(dims)};
-  const data = Float32Array.from({ length: d[0] * d[1] }, (_, i) => i + 1);
-  return async () => ({ dims: d, data });
-}
-`);
-  return pathToFileURL(entry).href;
-}
-
-test("defaultEngine: 假 transformers 入口可驱动嵌入，并按输出维度做行切分", async () => {
-  const entry = fakeEntry([2, 4]);
-  const embed = await defaultEngine(entry, { cacheDir: "/tmp/mneme-cache" });
-  const rows = await embed(["猫咪", "fox"]);
-  assert.equal(rows.length, 2);
-  assert.deepEqual(rows[0], [1, 2, 3, 4]);
-  assert.deepEqual(rows[1], [5, 6, 7, 8]);
-  // 缓存目录与离线开关必须落到 env：验证过程绝不能偷偷下载模型。
-  assert.equal(globalThis.__engineSeen.cacheDir, "/tmp/mneme-cache");
-  assert.equal(globalThis.__engineSeen.remote, false);
-  assert.equal(globalThis.__engineSeen.kind, "feature-extraction");
-});
-
-test("defaultEngine: 输出宽度为 0 时明确抛错（防止调用方死循环）", async () => {
-  const entry = fakeEntry([2, 0]);
-  const embed = await defaultEngine(entry, {});
-  await assert.rejects(() => embed(["x"]), /维度不可用/);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_PROBE_TEXTS, defaultEngine, verifyFunctional, verifyPayload } from "../src/runtime/verify.js";
+import { TRANSFORMERS_ENTRY } from "../src/runtime/layout.js";
+import { pathToFileURL } from "node:url";
+
+// 验证三件套（issue #131 / PR-A）。重点不是「能跑通」，而是「坏的那几种能被抓住」：
+// 结构对但原生二进制与本机不匹配、返回非归一化向量、向量退化、加载直接抛——
+// 这些都必须变成一条可读的失败结论，而不是让调用方拿到一个假的 ok。
+
+/** 造一个结构上合法的 payload（只有形状，没有真东西）。 */
+function makePayload({ platform = "win32", arch = "x64", withEntry = true } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-verify-"));
+  const write = (rel, body) => {
+    const full = join(dir, rel);
+    mkdirSync(join(full, ".."), { recursive: true });
+    writeFileSync(full, body);
+  };
+  for (const name of ["@huggingface/transformers", "onnxruntime-node", "sharp"]) {
+    write(join("node_modules", name, "package.json"), JSON.stringify({ name, version: name === "@huggingface/transformers" ? "4.2.0" : "1.0.0" }));
+  }
+  if (withEntry) write(TRANSFORMERS_ENTRY, "export const x = 1;\n");
+  mkdirSync(join(dir, "node_modules", "onnxruntime-node", "bin", "napi-v6", platform, arch), { recursive: true });
+  return dir;
+}
+
+/** 归一化的假向量：`rows` 行，每行 dim 维，方向由 seed 决定。 */
+function fakeRows(rows, dim, seed = 0) {
+  return Array.from({ length: rows }, (_, r) => {
+    const v = Array.from({ length: dim }, (_, i) => Math.sin((i + 1) * (r + 1 + seed)));
+    const length = Math.hypot(...v);
+    return v.map((x) => x / length);
+  });
+}
+
+/** 注入一个「什么都能返回」的 engine。 */
+function engineReturning(value) {
+  return async () => async () => value;
+}
+
+test("功能验证：正常的向量通过，并报出维度与耗时", async () => {
+  const result = await verifyFunctional("/whatever", { engine: engineReturning(fakeRows(2, 512)) });
+  assert.equal(result.ok, true, result.reason);
+  assert.equal(result.dim, 512);
+  assert.equal(result.rows, 2);
+  assert.ok(result.elapsedMs >= 0);
+});
+
+test("功能验证：行数不符要报出来（而不是只取第一行当作通过）", async () => {
+  const result = await verifyFunctional("/whatever", { engine: engineReturning(fakeRows(1, 512)) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /返回行数不符/);
+});
+
+test("功能验证：非归一化向量要报出来（说明 normalize 没生效）", async () => {
+  const rows = fakeRows(2, 8).map((row) => row.map((x) => x * 3));
+  const result = await verifyFunctional("/whatever", { engine: engineReturning(rows) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /不是 L2 归一化/);
+});
+
+test("功能验证：向量退化成同一方向要报出来", async () => {
+  const one = fakeRows(1, 16)[0];
+  const result = await verifyFunctional("/whatever", { engine: engineReturning([one, one]) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /嵌入退化/);
+});
+
+test("功能验证：加载失败与推理失败分别给出不同措辞", async () => {
+  const loadFail = await verifyFunctional("/whatever", {
+    engine: async () => {
+      throw new Error("Cannot find package 'onnxruntime-node'");
+    }
+  });
+  assert.equal(loadFail.ok, false);
+  assert.match(loadFail.reason, /加载运行时失败/);
+  assert.match(loadFail.reason, /onnxruntime-node/);
+
+  const embedFail = await verifyFunctional("/whatever", {
+    engine: async () => async () => {
+      throw new Error("boom");
+    }
+  });
+  assert.equal(embedFail.ok, false);
+  assert.match(embedFail.reason, /推理失败/);
+});
+
+test("功能验证：返回空向量要报出来，而不是当成 dim=0 通过", async () => {
+  const result = await verifyFunctional("/whatever", { engine: engineReturning([[], []]) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /空向量/);
+});
+
+test("三件套：结构不过就不再做功能验证（省掉一次无谓的加载）", async () => {
+  const dir = makePayload({ withEntry: false });
+  let engineCalled = false;
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: async () => {
+      engineCalled = true;
+      return async () => fakeRows(2, 8);
+    }
+  });
+  assert.equal(result.ok, false);
+  assert.equal(result.functional.ok, false);
+  assert.match(result.functional.reason, /跳过功能验证/);
+  assert.equal(engineCalled, false);
+});
+
+test("三件套：结构 + 功能都过、完整性缺失时如实标 unverified 且不判定失败", async () => {
+  const dir = makePayload();
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8))
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.integrity.status, "unverified");
+  assert.equal(result.integrity.ok, true);
+  assert.equal(result.version, "4.2.0");
+});
+
+test("三件套：--strict 场景下哈希不匹配即整体不通过", async () => {
+  const dir = makePayload();
+  const matched = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8)),
+    integrity: { status: "sha512-matched", detail: "tarball 比对通过" }
+  });
+  assert.equal(matched.ok, true);
+  assert.equal(matched.integrity.status, "sha512-matched");
+
+  const mismatch = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8)),
+    integrity: { status: "sha512-mismatch", detail: "与钉死的哈希不一致" }
+  });
+  assert.equal(mismatch.ok, false);
+  assert.equal(mismatch.structural.ok, true, "结构仍然是对的，失败来自完整性");
+  assert.equal(mismatch.functional.ok, true);
+});
+
+test("假通过防线 ①：行不是数组时返回失败，而不是抛异常", async () => {
+  // 契约是「任何失败都返回结果对象，不抛」；非数组行会让 .length/.some 直接抛。
+  const dir = makePayload();
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning([null, null])
+  });
+  assert.equal(result.ok, false);
+  assert.match(result.functional.reason, /不是数组/);
+});
+
+test("假通过防线 ②：非有限数值必须判失败（NaN 的比较恒为 false，会静默通过）", async () => {
+  const dir = makePayload();
+  for (const bad of [[NaN, 0], [Infinity, 0], ["0.5", "0.5"]]) {
+    const result = await verifyPayload(dir, {
+      platform: "win32",
+      arch: "x64",
+      engine: engineReturning([bad, [0, 0]])
+    });
+    assert.equal(result.ok, false, `含 ${JSON.stringify(bad)} 的向量不该被判通过`);
+    assert.match(result.functional.reason, /非有限数值/);
+  }
+});
+
+test("默认 engine 是导出的函数，且探针文本固定（改它等于改验收标准）", () => {
+  assert.equal(typeof defaultEngine, "function");
+  assert.deepEqual(DEFAULT_PROBE_TEXTS, ["猫咪喜欢晒太阳", "the quick brown fox"]);
+});
+
+// ── defaultEngine：注入假 transformers 模块，钉住「真 import + 行切分」的契约 ──
+
+/** 造一个假 transformers 入口：export env + pipeline，把收到的参数记到 globalThis。 */
+function fakeEntry(dims) {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-engine-"));
+  const entry = join(dir, "entry.mjs");
+  writeFileSync(entry, `
+export const env = {};
+export async function pipeline(kind, model, opts) {
+  globalThis.__engineSeen = { kind, model, opts, cacheDir: env.cacheDir, remote: env.allowRemoteModels };
+  const d = ${JSON.stringify(dims)};
+  const data = Float32Array.from({ length: d[0] * d[1] }, (_, i) => i + 1);
+  return async () => ({ dims: d, data });
+}
+`);
+  return pathToFileURL(entry).href;
+}
+
+test("defaultEngine: 假 transformers 入口可驱动嵌入，并按输出维度做行切分", async () => {
+  const entry = fakeEntry([2, 4]);
+  const embed = await defaultEngine(entry, { cacheDir: "/tmp/mneme-cache" });
+  const rows = await embed(["猫咪", "fox"]);
+  assert.equal(rows.length, 2);
+  assert.deepEqual(rows[0], [1, 2, 3, 4]);
+  assert.deepEqual(rows[1], [5, 6, 7, 8]);
+  // 缓存目录与离线开关必须落到 env：验证过程绝不能偷偷下载模型。
+  assert.equal(globalThis.__engineSeen.cacheDir, "/tmp/mneme-cache");
+  assert.equal(globalThis.__engineSeen.remote, false);
+  assert.equal(globalThis.__engineSeen.kind, "feature-extraction");
+});
+
+test("defaultEngine: 输出宽度为 0 时明确抛错（防止调用方死循环）", async () => {
+  const entry = fakeEntry([2, 0]);
+  const embed = await defaultEngine(entry, {});
+  await assert.rejects(() => embed(["x"]), /维度不可用/);
+});