@modusensus/dsh-mneme 0.8.0 → 0.8.1

package/test/scope-strict.test.js

@@ -4,9 +4,13 @@ import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createTools } from "../src/tools.js";
 
-// v0.8.0 A3（issue #17）：strictScope 硬过滤 + agent 不对称可见性。
-// 四象限公式：记忆可见 ⇔ (agent 维未标注或命中) AND (workspace 维未标注或命中)；
-// 当前会话维度解析不到时该维度带标注的记忆不可见（fail-closed）。
+// v0.8.0 A3（issue #17）→ v0.8.1 第 3 步（issue #170 4.3，作者已确认）：
+// strictScope 硬过滤只认显式声明。可见性公式收窄为：记忆可见 ⇔ 对每一维
+// （该维标注存在且来源=explicit 时：命中当前会话）AND。
+//   - explicit 行为硬墙：他者维度不可见（含 memory_get 无存在性泄漏）；
+//   - auto / 存量 NULL 来源（v0.8.0 自动标注）不进硬过滤，只吃 A2 软加权
+//     （foreign ×0.5 保留可见）；
+//   - 当前会话维度解析不到 → 该维 explicit 行一律不可见（fail-closed 收窄）。
 
 function setup(config) {
   const store = createStore(":memory:");
@@ -14,46 +18,69 @@ function setup(config) {
   return { store, service };
 }
 
-test("visibility predicate: four-quadrant semantics", () => {
+test("visibility predicate: explicit rows keep four-quadrant semantics", () => {
   const { service } = setup({ scopeEnabled: true, strictScope: true });
   const vis = service.isVisibleInScope;
   const me = { agent_scope: "coder", workspace_scope: "D:\\p" };
+  const E = "explicit";
 
   // 全局（未标注）对谁都可见。
   assert.equal(vis({}, me), true);
   // agent 专属：同 agent 任意 workspace 可见，他人不可见。
-  assert.equal(vis({ agent_scope: "coder" }, me), true);
-  assert.equal(vis({ agent_scope: "novelist" }, me), false);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: E }, me), true);
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: E }, me), false);
   // workspace 专属：同 workspace 任意 agent 可见，别的 workspace 不可见。
-  assert.equal(vis({ workspace_scope: "D:\\p" }, me), true);
-  assert.equal(vis({ workspace_scope: "D:\\q" }, me), false);
+  assert.equal(vis({ workspace_scope: "D:\\p", workspace_scope_source: E }, me), true);
+  assert.equal(vis({ workspace_scope: "D:\\q", workspace_scope_source: E }, me), false);
   // 双标注：精确命中才可见。
-  assert.equal(vis({ agent_scope: "coder", workspace_scope: "D:\\p" }, me), true);
-  assert.equal(vis({ agent_scope: "coder", workspace_scope: "D:\\q" }, me), false);
-  assert.equal(vis({ agent_scope: "novelist", workspace_scope: "D:\\p" }, me), false);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: E, workspace_scope: "D:\\p", workspace_scope_source: E }, me), true);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: E, workspace_scope: "D:\\q", workspace_scope_source: E }, me), false);
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: E, workspace_scope: "D:\\p", workspace_scope_source: E }, me), false);
 });
 
-test("visibility predicate: anonymous session sees only unscoped rows (fail-closed)", () => {
+test("visibility predicate: auto and legacy rows are NOT hard walls (soft only)", () => {
+  const { service } = setup({ scopeEnabled: true, strictScope: true });
+  const vis = service.isVisibleInScope;
+  const me = { agent_scope: "coder", workspace_scope: "D:\\p" };
+
+  // auto（v0.8.1 载体自动标注）与存量 NULL 来源（v0.8.0 自动标注）他者维度
+  // 也可见——硬过滤只认 explicit。
+  assert.equal(vis({ agent_scope: "novelist" }, me), true, "legacy NULL source");
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: "auto" }, me), true);
+  assert.equal(vis({ workspace_scope: "D:\\q", workspace_scope_source: "auto" }, me), true);
+  // 混合：agent 维 auto + workspace 维 explicit → 只 workspace 维构成硬墙。
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: "auto", workspace_scope: "D:\\q", workspace_scope_source: "explicit" }, me), false);
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: "explicit", workspace_scope: "D:\\q", workspace_scope_source: "auto" }, me), false);
+});
+
+test("visibility predicate: anonymous session fail-closes only explicit rows", () => {
   const { service } = setup({ scopeEnabled: true, strictScope: true });
   const vis = service.isVisibleInScope;
   const anon = { agent_scope: null, workspace_scope: null };
   assert.equal(vis({}, anon), true);
-  assert.equal(vis({ agent_scope: "coder" }, anon), false);
-  assert.equal(vis({ workspace_scope: "D:\\p" }, anon), false);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: "explicit" }, anon), false);
+  assert.equal(vis({ workspace_scope: "D:\\p", workspace_scope_source: "explicit" }, anon), false);
+  // auto/存量行照常可见（不冒认，但也不因身份缺失误杀软标注）。
+  assert.equal(vis({ agent_scope: "coder" }, anon), true);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: "auto" }, anon), true);
 });
 
-test("searchMemories hard-filters foreign scopes when strictScope is on", async () => {
+test("searchMemories: explicit foreign filtered, auto/legacy foreign stay visible under strictScope", async () => {
   const { store, service } = setup({ scopeEnabled: true, strictScope: true });
   store.save({ type: "project", title: "global needle", content: "x" });
-  store.save({ type: "project", title: "mine needle", content: "x", agent_scope: "me" });
-  store.save({ type: "project", title: "foreign needle", content: "x", agent_scope: "other" });
+  store.save({ type: "project", title: "mine needle", content: "x", agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "project", title: "explicit foreign needle", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "project", title: "auto foreign needle", content: "x", agent_scope: "other", agent_scope_source: "auto" });
+  store.save({ type: "project", title: "legacy foreign needle", content: "x", agent_scope: "other" });
 
   const rows = await service.searchMemories("needle", {
     mode: "keyword",
     scope: { agent_scope: "me", workspace_scope: null }
   });
-  // 他 scope 直接出局（区别于 A2 的降权保留可见）；未标注与命中行保留。
-  assert.deepEqual(rows.map((m) => m.title).sort(), ["global needle", "mine needle"]);
+  // explicit 他者出局；auto/存量他者保留（A2 降权仍可见）；未标注与命中行保留。
+  assert.deepEqual(rows.map((m) => m.title).sort(), [
+    "auto foreign needle", "global needle", "legacy foreign needle", "mine needle"
+  ]);
 });
 
 test("strictScope off keeps A2 behavior: foreign rows demoted but visible", async () => {
@@ -66,38 +93,73 @@ test("strictScope off keeps A2 behavior: foreign rows demoted but visible", asyn
   assert.deepEqual(rows.map((m) => m.title), ["foreign needle"]);
 });
 
-test("store.list/count visibility option filters in SQL with consistent totals", () => {
+test("store.list/count visibility: explicit hard wall + auto/legacy pass, consistent totals", () => {
   const { store } = setup({ scopeEnabled: true, strictScope: true });
   store.save({ type: "decision", title: "g", content: "x" });
-  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me", workspace_scope: "D:\\p" });
-  store.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other" });
-  store.save({ type: "decision", title: "other-ws", content: "x", workspace_scope: "D:\\q" });
+  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit", workspace_scope: "D:\\p", workspace_scope_source: "explicit" });
+  store.save({ type: "decision", title: "theirs-explicit", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "theirs-auto", content: "x", agent_scope: "other", agent_scope_source: "auto" });
+  store.save({ type: "decision", title: "theirs-legacy", content: "x", agent_scope: "other" });
+  store.save({ type: "decision", title: "other-ws-explicit", content: "x", workspace_scope: "D:\\q", workspace_scope_source: "explicit" });
 
   const vis = { agentScope: "me", workspaceScope: "D:\\p" };
   const titles = store.list({ visibility: vis }).map((m) => m.title).sort();
-  assert.deepEqual(titles, ["g", "mine"]);
-  assert.equal(store.count("decision", { visibility: vis }), 2);
+  assert.deepEqual(titles, ["g", "mine", "theirs-auto", "theirs-legacy"]);
+  assert.equal(store.count("decision", { visibility: vis }), 4);
 
-  // 匿名会话（维度解析不到）：只放行未标注行。
-  const anonTitles = store.list({ visibility: { agentScope: null, workspaceScope: null } }).map((m) => m.title);
-  assert.deepEqual(anonTitles, ["g"]);
+  // 匿名会话：explicit 行全出局，auto/存量/未标注放行。
+  const anonTitles = store.list({ visibility: { agentScope: null, workspaceScope: null } }).map((m) => m.title).sort();
+  assert.deepEqual(anonTitles, ["g", "theirs-auto", "theirs-legacy"]);
+  assert.equal(store.count("decision", { visibility: { agentScope: null, workspaceScope: null } }), 3);
 });
 
-test("injectCandidates hard-filters scoped rows when strictScope is on", () => {
+test("injectCandidates hard-filters explicit foreign rows when strictScope is on", () => {
   const { store, service } = setup({ scopeEnabled: true, strictScope: true });
   store.save({ type: "decision", title: "global", content: "x", importance: 4 });
-  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other" });
+  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "auto-foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "auto" });
 
   const injected = service.injectCandidates({
     maxItems: 5,
     threshold: 3,
     scope: { agent_scope: "me", workspace_scope: null }
   });
-  assert.deepEqual(injected.map((m) => m.title), ["global"]);
+  assert.deepEqual(injected.map((m) => m.title).sort(), ["auto-foreign", "global"]);
 
   // flag 下（scope 不传）→ 他 scope 照常注入（A2 前行为）。
   const unscoped = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.deepEqual(unscoped.map((m) => m.title).sort(), ["foreign", "global"]);
+  assert.deepEqual(unscoped.map((m) => m.title).sort(), ["auto-foreign", "foreign", "global"]);
+});
+
+test("memory_update/memory_delete hide explicit foreign-scope rows under strictScope (review item 4, aligned with memory_get)", async () => {
+  const { store, pick } = setupTools({ scopeEnabled: true, strictScope: true });
+  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
+  const autoTheirs = store.save({ type: "pitfall", title: "auto-theirs", content: "c", agent_scope: "other", agent_scope_source: "auto" });
+  const update = pick("memory_update");
+  const del = pick("memory_delete");
+
+  // explicit 他 scope：update 按不存在拒绝、delete 视作不存在——不能凭 id 直改直删。
+  await assert.rejects(() => runHandler(update, { id: theirs.id, content: "tampered" }, STRICT_EXEC), /memory not found/);
+  assert.equal(store.getById(theirs.id).content, "c", "row untouched by the rejected update");
+  const delOut = await runHandler(del, { id: theirs.id }, STRICT_EXEC);
+  assert.equal(delOut.deleted, false, "delete treats invisible rows as absent (no existence leak)");
+  assert.ok(store.getById(theirs.id), "row NOT deleted");
+
+  // auto 他 scope：不构成硬墙，照常可改（与 get 的可见性口径一致）。
+  const updAuto = await runHandler(update, { id: autoTheirs.id, content: "updated" }, STRICT_EXEC);
+  assert.equal(updAuto.memory.id, autoTheirs.id);
+
+  // 行主人自己照常可改。
+  const ownerOut = await runHandler(update, { id: theirs.id, content: "owner edit" }, OTHER_EXEC);
+  assert.equal(ownerOut.memory.id, theirs.id);
+
+  // strictScope 关：update/delete 不做可见性校验（管理语义回归）。
+  const { store: store2, pick: pick2 } = setupTools({ scopeEnabled: true });
+  const t2 = store2.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
+  await runHandler(pick2("memory_update"), { id: t2.id, content: "edited" }, STRICT_EXEC);
+  assert.equal(store2.getById(t2.id).content, "edited");
+  const del2 = await runHandler(pick2("memory_delete"), { id: t2.id }, STRICT_EXEC);
+  assert.equal(del2.deleted, true);
 });
 
 function setupTools(config) {
@@ -121,17 +183,21 @@ async function runHandler(def, args, exec) {
 const STRICT_EXEC = { agent: { session: { id: "s1", header: { agentPreset: "me", cwd: "D:\\p" } } } };
 const OTHER_EXEC = { agent: { session: { id: "s2", header: { agentPreset: "other", cwd: "D:\\q" } } } };
 
-test("memory_get hides foreign-scope rows under strictScope, resolvable for the owner", async () => {
+test("memory_get hides explicit foreign-scope rows under strictScope, resolvable for the owner", async () => {
   const { store, pick } = setupTools({ scopeEnabled: true, strictScope: true });
-  const mine = store.save({ type: "pitfall", title: "mine", content: "c", agent_scope: "me" });
-  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other" });
+  const mine = store.save({ type: "pitfall", title: "mine", content: "c", agent_scope: "me", agent_scope_source: "explicit" });
+  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
+  const autoTheirs = store.save({ type: "pitfall", title: "auto-theirs", content: "c", agent_scope: "other", agent_scope_source: "auto" });
   const get = pick("memory_get");
 
   const out = await runHandler(get, { id: mine.id }, STRICT_EXEC);
   assert.equal(out.memory.title, "mine");
 
-  // 他 scope → 按不存在处理（无存在性泄漏）。
+  // explicit 他 scope → 按不存在处理（无存在性泄漏）。
   await assert.rejects(() => runHandler(get, { id: theirs.id }, STRICT_EXEC), /memory not found/);
+  // auto 他 scope → 可见（软加权不进硬过滤）。
+  const autoOut = await runHandler(get, { id: autoTheirs.id }, STRICT_EXEC);
+  assert.equal(autoOut.memory.title, "auto-theirs");
   // 行主人自己照常可取。
   const ownerOut = await runHandler(get, { id: theirs.id }, OTHER_EXEC);
   assert.equal(ownerOut.memory.title, "theirs");
@@ -139,17 +205,17 @@ test("memory_get hides foreign-scope rows under strictScope, resolvable for the
 
 test("memory_get without strictScope returns any row regardless of scope annotation", async () => {
   const { store, pick } = setupTools({ scopeEnabled: true });
-  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other" });
+  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
   const get = pick("memory_get");
   const out = await runHandler(get, { id: theirs.id }, STRICT_EXEC);
   assert.equal(out.memory.title, "theirs");
 });
 
-test("memory_list filters rows and keeps total consistent under strictScope", async () => {
+test("memory_list filters explicit rows and keeps total consistent under strictScope", async () => {
   const { store, pick } = setupTools({ scopeEnabled: true, strictScope: true });
   store.save({ type: "decision", title: "g", content: "x" });
-  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me" });
-  store.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other" });
+  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
   const list = pick("memory_list");
 
   const out = await runHandler(list, { type: "decision" }, STRICT_EXEC);
@@ -158,7 +224,7 @@ test("memory_list filters rows and keeps total consistent under strictScope", as
 
   // flag 关（A2 默认）：他 scope 的行照常出现在浏览视图。
   const { store: store2, pick: pick2 } = setupTools({ scopeEnabled: true });
-  store2.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other" });
+  store2.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
   const out2 = await runHandler(pick2("memory_list"), { type: "decision" }, STRICT_EXEC);
   assert.deepEqual(out2.items.map((m) => m.title), ["theirs"]);
   assert.equal(out2.total, 1);

package/test/version-check.test.js

@@ -0,0 +1,152 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  validateRegistryUrl,
+  compareVersions,
+  classify,
+  fetchLatestVersion,
+  resetCacheForTest,
+  REGISTRY_URL,
+  PACKAGE_VERSION,
+} from '../src/version-check.js';
+
+describe('version-check.js', () => {
+  // ---- validateRegistryUrl：https + 精确 host 白名单（构造性排除本机/内网）----
+  describe('validateRegistryUrl', () => {
+    test('白名单内 https 地址通过', () => {
+      assert.equal(validateRegistryUrl('https://registry.npmjs.org/@modusensus%2Fdsh-mneme/latest'), true);
+      assert.equal(validateRegistryUrl('https://registry.npmjs.org/anything'), true);
+    });
+
+    test('非 https 一律拒绝', () => {
+      assert.equal(validateRegistryUrl('http://registry.npmjs.org/latest'), false);
+      assert.equal(validateRegistryUrl('ftp://registry.npmjs.org/latest'), false);
+      assert.equal(validateRegistryUrl('file:///etc/passwd'), false);
+    });
+
+    test('host 不在白名单一律拒绝（含本机/内网/相似域名）', () => {
+      assert.equal(validateRegistryUrl('https://localhost/latest'), false);
+      assert.equal(validateRegistryUrl('https://127.0.0.1/latest'), false);
+      assert.equal(validateRegistryUrl('https://[::1]/latest'), false);
+      assert.equal(validateRegistryUrl('https://10.0.0.5/latest'), false);
+      assert.equal(validateRegistryUrl('https://192.168.1.10/latest'), false);
+      assert.equal(validateRegistryUrl('https://evil-registry.npmjs.org.example.com/latest'), false);
+      assert.equal(validateRegistryUrl('https://registry.npmjs.org.evil.com/latest'), false);
+      assert.equal(validateRegistryUrl('https://npmjs.org/latest'), false);
+    });
+
+    test('非法 URL 拒绝而不抛出', () => {
+      assert.equal(validateRegistryUrl('not a url'), false);
+      assert.equal(validateRegistryUrl(''), false);
+    });
+  });
+
+  // ---- compareVersions / classify：纯函数比对 ----
+  describe('compareVersions', () => {
+    test('三元组数值比较', () => {
+      assert.equal(compareVersions('0.8.0', '0.8.1'), -1);
+      assert.equal(compareVersions('0.8.1', '0.8.0'), 1);
+      assert.equal(compareVersions('0.8.0', '0.8.0'), 0);
+      assert.equal(compareVersions('0.10.0', '0.9.0'), 1);
+      assert.equal(compareVersions('1.0.0', '0.9.9'), 1);
+    });
+
+    test('同号带 prerelease 的一方更旧；两侧都带视为同版', () => {
+      assert.equal(compareVersions('0.9.0-rc.1', '0.9.0'), -1);
+      assert.equal(compareVersions('0.9.0', '0.9.0-rc.1'), 1);
+      assert.equal(compareVersions('0.9.0-rc.1', '0.9.0-rc.1'), 0);
+      // 数字三元组相等、两侧都带后缀 → 同版（横幅只关心是否落后 latest，
+      // 不追求完整 semver prerelease 序）
+      assert.equal(compareVersions('0.9.0-rc.2', '0.9.0-rc.1'), 0);
+    });
+
+    test('解析失败返回 null', () => {
+      assert.equal(compareVersions('unknown', '0.8.0'), null);
+      assert.equal(compareVersions('0.8.0', ''), null);
+      assert.equal(compareVersions(null, null), null);
+    });
+  });
+
+  describe('classify', () => {
+    test('四种形态', () => {
+      assert.equal(classify('0.8.0', '0.8.1'), 'outdated');
+      assert.equal(classify('0.8.0', '0.8.0'), 'up-to-date');
+      // workspace/link 直载开发态：运行版本高于已发布 → ahead（前端不打扰）
+      assert.equal(classify('0.9.0', '0.8.1'), 'ahead');
+      // 查询失败/离线 → unknown（前端完全静默）
+      assert.equal(classify('0.8.0', null), 'unknown');
+      assert.equal(classify('unknown', '0.8.0'), 'unknown');
+    });
+  });
+
+  // ---- fetchLatestVersion：TTL 缓存 + 失败静默 ----
+  describe('fetchLatestVersion', () => {
+    test('正常响应取 latest；TTL 内复用缓存不重复请求', async () => {
+      resetCacheForTest();
+      let calls = 0;
+      let clock = 1000;
+      const fetchImpl = async () => { calls += 1; return { ok: true, json: async () => ({ version: '0.8.1' }) }; };
+      const now = () => clock;
+
+      assert.equal(await fetchLatestVersion({ fetchImpl, now }), '0.8.1');
+      assert.equal(await fetchLatestVersion({ fetchImpl, now }), '0.8.1');
+      assert.equal(calls, 1);
+
+      clock += 60 * 60 * 1000 - 1;
+      assert.equal(await fetchLatestVersion({ fetchImpl, now }), '0.8.1');
+      assert.equal(calls, 1);
+
+      // 过 TTL 后重新请求
+      clock += 1;
+      assert.equal(await fetchLatestVersion({ fetchImpl, now }), '0.8.1');
+      assert.equal(calls, 2);
+      resetCacheForTest();
+    });
+
+    test('失败静默返回 null：网络异常 / 非 2xx / 形状不对', async () => {
+      resetCacheForTest();
+      assert.equal(await fetchLatestVersion({ fetchImpl: async () => { throw new Error('offline'); }, now: () => 1000 }), null);
+      assert.equal(await fetchLatestVersion({ fetchImpl: async () => ({ ok: false, status: 503 }), now: () => 1000 }), null);
+      assert.equal(await fetchLatestVersion({ fetchImpl: async () => ({ ok: true, json: async () => ({ nope: true }) }), now: () => 1000 }), null);
+      resetCacheForTest();
+    });
+
+    test('失败不写缓存：下次调用立刻重试', async () => {
+      resetCacheForTest();
+      let calls = 0;
+      let fail = true;
+      const fetchImpl = async () => {
+        calls += 1;
+        if (fail) throw new Error('boom');
+        return { ok: true, json: async () => ({ version: '0.8.2' }) };
+      };
+      assert.equal(await fetchLatestVersion({ fetchImpl, now: () => 1000 }), null);
+      assert.equal(await fetchLatestVersion({ fetchImpl, now: () => 1000 }), null);
+      assert.equal(calls, 2);
+      fail = false;
+      assert.equal(await fetchLatestVersion({ fetchImpl, now: () => 1000 }), '0.8.2');
+      resetCacheForTest();
+    });
+
+    test('运行环境无全局 fetch 时走默认参兜底：resolve null 而非同步抛', async () => {
+      resetCacheForTest();
+      const original = globalThis.fetch;
+      globalThis.fetch = undefined;
+      try {
+        // 修复前：默认参 fetchImpl = fetch 在参数求值期同步抛 ReferenceError，
+        // 路由的 .catch 接不住；修复后应归入常规失败路径静默返 null。
+        assert.equal(await fetchLatestVersion({ now: () => 1000 }), null);
+      } finally {
+        globalThis.fetch = original;
+      }
+      resetCacheForTest();
+    });
+  });
+
+  // ---- 模块常量：URL 必须过白名单，运行版本可读 ----
+  test('REGISTRY_URL 自身通过白名单校验；PACKAGE_VERSION 可读', () => {
+    assert.equal(validateRegistryUrl(REGISTRY_URL), true);
+    assert.match(PACKAGE_VERSION, /^\d+\.\d+\.\d+/);
+  });
+});