@mzzsfy/dsh-bug-perf 0.1.0 → 0.2.0

package/test/host.test.mjs

@@ -13,16 +13,36 @@ function makeRes() {
   }
 }
 
-function makeCtx({ server, registerError } = {}) {
+function makeCtx({ server, registerError, sessionController, settings, configEditor, fiberEntry } = {}) {
   const registrations = []
   const disposed = []
   const ctx = {
-    get: (service) => (service === 'webServer' ? server : undefined),
+    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,
@@ -55,7 +75,7 @@ test('宿主_注入声明_等待webServer', async () => {
   assert.deepEqual(index.inject, ['webServer'])
 })
 
-// Given 宿主提供 webServer, When 插件激活, Then 注册只读配置路由且路径固定
+// Given 宿主提供 webServer, When 插件激活, Then 注册配置读写路由且路径固定
 test('宿主_激活_注册配置路由', () => {
   const ctx = makeCtx({ server: {} })
   apply(ctx, undefined)
@@ -86,6 +106,124 @@ test('宿主_部分覆盖_返回归一化结果', async () => {
   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: {} })
@@ -119,9 +257,70 @@ test('宿主_Config默认值_与共享默认一致', () => {
   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 浏览器上报采样, When 宿主收到合法载荷, Then 返回 ok 并落盘
+// Given diag 开关默认关闭, When 浏览器仍上报合法载荷, Then 宿主不按开关拒绝, 返回 ok 并落盘
 test('宿主_采样上报_接受合法载荷', async () => {
   const ctx = makeCtx({ server: {} })
   apply(ctx, undefined)

package/test/list-slim.test.mjs

@@ -0,0 +1,421 @@
+// 列表瘦身的契约:只裁白名单、命中缓存不重建、增删事件失效、任何异常回落到原行为。
+// 安全面:包装必须保留调用方 receiver(宿主在 list 内按 invocation 逐项鉴权),
+// 缓存只服务 owner/本地调用,非 owner 主体不得命中共享缓存。
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { installListSlim, slimItem } from '../src/list-slim.mjs'
+
+/** 一条带完整投影的列表项。 */
+const item = (id, values) => ({ sessionId: id, updatedAt: 1, projections: { kind: 'cached', asOfSeq: 1, values } })
+
+/** 造一个只实现本模块用到表面的上下文(缺服务时不回调,模拟 cordis inject 门控)。 */
+function makeContext(list, { withController = true, controller: given, effectError } = {}) {
+  const handlers = new Map()
+  const disposers = []
+  const logs = { info: [], warn: [] }
+  const controller = withController ? (given ?? { ctx: {}, list }) : undefined
+  const ctx = {
+    get: (name) => (name === 'sessionController' ? controller : undefined),
+    on: (event, handler) => handlers.set(event, handler),
+    logger: {
+      info: (message) => logs.info.push(message),
+      warn: (message) => logs.warn.push(message),
+    },
+    inject: (deps, callback) => {
+      if (controller === undefined) return
+      callback({
+        sessionController: controller,
+        on: (event, handler) => handlers.set(event, handler),
+        effect: (factory) => {
+          if (effectError !== undefined) throw effectError
+          disposers.push(factory())
+        },
+      })
+    },
+  }
+  return { ctx, controller, handlers, disposers, logs }
+}
+
+const sample = () => [
+  item('a', { title: 'A', sessionListMetadata: { blank: false }, contextHeaders: [{ pad: 'x'.repeat(64) }] }),
+  item('b', { title: 'B', inbox: { 'next-turn': [], 'next-step': [] } }),
+]
+
+/** 模拟宿主 service proxy 的 receiver:invocation 决定 remoteAccess 的判定。 */
+const receiverOf = (principal) => ({ ctx: { invocation: principal === undefined ? undefined : { peer: { principal } } } })
+
+test('裁剪只保留白名单里的投影', () => {
+  const slim = slimItem(sample()[0], ['title'])
+  assert.deepEqual(Object.keys(slim.projections.values), ['title'])
+  assert.equal(slim.projections.kind, 'cached')
+  assert.equal(slim.sessionId, 'a')
+})
+
+test('形状不符的条目原样返回', () => {
+  const bare = { sessionId: 'c' }
+  assert.equal(slimItem(bare, ['title']), bare)
+  assert.equal(slimItem({ projections: { values: null } }, ['title']).projections.values, null)
+  const array = { projections: { values: ['x'] } }
+  assert.equal(slimItem(array, ['title']), array)
+})
+
+test('开关关闭时包装保留,但每次调用透传原方法', async () => {
+  const original = async () => ({ items: sample() })
+  const { ctx, controller } = makeContext(original)
+  installListSlim(ctx, { isEnabled: () => false, warmupDelayMs: -1 })
+  assert.notEqual(controller.list, original)
+  const value = await controller.list({}, undefined)
+  assert.equal(value.items[0].projections.values.contextHeaders[0].pad.length, 64)
+})
+
+// Given 宿主没有 sessionController, When 装载, Then inject 不回调、不接管、不抛错
+test('宿主没有 sessionController 时静默等待', () => {
+  const { ctx, logs } = makeContext(undefined, { withController: false })
+  assert.equal(installListSlim(ctx, { warmupDelayMs: -1 }), true)
+  assert.deepEqual(logs.warn, [])
+})
+
+// Given 服务在场但没有 list 方法, When 装载, Then 记录原因并放弃
+test('controller 缺 list 方法时记录原因', () => {
+  const { ctx, logs } = makeContext(undefined, { controller: { ctx: {} } })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  assert.ok(logs.warn.some((message) => message.includes('list 不可用')))
+})
+
+test('第二次调用命中缓存,不重建', async () => {
+  let built = 0
+  const { ctx, controller } = makeContext(async () => {
+    built += 1
+    return { items: sample() }
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  await controller.list({}, undefined)
+  const value = await controller.list({}, undefined)
+  assert.equal(built, 1)
+  assert.equal(value.items[0].projections.values.contextHeaders, undefined)
+})
+
+test('过期后重建', async () => {
+  let built = 0
+  const { ctx, controller } = makeContext(async () => {
+    built += 1
+    return { items: sample() }
+  })
+  installListSlim(ctx, { ttlMs: 0, warmupDelayMs: -1 })
+  await controller.list({}, undefined)
+  await controller.list({}, undefined)
+  assert.equal(built, 2)
+})
+
+test('会话增删让缓存失效', async () => {
+  let built = 0
+  const { ctx, controller, handlers } = makeContext(async () => {
+    built += 1
+    return { items: sample() }
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  await controller.list({}, undefined)
+  handlers.get('api-session/added')()
+  await controller.list({}, undefined)
+  assert.equal(built, 2)
+  handlers.get('api-session/removed')()
+  await controller.list({}, undefined)
+  assert.equal(built, 3)
+})
+
+test('并发请求只触发一次重建', async () => {
+  let built = 0
+  const { ctx, controller } = makeContext(async () => {
+    built += 1
+    return { items: sample() }
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  await Promise.all([controller.list({}, undefined), controller.list({}, undefined), controller.list({}, undefined)])
+  assert.equal(built, 1)
+})
+
+test('不同 signal 的并发调用共享一次构建,取消互不影响', async () => {
+  let built = 0
+  let release
+  const { ctx, controller } = makeContext(() => {
+    built += 1
+    return new Promise((resolve) => {
+      release = () => resolve({ items: sample() })
+    })
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const firstController = new AbortController()
+  const secondController = new AbortController()
+  const first = controller.list({}, firstController.signal)
+  const second = controller.list({}, secondController.signal)
+  firstController.abort()
+  release()
+  const [firstResult, secondResult] = await Promise.allSettled([first, second])
+  assert.equal(built, 1)
+  assert.equal(firstResult.status, 'rejected')
+  assert.equal(secondResult.status, 'fulfilled')
+})
+
+test('原方法抛错时错误照旧透传给调用方', async () => {
+  const { ctx, controller } = makeContext(async () => {
+    throw new Error('宿主故障')
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  await assert.rejects(() => controller.list({}, undefined), /宿主故障/)
+})
+
+test('响应形状不符时原样透传,不缓存', async () => {
+  let built = 0
+  const { ctx, controller } = makeContext(async () => {
+    built += 1
+    return { sessions: sample() }
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const first = await controller.list({}, undefined)
+  const second = await controller.list({}, undefined)
+  assert.deepEqual(Object.keys(first), ['sessions'])
+  assert.equal(built, 2)
+  assert.notEqual(second, first)
+})
+
+test('把调用方 request 原样交给原方法', async () => {
+  const seen = []
+  const { ctx, controller } = makeContext(async (request) => {
+    seen.push(request)
+    return { items: sample() }
+  })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const request = { cursor: 'abc' }
+  await controller.list(request, undefined)
+  assert.equal(seen[0], request)
+})
+
+test('预热在延迟后构建一次', async () => {
+  let built = 0
+  const { ctx } = makeContext(async () => {
+    built += 1
+    return { items: sample() }
+  })
+  installListSlim(ctx, { warmupDelayMs: 0 })
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  assert.equal(built, 1)
+})
+
+test('卸载时恢复原方法', async () => {
+  const original = async () => ({ items: sample() })
+  const { ctx, controller, disposers } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  assert.notEqual(controller.list, original)
+  for (const dispose of disposers) dispose()
+  assert.equal(controller.list, original)
+})
+
+// Given 另一个插件在本插件之后包装了 list, When 本插件卸载, Then 不摘掉后装包装且链上透传
+test('卸载不摘掉后装的包装', async () => {
+  const original = async () => ({ items: sample() })
+  const { ctx, controller, disposers } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const wrapped = controller.list
+  const later = async function (request, signal) {
+    return wrapped.call(this, request, signal)
+  }
+  controller.list = later
+  for (const dispose of disposers) dispose()
+  assert.equal(controller.list, later)
+  const value = await controller.list({}, undefined)
+  assert.equal(value.items[0].projections.values.contextHeaders[0].pad.length, 64, '卸载后链上的旧包装应透传')
+})
+
+// Given 服务代理每次读取 list 都返回新引用(真实 cordis traceable), When 卸载, Then 按包装标记仍恢复原方法
+test('服务代理返回新引用时卸载仍恢复原方法', async () => {
+  const original = async () => ({ items: sample() })
+  let current = original
+  const service = {
+    ctx: {},
+    get list() {
+      return new Proxy(current, {})
+    },
+    set list(value) {
+      current = value
+    },
+  }
+  const { ctx, disposers } = makeContext(undefined, { controller: service })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const installed = current
+  assert.notEqual(service.list, installed, '代理每次返回新引用')
+  for (const dispose of disposers) dispose()
+  assert.notEqual(current, installed, '卸载后不再指向包装')
+  const value = await current({})
+  assert.equal(value.items[0].projections.values.contextHeaders[0].pad.length, 64, '恢复后透传完整投影')
+})
+
+// Given 宿主 effect 注册失败, When 装载, Then 包装与标记回滚,不留下无法卸载的包装
+test('effect 注册失败时回滚包装', () => {
+  const original = async () => ({ items: sample() })
+  const { ctx, controller, logs } = makeContext(original, { effectError: new Error('inactive') })
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  assert.equal(controller.list, original)
+  assert.equal(controller[Symbol.for('@mzzsfy/dsh-bug-perf/list-slim')], undefined)
+  assert.ok(logs.warn.some((message) => message.includes('装载失败')))
+})
+
+// Given 第一实例的安装标记不可见, When 第二实例再包装且第一实例卸载, Then 不摘掉第二实例的包装
+test('不摘掉其它实例的包装', () => {
+  const original = async () => ({ items: sample() })
+  const first = makeContext(original)
+  installListSlim(first.ctx, { warmupDelayMs: -1 })
+  const firstWrapped = first.controller.list
+  delete first.controller[Symbol.for('@mzzsfy/dsh-bug-perf/list-slim')]
+  const second = makeContext(undefined, { controller: first.controller })
+  installListSlim(second.ctx, { warmupDelayMs: -1 })
+  const secondWrapped = first.controller.list
+  assert.notEqual(secondWrapped, firstWrapped)
+  for (const dispose of first.disposers) dispose()
+  assert.equal(first.controller.list, secondWrapped)
+})
+
+// Given 所有调用者都取消, When 最后一个等待者结束, Then 中止共享构建,后续调用可重试
+test('所有调用者取消后中止共享构建', async () => {
+  let built = 0
+  const signals = []
+  const original = (request, signal) => {
+    built += 1
+    signals.push(signal)
+    if (built === 1) {
+      return new Promise((_, reject) => {
+        signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true })
+      })
+    }
+    return Promise.resolve({ items: sample() })
+  }
+  const { ctx, controller } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const first = new AbortController()
+  const second = new AbortController()
+  const waitFirst = controller.list({}, first.signal)
+  const waitSecond = controller.list({}, second.signal)
+  first.abort()
+  second.abort()
+  await Promise.allSettled([waitFirst, waitSecond])
+  assert.equal(signals[0].aborted, true, '所有等待者取消后应中止构建')
+  const third = await controller.list({}, undefined)
+  assert.equal(built, 2)
+  assert.deepEqual(third.items.map((entry) => entry.sessionId), ['a', 'b'])
+})
+
+// Given 列表构建在途, When 卸载, Then 中止内部构建
+test('卸载中止在途构建', () => {
+  let internal
+  const original = (request, signal) => {
+    internal = signal
+    return new Promise(() => {})
+  }
+  const { ctx, controller, disposers } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  void controller.list({}, undefined)
+  for (const dispose of disposers) dispose()
+  assert.equal(internal.aborted, true)
+})
+
+// Given 同一服务重复装载, When 再次 install, Then 不叠加第二层包装
+test('重复装载不叠加包装', () => {
+  const original = async () => ({ items: sample() })
+  const { ctx, controller } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const first = controller.list
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  assert.equal(controller.list, first)
+})
+
+// Given 宿主 list 按 this.ctx.invocation 过滤, When viewer 主体调用, Then 包装保留 receiver 且只拿到可见项
+test('包装保留调用方 receiver,非 owner 由宿主逐项过滤', async () => {
+  const original = async function list() {
+    const principal = this?.ctx?.invocation?.peer?.principal
+    const items = principal?.kind === 'viewer' ? [item('shared', { title: 'S' })] : [item('secret', { title: 'X' }), item('shared', { title: 'S' })]
+    return { items }
+  }
+  const { ctx } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const value = await ctx.get('sessionController').list.call(receiverOf({ kind: 'viewer' }), {}, undefined)
+  assert.deepEqual(value.items.map((entry) => entry.sessionId), ['shared'])
+})
+
+// Given owner 已把全量列表写入缓存, When viewer 调用, Then 不命中 owner 缓存、仍由宿主过滤
+test('非 owner 不命中 owner 缓存', async () => {
+  let built = 0
+  const original = async function list() {
+    built += 1
+    const principal = this?.ctx?.invocation?.peer?.principal
+    const items = principal?.kind === 'viewer' ? [item('shared', { title: 'S' })] : [item('secret', { title: 'X' }), item('shared', { title: 'S' })]
+    return { items }
+  }
+  const { ctx, controller } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const owner = await controller.list({}, undefined)
+  assert.deepEqual(owner.items.map((entry) => entry.sessionId), ['secret', 'shared'])
+  const viewer = await controller.list.call(receiverOf({ kind: 'viewer' }), {}, undefined)
+  assert.deepEqual(viewer.items.map((entry) => entry.sessionId), ['shared'])
+  assert.equal(built, 2, 'viewer 调用必须重新走原方法')
+})
+
+// Given 预热已构建 owner 缓存, When viewer 调用, Then 仍不命中缓存
+test('预热缓存不对非 owner 生效', async () => {
+  let built = 0
+  const original = async function list() {
+    built += 1
+    const principal = this?.ctx?.invocation?.peer?.principal
+    const items = principal?.kind === 'viewer' ? [item('shared', { title: 'S' })] : [item('secret', { title: 'X' }), item('shared', { title: 'S' })]
+    return { items }
+  }
+  const { ctx, controller } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: 0 })
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  assert.equal(built, 1)
+  const viewer = await controller.list.call(receiverOf({ kind: 'viewer' }), {}, undefined)
+  assert.deepEqual(viewer.items.map((entry) => entry.sessionId), ['shared'])
+  assert.equal(built, 2)
+})
+
+// Given 列表构建在途, When 会话增删事件触发且同 signal 再次调用, Then 不复用失效前的构建
+test('在途构建遇到失效后新调用重建', async () => {
+  let built = 0
+  const releases = []
+  const original = () => {
+    built += 1
+    return new Promise((resolve) => {
+      releases.push(() => resolve({ items: sample() }))
+    })
+  }
+  const { ctx, controller, handlers } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const signal = new AbortController().signal
+  const pending = controller.list({}, signal)
+  handlers.get('api-session/added')()
+  const second = controller.list({}, signal)
+  assert.equal(built, 2, '失效后的新调用必须重建')
+  releases[0]()
+  releases[1]()
+  await Promise.all([pending, second])
+})
+
+// Given 在途构建期间失效, When 旧构建完成, Then 旧结果不写回缓存
+test('在途构建遇到失效后不写回旧快照', async () => {
+  let built = 0
+  const releases = []
+  const original = () => {
+    built += 1
+    return new Promise((resolve) => {
+      releases.push(() => resolve({ items: sample() }))
+    })
+  }
+  const { ctx, controller, handlers } = makeContext(original)
+  installListSlim(ctx, { warmupDelayMs: -1 })
+  const pending = controller.list({}, undefined)
+  handlers.get('api-session/added')()
+  releases[0]()
+  await pending
+  const second = controller.list({}, undefined)
+  assert.equal(built, 2, '失效期间的结果不得作为缓存命中')
+  releases[1]()
+  await second
+})