@mzzsfy/dsh-bug-perf 0.0.0-stage → 0.2.0

package/test/client-watchdog.test.mjs

@@ -0,0 +1,186 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../src/client.js', import.meta.url), 'utf8')
+
+function loadPlugin() {
+  let registered
+  const window = { __ModuleLoader__: { load: (entry) => { registered = entry } } }
+  new Function('window', source)(window)
+  return registered.factory(() => { throw new Error('no modules') })
+}
+
+function fakeTimers() {
+  let now = 0
+  let nextId = 0
+  const intervals = new Map()
+  return {
+    now: () => now,
+    setInterval: (fn, ms) => { const id = ++nextId; intervals.set(id, { fn, every: ms, at: now + ms }); return id },
+    clearInterval: (id) => { intervals.delete(id) },
+    advance(ms) {
+      now += ms
+      for (const [id, timer] of [...intervals]) {
+        if (timer.at <= now) {
+          timer.at = now + timer.every
+          timer.fn()
+        }
+      }
+    },
+    intervalCount: () => intervals.size,
+  }
+}
+
+function fakeView({ writable = false, phase = 'connected', revision = 1, pendingRender, hasStream = true } = {}) {
+  const snapshot = { phase, writable }
+  return {
+    sessionId: 'session-a',
+    id: 'term-a',
+    revision,
+    pendingRender,
+    stream: hasStream ? {} : undefined,
+    connects: 0,
+    lifetime: { signal: { addEventListener() {} } },
+    state: { getSnapshot: () => snapshot },
+    snapshot,
+    connect() { this.connects += 1 },
+  }
+}
+
+const OPTIONS = { checkMs: 2000, stallMs: 8000, cooldownMs: 60000 }
+
+function stateFor(view, now = 0) {
+  return { revision: view.revision, changedAt: now, armed: false, healedAt: -Infinity }
+}
+
+// Given 视图从未可写(旁观只读), When 长时间无输出, Then 不触发重连
+test('看门狗_未武装_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: false })
+  const state = stateFor(view)
+  const result = plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 30000, visible: true })
+  assert.equal(result, 'idle')
+  assert.equal(state.armed, false)
+})
+
+// Given 视图曾接管输入随后卡住, When 停滞超过阈值, Then 触发一次重连并释放武装
+test('看门狗_已武装停滞_触发重连', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true }), 'progress')
+  assert.equal(state.armed, true)
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 5000, visible: true }), 'idle')
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 10500, visible: true }), 'heal')
+  assert.equal(state.armed, false)
+  assert.equal(state.healedAt, 10500)
+})
+
+// Given 视图持续有新帧, When 每轮检查, Then 只报进度不触发
+test('看门狗_持续有新帧_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  for (let i = 1; i <= 6; i++) {
+    view.revision = i
+    const result = plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: i * 10000, visible: true })
+    assert.equal(result, 'progress')
+  }
+})
+
+// Given 刚自愈过, When 再次停滞进入冷却期, Then 不重复重连
+test('看门狗_冷却期_不重复', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true })
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 9500, visible: true }), 'heal')
+  state.armed = true
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 20000, visible: true }), 'cooldown')
+})
+
+// Given 页面隐藏, When 停滞判定到期, Then 不触发(隐藏期的停顿不是故障)
+test('看门狗_页面隐藏_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true })
+  const state = stateFor(view)
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true }), 'progress')
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 20000, visible: false }), 'hidden')
+})
+
+// Given 视图正在等渲染或没有 attach 流, When 检查, Then 不当作冻结处理
+test('看门狗_待渲染或无流_不触发', () => {
+  const plugin = loadPlugin()
+  const pending = fakeView({ writable: true, pendingRender: {} })
+  const pendingState = stateFor(pending)
+  plugin.__test.watchdogTick({ view: pending, state: pendingState, options: OPTIONS, now: 1000, visible: true })
+  pending.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view: pending, state: pendingState, options: OPTIONS, now: 20000, visible: true }), 'pending-render')
+
+  const detached = fakeView({ writable: true, hasStream: false })
+  const detachedState = stateFor(detached)
+  plugin.__test.watchdogTick({ view: detached, state: detachedState, options: OPTIONS, now: 1000, visible: true })
+  detached.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view: detached, state: detachedState, options: OPTIONS, now: 20000, visible: true }), 'no-stream')
+})
+
+// Given 视图已断开重连中, When 检查, Then 只报未连接, 不叠加重连
+test('看门狗_未连接_不触发', () => {
+  const plugin = loadPlugin()
+  const view = fakeView({ writable: true, phase: 'connecting' })
+  const state = stateFor(view)
+  plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 1000, visible: true })
+  view.snapshot.writable = false
+  assert.equal(plugin.__test.watchdogTick({ view, state, options: OPTIONS, now: 20000, visible: true }), 'not-connected')
+})
+
+// Given 新视图由官方服务创建, When 看门狗安装后推进到停滞阈值, Then 自动调用 connect 恢复输出
+test('看门狗_新建视图_自动重连', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const holder = { view() { return this.created }, created: fakeView({ writable: true }), views: new Map() }
+  const result = plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  assert.equal(result.installed, true)
+  const view = holder.view('session-a', 'tab-1', 'content-1')
+  timers.advance(2000)
+  view.snapshot.writable = false
+  timers.advance(8000)
+  assert.equal(view.connects, 1)
+})
+
+// Given 已存在的视图, When 安装时遍历 views, Then 同样进入监控
+test('看门狗_既有视图_进入监控', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const existing = fakeView({ writable: true })
+  const holder = { view: () => existing, views: new Map([['session-a', new Map([['tab-1', existing]])]]) }
+  plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  timers.advance(2000)
+  existing.snapshot.writable = false
+  timers.advance(8000)
+  assert.equal(existing.connects, 1)
+})
+
+// Given 宿主版本没有 webTerminals.view, When 安装, Then 跳过并不抛错
+test('看门狗_服务结构缺失_跳过不抛', () => {
+  const plugin = loadPlugin()
+  const missing = plugin.__test.installTerminalWatchdog({ holder: {}, options: OPTIONS, timers: fakeTimers(), isVisible: () => true })
+  assert.equal(missing.installed, false)
+  const alsoMissing = plugin.__test.installTerminalWatchdog({ holder: undefined, options: OPTIONS, timers: fakeTimers(), isVisible: () => true })
+  assert.equal(alsoMissing.installed, false)
+})
+
+// Given 已安装, When 再次安装, Then 幂等不重复挂定时器
+test('看门狗_重复安装_幂等', () => {
+  const plugin = loadPlugin()
+  const timers = fakeTimers()
+  const holder = { view: () => fakeView({ writable: true }), views: new Map() }
+  plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  const again = plugin.__test.installTerminalWatchdog({ holder, options: OPTIONS, timers, isVisible: () => true })
+  assert.equal(again.installed, false)
+  assert.equal(timers.intervalCount() <= 1, true)
+})

package/test/config.test.mjs

@@ -0,0 +1,145 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { DEFAULT_CONFIG, normalizeConfig } from '../src/config.mjs'
+
+// Given 无配置, When 归一化, Then 各补丁默认开启(诊断上报默认关闭)且阈值取默认
+test('配置_缺省_功能默认值与阈值', () => {
+  const config = normalizeConfig(undefined)
+  assert.deepEqual(config, DEFAULT_CONFIG)
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.restartCoalesce.windowMs, 100)
+  assert.equal(config.terminalWatchdog.enabled, true)
+  assert.equal(config.terminalWatchdog.checkMs, 2000)
+  assert.equal(config.terminalWatchdog.stallMs, 8000)
+  assert.equal(config.terminalWatchdog.cooldownMs, 60000)
+})
+
+// Given 只覆盖一个字段, When 归一化, Then 其余字段保持默认
+test('配置_部分覆盖_其余保持默认', () => {
+  const config = normalizeConfig({ restartCoalesce: { windowMs: 250 } })
+  assert.equal(config.restartCoalesce.windowMs, 250)
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.terminalWatchdog.stallMs, 8000)
+})
+
+// Given 功能关闭, When 归一化, Then 关闭语义原样保留而阈值仍可取
+test('配置_功能关闭_保留阈值', () => {
+  const config = normalizeConfig({ terminalWatchdog: { enabled: false, stallMs: 4000 } })
+  assert.equal(config.terminalWatchdog.enabled, false)
+  assert.equal(config.terminalWatchdog.stallMs, 4000)
+})
+
+// Given 非法类型与越界值, When 归一化, Then 回退默认而不是把坏值带进运行时
+test('配置_非法值_回退默认', () => {
+  const config = normalizeConfig({
+    restartCoalesce: { enabled: 'yes', windowMs: -1 },
+    terminalWatchdog: { checkMs: 0, stallMs: 'soon', cooldownMs: Number.NaN },
+  })
+  assert.equal(config.restartCoalesce.enabled, true)
+  assert.equal(config.restartCoalesce.windowMs, 100)
+  assert.equal(config.terminalWatchdog.checkMs, 2000)
+  assert.equal(config.terminalWatchdog.stallMs, 8000)
+  assert.equal(config.terminalWatchdog.cooldownMs, 60000)
+})
+
+// Given 超上限的阈值, When 归一化, Then 收敛到上限(防止错误配置把功能变成滥用)
+test('配置_越界上限_收敛', () => {
+  const config = normalizeConfig({
+    restartCoalesce: { windowMs: 60000 },
+    terminalWatchdog: { checkMs: 600000, stallMs: 999999999, cooldownMs: 999999999 },
+  })
+  assert.equal(config.restartCoalesce.windowMs, 2000)
+  assert.equal(config.terminalWatchdog.checkMs, 60000)
+  assert.equal(config.terminalWatchdog.stallMs, 600000)
+  assert.equal(config.terminalWatchdog.cooldownMs, 3600000)
+})
+
+// Given 未知字段, When 归一化, Then 被丢弃(配置面只认已声明字段)
+test('配置_未知字段_丢弃', () => {
+  const config = normalizeConfig({ unknown: 1, restartCoalesce: { windowMs: 150 } })
+  assert.equal(config.unknown, undefined)
+  assert.equal(config.restartCoalesce.windowMs, 150)
+})
+
+// Given 无配置, When 归一化, Then 保活与停滞兜底默认开启且阈值取默认
+test('配置_保活与停滞_默认值', () => {
+  const config = normalizeConfig(undefined)
+  assert.deepEqual(config.socketKeepAlive, { enabled: true, intervalMs: 1500 })
+  assert.deepEqual(config.stuckSession, {
+    enabled: true,
+    checkMs: 2000,
+    stallMs: 8000,
+    reconnect: true,
+    maxReconnectAttempts: 5,
+    reconnectIntervalMs: 15000,
+  })
+  assert.deepEqual(config.jobStreamLimit, { enabled: true, base: 32, max: 48 })
+})
+
+// Given 新增补丁的非法值, When 归一化, Then 回退默认而不是把坏值带进运行时
+test('配置_保活与停滞_非法值回退', () => {
+  const config = normalizeConfig({
+    socketKeepAlive: { enabled: 'on', intervalMs: 0 },
+    stuckSession: { checkMs: -5, stallMs: 'slow', reconnect: 1, maxReconnectAttempts: Number.NaN, reconnectIntervalMs: 0 },
+  })
+  assert.equal(config.socketKeepAlive.enabled, true)
+  assert.equal(config.socketKeepAlive.intervalMs, 1500)
+  assert.equal(config.stuckSession.checkMs, 2000)
+  assert.equal(config.stuckSession.stallMs, 8000)
+  assert.equal(config.stuckSession.reconnect, true)
+  assert.equal(config.stuckSession.maxReconnectAttempts, 5)
+  assert.equal(config.stuckSession.reconnectIntervalMs, 15000)
+})
+
+// Given 超上限的阈值, When 归一化, Then 收敛到上限
+test('配置_保活与停滞_越界收敛', () => {
+  const config = normalizeConfig({
+    socketKeepAlive: { intervalMs: 999999 },
+    stuckSession: { checkMs: 999999, stallMs: 999999999, maxReconnectAttempts: 999999, reconnectIntervalMs: 999999999 },
+  })
+  assert.equal(config.socketKeepAlive.intervalMs, 60000)
+  assert.equal(config.stuckSession.checkMs, 60000)
+  assert.equal(config.stuckSession.stallMs, 600000)
+  assert.equal(config.stuckSession.maxReconnectAttempts, 20)
+  assert.equal(config.stuckSession.reconnectIntervalMs, 600000)
+})
+
+// Given 任务流上限被关掉或给了非法值, When 归一化, Then 关闭生效、非法值回退默认
+test('配置_任务流上限_开关与回退', () => {
+  const off = normalizeConfig({ jobStreamLimit: { enabled: false } })
+  assert.equal(off.jobStreamLimit.enabled, false)
+  const bad = normalizeConfig({ jobStreamLimit: { base: 0, max: 0 } })
+  assert.equal(bad.jobStreamLimit.base, 32)
+  assert.equal(bad.jobStreamLimit.max, 48)
+  const capped = normalizeConfig({ jobStreamLimit: { max: 99999 } })
+  assert.equal(capped.jobStreamLimit.max, 512)
+  const inverted = normalizeConfig({ jobStreamLimit: { base: 200, max: 10 } })
+  assert.equal(inverted.jobStreamLimit.base, 10)
+})
+
+// Given 列表瘦身缺省或关闭, When 归一化, Then 默认开启、显式关闭保留、非法类型回退默认
+test('配置_列表瘦身_开关与回退', () => {
+  assert.deepEqual(normalizeConfig(undefined).listSlim, { enabled: true })
+  assert.equal(normalizeConfig({ listSlim: { enabled: false } }).listSlim.enabled, false)
+  assert.equal(normalizeConfig({ listSlim: { enabled: 'off' } }).listSlim.enabled, true)
+})
+
+// Given 诊断上报缺省, When 归一化, Then 默认关闭且上报间隔取默认
+test('配置_诊断上报_默认关闭', () => {
+  assert.deepEqual(normalizeConfig(undefined).diag, { enabled: false, reportEvery: 12 })
+})
+
+// Given 诊断上报显式开关与非法值, When 归一化, Then 开关保留、非法类型回退、间隔越界收敛、未知字段丢弃
+test('配置_诊断上报_开关边界', () => {
+  const off = normalizeConfig({ diag: { enabled: false, reportEvery: 5 } })
+  assert.equal(off.diag.enabled, false)
+  assert.equal(off.diag.reportEvery, 5)
+  const on = normalizeConfig({ diag: { enabled: true } })
+  assert.equal(on.diag.enabled, true)
+  const bad = normalizeConfig({ diag: { enabled: 'yes', reportEvery: 'often' } })
+  assert.equal(bad.diag.enabled, false)
+  assert.equal(bad.diag.reportEvery, 12)
+  assert.equal(normalizeConfig({ diag: { reportEvery: 0 } }).diag.reportEvery, 1)
+  assert.equal(normalizeConfig({ diag: { reportEvery: 99999 } }).diag.reportEvery, 720)
+  assert.deepEqual(normalizeConfig({ diag: { reportEvery: 3, unknown: 1 } }).diag, { enabled: false, reportEvery: 3 })
+})

package/test/host.test.mjs

@@ -0,0 +1,340 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { DEFAULT_CONFIG } from '../src/config.mjs'
+import { apply, Config, name } from '../src/index.js'
+
+function makeRes() {
+  return {
+    status: undefined,
+    headers: undefined,
+    body: undefined,
+    writeHead(status, headers) { this.status = status; this.headers = headers },
+    end(body) { this.body = body },
+  }
+}
+
+function makeCtx({ server, registerError, sessionController, settings, configEditor, fiberEntry } = {}) {
+  const registrations = []
+  const disposed = []
+  const ctx = {
+    fiber: { entry: fiberEntry },
+    get: (service) => {
+      if (service === 'webServer') return server
+      if (service === 'sessionController') return sessionController
+      if (service === 'settings') return settings
+      if (service === 'configEditor') return configEditor
+      return undefined
+    },
+    effect: (factory) => {
+      const dispose = factory()
+      ctx.effects.push(dispose)
+      return dispose
+    },
+    inject: (services, callback) => {
+      const scope = {
+        get: ctx.get,
+        get sessionController() { return sessionController },
+        get settings() { return settings },
+        on: () => {},
+        effect: (factory) => {
+          ctx.effects.push(factory())
+        },
+      }
+      if (services.includes('sessionController') && sessionController !== undefined) callback(scope)
+      if (services.includes('settings') && settings !== undefined) callback(scope)
+    },
+    effects: [],
+    registrations,
+    disposed,
+  }
+  if (server !== undefined) {
+    server.register = (route) => {
+      if (registerError !== undefined) throw registerError
+      registrations.push(route)
+      return () => disposed.push(route.path)
+    }
+  }
+  return ctx
+}
+
+async function request(route, config) {
+  const res = makeRes()
+  await route.handler({ url: '/api/dsh-bug-perf/config', method: 'GET' }, res)
+  return res
+}
+
+async function requestDiag(route, query) {
+  const res = makeRes()
+  await route.handler({ url: `/api/dsh-bug-perf/diag${query}`, method: 'GET' }, res)
+  return res
+}
+
+// Given 插件声明注入, When 装载器解析, Then 等待 webServer 就绪后再激活(不是同步探测)
+test('宿主_注入声明_等待webServer', async () => {
+  const index = await import('../src/index.js')
+  assert.deepEqual(index.inject, ['webServer'])
+})
+
+// Given 宿主提供 webServer, When 插件激活, Then 注册配置读写路由且路径固定
+test('宿主_激活_注册配置路由', () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  assert.equal(name, 'dsh-bug-perf')
+  assert.equal(ctx.registrations.length, 2)
+  assert.equal(ctx.registrations[0].kind, 'exact')
+  assert.equal(ctx.registrations[0].path, '/api/dsh-bug-perf/config')
+  assert.equal(ctx.registrations[1].path, '/api/dsh-bug-perf/diag')
+})
+
+// Given 行配置为缺省, When 客户端读取配置, Then 返回默认配置 JSON
+test('宿主_缺省配置_返回默认值', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const res = await request(ctx.registrations[0])
+  assert.equal(res.status, 200)
+  const json = JSON.parse(res.body)
+  assert.deepEqual(json.config, DEFAULT_CONFIG)
+})
+
+// Given 行配置部分覆盖, When 客户端读取, Then 覆盖项生效且其余为默认
+test('宿主_部分覆盖_返回归一化结果', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, { restartCoalesce: { enabled: false }, terminalWatchdog: { stallMs: 12000 } })
+  const json = JSON.parse((await request(ctx.registrations[0])).body)
+  assert.equal(json.config.restartCoalesce.enabled, false)
+  assert.equal(json.config.restartCoalesce.windowMs, 100)
+  assert.equal(json.config.terminalWatchdog.stallMs, 12000)
+})
+
+async function postConfig(route, body) {
+  const res = makeRes()
+  const payload = typeof body === 'string' ? body : JSON.stringify(body)
+  const req = {
+    url: '/api/dsh-bug-perf/config',
+    method: 'POST',
+    on(event, callback) {
+      if (event === 'data') callback(Buffer.from(payload))
+      else if (event === 'end') callback()
+    },
+    destroy() {},
+  }
+  await route.handler(req, res)
+  return res
+}
+
+// Given 旧宿主 settings 命名空间可用, When POST 配置, Then 归一化后持久化并可读回
+test('宿主_配置保存_settings持久化', async () => {
+  const settings = {
+    stored: undefined,
+    registered: undefined,
+    register(namespace, schema, options) { this.registered = { namespace, schema, options } },
+    get() { return this.stored },
+    async update(_namespace, patch) { this.stored = { ...(this.stored ?? {}), ...patch } },
+  }
+  const ctx = makeCtx({ server: {}, settings })
+  apply(ctx, undefined)
+  assert.equal(settings.registered.namespace, 'bug-perf')
+  const res = await postConfig(ctx.registrations[0], { config: { listSlim: { enabled: false } } })
+  assert.equal(res.status, 200)
+  const saved = JSON.parse(res.body).config
+  assert.equal(saved.listSlim.enabled, false)
+  assert.equal(settings.stored.listSlim.enabled, false)
+  const read = JSON.parse((await request(ctx.registrations[0])).body)
+  assert.equal(read.config.listSlim.enabled, false)
+})
+
+// Given legacy settings 只存 diag, When 读取配置, Then diag 节也参与已存判断
+test('宿主_配置读取_settings仅diag_生效', async () => {
+  const settings = {
+    stored: { diag: { enabled: true, reportEvery: 2 } },
+    register() {},
+    get() { return this.stored },
+    async update() {},
+  }
+  const ctx = makeCtx({ server: {}, settings })
+  apply(ctx, undefined)
+  const read = JSON.parse((await request(ctx.registrations[0])).body)
+  assert.deepEqual(read.config.diag, { enabled: true, reportEvery: 2 })
+})
+
+// Given 保存值越界, When POST, Then 上限收敛后再落盘
+test('宿主_配置保存_数值收敛', async () => {
+  const settings = {
+    stored: undefined,
+    register() {},
+    get() { return this.stored },
+    async update(_namespace, patch) { this.stored = patch },
+  }
+  const ctx = makeCtx({ server: {}, settings })
+  apply(ctx, undefined)
+  const res = await postConfig(ctx.registrations[0], { config: { terminalWatchdog: { stallMs: 99999999 } } })
+  assert.equal(JSON.parse(res.body).config.terminalWatchdog.stallMs, 600000)
+  assert.equal(settings.stored.terminalWatchdog.stallMs, 600000)
+})
+
+// Given 0.1.7 行配置编辑器可用, When POST, Then 通过 editor.edit 写当前 fiber 条目
+test('宿主_配置保存_行配置编辑器', async () => {
+  const edits = []
+  const configEditor = {
+    async edit(entry, update) {
+      const next = update({ restartCoalesce: { enabled: true, windowMs: 100 } })
+      edits.push({ entry, next })
+    },
+  }
+  const entry = { id: 'dsh-bug-perf' }
+  const ctx = makeCtx({ server: {}, configEditor, fiberEntry: entry })
+  apply(ctx, undefined)
+  const res = await postConfig(ctx.registrations[0], { config: { restartCoalesce: { windowMs: 250 } } })
+  assert.equal(res.status, 200)
+  assert.equal(edits.length, 1)
+  assert.equal(edits[0].entry, entry)
+  assert.equal(edits[0].next.restartCoalesce.windowMs, 250)
+})
+
+// Given 坏 JSON 或非法 config, When POST, Then 400 且不写
+test('宿主_配置保存_拒绝坏载荷', async () => {
+  let updates = 0
+  const settings = {
+    register() {},
+    get() { return undefined },
+    async update() { updates += 1 },
+  }
+  const ctx = makeCtx({ server: {}, settings })
+  apply(ctx, undefined)
+  assert.equal((await postConfig(ctx.registrations[0], 'not-json')).status, 400)
+  assert.equal((await postConfig(ctx.registrations[0], { config: null })).status, 400)
+  assert.equal((await postConfig(ctx.registrations[0], { config: [] })).status, 400)
+  assert.equal(updates, 0)
+})
+
+// Given 宿主没有 settings 与 configEditor, When POST, Then 503 且不抛
+test('宿主_配置保存_服务缺失返回503', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const res = await postConfig(ctx.registrations[0], { config: { listSlim: { enabled: false } } })
+  assert.equal(res.status, 503)
+})
+
+// Given 非 GET/POST 方法, When 请求配置路由, Then 405 且不读不写
+test('宿主_配置路由_拒绝未知方法', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const res = makeRes()
+  await ctx.registrations[0].handler({ url: '/api/dsh-bug-perf/config', method: 'DELETE' }, res)
+  assert.equal(res.status, 405)
+})
+
+// Given 0.1.7 宿主把整节配置包成 volatile ref, When 读取, Then 解箱后返回
+test('宿主_volatile配置_解箱', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, { get: () => ({ terminalWatchdog: { enabled: false } }) })
+  const json = JSON.parse((await request(ctx.registrations[0])).body)
+  assert.equal(json.config.terminalWatchdog.enabled, false)
+})
+
+// Given 宿主没有 webServer 服务, When 插件激活, Then 不注册不抛错(旧宿主/无 web 场景)
+test('宿主_无webServer_干净跳过', () => {
+  const ctx = makeCtx()
+  assert.doesNotThrow(() => apply(ctx, undefined))
+  assert.equal(ctx.registrations.length, 0)
+  assert.equal(ctx.effects.length, 0)
+})
+
+// Given 路由注册抛错, When 插件激活, Then 错误被记录而不是拖垮页面
+test('宿主_注册失败_不抛', () => {
+  const ctx = makeCtx({ server: {}, registerError: new Error('route table frozen') })
+  assert.doesNotThrow(() => apply(ctx, undefined))
+  assert.equal(ctx.registrations.length, 0)
+})
+
+// Given 插件导出 Config, When 取各节默认值, Then 与共享默认值一致(设置页与运行时同源)
+test('宿主_Config默认值_与共享默认一致', () => {
+  const restart = Config.dict.restartCoalesce({})
+  const watchdog = Config.dict.terminalWatchdog({})
+  assert.equal(restart.enabled, DEFAULT_CONFIG.restartCoalesce.enabled)
+  assert.equal(restart.windowMs, DEFAULT_CONFIG.restartCoalesce.windowMs)
+  assert.equal(watchdog.enabled, DEFAULT_CONFIG.terminalWatchdog.enabled)
+  assert.equal(watchdog.checkMs, DEFAULT_CONFIG.terminalWatchdog.checkMs)
+  assert.equal(watchdog.stallMs, DEFAULT_CONFIG.terminalWatchdog.stallMs)
+  assert.equal(watchdog.cooldownMs, DEFAULT_CONFIG.terminalWatchdog.cooldownMs)
+  assert.deepEqual(Config.dict.listSlim({}), DEFAULT_CONFIG.listSlim)
+  assert.deepEqual(Config.dict.diag({}), DEFAULT_CONFIG.diag)
+  assert.equal(Config.dict.diag({}).enabled, false)
+})
+
+// Given sessionController 就绪, When 插件激活并调用列表接口, Then 投影按白名单裁剪且第二次命中缓存
+test('宿主_列表瘦身_按配置接管列表接口', async () => {
+  let built = 0
+  const controller = {
+    list: async () => {
+      built += 1
+      return { items: [{ sessionId: 'a', projections: { kind: 'cached', values: { title: 'A', contextHeaders: [1] } } }] }
+    },
+  }
+  const ctx = makeCtx({ server: {}, sessionController: controller })
+  apply(ctx, undefined)
+  const first = await controller.list({}, undefined)
+  const second = await controller.list({}, undefined)
+  assert.equal(built, 1)
+  assert.deepEqual(Object.keys(first.items[0].projections.values), ['title'])
+  assert.equal(second, first)
+})
+
+// Given 行配置关闭列表瘦身, When 调用列表接口, Then 原样透传且不缓存
+test('宿主_列表瘦身_关闭时原样透传', async () => {
+  let built = 0
+  const controller = {
+    list: async () => {
+      built += 1
+      return { items: [{ sessionId: 'a', projections: { values: { contextHeaders: [1] } } }] }
+    },
+  }
+  const ctx = makeCtx({ server: {}, sessionController: controller })
+  apply(ctx, { listSlim: { enabled: false } })
+  await controller.list({}, undefined)
+  const value = await controller.list({}, undefined)
+  assert.equal(built, 2)
+  assert.deepEqual(value.items[0].projections.values, { contextHeaders: [1] })
+})
+
+// Given 0.1.7 live ref 热更新行配置, When 连续切换 listSlim 开关, Then 每次调用按当前值决定裁剪或透传
+test('宿主_列表瘦身_热切换开关即时生效', async () => {
+  let current = { listSlim: { enabled: false } }
+  let built = 0
+  const controller = {
+    list: async () => {
+      built += 1
+      return { items: [{ sessionId: 'a', projections: { values: { title: 'A', contextHeaders: [1] } } }] }
+    },
+  }
+  const ctx = makeCtx({ server: {}, sessionController: controller })
+  apply(ctx, { get: () => current })
+  const off = await controller.list({}, undefined)
+  assert.deepEqual(off.items[0].projections.values.contextHeaders, [1], '关闭时透传完整投影')
+  current = { listSlim: { enabled: true } }
+  const on = await controller.list({}, undefined)
+  assert.deepEqual(Object.keys(on.items[0].projections.values), ['title'], '开启后裁剪')
+  current = { listSlim: { enabled: false } }
+  const offAgain = await controller.list({}, undefined)
+  assert.deepEqual(offAgain.items[0].projections.values.contextHeaders, [1], '再次关闭恢复完整投影')
+  assert.equal(built, 3)
+})
+
+// Given diag 开关默认关闭, When 浏览器仍上报合法载荷, Then 宿主不按开关拒绝, 返回 ok 并落盘
+test('宿主_采样上报_接受合法载荷', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const res = await requestDiag(ctx.registrations[1], `?d=${encodeURIComponent(JSON.stringify({ at: 1, totals: { opened: 1 } }))}`)
+  assert.equal(res.status, 200)
+  assert.deepEqual(JSON.parse(res.body), { ok: true })
+})
+
+// Given 缺少载荷或载荷不是 JSON, When 上报, Then 返回 400 且不抛出
+test('宿主_采样上报_拒绝坏载荷', async () => {
+  const ctx = makeCtx({ server: {} })
+  apply(ctx, undefined)
+  const missing = await requestDiag(ctx.registrations[1], '')
+  assert.equal(missing.status, 400)
+  const broken = await requestDiag(ctx.registrations[1], '?d=not-json')
+  assert.equal(broken.status, 400)
+})