dsh-notify-say 0.4.35 → 0.4.44

package/lib/dev-reload.js

@@ -130,15 +130,33 @@ const GEN_PARAM = 'dns-reload';
  * @returns {Promise<void>} 注册完成后 resolve（便于测试与调用方等待）
  */
 export async function enableFreshDependencies(packageUrl) {
-  if (reloadHooks.has(packageUrl)) return;
-  if (reloadHooks.has(packageUrl)) return;
-  // 标记为"已尝试"，避免重复注册导致 Node 抛错
-  reloadHooks.set(packageUrl, null);
-
-  // Node < 22.15 没有 registerHooks：静默跳过即可。
-  // 代际绕过不成，重载仍走"清缓存 + 校验"的常规路径。
-  await loadRegisterHooks().then((registerHooks) => {
-    if (!registerHooks) return;
+  // ⚠️ 2026-10-18 外部审阅指出两个问题（都属实，此前没改过）：
+  //
+  // 1. 调用方只写 `enableFreshDependencies(packageUrl)`，**没 await**。
+  //    而它要 `await import('node:module')` 才拿得到 registerHooks ——
+  //    于是新入口可能在钩子装好之前就被导入，依赖仍是旧的。
+  //    这恰好是热重载要解决的那个问题。
+  //
+  // 2. 原实现在注册**前**就 `reloadHooks.set(packageUrl, null)` 占位，
+  //    第二个并发调用看到 key 存在就直接 return，哪怕第一次还没装完。
+  //
+  // 修法：Map 里存 `{ pending, hook }` —— 后来者 await 同一个 Promise，
+  // 这样"返回时已装好"成立。hook 的 resolve 逻辑一字未动。
+
+  const prev = reloadHooks.get(packageUrl);
+  // 已装好：直接返回 hook
+  if (prev && prev.hook) return prev.hook;
+  // 正在装：等同一次 Promise（这就是修竞态的关键）
+  if (prev && prev.pending) return prev.pending;
+
+  const slot = { pending: null, hook: null };
+  reloadHooks.set(packageUrl, slot);
+
+  slot.pending = (async () => {
+    // Node < 22.15 没有 registerHooks：静默跳过即可。
+    // 代际绕过不成，重载仍走"清缓存 + 校验"的常规路径。
+    const registerHooks = await loadRegisterHooks();
+    if (!registerHooks) return null;
     try {
       const hook = registerHooks({
         resolve(specifier, context, nextResolve) {
@@ -159,11 +177,15 @@ export async function enableFreshDependencies(packageUrl) {
           }
         },
       });
-      reloadHooks.set(packageUrl, hook);
+      slot.hook = hook;
+      return hook;
     } catch {
       // 重复注册等情况：忽略，不影响正常路径
+      return null;
     }
-  }).catch(() => { /* 拿不到 registerHooks：忽略 */ });
+  })();
+
+  return slot.pending;
 }
 
 /**
@@ -494,22 +516,37 @@ export function selfReload(ctx, options = {}) {
     };
 
     let replacement;
+    // verdict 在 try 块内算出，但要一直用到"注册成功"之后（返回值里）。
+    // 所以把结论提到外层 —— 直接引用 verdict 会出作用域（S1 实测报过
+    // "verdict is not defined"）。
+    let verifiedOk = false;
     let busted = false;
     try {
       replacement = await importFresh(entryUrl);
       if (!replacement || typeof replacement.apply !== 'function') {
         throw new Error('reloaded module does not export apply()');
       }
-
-      // 缓存没清掉 / 这是新内核的 loadCache 形状 —— 改用代际绕过。
+      // v0.4.41：**无条件**走代际绕过。
+      //
+      // 原来是：
+      //   if (backup.esm.size === 0 || isSameAsPrevious(replacement, previous))
+      //
+      // 只在「一个缓存都没清掉」或「拿到同一个对象」时才绕过。
+      // 但 2026-10-18 重启后实测发现第三种情况：
+      //   · 清了部分缓存 → backup.esm.size > 0
+      //   · 拿到新壳对象   → isSameAsPrevious 为 false
+      //   · 于是**跳过**代际绕过
+      //   · 可新对象是壳，模块级 const 的求值结果被复用
+      //   · 指纹仍是旧的 → verifyReload 判 fingerprint unchanged
+      // 日志里三次不同编辑的指纹一模一样（adb61783），就是这个原因。
       //
-      // 2026-10-17 的教训：这里原本是"直接失败返回"，于是重载报 ok:false，
-      // 但调用方（watchPackage）把它当普通失败吞掉，用户看到的是"好像没生效"。
-      // 更要命的是有些内核能清掉**部分**条目，于是入口换了、依赖没换。
-      // 现在两种异常（purged=0 或 拿到旧对象）都走代际绕过，强制整棵树重求值。
-      if (backup.esm.size === 0 || isSameAsPrevious(replacement, previous)) {
+      // 代际绕过只是强制重新求值，语义不变、代价是一次多余求值；
+      // 而省掉它的代价是「改了代码拿不到新代码」——今天为此排查一整天。
+      {
+        
         try { logger.info?.('[dsh-notify-say] reload: falling back to generation bust'); } catch { /* ignore */ }
-        enableFreshDependencies(packageUrl);
+        // ⚠️ 必须 await：钩子装好之前导入新入口，依赖仍会是旧的。
+      await enableFreshDependencies(packageUrl);
         const freshUrl = new URL(entryUrl);
         freshUrl.searchParams.set(GEN_PARAM, `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
         replacement = await importFresh(freshUrl.href);
@@ -532,12 +569,22 @@ export function selfReload(ctx, options = {}) {
       // 求值了，不证明它 import 的依赖也换了。2026-10-17 实测出现过
       // "入口换了、config-store 没换"的半新半旧，而重载照样报 ok。
       const gotFp = typeof replacement.fingerprint === 'string' ? replacement.fingerprint : '';
+      // ⚠️ 2026-10-18 外部审阅指出：调用方算好了 diskFingerprint 传进来，
+      // 但这里根本没用 → 「验证通过」不等于「加载的是磁盘上那份代码」。
+      //
+      // 现在：有 diskFingerprint 就拿它当期望指纹（expectedFingerprint 优先，
+      // 便于测试注入）。
+      const expectedFp = options.expectedFingerprint !== undefined
+        ? options.expectedFingerprint
+        : options.diskFingerprint;
+
       const verdict = verifyReload({
         gotFingerprint: gotFp,
         differFrom: options.differFrom,
-        expectedFingerprint: options.expectedFingerprint,
+        expectedFingerprint: expectedFp,
       });
       if (!verdict.ok) throw new Error(verdict.error);
+      verifiedOk = !!verdict.checked;
       if (verdict.checked) {
         try { logger.info?.(`[dsh-notify-say] reload: verified (fp=${gotFp})`); } catch { /* ignore */ }
       }
@@ -546,11 +593,42 @@ export function selfReload(ctx, options = {}) {
       return { ok: false, error: `re-import failed: ${(error && error.message) || error}`, restored: true };
     }
 
+    // ⚠️ 2026-10-18 外部审阅指出：原来这里 catch 之后**仍然继续**注册新实例。
+    //
+    // 如果旧实例没真正退出，就会出现两个实例同时持有事件监听/文件句柄 ——
+    // 表现是通知重复、日志错乱，而且极难查（"有时响两次"）。
+    //
+    // 现在区分两种情况：
+    //   · dispose 只是"报告了错误"，但 fiber 确实停了 → 继续（正常路径）
+    //   · fiber 仍有未停的                → 返回结构化失败，不切换
+    //
+    // 判据：`fiber.await()` 抛错说明停不下来；不抛就认为已停。
     try {
       registry.delete(previous);
       await Promise.all(fibers.map(({ fiber }) => fiber.await()));
     } catch (error) {
-      try { logger.warn?.(`[dsh-notify-say] reload: dispose reported ${(error && error.message) || error}`); } catch { /* ignore */ }
+      // dispose 报错本身不一定是致命的（旧代码可能已部分卸载），
+      // 但必须确认没有残留的活动 fiber，否则不能切换。
+      const stillAlive = fibers.filter(({ fiber }) => {
+        try {
+          // Cordis 的 fiber 若已 dispose，status 会变成非 active
+          const st = fiber && (fiber.status !== undefined ? fiber.status : fiber.state);
+          return st === 'active' || st === 'pending' || st === 2 || st === 1;
+        } catch {
+          return true;   // 查不清就当作还活着（宁可失败也不双开）
+        }
+      });
+      const msg = (error && error.message) || error;
+      if (stillAlive.length > 0) {
+        restoreCaches(internal, backup);
+        return {
+          ok: false,
+          error: `dispose-incomplete: ${stillAlive.length}/${fibers.length} fiber(s) still active (${msg})`,
+          restored: true,
+        };
+      }
+      // 都停干净了：只是报了个错，继续切换
+      try { logger.warn?.(`[dsh-notify-say] reload: dispose reported ${msg} (all fibers stopped, continuing)`); } catch { /* ignore */ }
     }
 
     try {
@@ -566,7 +644,10 @@ export function selfReload(ctx, options = {}) {
       }
       await Promise.all(created.map((fiber) => fiber.await()));
       try { logger.info?.(`[dsh-notify-say] reload: complete, ${created.length} fiber(s)`); } catch { /* ignore */ }
-      return { ok: true, fibers: created.length };
+      // ⚠️ 2026-10-18 外部审阅指出：调用方读 r.busted / r.verified 来显示
+    // 「走了代际绕过」「指纹校验通过」，但这里从来没返回过这两个字段 ——
+    // 于是日志永远显示不出来，我据此判断重载行为时一直是盲的。
+    return { ok: true, fibers: created.length, busted, verified: verifiedOk };
     } catch (error) {
       restoreCaches(internal, backup);
       try { registry.delete(replacement); } catch { /* 可能从未启动 */ }
@@ -618,13 +699,27 @@ export function watchPackage(packageDir, opts = {}) {
   let paused = false;
   let watcher;
   try {
+    // ⚠️ 2026-10-18 外部审阅指出：监听整个目录，但指纹只覆盖
+    // package.json + lib/*.js。改文档或测试也会触发一次注定失败的重载。
+    // 过滤在 schedule(filename) 里做（见 isSourceFile）。
     watcher = fs.watch(packageDir, { recursive: true });
+    try { opts.diag?.('watching ', packageDir); } catch {}
   } catch (error) {
     try { logger.warn?.(`[dsh-notify-say] cannot watch ${packageDir}: ${(error && error.message) || error}`); } catch { /* ignore */ }
     return () => {};
   }
-  const schedule = () => {
+  // 只有这些文件变了才值得重载（与指纹覆盖范围保持一致）。
+  const isSourceFile = (filename) => {
+    if (!filename) return true;   // 拿不到文件名时保守处理：当真
+    const f = String(filename).replace(/\\/g, '/');
+    if (f === 'package.json') return true;
+    if (f.startsWith('lib/') && f.endsWith('.js')) return true;
+    return false;
+  };
+
+  const schedule = (filename) => {
     if (paused) return;
+    if (!isSourceFile(filename)) return;   // 文档/测试变更不触发重载
     clearTimeout(timer);
     timer = setTimeout(() => {
       timer = undefined;
@@ -635,7 +730,11 @@ export function watchPackage(packageDir, opts = {}) {
     }, debounceMs);
     if (timer && typeof timer.unref === 'function') timer.unref();
   };
-  watcher.on('change', schedule);
+  // fs.watch 的监听器签名是 (eventType, filename)
+  watcher.on('change', (eventType, filename) => {
+    try { opts.diag?.('event ', String(filename), ' accepted=', String(isSourceFile(filename))); } catch {}
+    schedule(filename);
+  });
   watcher.on('error', (error) => {
     try { logger.warn?.(`[dsh-notify-say] watcher error: ${(error && error.message) || error}`); } catch { /* ignore */ }
   });