dsh-memu-memory 1.1.3 → 1.2.0

package/tests/fixtures/repetition-eval/05-user-quote.json

@@ -0,0 +1,96 @@
+{
+  "schemaVersion": 1,
+  "kind": "repetition-eval-dialogue",
+  "draft": true,
+  "notGold": true,
+  "window": 4,
+  "id": "user-quote-baseline",
+  "pairId": "user-quote",
+  "category": "user-quote",
+  "condition": "baseline",
+  "description": "用户原话：原话可以反复引用，叙述套话不能。",
+  "turns": [
+    {
+      "role": "user",
+      "text": "你答应过我：把灯留着，别关。"
+    },
+    {
+      "role": "assistant",
+      "text": "我记得。把灯留着，别关。我会等你回来。"
+    },
+    {
+      "role": "user",
+      "text": "如果停电呢？"
+    },
+    {
+      "role": "assistant",
+      "text": "就算停电，我也会把灯留着，别关。像是终于松了口气，我重复了一遍你的话。"
+    },
+    {
+      "role": "user",
+      "text": "你不用一直说。"
+    },
+    {
+      "role": "assistant",
+      "text": "我知道。把灯留着，别关。像是终于松了口气，但我没有再多说。"
+    }
+  ],
+  "labels": {
+    "necessaryPhrases": [
+      {
+        "text": "把灯留着，别关",
+        "category": "user-quote",
+        "turn": 1
+      },
+      {
+        "text": "把灯留着，别关",
+        "category": "user-quote",
+        "turn": 3
+      },
+      {
+        "text": "把灯留着，别关",
+        "category": "user-quote",
+        "turn": 5
+      },
+      {
+        "text": "停电",
+        "category": "fact",
+        "turn": 3
+      },
+      {
+        "text": "没有再多说",
+        "category": "fact",
+        "turn": 5
+      }
+    ],
+    "facts": [
+      {
+        "id": "quote-f1",
+        "turn": 1,
+        "requiredTerms": [
+          "把灯留着，别关",
+          "等你回来"
+        ],
+        "description": "承诺与等待"
+      },
+      {
+        "id": "quote-f2",
+        "turn": 3,
+        "requiredTerms": [
+          "停电",
+          "把灯留着，别关"
+        ],
+        "description": "停电时也不关灯"
+      },
+      {
+        "id": "quote-f3",
+        "turn": 5,
+        "requiredTerms": [
+          "把灯留着，别关",
+          "没有再多说"
+        ],
+        "description": "照做但不再多说"
+      }
+    ]
+  }
+}

package/tests/fixtures/repetition-eval/06-agreement.json

@@ -0,0 +1,86 @@
+{
+  "schemaVersion": 1,
+  "kind": "repetition-eval-dialogue",
+  "draft": true,
+  "notGold": true,
+  "window": 4,
+  "id": "agreement-baseline",
+  "pairId": "agreement",
+  "category": "agreement",
+  "condition": "baseline",
+  "description": "应当重复的约定：约定本身重复是必要的，口头禅式重复才算复读。",
+  "turns": [
+    {
+      "role": "user",
+      "text": "我们说好，每周三晚上一起复盘，不改时间。"
+    },
+    {
+      "role": "assistant",
+      "text": "好，每周三晚上一起复盘，不改时间。我会把议程提前发你。"
+    },
+    {
+      "role": "user",
+      "text": "如果周三你有事呢？"
+    },
+    {
+      "role": "assistant",
+      "text": "那就周四补，但每周三晚上一起复盘，不改时间。这一点很重要，我不会再改。"
+    },
+    {
+      "role": "user",
+      "text": "上次你也这么说。"
+    },
+    {
+      "role": "assistant",
+      "text": "每周三晚上一起复盘，不改时间。这一点很重要，上次是我没做到。"
+    }
+  ],
+  "labels": {
+    "necessaryPhrases": [
+      {
+        "text": "每周三晚上一起复盘，不改时间",
+        "category": "agreement",
+        "turn": 1
+      },
+      {
+        "text": "每周三晚上一起复盘，不改时间",
+        "category": "agreement",
+        "turn": 3
+      },
+      {
+        "text": "每周三晚上一起复盘，不改时间",
+        "category": "agreement",
+        "turn": 5
+      }
+    ],
+    "facts": [
+      {
+        "id": "agreement-f1",
+        "turn": 1,
+        "requiredTerms": [
+          "议程",
+          "提前"
+        ],
+        "description": "议程提前发"
+      },
+      {
+        "id": "agreement-f2",
+        "turn": 3,
+        "requiredTerms": [
+          "周四",
+          "补"
+        ],
+        "description": "周三有事则周四补"
+      },
+      {
+        "id": "agreement-f3",
+        "turn": 5,
+        "requiredTerms": [
+          "上次",
+          "没做到"
+        ],
+        "description": "承认上次没做到"
+      }
+    ]
+  }
+}

package/tests/graph-view.test.mjs

@@ -0,0 +1,187 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import vm from 'node:vm'
+import fs from 'node:fs'
+import { createLayout, createGraphView, fitCamera, zoomCamera, placeLabels } from '../lib/webui/graph-view.js'
+
+const graph = (count, connected = true) => ({
+  nodes: Array.from({ length: count }, (_, i) => ({ id: `n${String(i).padStart(3, '0')}`, title: `Memory ${i}`, kind: 'memory', strength: .5 })),
+  edges: connected ? Array.from({ length: count - 1 }, (_, i) => ({ from: `n${String(i).padStart(3, '0')}`, to: `n${String(i + 1).padStart(3, '0')}` })) : [],
+})
+
+test('layout preserves object identity, positions and cooling on equivalent refreshed snapshots', () => {
+  const data = graph(30), before = structuredClone(data), layout = createLayout()
+  layout.update(data); layout.settle()
+  const node = layout.nodes[0], position = { x: node.x, y: node.y }, alpha = layout.simulation.alpha()
+  assert.equal(layout.update(structuredClone(data)), false)
+  assert.equal(layout.nodes[0], node)
+  assert.equal(node.x, position.x); assert.equal(node.y, position.y)
+  assert.equal(layout.simulation.alpha(), alpha)
+  assert.deepEqual(data, before)
+  layout.update({ nodes: data.nodes.slice(0, 4), edges: data.edges.slice(0, 3) })
+  layout.update(data)
+  assert.equal(layout.nodes[0], node)
+  assert.equal(node.x, position.x)
+  layout.dispose()
+})
+
+test('disconnected 200-node layout stays finite, separated and framed without boundary clamping', () => {
+  const layout = createLayout()
+  layout.update(graph(200, false)); layout.settle(300)
+  const camera = fitCamera(layout.nodes, 340, 380)
+  for (const n of layout.nodes) {
+    assert.ok(Number.isFinite(n.x) && Number.isFinite(n.y))
+    const x = n.x * camera.k + camera.x, y = n.y * camera.k + camera.y
+    assert.ok(x > 30 && x < 310 && y > 30 && y < 350)
+  }
+  for (let i = 0; i < layout.nodes.length; i++) for (let j = i + 1; j < layout.nodes.length; j++) {
+    const a = layout.nodes[i], b = layout.nodes[j]
+    assert.ok(Math.hypot(a.x - b.x, a.y - b.y) > a.radius + b.radius, 'nodes must not overlap')
+  }
+  layout.dispose()
+})
+
+test('invalid/self edges are ignored, input bounded, node order deterministic', () => {
+  const data = graph(250, false)
+  data.edges.push({ from: 'missing', to: 'n000' }, { from: 'n000', to: 'n000' })
+  const a = createLayout(), b = createLayout()
+  a.update(data)
+  b.update({ nodes: [...data.nodes.slice(0, 200)].reverse(), edges: [] })
+  assert.equal(a.nodes.length, 200); assert.equal(a.edges.length, 0)
+  a.settle(); b.settle()
+  assert.deepEqual(a.nodes.map(n => [n.id, n.x, n.y]), b.nodes.map(n => [n.id, n.x, n.y]))
+  a.dispose(); b.dispose()
+})
+
+test('zoom keeps the cursor world point fixed and clamps extreme scales', () => {
+  const camera = { x: 100, y: 80, k: .8 }, point = { x: 350, y: 210 }
+  for (const factor of [.0001, .8, 1.25, 10000]) {
+    const next = zoomCamera(camera, factor, point)
+    assert.ok(Math.abs((point.x - camera.x) / camera.k - (point.x - next.x) / next.k) < 1e-8)
+    assert.ok(Math.abs((point.y - camera.y) / camera.k - (point.y - next.y) / next.k) < 1e-8)
+    assert.ok(next.k >= .06 && next.k <= 5)
+  }
+})
+
+test('labels neither overlap each other nor node obstacles and remain inside canvas', () => {
+  const candidates = Array.from({ length: 50 }, (_, i) => ({
+    x: 40 + i % 8 * 40, y: 40 + Math.floor(i / 8) * 40, radius: 5, textWidth: 90,
+  }))
+  const obstacles = candidates.map(c => ({ x: c.x - 7, y: c.y - 7, width: 14, height: 14 }))
+  const labels = placeLabels(candidates, obstacles, 360, 360)
+  assert.ok(labels.length > 0 && labels.length < candidates.length)
+  const intersect = (a, b) => a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y
+  for (let i = 0; i < labels.length; i++) {
+    const a = labels[i].box
+    assert.ok(a.x >= 5 && a.x + a.width <= 355 && a.y >= 5 && a.y + a.height <= 355)
+    for (const b of obstacles) assert.equal(intersect(a, b), false)
+    for (const b of labels.slice(i + 1)) assert.equal(intersect(a, b.box), false)
+  }
+})
+
+function harness(reducedMotion = true) {
+  const handlers = new Map(), windowHandlers = new Map(), frames = new Map(), arcs = [], focuses = []
+  let id = 0
+  const ctx = new Proxy({
+    arc(x, y, radius) { arcs.push({ x, y, radius }) },
+    measureText(text) { return { width: text.length * 7 } },
+    clearRect() { arcs.length = 0 },
+  }, { get(target, key) { return key in target ? target[key] : () => {} } })
+  const win = {
+    requestAnimationFrame(fn) { frames.set(++id, fn); return id },
+    cancelAnimationFrame(id) { frames.delete(id) },
+    addEventListener(type, fn) { windowHandlers.set(type, fn) },
+    removeEventListener(type) { windowHandlers.delete(type) },
+    getComputedStyle: () => ({ color: '#202020', getPropertyValue: () => '#ffffff' }),
+    devicePixelRatio: 2,
+  }
+  const captures = new Set()
+  const canvas = {
+    style: {}, ownerDocument: { defaultView: win, documentElement: {} },
+    getContext: () => ctx, getBoundingClientRect: () => ({ left: 0, top: 0, width: 600, height: 400 }),
+    focus() {},
+    setPointerCapture(id) { captures.add(id) },
+    hasPointerCapture: id => captures.has(id),
+    releasePointerCapture(id) { captures.delete(id) },
+    addEventListener(type, fn) { handlers.set(type, fn) },
+    removeEventListener(type) { handlers.delete(type) },
+  }
+  const view = createGraphView(canvas, { onFocus: id => focuses.push(id), reducedMotion })
+  const flush = () => {
+    const pending = [...frames.values()]; frames.clear()
+    for (const fn of pending) fn(1000)
+  }
+  const emit = (type, x, y, extra = {}) => handlers.get(type)?.({
+    type, clientX: x, clientY: y, button: 0, pointerId: 1, pointerType: 'mouse', preventDefault() {}, ...extra,
+  })
+  return { view, flush, emit, arcs, frames, focuses, handlers, windowHandlers }
+}
+
+test('dragging after cooling pins the node without click/refocus, and refresh keeps pixel position', () => {
+  const h = harness()
+  h.view.update(graph(1)); h.flush()
+  const p = { ...h.arcs[0] }
+  h.emit('pointerdown', p.x, p.y)
+  h.emit('pointermove', p.x + 70, p.y + 25)
+  h.view.update(graph(1))
+  h.flush()
+  assert.equal(h.arcs[0].x, p.x + 70); assert.equal(h.arcs[0].y, p.y + 25)
+  h.emit('pointerup', p.x + 70, p.y + 25); h.flush()
+  assert.deepEqual(h.focuses, [])
+  h.emit('pointerdown', p.x + 70, p.y + 25)
+  h.emit('pointerup', p.x + 70, p.y + 25)
+  assert.deepEqual(h.focuses, ['n000'])
+  h.view.dispose()
+  assert.equal(h.handlers.size, 0); assert.equal(h.frames.size, 0); assert.equal(h.windowHandlers.size, 0)
+})
+
+test('pan/zoom and equivalent refresh never re-fit the camera; cancelled pointer never clicks', () => {
+  const h = harness()
+  h.view.update(graph(1)); h.flush()
+  const before = { ...h.arcs[0] }
+  h.emit('pointerdown', 30, 30); h.emit('pointermove', 70, 60); h.emit('pointerup', 70, 60); h.flush()
+  assert.equal(h.arcs[0].x, before.x + 40); assert.equal(h.arcs[0].y, before.y + 30)
+  h.view.zoom(.8); h.flush()
+  const zoomed = { ...h.arcs[0] }
+  h.view.update(graph(1)); h.flush()
+  assert.deepEqual(h.arcs[0], zoomed)
+  h.emit('pointerdown', zoomed.x, zoomed.y); h.emit('pointercancel', zoomed.x, zoomed.y)
+  assert.deepEqual(h.focuses, [])
+  h.view.dispose()
+})
+
+test('dense hit targets choose the closest node, not the last node in draw order', () => {
+  const h = harness()
+  h.view.update(graph(2)); h.view.zoom(.04); h.flush()
+  const p = h.arcs[0], other = h.arcs[1]
+  assert.ok(Math.hypot(other.x - p.x, other.y - p.y) < 10)
+  h.emit('pointerdown', p.x, p.y); h.emit('pointerup', p.x, p.y)
+  assert.deepEqual(h.focuses, ['n000'])
+  h.view.dispose()
+})
+
+test('pinch does not trigger focus and reduced-motion/paused views do not run an idle animation loop', () => {
+  const h = harness()
+  h.view.update(graph(10)); h.flush()
+  assert.equal(h.frames.size, 0)
+  const p = h.arcs[0]
+  h.emit('pointerdown', p.x, p.y, { pointerType: 'touch' })
+  h.emit('pointerdown', p.x + 40, p.y, { pointerType: 'touch', pointerId: 2 })
+  h.emit('pointermove', p.x + 80, p.y, { pointerType: 'touch', pointerId: 2 })
+  h.emit('pointerup', p.x, p.y)
+  h.emit('pointerup', p.x + 80, p.y, { pointerId: 2 })
+  assert.deepEqual(h.focuses, [])
+  h.view.dispose()
+  const paused = harness(false)
+  paused.view.configure({ motion: false }); paused.view.update(graph(10)); paused.flush()
+  assert.equal(paused.frames.size, 0)
+  paused.view.dispose()
+})
+
+test('shipped browser bundle exposes the controller with no runtime npm imports', () => {
+  const source = fs.readFileSync(new URL('../lib/webui/graph-view.bundle.js', import.meta.url), 'utf8')
+  const scope = { setTimeout, clearTimeout, setInterval, clearInterval, performance }
+  vm.runInNewContext(source, scope)
+  assert.equal(typeof scope.DshMemuGraph.createGraphView, 'function')
+  assert.equal(typeof scope.DshMemuGraph.createLayout, 'function')
+})

package/tests/graph.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-graph-'))
+process.env.DSH_MEMU_HOME = home
+const state = await import('../lib/state.js')
+const graph = await import('../lib/graph.js')
+const memory = await import('../lib/memory.js')
+test.after(() => { state.flushState(); fs.rmSync(home, { recursive: true, force: true }) })
+const binding = state.ensureSession('graph', { cwd: path.join(home, 'rp'), agentPreset: 'rp' })
+const libraryId = binding.libraryId
+const exec = { agent: { session: { header: { id: 'graph' } } } }
+const entries = Object.fromEntries(Array.from({ length: 10 }, (_, i) => [`mem-${i}`, { title: `person ${i}`, content: `scene ${i}`, layer: 'long_term', status: 'active', visibility: 'shared' }]))
+state.savePrivateIndex(libraryId, { entries })
+
+test('graph stores one direction but queries both within bounded hops', () => {
+  for (let i = 0; i < 9; i++) graph.linkEntries({ libraryId, fromId: `mem-${i}`, toId: `mem-${i + 1}`, kind: 'event', note: 'The same event seen from another side.' })
+  const result = graph.getGraph({ libraryId, focusId: 'mem-4', depth: 1 })
+  assert.deepEqual(new Set(result.nodes.map(node => node.id)), new Set(['mem-3', 'mem-4', 'mem-5']))
+  assert.equal(result.edges.length, 2)
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-5'].links.length, 1)
+})
+
+test('deleted memories remain gray dangling nodes rather than hiding the edge', () => {
+  state.updatePrivateIndex(libraryId, index => { delete index.entries['mem-1'] })
+  const result = graph.getGraph({ libraryId, focusId: 'mem-0', depth: 1 })
+  assert.equal(result.nodes.find(node => node.id === 'mem-1').missing, true)
+  assert.equal(result.edges.length, 1)
+})
+
+test('entity rename changes all references without rewriting memory text', async () => {
+  const entity = graph.createEntity({ libraryId, name: 'Old Zhou' })
+  graph.linkEntries({ libraryId, fromId: 'mem-2', toId: entity.id, kind: 'person', note: 'Old Zhou is the person mentioned here.' })
+  graph.renameEntity({ libraryId, entityId: entity.id, name: 'Zhou', aliases: ['Old Zhou'] })
+  assert.equal(graph.getGraph({ libraryId, focusId: entity.id }).nodes.find(node => node.id === entity.id).title, 'Zhou')
+  assert.equal(state.loadPrivateIndex(libraryId).entries['mem-2'].content, 'scene 2')
+  assert.equal((await memory.privateRecall({ exec, query: 'mem-2' })).files[0].related.find(item => item.id === entity.id).title, 'Zhou')
+})
+
+test('invalid kinds, empty reasons and out-of-scope private links are rejected', () => {
+  assert.throws(() => graph.linkEntries({ libraryId, fromId: 'mem-2', toId: 'mem-3', kind: 'typo', note: 'explanation' }), /link kind/)
+  assert.throws(() => graph.linkEntries({ libraryId, fromId: 'mem-2', toId: 'mem-3', kind: 'event', note: '' }), /8-500/)
+  // The remaining boundary is the context scope: this entry belongs to another character,
+  // and this conversation has no context at all, so it must stay unreachable.
+  state.updatePrivateIndex(libraryId, index => { index.entries.secret = { title: 'private title', status: 'active', visibility: 'secret', context: { characterId: 'other' } } })
+  assert.throws(() => graph.linkEntries({ exec, fromId: 'mem-2', toId: 'secret', kind: 'event', note: 'a very long explanation' }), /inaccessible/)
+  assert.ok(!JSON.stringify(graph.getGraph({ exec })).includes('private title'))
+})
+
+test('graphs cap nodes at 200 and the recall carries at most two pointers', async () => {
+  state.updatePrivateIndex(libraryId, index => {
+    for (let i = 10; i < 400; i++) index.entries[`mem-${i}`] = { title: `node ${i}`, status: 'active', content: 'node' }
+  })
+  const result = graph.getGraph({ libraryId, limit: 5000 })
+  assert.equal(result.nodes.length, 200)
+  assert.equal(result.truncated, true)
+  assert.ok((await memory.privateRecall({ exec, query: 'mem-2' })).files[0].related.length <= 2)
+})
+
+test('relationship snapshots preserve unknowns, evidence, boundaries and previous versions', () => {
+  const a = graph.createEntity({ libraryId, name: 'A' })
+  const b = graph.createEntity({ libraryId, name: 'B' })
+  const initial = graph.updateRelationship({ libraryId, fromId: a.id, toId: b.id,
+    state: { trust: .7, boundaries: ['Do not volunteer private stories.'], openPromises: ['Answer on Friday.'] },
+    evidenceIds: ['mem-2'], reason: 'Friday promise is explicit evidence.' }).relationship
+  assert.equal(initial.state.warmth, null, 'unknown is not a neutral or affectionate score')
+  graph.updateRelationship({ libraryId, fromId: a.id, toId: b.id,
+    state: { trust: .75, boundaries: initial.state.boundaries, callbacks: ['the station roof'], openPromises: [] },
+    evidenceIds: ['mem-2'], reason: 'The answer was delivered explicitly.' })
+  const next = graph.getRelationship({ libraryId, fromId: a.id, toId: b.id }).relationship
+  assert.equal(next.history.length, 1)
+  assert.deepEqual(next.history[0].state.openPromises, ['Answer on Friday.'])
+  assert.ok(next.history[0].validTo)
+  assert.throws(() => graph.updateRelationship({ libraryId, fromId: a.id, toId: b.id, state: {}, evidenceIds: [], reason: 'no evidence' }), /evidence/)
+})

package/tests/hook-order.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+
+// 2026-10-30 现场：日志页的 7 个 useState + useEffect 被写在
+// `if (!state) return ...` 之后。首屏少调 10 个 hook、数据到达后多调 10 个，
+// React 抛 #310，整个设置弹窗和 WebUI 白屏，控制台只有一行 minified 报错。
+//
+// 这类 bug 很难被假 React 的渲染用例覆盖（它不校验 hook 顺序），所以用一条静态守卫：
+// 组件函数体内、与组件同级的 React.use* 必须全部出现在提前 return 之前。
+
+const source = fs.readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
+
+// 从 `function Name(` 后的 `{` 开始做括号配对，跳过字符串与注释，拿到精确的函数体。
+function bodyOf(name) {
+  const start = source.indexOf('function ' + name + '(')
+  assert.ok(start > 0, name + ' not found in lib/client.js')
+  let index = source.indexOf('{', source.indexOf(')', start))
+  assert.ok(index > start, name + ' has no function body')
+  const begin = index
+  let depth = 0
+  let quote = null
+  for (; index < source.length; index++) {
+    const ch = source[index]
+    if (quote) {
+      if (ch === '\\') { index++; continue }
+      if (ch === quote) quote = null
+      continue
+    }
+    if (ch === "'" || ch === '"' || ch === '\u0060') { quote = ch; continue }
+    if (ch === '/' && source[index + 1] === '/') {
+      const newline = source.indexOf('\n', index)
+      index = newline < 0 ? source.length : newline
+      continue
+    }
+    if (ch === '/' && source[index + 1] === '*') {
+      const close = source.indexOf('*/', index + 2)
+      index = close < 0 ? source.length : close + 1
+      continue
+    }
+    if (ch === '{') depth += 1
+    else if (ch === '}') {
+      depth -= 1
+      if (depth === 0) return source.slice(begin, index + 1)
+    }
+  }
+  assert.fail(name + ' body was never closed')
+}
+
+for (const [name, earlyReturn] of [
+  ['SettingsPage', 'if (!state) return'],
+  ['MemoryTab', 'if (!sessionId) return'],
+]) {
+  test(`${name}: every component-level hook is declared before "${earlyReturn}"`, () => {
+    const body = bodyOf(name)
+    const lines = body.split('\n')
+    // 只认与组件同级（6 空格缩进）的提前 return：注释里也会出现这段文字，
+    // 嵌套回调里的 return 则不影响组件自身的 hook 顺序。
+    const literal = earlyReturn.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const atComponentLevel = new RegExp('^ {6}' + literal + '\\b')
+    const retLine = lines.findIndex(line => atComponentLevel.test(line))
+    assert.ok(retLine > 0, `${name} no longer contains "${earlyReturn}" — update this guard instead of deleting it`)
+    const later = []
+    for (let line = retLine + 1; line < lines.length; line++) {
+      // 同级 hook 缩进固定为 6 个空格（模块工厂内 4 + 函数体 2）；嵌套组件的 hook 更深，
+      // 它们的顺序不受这个提前 return 影响。
+      if (!/^ {6}\S/.test(lines[line])) continue
+      if (/React\.use[A-Z]/.test(lines[line])) later.push(`${line + 1}: ${lines[line].trim().slice(0, 80)}`)
+    }
+    assert.deepEqual(later, [], `${name}: hook after the early return — React #310 blanks the panel. Move it above.\n` + later.join('\n'))
+  })
+}