dsh-unlag 1.7.7 → 1.7.9

package/README.md

@@ -1,6 +1,6 @@
 # dsh-unlag（解除卡顿）
 
-**改完插件点一下就生效。界面卡了点一下就顺。正在跑的任务不受影响。**
+**改完插件点一下就生效。界面卡了点一下就顺。正在跑的任务照常跑完。**
 
 窗口右上角一个按钮，不重启进程、不刷新掉会话：插件代码原地换掉，老旧卡顿的界面重建一次。
 
@@ -8,10 +8,10 @@
 
 | 情况 | 按一下 |
 | --- | --- |
-| 改了插件，手里还有任务在跑 | 大部分插件当场更新，任务继续跑完 |
+| 改了界面类插件，手里还有任务在跑 | 插件当场换掉，任务继续跑完 |
 | 界面越用越卡 | 直接恢复流畅，会话、队列、草稿都还在 |
 
-以前两种都得重启 App。现在不用，也不用挑空闲时间——马上换，不等。
+以前两种都得关掉 App 再来。现在不用，也不用挑空闲时间——马上换，不等。
 
 ## 装
 
@@ -19,7 +19,7 @@
 dsh plugin install dsh-unlag
 ```
 
-重载一次 App 让它进来，之后所有更新都走按钮。
+安装后由 DSH 完成首次加载，之后的更新都走按钮。
 
 ## 用
 
@@ -33,16 +33,20 @@ dsh plugin install dsh-unlag
 ## 不会丢什么
 
 - 轮次、子代理、终端进程：在宿主侧，一路继续。
-- 排队消息、输入草稿、附件：重建前先提交焦点里的内容。
-- 有未保存改动或开着弹窗：重建被拦下并提示，不硬刷。
-- 从不自己重启或退出 App；启动模块缺失时宁可放弃重建并提示，也不冒把 App 带下去的风险。
+- 排队消息、输入草稿、附件：重建前先提交焦点里的内容；有人没存完就拦下，不硬刷。
+- 有未保存改动、开着弹窗、或下个页面要用的模块读不全：拦下并提示，宁可不刷。
+- 从不自己重启或退出 App。
 
-管不到：独立进程和进程级的东西（宠物窗口自己的配置、DSH 自身升级、原生依赖变化）。
+管不到（它会拦下并说明，不会硬来）：
+
+- 改动落在宿主侧的插件：新增原生能力、改服务声明、改权限。
+- 更新时正被某个任务使用的插件：那个任务可能随之结束。
+- 独立进程和进程级的东西：宠物窗口自己的配置、DSH 自身升级、原生依赖变化。
 
 ## 排错
 
 - 日志：`~/.dsh/unlag-reload.log`，换代码／跳过／被拦各一行，含原因。
-- 状态：`GET /dsh-unlag/state` → `{"plugins":true,"page":true}`。
+- 状态：`GET /dsh-unlag/state` → `{"plugins":true,"page":true,"shim":{...}}`。
 
 ## 测试
 

package/client.js

@@ -6,8 +6,8 @@ window.__ModuleLoader__.load({
 
     const zh = /^zh/i.test(navigator.language || '');
     const COPY = zh
-      ? { label: '解除卡顿', hint: '卡顿时用：换掉插件代码并重建界面；运行中的任务、排队的消息保留', blocked: '暂时无法重建界面，稍后再试', unsaved: '有未保存的改动，先保存再重试', dialog: '先关闭打开的窗口再重载', queued: '已排队：任务跑完自动重载' } // ui-copy-ignore
-      : { label: 'Unlag', hint: 'For a sluggish interface: replaces plugin code and rebuilds the page; running turns and queued messages are kept', blocked: 'Cannot rebuild the page right now; try again', unsaved: 'Unsaved changes; save them, then retry', dialog: 'Close the open window first', queued: 'Queued; it reloads once the turn ends' };
+      ? { label: '解除卡顿', hint: '卡顿时用：换掉插件代码并重建界面；运行中的任务、排队的消息保留', blocked: '暂时无法重建界面，稍后再试', unsaved: '有未保存的改动，先保存再重试', dialog: '先关闭打开的窗口再重载', queued: '已排队：任务跑完自动重载', failed: '插件更新没完成，稍后再按一次' } // ui-copy-ignore
+      : { label: 'Unlag', hint: 'For a sluggish interface: replaces plugin code and rebuilds the page; running turns and queued messages are kept', blocked: 'Cannot rebuild the page right now; try again', unsaved: 'Unsaved changes; save them, then retry', dialog: 'Close the open window first', queued: 'Queued; it reloads once the turn ends', failed: 'The plugin update did not finish; press again later' };
 
     // Desktop shell only: the macOS and Windows desktop build owns the page and the running
     // app, so this is where the button belongs. A browser tab can reload freely on its own.
@@ -71,12 +71,27 @@ window.__ModuleLoader__.load({
         });
         if (!response.ok) return 'failed';
         const data = await response.json();
-        return typeof data?.status === 'string' ? data.status : 'failed';
+        return reloadVerdict(data);
       } catch {
         return 'failed';
       }
     }
 
+    /**
+     * What the app's answer to a plugin replacement really means for the rebuild that follows.
+     * Only a set the app has finished starting can be rebuilt against: one still starting would
+     * boot a document over plugins that are not ready, and one the app says cannot be applied to a
+     * running page would boot the old code behind a fresh interface.
+     * @returns 'done' | 'off' | 'queued' | 'unavailable' | 'failed'
+     */
+    function reloadVerdict(data) {
+      if (data === null || typeof data !== 'object') return 'failed';
+      const status = typeof data.status === 'string' ? data.status : 'failed';
+      if (Array.isArray(data.pending) && data.pending.length > 0) return 'queued';
+      if (typeof data.restartReason === 'string' && data.restartReason !== '') return 'failed';
+      return status;
+    }
+
     /** The plugin ids one startup bundle covers, read from its `??<id>/client.js,…` list. */
     function bundledIds(url) {
       const match = /\?\?([^&]+)/.exec(url);
@@ -151,6 +166,12 @@ window.__ModuleLoader__.load({
      * after that, so this is the only way to see what a rebuild would really boot from.
      * @returns the list rows, or null when this page is not running inside the desktop shell.
      */
+    /** Whether this document is owned by the desktop shell, whose saved list decides a boot. */
+    function desktopShellPresent() {
+      const bridge = window.dshDesktopBoot;
+      return bridge !== undefined && bridge !== null && typeof bridge.ready === 'function';
+    }
+
     async function desktopStartupPayload() {
       const bridge = window.dshDesktopBoot;
       if (bridge === undefined || bridge === null || typeof bridge.ready !== 'function') return null;
@@ -301,6 +322,9 @@ window.__ModuleLoader__.load({
     async function startupLooksServable() {
       for (let attempt = 0; attempt < 2; attempt += 1) {
         const saved = await desktopStartupPayload();
+        // The desktop shell replays one startup list for every document. If it is running but its
+        // copy cannot be read, nothing here proves a new document would boot, so the page stays.
+        if (saved === null && desktopShellPresent()) return false;
         const servable =
           saved === null
             ? await bundlesCoverStartup((await servedBootGraph()) ?? window.__DSH_BOOT__)
@@ -322,10 +346,15 @@ window.__ModuleLoader__.load({
       if (event.defaultPrevented) return false;
       const pending = Array.isArray(detail.pending) ? detail.pending.filter((item) => item !== null && typeof item?.then === 'function') : [];
       if (pending.length === 0) return true;
-      await Promise.race([
+      const slow = Symbol('slow'); // ui-copy-ignore
+      const settled = await Promise.race([
         Promise.allSettled(pending),
-        new Promise((resolve) => setTimeout(resolve, 1200)), // ui-copy-ignore
+        new Promise((resolve) => setTimeout(() => resolve(slow), 1200)), // ui-copy-ignore
       ]);
+      // A save that never settled in time is as uncommitted as one that rejected: the rebuild
+      // would drop the work it still holds, so the page stays.
+      if (settled === slow) return false;
+      if (settled.some((entry) => entry.status === 'rejected')) return false;
       return event.defaultPrevented === false;
     }
 
@@ -446,15 +475,18 @@ window.__ModuleLoader__.load({
           return;
         }
         // Replace first: a plugin that only changed the interface is then covered by the rebuild.
-        let pluginNote = null;
+        // A replacement that did not finish stops the press here: rebuilding the page anyway would
+        // start a document against a plugin set the app has not finished applying.
         if (replace) {
           const status = await replacePlugins();
-          if (status === 'queued') pluginNote = 'queued';
-          else if (status !== 'done' && status !== 'off') pluginNote = 'blocked';
+          if (status !== 'done' && status !== 'off') {
+            const key = status === 'queued' ? 'queued' : status === 'unavailable' ? 'blocked' : 'failed';
+            report('plugin-held', key);
+            return stop(key);
+          }
         }
         if (!rebuild) {
           setPending(false);
-          if (pluginNote !== null) setNotice(COPY[pluginNote]);
           return;
         }
         window.sessionStorage.setItem(STAMP_KEY, String(Date.now()));
@@ -498,7 +530,15 @@ window.__ModuleLoader__.load({
      * must never cause is a navigation the saved startup list cannot survive, and that question is
      * worth asking without starting a desktop app.
      */
-    const PROBE = { prepareInterface, startupLooksServable, frozenStartupLooksServable, desktopStartupPayload, reloadFreshPage };
+    const PROBE = {
+      prepareInterface,
+      startupLooksServable,
+      frozenStartupLooksServable,
+      desktopStartupPayload,
+      desktopShellPresent,
+      reloadVerdict,
+      reloadFreshPage,
+    };
 
     return {
       inject: ['slots'], // ui-copy-ignore

package/index.js

@@ -162,19 +162,6 @@ function pluginReloader(ctx, config) {
   let deferrals = 0
   let lastRun = 0
 
-  /** Resolve true when the HMR queue is empty, i.e. no transaction is really running right now. */
-  const queueIsIdle = async (hmr) => {
-    const queue = hmr?.operations
-    if (typeof queue?.then !== 'function') return true
-    let settled = false
-    Promise.resolve(queue).then(
-      () => (settled = true),
-      () => (settled = true),
-    )
-    await new Promise((resolve) => setTimeout(resolve, 40))
-    return settled
-  }
-
   const turnsRunning = () => {
     try {
       const agents = ctx.get('agents')
@@ -187,9 +174,12 @@ function pluginReloader(ctx, config) {
   const busy = () => idleOnly && turnsRunning()
 
   /**
-   * Ask the HMR service to recompose; it throws rather than half-applying, so a catch is enough.
-   * Another reload may already hold the transaction (a save landing next to a session's own swap),
-   * so a nested refusal is retried instead of being reported as a reload that failed.
+   * Ask the HMR service to recompose through its own queue. The service throws instead of
+   * half-applying, so a catch is enough. Another reload may already hold the transaction (a save
+   * landing next to a session's own swap), so a nested refusal waits and asks again through the
+   * same queue. It never recomposes outside the queue: two recompositions at once can leave half
+   * the plugin set stopped, and a document started in that state does not boot.
+   * @returns what the service reported, so the caller can tell done from partly done.
    */
   const reload = async (hmr) => {
     let result = null
@@ -200,22 +190,17 @@ function pluginReloader(ctx, config) {
       } catch (error) {
         const message = String(error?.message ?? error)
         if (message.includes('nested') === false) throw error
-        if (await queueIsIdle(hmr)) {
-          // The refusal came from a finished transaction whose context this callback inherited
-          // (a watcher created while a reload was restarting this plugin). With the queue empty
-          // there is nothing to serialize against, so recompose directly.
-          log('reload ran outside the queue: the caller inherited a finished transaction')
-          result = await hmr.reconcileProfile([])
-          break
-        }
         if (attempt >= 9) throw error
         await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)))
       }
     }
-    const warnings = Array.isArray(result?.warnings) ? result.warnings.length : 0
-    const pending = Array.isArray(result?.pending) ? result.pending.length : 0
-    const suffix = typeof result?.restartReason === 'string' ? ` restart=${result.restartReason}` : ''
-    log(`plugins reloaded (warnings=${warnings} pending=${pending}${suffix})`)
+    const warnings = Array.isArray(result?.warnings) ? result.warnings : []
+    const pending = Array.isArray(result?.pending) ? result.pending : []
+    const restartReason = typeof result?.restartReason === 'string' ? result.restartReason : null
+    log(
+      `plugins reloaded (warnings=${warnings.length} pending=${pending.length}${restartReason === null ? '' : ` restart=${restartReason}`})`,
+    )
+    return { status: 'done', warnings, pending, restartReason }
   }
 
   const flush = async () => {
@@ -247,7 +232,7 @@ function pluginReloader(ctx, config) {
       running = true
       await reload(hmr)
     } catch (error) {
-      log(`reload failed, the previous code keeps running: ${error?.message ?? error}`)
+      log(`reload did not finish; the plugin set may be partly applied: ${error?.message ?? error}`)
     } finally {
       running = false
       if (again) {
@@ -293,19 +278,27 @@ function pluginReloader(ctx, config) {
     return 'queued'
   }
 
+  /** The answer shape a press always gets, whether or not a reload was started. */
+  const queuedAnswer = (answer) => ({
+    status: answer === 'unavailable' ? 'unavailable' : 'queued',
+    warnings: [],
+    pending: [],
+    restartReason: null,
+  })
+
   /**
    * The button path: run now and report what happened, so the page can tell the user why the
    * press did not replace anything instead of looking broken.
-   * @returns 'done' | 'queued' | 'unavailable' | 'failed'
+   * @returns {{status: string, warnings: string[], pending: string[], restartReason: string|null}}
    */
   const reloadNow = async (force = false) => {
     const hmr = hmrService()
-    if (hmr === null) return 'unavailable'
+    if (hmr === null) return { status: 'unavailable', warnings: [], pending: [], restartReason: null }
     if (turnsRunning()) log('reloading while turns are still running; they keep running')
-    if (running || (force === false && busy())) return queueReload()
+    if (running || (force === false && busy())) return queuedAnswer(queueReload())
     const wait = lastRun + MIN_INTERVAL_MS - Date.now()
     if (wait > 0) await new Promise((resolve) => setTimeout(resolve, Math.min(wait, 2000)))
-    if (running || (force === false && busy())) return queueReload()
+    if (running || (force === false && busy())) return queuedAnswer(queueReload())
     if (timer !== null) {
       clearTimeout(timer)
       timer = null
@@ -314,11 +307,16 @@ function pluginReloader(ctx, config) {
     deferrals = 0
     lastRun = Date.now()
     try {
-      await reload(hmr)
-      return 'done'
+      const outcome = await reload(hmr)
+      if (outcome.pending.length > 0 || outcome.restartReason !== null) {
+        // The app accepted the update but has not finished starting the new plugin set. Rebuilding
+        // the page now would start a document against a set that is still settling.
+        return { status: 'failed', warnings: outcome.warnings, pending: outcome.pending, restartReason: outcome.restartReason }
+      }
+      return outcome
     } catch (error) {
-      log(`reload failed, the previous code keeps running: ${error?.message ?? error}`)
-      return 'failed'
+      log(`reload did not finish; the plugin set may be partly applied: ${error?.message ?? error}`)
+      return { status: 'failed', warnings: [], pending: [], restartReason: null }
     } finally {
       running = false
       again = false
@@ -459,48 +457,98 @@ function currentBundleUrls(graph, request) {
 }
 
 /**
- * Answer one request the running app cannot serve because the revision it names is gone. The
- * bundle module table is asked for the same set at its current revision, and only a body that
- * really contains every plugin it claims is handed back; anything else falls through to the
- * route as before, so an unknown id still ends as a plain 404.
+ * Ask the module table for one bundle at one URL. The newest app takes a standard request object;
+ * older ones take the method and address on their own, so both shapes are offered instead of one
+ * silently failing on the other.
+ */
+async function fetchBundleAt(clientModules, url, method) {
+  const address = `http://unlag.invalid${url}`
+  if (typeof Request === 'function') {
+    try {
+      return await clientModules.fetchBundle(new Request(address, { method, headers: {} }))
+    } catch (error) {
+      if (error?.name !== 'TypeError') throw error
+    }
+  }
+  return clientModules.fetchBundle({ method, url: address })
+}
+
+/**
+ * The plugin set one stale request names, answered at the revision the app serves now. Only a body
+ * that really contains every plugin it claims is handed back; anything unsure answers null, so the
+ * route then behaves exactly as before and an unknown id still ends as a plain 404.
  */
+async function currentBundleAnswer(clientModules, method, url) {
+  const request = bundleRequest(url)
+  if (request === null) return null
+  const urls = currentBundleUrls(clientModules.graph(), request)
+  if (urls.length === 0) return null
+  if (request.rev !== '' && urls.some((target) => target.endsWith(`&rev=${request.rev}`))) return null
+  for (const target of urls) {
+    const response = await fetchBundleAt(clientModules, target, 'GET')
+    if (response.status !== 200) continue
+    const body = Buffer.from(await response.arrayBuffer())
+    if (body.length === 0) continue
+    if (!request.sourceMap && !request.ids.every((id) => body.includes(id))) continue
+    return {
+      body,
+      contentType: String(response.headers.get('content-type') ?? 'text/javascript; charset=utf-8'),
+      ids: request.ids,
+    }
+  }
+  return null
+}
+
+/** Answer one stale request over the plain request/response route an app registers. */
 async function serveCurrentBundle(clientModules, req, res) {
   try {
     const method = String(req?.method ?? 'GET').toUpperCase()
     if (method !== 'GET' && method !== 'HEAD') return false
-    const request = bundleRequest(req?.url)
-    if (request === null) return false
-    const urls = currentBundleUrls(clientModules.graph(), request)
-    if (urls.length === 0) return false
-    if (request.rev !== '' && urls.some((url) => url.endsWith(`&rev=${request.rev}`))) return false
-    for (const url of urls) {
-      const response = await clientModules.fetchBundle({ method: 'GET', url: `http://unlag.invalid${url}` })
-      if (response.status !== 200) continue
-      const body = Buffer.from(await response.arrayBuffer())
-      if (body.length === 0) continue
-      if (!request.sourceMap && !request.ids.every((id) => body.includes(id))) continue
-      if (res.writableEnded === true || res.destroyed === true) return true
-      res.writeHead(200, {
-        'content-type': String(response.headers.get('content-type') ?? 'text/javascript; charset=utf-8'),
-        'cache-control': 'no-store',
-        'content-length': String(body.length),
-      })
-      res.end(method === 'HEAD' ? undefined : body)
-      log(`served ${request.ids.join(', ')} at the current revision: a page asked for an older one`)
-      return true
-    }
-    return false
+    const answer = await currentBundleAnswer(clientModules, method, req?.url)
+    if (answer === null) return false
+    if (res.writableEnded === true || res.destroyed === true) return true
+    res.writeHead(200, {
+      'content-type': answer.contentType,
+      'cache-control': 'no-store',
+      'content-length': String(answer.body.length),
+    })
+    res.end(method === 'HEAD' ? undefined : answer.body)
+    log(`served ${answer.ids.join(', ')} at the current revision: a page asked for an older one`)
+    return true
   } catch (error) {
     log(`cannot serve a bundle from an older revision: ${error?.message ?? error}`)
     return false
   }
 }
 
+/** The same answer over the request-in/response-out route a newer app registers. */
+async function serveCurrentBundleResource(clientModules, request) {
+  try {
+    const method = String(request?.method ?? 'GET').toUpperCase()
+    if (method !== 'GET' && method !== 'HEAD') return null
+    const answer = await currentBundleAnswer(clientModules, method, request?.url)
+    if (answer === null) return null
+    log(`served ${answer.ids.join(', ')} at the current revision: a page asked for an older one`)
+    return new Response(method === 'HEAD' ? null : answer.body, {
+      status: 200,
+      headers: {
+        'content-type': answer.contentType,
+        'cache-control': 'no-store',
+        'content-length': String(answer.body.length),
+      },
+    })
+  } catch (error) {
+    log(`cannot serve a bundle from an older revision: ${error?.message ?? error}`)
+    return null
+  }
+}
+
 /**
  * Wrap the bundle route so a document booting from an older startup list still runs. The route
- * belongs to the module table, and a second registration of the same prefix is refused, so the
- * handler already there is wrapped in place and put back on dispose. Every path through the
- * wrapper falls back to that handler: a bundle it cannot place is answered exactly as before.
+ * belongs to the module table, and a second registration of the same prefix is refused, so what is
+ * already there is wrapped in place and put back on dispose. A newer app registers the route as a
+ * request-in/response-out resource instead of a handler, and the dispatch prefers that one, so the
+ * shape the app actually registers is the shape wrapped — otherwise the guard would be a no-op.
  */
 function serveBundlesAtCurrentRevision(ctx) {
   const server = ctx.get('webServer')
@@ -508,8 +556,24 @@ function serveBundlesAtCurrentRevision(ctx) {
   if (server?.prefixes?.get === undefined) return null
   if (typeof clientModules?.fetchBundle !== 'function' || typeof clientModules?.graph !== 'function') return null
   const route = server.prefixes.get(BUNDLE_ROUTE)
-  if (route === null || route === undefined || typeof route.handler !== 'function') return null
-  if (route[SHIM_MARK] === true) return null
+  if (route === null || route === undefined || route[SHIM_MARK] === true) return null
+  if (typeof route.resource === 'function') {
+    const original = route.resource
+    const wrapped = async (request) => {
+      try {
+        const served = await serveCurrentBundleResource(clientModules, request)
+        if (served !== null) return served
+      } catch (error) {
+        log(`cannot answer a bundle request: ${error?.message ?? error}`)
+      }
+      return original(request)
+    }
+    route[SHIM_MARK] = true
+    route.resource = wrapped
+    log('bundles asked for under an older revision are answered at the current one')
+    return { route, slot: 'resource', original, wrapped }
+  }
+  if (typeof route.handler !== 'function') return null
   const original = route.handler
   const wrapped = (req, res) => {
     const fallback = () => original(req, res)
@@ -523,18 +587,52 @@ function serveBundlesAtCurrentRevision(ctx) {
   route[SHIM_MARK] = true
   route.handler = wrapped
   log('bundles asked for under an older revision are answered at the current one')
-  return { route, original, wrapped }
+  return { route, slot: 'handler', original, wrapped }
 }
 
 /** Put the bundle route back the way it was found; a route replaced since then is left alone. */
 function releaseBundleShim(shim) {
   try {
     if (shim === null || shim === undefined) return
-    if (shim.route.handler === shim.wrapped) shim.route.handler = shim.original
+    if (shim.slot === 'resource') {
+      if (shim.route.resource === shim.wrapped) shim.route.resource = shim.original
+    } else if (shim.route.handler === shim.wrapped) shim.route.handler = shim.original
     if (shim.route[SHIM_MARK] === true) delete shim.route[SHIM_MARK]
   } catch {}
 }
 
+/**
+ * Wrap the bundle route unless the wrap already there is the one still on the route. The route can
+ * appear after this plugin starts and can be replaced afterwards, so every caller that is about to
+ * matter (a reload, a page asking for the graph) asks again instead of trusting an earlier answer.
+ */
+function ensureBundleShim(ctx) {
+  const shim = globalThis[SHIM_KEY]
+  if (shim !== null && shim !== undefined) {
+    const route = ctx.get('webServer')?.prefixes?.get?.(BUNDLE_ROUTE)
+    if (route === shim.route && route[shim.slot] === shim.wrapped && route[SHIM_MARK] === true) return shim
+    releaseBundleShim(shim)
+    globalThis[SHIM_KEY] = null
+  }
+  globalThis[SHIM_KEY] = serveBundlesAtCurrentRevision(ctx)
+  return globalThis[SHIM_KEY]
+}
+
+/** What the bundle route looks like from here, so a stale answer can be told from a missing wrap. */
+function bundleShimStatus(ctx) {
+  const route = ctx.get('webServer')?.prefixes?.get?.(BUNDLE_ROUTE)
+  const clientModules = ctx.get('clientModules')
+  const shape =
+    typeof route?.resource === 'function' ? 'resource' : typeof route?.handler === 'function' ? 'handler' : 'none'
+  return {
+    route: route !== null && route !== undefined,
+    kind: shape,
+    wrapped: route?.[SHIM_MARK] === true && typeof route?.[shape === 'none' ? 'handler' : shape] === 'function',
+    fetch: typeof clientModules?.fetchBundle === 'function',
+    graph: typeof clientModules?.graph === 'function',
+  }
+}
+
 /**
  * The entry points the header button calls. Each answers with the current switches so the page
  * never guesses: with both off it does nothing, and a turn still running is reported rather than
@@ -552,12 +650,13 @@ function serveButton(ctx, controller, config) {
     [
       `${BASE_PATH}/state`,
       (_req, res) => {
-        sendJson(res, 200, { plugins: settings.reloadPlugins, page: settings.reloadInterface })
+        sendJson(res, 200, { plugins: settings.reloadPlugins, page: settings.reloadInterface, shim: bundleShimStatus(ctx) })
       },
     ],
     [
       `${BASE_PATH}/graph`,
       (_req, res) => {
+        ensureBundleShim(ctx)
         sendJson(res, 200, { graph: liveBootGraph(server) })
       },
     ],
@@ -587,8 +686,8 @@ function serveButton(ctx, controller, config) {
         const header = req?.headers?.[BUTTON_HEADER]
         if (typeof header !== 'string' || header === '') return sendJson(res, 403, { status: 'forbidden' })
         if (!settings.reloadPlugins) return sendJson(res, 200, { status: 'off' })
-        const status = await controller.reloadNow()
-        sendJson(res, 200, { status })
+        const outcome = await controller.reloadNow()
+        sendJson(res, 200, outcome)
       },
     ],
   ]
@@ -622,8 +721,7 @@ export function apply(ctx, config) {
      * half starts, and one that appears after it.
      */
     const syncBundles = () => {
-      if (globalThis[SHIM_KEY] !== null) return
-      globalThis[SHIM_KEY] = serveBundlesAtCurrentRevision(ctx)
+      ensureBundleShim(ctx)
     }
     /** Watching needs HMR; start as soon as it exists, drop the watcher when it goes away. */
     const syncWatching = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-unlag",
-  "version": "1.7.7",
+  "version": "1.7.9",
   "type": "module",
   "description": "One press applies plugin edits right away and brings a laggy interface back; running turns, queued messages and unsent input are untouched, and nothing restarts.",
   "license": "MIT",