/**
 * 覆盖网络 · **序③ 一机一钥 + 信任根** 单测 —— 身份层是不是"真的挡得住"。
 *
 * ## 这个文件要回答的四个问题（= `交接单_一机一钥与信任根_20260917.md §5/§6`）
 * 1. **四层模型**：根（离线）→ 签名者（在线）→ 节点（每机一把）→ 会话（复用 TLS）
 *    的载体能不能**真签发、真验签**？（A 组）
 * 2. **入网 = 签名**：篡改过的入网凭据**建不起会话**，且原因**结构化**？（B 组 + D 组）
 * 3. **relay 准入按 `hostId` + 成员资格**：拿 A 网的凭据进 B 网必须被拒？（C 组 + D1）
 * 4. **撤销单台 ≠ 全网换密钥**：撤 w106 之后，w47 照旧在线？（D6）
 *
 * ## 🔴 "先红后绿"在本文件里的落点（⛔ 不是口头声明）
 * 身份校验**默认不强制**（`requireIdentity=false`，存量过渡）⇒ 同一份**被搬家的凭据**，
 * 在 `verifyIdentity:false` 的服务器上**能注册进去**（= 没有这道门时的攻击面，**红**），
 * 在 `verifyIdentity:true` 的服务器上**被拒**（**绿**）。两组用**同一份坏凭据、同一个 hostId**，
 * 唯一变量就是那一道门 ⇒ 证明"挡住它的正是这道门"，而不是别的巧合（D5）。
 *
 * 运行：`node --test test/overlay-identity.test.mjs`（Node ≥ 22；测的是 `lib/` 产物，先 `npm run build`）。
 *
 * @module test/overlay-identity
 */

import assert from 'node:assert/strict'
import { createHmac, randomBytes } from 'node:crypto'
import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { test } from 'node:test'

import { RelayClient } from '../lib/net/relay/client.js'
import {
  OverlaySerialGuard,
  generateAuthorityKey,
  generateNodeKey,
  loadRevocations,
  loadRootSet,
  loadTrustedSigners,
  nodeKeyFingerprint,
  parseRevocationList,
  parseRootSet,
  parseSignerSet,
  publicKeyOfPrivate,
  serialScopeKey,
  signNodeGrant,
  signProof,
  signRevocations,
  signRootSet,
  signSignerSet,
  signerSetPayload,
  verifyNodeGrant,
  verifyPeerGrant,
  verifyProof,
  verifyRevocations,
  verifyRootSet,
  verifySignerSet,
  writeSignedFile,
} from '../lib/net/relay/identity.js'
import { describeKeyEntry, loadKeysFile, parseKeysInline } from '../lib/net/relay/keys.js'
import { OPS_NETWORK } from '../lib/net/relay/network.js'
import { RelayServer } from '../lib/net/relay/server.js'
import { MUX, decodeMux, encodeJsonFrame } from '../lib/net/relay/wire.js'

const BASE = 47100
const SPAN = 200
const PATH = '/dshs-relay'
const U_A = 'u:alpha'
const U_B = 'u:beta'
const NOW = Date.parse('2026-09-17T00:00:00Z')

/* ─────────────────────────── 工具 ─────────────────────────── */

async function waitFor(fn, ms = 4000) {
  const until = Date.now() + ms
  while (Date.now() < until) {
    if (fn()) return true
    await new Promise((r) => setTimeout(r, 20))
  }
  return false
}

/**
 * 一套"根 → 签名者 → 节点"的密钥与凭据（**建网的标准动作**：测试与部署脚本同一形状）。
 *
 * ⚠️ F1.5：三份文档都带 `serial`（签名覆盖它）。**形状不变** —— `serial` 是**追加**在
 * 载荷末尾的可选字段（老文档缺它 ⇒ 视为 `0`），所以本函数只是把"签发时盖序号"补上。
 */
function buildAuthority(network = OPS_NETWORK, serial = 1) {
  const root = generateAuthorityKey()
  const signer = generateAuthorityKey()
  const signerSet = {
    version: 1,
    network,
    issuedAt: new Date(NOW).toISOString(),
    serial,
    signers: [signer.publicKey],
  }
  const signerSetSig = signSignerSet(signerSet, root.privateKeyPem)
  const issue = (hostId, opts = {}) => {
    const node = generateNodeKey()
    const grant = {
      version: 1,
      network: opts.network ?? network,
      hostId,
      nodeKey: node.publicKey,
      issuedAt: opts.issuedAt ?? new Date(NOW).toISOString(),
      expiresAt: opts.expiresAt ?? '',
      // 凭据序号逐设备独立（键含 nodeKey）⇒ 默认 1 不会与"另一台设备的 1"冲突。
      serial: opts.serial ?? 1,
    }
    return { node, grant, sig: signNodeGrant(grant, signer.privateKeyPem) }
  }
  return { root, signer, signerSet, signerSetSig, issue }
}

/** 吊销清单（签名者签发）。 */
function revocationOf(signerPem, hosts, nodeKeys = [], serial = 1) {
  const doc = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), serial, hosts, nodeKeys }
  return { doc, sig: signRevocations(doc, signerPem) }
}

/** 撤根声明（**根**阈值联签：对同一份载荷各签一次，`sigs` 收齐）。 */
function rootSetOf(doc, rootPems) {
  return { doc, sigs: rootPems.map((pem) => signRootSet(doc, pem)) }
}

/** 一个**独立的**序号水位文件（每个用例一份，⛔ 不跨用例共用 —— 否则断言互相污染）。 */
function freshSerialGuard(t) {
  const dir = mkdtempSync(join(tmpdir(), 'dshs-serial-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const file = join(dir, 'overlay-identity-state.json')
  return { file, guard: new OverlaySerialGuard({ file }) }
}

/**
 * 手工发一个 `HELLO` 并取回**首个回帧**（用于构造"正常 client 不会发"的帧）。
 *
 * ⚠️ MAC 输入串与 `client.ts` 逐字同源（**不含身份字段**）—— 身份是**追加**字段、不动 MAC；
 * 这一条本身就是被测对象之一（旧客户端算出的 MAC 必须仍被接受）。
 */
async function rawHello(wsUrl, opts) {
  const { hostId, secret, portsCsv = '', network, identity } = opts
  const ws = new WebSocket(wsUrl)
  ws.binaryType = 'arraybuffer'
  await new Promise((resolve, reject) => {
    ws.addEventListener('open', resolve, { once: true })
    ws.addEventListener('error', () => reject(new Error('ws open failed')), { once: true })
  })
  const ts = Date.now()
  const nonce = randomBytes(16).toString('hex')
  const challenge = `${hostId}|${ts}|${nonce}|${portsCsv}`
  const mac = createHmac('sha256', Buffer.from(secret, 'hex')).update(challenge).digest('hex')
  const payload = { v: 1, hostId, ts, nonce, portsCsv, mac }
  if (network !== undefined) payload.network = network
  if (identity !== undefined) {
    const { nodePrivateKeyPem, nodeSigOverride, ...rest } = identity
    Object.assign(payload, rest)
    // 默认按**正确的挑战串**签（走真实路径）；给了 override 就按 override（用来构造"签名错"）。
    if (nodeSigOverride !== undefined) payload.nodeSig = nodeSigOverride
    else if (nodePrivateKeyPem !== undefined) payload.nodeSig = signProof(nodePrivateKeyPem, challenge)
  }
  ws.send(encodeJsonFrame(MUX.HELLO, 0, payload))
  const frame = await new Promise((resolve) => {
    const timer = setTimeout(() => resolve(undefined), 3000)
    ws.addEventListener('message', (ev) => {
      clearTimeout(timer)
      resolve(decodeMux(Buffer.from(ev.data)))
    })
    ws.addEventListener('close', () => {
      clearTimeout(timer)
      resolve(undefined)
    })
  })
  return { ws, frame }
}

function reasonOf(frame) {
  assert.ok(frame !== undefined, '必须得到结构化回帧')
  return JSON.parse(frame.payload.toString('utf8')).reason
}

/** 建一个 relay：所有 host 都是"拨号方"（端口表为空）⇒ 不需要任何 TCP 回显服务。 */
async function startRelay(t, opts = {}) {
  const hosts = opts.hosts ?? {}
  const srv = new RelayServer({
    port: 0,
    // ⚠️ 必须是 `Map`（服务端按 `keys.get(hostId)` 取；传普通对象会得到
    //    `this.opts.keys.get is not a function` 这种**与判据无关**的崩 —— 会淹掉真正的结论）。
    keys: new Map(Object.entries(hosts)),
    instancePortBase: BASE,
    instancePortSpan: SPAN,
    dialers: new Map([[OPS_NETWORK, new Set(Object.keys(hosts))]]),
    trustedSignerKeys: opts.trustedSignerKeys ?? [],
    revocations: opts.revocations,
    requireIdentity: opts.requireIdentity ?? false,
    verifyIdentity: opts.verifyIdentity ?? true,
    log: opts.log ?? (() => {}),
  })
  await srv.start()
  t.after(async () => {
    await srv.stop()
  })
  return { srv, url: `ws://127.0.0.1:${srv.boundPort}${PATH}` }
}

/* ─────────── A：四层密钥模型（根 → 签名者） ─────────── */

test('A1 根签名的签名者集合：受信根验得过', () => {
  const { root, signer, signerSet, signerSetSig } = buildAuthority()
  const verdict = verifySignerSet(signerSet, signerSetSig, [root.publicKey])
  assert.equal(verdict.ok, true, `根签的集合必须验得过，实测：${JSON.stringify(verdict)}`)
  assert.deepEqual(verdict.doc.signers, [signer.publicKey])
})

test('A2 篡改签名者集合（加一把签名者后沿用旧签名）⇒ **signature-mismatch**', () => {
  const { root, signerSet, signerSetSig } = buildAuthority()
  const evil = generateAuthorityKey()
  const tampered = { ...signerSet, signers: [...signerSet.signers, evil.publicKey] }
  const verdict = verifySignerSet(tampered, signerSetSig, [root.publicKey])
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'signature-mismatch', '加签名者 = 加攻击面 ⇒ 必须失败关闭')
})

test('A3 **不可验 = 不接受**：一把受信根都没有 ⇒ no-trusted-keys（不"先用着"）', () => {
  const { signerSet, signerSetSig } = buildAuthority()
  const verdict = verifySignerSet(signerSet, signerSetSig, [])
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'no-trusted-keys')
})

test('A4 换一把没被授权的根来签 ⇒ 不认（根是唯一信任源）', () => {
  const a = buildAuthority()
  const b = buildAuthority()
  const crossSig = signSignerSet(a.signerSet, b.root.privateKeyPem)
  const verdict = verifySignerSet(a.signerSet, crossSig, [a.root.publicKey])
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'signature-mismatch')
})

/* ─────────── B：节点凭据 + 本地校验（D2 的判据落点） ─────────── */

test('B1 合法凭据：受信签名者签发 ⇒ 过，且能取出 hostId / 网 / 节点公钥', () => {
  const auth = buildAuthority()
  const { grant, sig } = auth.issue('w106')
  const verdict = verifyNodeGrant(grant, sig, [auth.signer.publicKey])
  assert.equal(verdict.ok, true)
  assert.equal(verdict.doc.hostId, 'w106')
  assert.equal(verdict.doc.network, OPS_NETWORK)
  assert.equal(verdict.doc.nodeKey, grant.nodeKey)
})

test('B2 🔴 核心：**篡改 hostId 后沿用原签名** ⇒ signature-mismatch（凭据不可搬家）', () => {
  const auth = buildAuthority()
  const { grant, sig } = auth.issue('w106')
  const moved = { ...grant, hostId: 'w47' }
  const verdict = verifyNodeGrant(moved, sig, [auth.signer.publicKey])
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'signature-mismatch', '凭据被搬到别的 hostId 上必须拒（签名覆盖 hostId）')
})

test('B3 期望网不符 ⇒ network-mismatch（跨网签发进不来）', () => {
  const auth = buildAuthority()
  const { grant, sig } = auth.issue('w106')
  const verdict = verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], network: U_B })
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'network-mismatch')
})

test('B4/B5 期望 hostId 不符 ⇒ host-mismatch；期望公钥不符 ⇒ key-mismatch', () => {
  const auth = buildAuthority()
  const { grant, sig } = auth.issue('w106')
  const other = generateNodeKey()
  assert.equal(
    verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], hostId: 'w47' }).reason,
    'host-mismatch',
  )
  assert.equal(
    verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], nodeKey: other.publicKey }).reason,
    'key-mismatch',
    '私钥被换过（公钥对不上）⇒ 拒',
  )
  // 对得上的那一组必须**过** —— 否则上面两条可能只是"恒拒"，测了个寂寞
  assert.equal(
    verifyPeerGrant(grant, sig, {
      trustedSignerKeys: [auth.signer.publicKey],
      network: OPS_NETWORK,
      hostId: 'w106',
      nodeKey: grant.nodeKey,
    }).ok,
    true,
  )
})

test('B6 过期凭据 ⇒ expired（带过期时间的节点会真的过期）', () => {
  const auth = buildAuthority()
  const { grant, sig } = auth.issue('w106', {
    issuedAt: new Date(NOW - 120_000).toISOString(),
    expiresAt: new Date(NOW - 60_000).toISOString(),
  })
  const verdict = verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], nowMs: NOW })
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'expired')
})

test('B7/B8 吊销：撤 hostId ⇒ revoked-host；撤节点公钥 ⇒ revoked-node-key；撤单台不牵连别的', () => {
  const auth = buildAuthority()
  const { grant, sig } = auth.issue('w106')
  const byHost = { ...revocationOf(auth.signer.privateKeyPem, ['w106']).doc }
  const byKey = { ...revocationOf(auth.signer.privateKeyPem, [], [grant.nodeKey]).doc }
  const other = { ...revocationOf(auth.signer.privateKeyPem, ['manager']).doc }
  assert.equal(
    verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], revocations: byHost }).reason,
    'revoked-host',
  )
  assert.equal(
    verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], revocations: byKey }).reason,
    'revoked-node-key',
    '设备被盗场景：hostId 可能被复用，公钥不会 ⇒ 两条都要能撤',
  )
  assert.equal(
    verifyPeerGrant(grant, sig, { trustedSignerKeys: [auth.signer.publicKey], revocations: other }).ok,
    true,
    '撤销单台不得牵动其它节点',
  )
})

test('B9 吊销清单本身也要**验签**（清单被改坏 ⇒ 撤销失效 ⇒ 不能当没事）', () => {
  const auth = buildAuthority()
  const rogue = generateAuthorityKey()
  const good = revocationOf(auth.signer.privateKeyPem, ['w106'])
  assert.equal(verifyRevocations(good.doc, good.sig, [auth.signer.publicKey]).ok, true)
  const forged = revocationOf(rogue.privateKeyPem, ['w106'])
  assert.equal(verifyRevocations(forged.doc, forged.sig, [auth.signer.publicKey]).reason, 'signature-mismatch')
  // 篡改内容后沿用原签名
  const tampered = { ...good.doc, hosts: ['w47'] }
  assert.equal(verifyRevocations(tampered, good.sig, [auth.signer.publicKey]).reason, 'signature-mismatch')
})

test('B10 会话证明（proof）：握有私钥才签得出；换公钥 / 改挑战 ⇒ 验不过', () => {
  const auth = buildAuthority()
  const { node } = auth.issue('w106')
  const challenge = 'w106|123|abc|'
  const sig = signProof(node.privateKeyPem, challenge)
  assert.equal(verifyProof(node.publicKey, challenge, sig), true)
  const other = generateNodeKey()
  assert.equal(verifyProof(other.publicKey, challenge, sig), false, '别的公钥验不过 ⇒ 证明绑定了具体私钥')
  assert.equal(verifyProof(node.publicKey, `${challenge}x`, sig), false, '挑战被改 ⇒ 验不过（防重放 / 防挪用）')
})

test('B11 非受信签名者签发的凭据 ⇒ signature-mismatch（名单之外一律不认）', () => {
  const auth = buildAuthority()
  const rogue = generateAuthorityKey()
  const node = generateNodeKey()
  const grant = {
    version: 1,
    network: OPS_NETWORK,
    hostId: 'w106',
    nodeKey: node.publicKey,
    issuedAt: new Date(NOW).toISOString(),
    expiresAt: '',
  }
  const sig = signNodeGrant(grant, rogue.privateKeyPem)
  const verdict = verifyNodeGrant(grant, sig, [auth.signer.publicKey])
  assert.equal(verdict.ok, false)
  assert.equal(verdict.reason, 'signature-mismatch')
})

test('B12 指纹：每机一把 ⇒ 指纹互不相同；解析不出来就 undefined（不猜）', () => {
  const a = generateNodeKey()
  const b = generateNodeKey()
  assert.notEqual(nodeKeyFingerprint(a.publicKey), nodeKeyFingerprint(b.publicKey), '每机一把 ⇒ 指纹必须不同')
  assert.equal(nodeKeyFingerprint(a.publicKey), nodeKeyFingerprint(a.publicKey))
  assert.equal(nodeKeyFingerprint('not-a-key'), undefined)
})

/* ─────────── C：keys 表带"网"（成员资格的唯一判据） ─────────── */

test('C1 旧写法（裸 hostId + hex 串）⇒ 归入运维网 ops（现网配置一字不改）', () => {
  const s = randomBytes(32).toString('hex')
  const map = parseKeysInline(`w-1:${s}`)
  // 键 = **逻辑名**（序③）⇒ 裸 `w-1` 归一成 `ops/w-1`
  assert.deepEqual(map.get('ops/w-1'), { network: OPS_NETWORK, secret: s })
  assert.equal(describeKeyEntry('w-1', map.get('ops/w-1')), 'w-1', 'ops 下省略网络前缀（日志读法与 R5 一致）')
})

test('C2 新写法：`网/hostId:secret` 与 `网:hostId:secret` 都切得出网络（切点是**最后一个冒号**）', () => {
  const s = randomBytes(32).toString('hex')
  const slash = parseKeysInline(`${U_A}/pc-1:${s}`)
  assert.deepEqual(slash.get(U_A + '/pc-1'), { network: U_A, secret: s })
  // ⚠️ 网络 id 自己含 `:`（`u:5`）⇒ 用**第一个**冒号切会切出网络段 `u`，
  //    于是"配置写错"就长得像"这张网不存在"（静默拒绝）——这正是本线反复要根治的病。
  const colon = parseKeysInline(`u:5:pc-1:${s}`)
  assert.deepEqual(colon.get('u:5/pc-1'), { network: 'u:5', secret: s })
  assert.equal(describeKeyEntry('pc-1', colon.get('u:5/pc-1')), 'u:5/pc-1')
})

test('C3 网络段非法 / 密钥长度不对 ⇒ **抛**（不静默回落：那会让"配错"伪装成"网络不通"）', () => {
  const s = randomBytes(32).toString('hex')
  assert.throws(() => parseKeysInline(`u/pc-1:${s}`), /非法/, '裸 `u` 是保留字，不是合法网名')
  assert.throws(() => parseKeysInline(`pc-1:deadbeef`), /64 hex/)
  assert.throws(() => parseKeysInline('no-colon'), /malformed/)
})

/* ─────────── D：端到端（relay 准入 + 身份） ─────────── */

test('D1 成员资格：声称别的网 ⇒ **network-mismatch**（失败关闭，不回落 ops）', async (t) => {
  const s = randomBytes(32).toString('hex')
  const { url } = await startRelay(t, { hosts: { w106: s } })
  const { ws, frame } = await rawHello(url, { hostId: 'w106', secret: s, network: U_B })
  t.after(() => ws.close())
  assert.equal(frame.type, MUX.HELLO_ERR)
  assert.equal(reasonOf(frame), 'network-mismatch', '密钥表说它在 ops，声称别张网 ⇒ 必须拒')
})

test('D2 未登记的 hostId ⇒ unknown-host（默认拒绝）', async (t) => {
  const s = randomBytes(32).toString('hex')
  const { url } = await startRelay(t, { hosts: { w106: s } })
  const { ws, frame } = await rawHello(url, { hostId: 'nobody', secret: s })
  t.after(() => ws.close())
  assert.equal(reasonOf(frame), 'unknown-host')
})

test('D3 强制身份但客户端**不带**凭据 ⇒ identity-incomplete（明确拒，不放行）', async (t) => {
  const s = randomBytes(32).toString('hex')
  const auth = buildAuthority()
  const { url } = await startRelay(t, {
    hosts: { w106: s },
    trustedSignerKeys: [auth.signer.publicKey],
    requireIdentity: true,
  })
  const { ws, frame } = await rawHello(url, { hostId: 'w106', secret: s, network: OPS_NETWORK })
  t.after(() => ws.close())
  assert.equal(reasonOf(frame), 'identity-incomplete')
})

test('D4 relay 侧**没有**受信签名者时，带了凭据也拒（不可验 = 不接受）', async (t) => {
  const s = randomBytes(32).toString('hex')
  const auth = buildAuthority()
  const { grant, sig, node } = auth.issue('w106')
  const { url } = await startRelay(t, { hosts: { w106: s }, trustedSignerKeys: [] })
  const { ws, frame } = await rawHello(url, {
    hostId: 'w106',
    secret: s,
    network: OPS_NETWORK,
    identity: { nodeKey: node.publicKey, grant, grantSig: sig, nodePrivateKeyPem: node.privateKeyPem },
  })
  t.after(() => ws.close())
  assert.equal(reasonOf(frame), 'identity-no-trusted-signers')
})

test('D5 🔴 **先红后绿**：同一份"被搬家的凭据" —— 没有这道门时能注册（红），有门时被拒（绿）', async (t) => {
  const s = randomBytes(32).toString('hex')
  const auth = buildAuthority()
  const good = auth.issue('w106')
  // 篡改形态：把 w106 的凭据"搬家"到 w47 并沿用原签名 —— 这正是"控制面被攻破后插入节点"的形状。
  const evilGrant = { ...good.grant, hostId: 'w47' }
  const identity = { nodeKey: good.node.publicKey, grant: evilGrant, grantSig: good.sig }
  const hosts = { w106: s, w47: s }

  /* ① 红：门关着（verifyIdentity:false）⇒ **同一份坏凭据确实注册进去了** */
  const open = await startRelay(t, { hosts, trustedSignerKeys: [auth.signer.publicKey], verifyIdentity: false })
  const red = await rawHello(open.url, { hostId: 'w47', secret: s, network: OPS_NETWORK, identity })
  t.after(() => red.ws.close())
  assert.equal(red.frame.type, MUX.HELLO_ACK, '【红】门关着时坏凭据能注册 —— 这就是被治的攻击面，必须有实测')
  assert.ok(open.srv.status().counters.authed > 0)

  /* ② 绿：门开着（verifyIdentity:true）⇒ 同一份坏凭据被拒 */
  const closed = await startRelay(t, { hosts, trustedSignerKeys: [auth.signer.publicKey] })
  const green = await rawHello(closed.url, { hostId: 'w47', secret: s, network: OPS_NETWORK, identity })
  t.after(() => green.ws.close())
  assert.equal(reasonOf(green.frame), 'identity-signature-mismatch', '搬家的凭据必须被签名校验挡住')
  assert.equal(closed.srv.status().counters.identityOk, 0)
  assert.equal(closed.srv.status().sessions.length, 0, '被拒的节点不得留下任何会话')
})

test('D6 凭据合法但**节点证明**是错的 ⇒ identity-bad-proof（有证书 ≠ 有私钥）', async (t) => {
  const s = randomBytes(32).toString('hex')
  const auth = buildAuthority()
  const { grant, sig, node } = auth.issue('w106')
  const attacker = generateNodeKey()
  const { url } = await startRelay(t, { hosts: { w106: s }, trustedSignerKeys: [auth.signer.publicKey] })
  const { ws, frame } = await rawHello(url, {
    hostId: 'w106',
    secret: s,
    network: OPS_NETWORK,
    identity: {
      nodeKey: node.publicKey, // 声明的是**真**公钥（凭据也对得上）
      grant,
      grantSig: sig,
      nodeSigOverride: signProof(attacker.privateKeyPem, 'anything'), // 但签名不是那把私钥签的
    },
  })
  t.after(() => ws.close())
  assert.equal(reasonOf(frame), 'identity-bad-proof', '凭据是公开可转发的 ⇒ 必须再证"握有私钥"')
})

test('D7 合法身份 ⇒ 真 `RelayClient` 连得上；**撤销单台不牵动全网**', async (t) => {
  const sA = randomBytes(32).toString('hex')
  const sB = randomBytes(32).toString('hex')
  const auth = buildAuthority()
  const a = auth.issue('w106')
  const b = auth.issue('w47')
  const rev = revocationOf(auth.signer.privateKeyPem, ['w106'])
  assert.equal(verifyRevocations(rev.doc, rev.sig, [auth.signer.publicKey]).ok, true, '清单本身先要验得过')

  const { srv, url } = await startRelay(t, {
    hosts: { w106: sA, w47: sB },
    trustedSignerKeys: [auth.signer.publicKey],
    revocations: rev.doc,
    requireIdentity: true,
  })

  /** 用**真** `RelayClient` 连（证明客户端侧字段拼得对，不是只有 rawHello 能过）。 */
  const connect = (hostId, secret, issued) => {
    const c = new RelayClient({
      url,
      hostId,
      secret,
      ports: [],
      dialer: true,
      identity: { privateKeyPem: issued.node.privateKeyPem, grant: issued.grant, grantSig: issued.sig },
      log: () => {},
    })
    c.start()
    return c
  }

  const cA = connect('w106', sA, a)
  const cB = connect('w47', sB, b)
  t.after(() => {
    cA.stop()
    cB.stop()
  })
  assert.ok(await waitFor(() => cB.status().state === 'up'), '未被撤的 w47 必须连上（撤销不得牵动全网）')
  assert.equal(await waitFor(() => cA.status().state === 'up', 1500), false, '被撤的 w106 不得连上')
  assert.equal(srv.status().counters.identityOk, 1, '只有一台通过身份校验')
  assert.equal(
    srv.status().sessions.filter((x) => x.hostId === 'w106').length,
    0,
    '被撤节点不得在 relay 侧留下会话',
  )
  assert.equal(publicKeyOfPrivate(a.node.privateKeyPem), a.grant.nodeKey, '客户端带的 nodeKey 必须与凭据里那把一致')
})

/* ─────────── E：文件面（密钥落点与原地升级） ─────────── */

test('E1 keys 文件：新旧写法可**共存**（原地升级 ⇒ 可原子替换 + 可回滚）', (t) => {
  const dir = mkdtempSync(join(tmpdir(), 'dshs-keys-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const s1 = randomBytes(32).toString('hex')
  const s2 = randomBytes(32).toString('hex')
  const file = join(dir, 'relay-keys.json')
  writeFileSync(file, JSON.stringify({ 'w-1': s1, w106: { network: OPS_NETWORK, secret: s2 } }))
  const map = loadKeysFile(file)
  assert.deepEqual(map.get('ops/w-1'), { network: OPS_NETWORK, secret: s1 })
  assert.deepEqual(map.get('ops/w106'), { network: OPS_NETWORK, secret: s2 })

  // 非法网络段 ⇒ **装载即抛**（"配置错就炸"，不变成运行期的静默拒绝）
  writeFileSync(file, JSON.stringify({ bad: { network: 'u', secret: s1 } }))
  assert.throws(() => loadKeysFile(file), /非法/)
})

/* ─────────── F：F1.5 防重放序号（G1）＋ 撤根机制（G6） ─────────── */

/**
 * F1.5 的验收判据落点。**五类负控逐条对应交接单 §6.2**，每条都要能"做坏一点就被抓到"。
 *
 * 走的是**新入口**（`loadTrustedSigners` / `loadRevocations` / `loadRootSet`），⛔ 不是
 * 直接调 `verifySignerSet` —— 后者只验签、不含序号判定，用它测不出重放。
 */

test('F1 🔴 兼容性：**无 serial 的老文档**在新代码下必须仍验得过（升级窗口不许掐死）', () => {
  const auth = buildAuthority()
  // 模拟 F1.5 **之前**那份代码签的东西：载荷末尾没有 serial 段。
  const oldSet = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), signers: [auth.signer.publicKey] }
  const oldSig = signSignerSet(oldSet, auth.root.privateKeyPem)
  const verdict = verifySignerSet(oldSet, oldSig, [auth.root.publicKey])
  assert.equal(verdict.ok, true, `老文档必须验得过（载荷缺 serial 段 ⇒ 与旧版逐字相同），实测：${JSON.stringify(verdict)}`)
  assert.equal(verdict.doc.serial, 0, '缺失 ⇒ 视为 0（= 老格式）')
  // 载荷形状：**serial 段整段不出现**（多一行 "0" 就会让所有存量文档永远验不过 —— 实测踩过）
  assert.equal(verdict.payload.split('\n').length, 5, `老文档载荷必须是 5 段，实测：${JSON.stringify(verdict.payload)}`)
  const fresh = { ...oldSet, serial: 7 }
  assert.equal(
    verifySignerSet(fresh, signSignerSet(fresh, auth.root.privateKeyPem), [auth.root.publicKey]).ok,
    true,
    '带序号的新文档照旧验得过',
  )
  assert.equal(signerSetPayload(fresh).split('\n').length, 6, '带序号的载荷是 6 段（末尾多一项）')
})

test('F2 序号判定：新鲜接受 ⇒ 重放拒 ⇒ 同号拒 ⇒ 且**先落盘后采用**', async (t) => {
  const auth = buildAuthority()
  const dir = mkdtempSync(join(tmpdir(), 'dshs-serial-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const stateFile = join(dir, 'state.json')
  const guard = new OverlaySerialGuard({ file: stateFile })
  const setFile = join(dir, 'signerset.json')
  const write = (doc) => writeSignedFile(setFile, doc, signSignerSet(doc, auth.root.privateKeyPem))
  const load = () =>
    loadTrustedSigners({ roots: [auth.root.publicKey], directSigners: [], signerSetFile: setFile, serialGuard: guard })

  write({ ...auth.signerSet, serial: 5 })
  const first = await load()
  assert.equal(first.error, undefined, `serial=5 首次装载必须过，实测：${first.error}`)

  write({ ...auth.signerSet, serial: 4 })
  const replay = await load()
  assert.equal(replay.keys.length, 0, '重放更旧的序号 ⇒ 不得取出任何签名者')
  assert.match(replay.error ?? '', /stale-serial/, `重放必须具名 stale-serial，实测：${replay.error}`)

  write({ ...auth.signerSet, serial: 5 })
  assert.match((await load()).error ?? '', /stale-serial/, '**等于也拒**（重复下发同一号没有理由再接受一次）')

  // 先落盘后采用：水位文件此刻**已经**是 5（不是"采用时才写"）
  assert.equal(
    readFileSync(stateFile, 'utf8').includes(`"signerset|${OPS_NETWORK}": 5`),
    true,
    '水位必须在采用前已落盘',
  )
  write({ ...auth.signerSet, serial: 6 })
  assert.equal((await load()).error, undefined, '更高的序号必须接受')
})

test('F3 🔴 次序：**验签必须在序号之前**（垃圾签名＋超大序号不得顶死水位）', async (t) => {
  const auth = buildAuthority()
  const dir = mkdtempSync(join(tmpdir(), 'dshs-serial-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const stateFile = join(dir, 'state.json')
  const guard = new OverlaySerialGuard({ file: stateFile })
  const setFile = join(dir, 'signerset.json')
  // 签名**长度合法**（64 字节）但签名者**不在受信根里** ⇒ 走到 `signature-mismatch` 那一步，
  // 而序号顶到天花板。若先比序号，水位会被顶死、此后一切合法文档全 stale（零成本永久 DoS）。
  const evil = { ...auth.signerSet, serial: Number.MAX_SAFE_INTEGER }
  const rogue = generateAuthorityKey()
  writeSignedFile(setFile, evil, signSignerSet(evil, rogue.privateKeyPem))
  const r = await loadTrustedSigners({
    roots: [auth.root.publicKey],
    directSigners: [],
    signerSetFile: setFile,
    serialGuard: guard,
  })

  assert.match(r.error ?? '', /signature-mismatch/, `必须先失败在验签上，实测：${r.error}`)
  assert.equal(existsSync(stateFile), false, '验签失败**不得**触碰水位文件（碰了就是 DoS 面）')
  const good = { ...auth.signerSet, serial: 1 }
  writeSignedFile(setFile, good, signSignerSet(good, auth.root.privateKeyPem))
  assert.equal(
    (await loadTrustedSigners({ roots: [auth.root.publicKey], directSigners: [], signerSetFile: setFile, serialGuard: guard }))
      .error,
    undefined,
    '水位未被污染 ⇒ 一份合法的 serial=1 仍必须被接受（证明 DoS 面没成立）',
  )
})

test('F4 🔴 负控①/② 重放与同号 ⇒ `stale-serial`（同一入口两种形态）', async (t) => {
  const { file, guard } = freshSerialGuard(t)
  const key = serialScopeKey({ kind: 'revocation', network: OPS_NETWORK })
  assert.equal((await guard.check(key, 1)).ok, true, '水位 0 时 serial=1 必须接受')
  assert.equal((await guard.check(key, 1)).reason, 'stale-serial', '负控②：同号重复 ⇒ 拒（严格大于才接受）')
  assert.equal((await guard.check(key, 0)).reason, 'stale-serial', '负控①：更旧的序号 ⇒ 拒')
  assert.equal((await guard.check(key, 2)).ok, true, '更高的序号必须接受')
  assert.equal((await guard.check(key, 0)).reason, 'stale-serial', '水位 ≥1 之后老格式文档也必须拒')
  // 另一把键是**独立水位**（T-8：两个独立序列、两个键）
  assert.equal(
    (await guard.check(serialScopeKey({ kind: 'revocation', network: U_A }), 1)).ok,
    true,
    'A 网的文档不得推进 B 网的水位（按网隔离）',
  )
  assert.equal(existsSync(file), true, '水位文件必须已落盘')
})

test('F5 🔴 负控（T-10）状态文件坏掉 ⇒ **失败关闭**，⛔ 不当成水位 0', async (t) => {
  const auth = buildAuthority()
  const dir = mkdtempSync(join(tmpdir(), 'dshs-serial-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const stateFile = join(dir, 'state.json')
  const setFile = join(dir, 'signerset.json')
  const doc = { ...auth.signerSet, serial: 3 }
  writeSignedFile(setFile, doc, signSignerSet(doc, auth.root.privateKeyPem))
  const load = (guard) =>
    loadTrustedSigners({ roots: [auth.root.publicKey], directSigners: [], signerSetFile: setFile, serialGuard: guard })

  // 情形一：文件**不存在** ⇒ 视为水位 0 ⇒ 接受（首次升级的正常形态）
  assert.equal((await load(new OverlaySerialGuard({ file: stateFile }))).error, undefined, '文件不存在 ⇒ 视为水位 0（不是错误）')
  // 情形二：文件**存在但坏掉** ⇒ 拒，且拒因具名
  writeFileSync(stateFile, '{ 这不是 JSON')
  assert.match(
    (await load(new OverlaySerialGuard({ file: stateFile }))).error ?? '',
    /serial-state-unreadable/,
    '坏掉的状态文件必须失败关闭',
  )
  // 情形三：形状不对（缺 seen 对象）⇒ 同样失败关闭
  writeFileSync(stateFile, JSON.stringify({ version: 1 }))
  assert.match(
    (await load(new OverlaySerialGuard({ file: stateFile }))).error ?? '',
    /serial-state-unreadable/,
    '形状不对也必须失败关闭',
  )
})

test('F6 负控③ 单把根签"撤掉其余所有根" ⇒ `insufficient-root-signatures`（单根先手被挡）', () => {
  const r1 = generateAuthorityKey()
  const r2 = generateAuthorityKey()
  const r3 = generateAuthorityKey()
  // 文档：r1 想撤掉 r2、r3（= 先手把其余根全撤掉）。候选签名者只剩 r1 自己。
  const doc = {
    version: 1,
    network: OPS_NETWORK,
    issuedAt: new Date(NOW).toISOString(),
    serial: 1,
    revoked: [r2.publicKey, r3.publicKey],
  }
  const verdict = verifyRootSet(doc, [signRootSet(doc, r1.privateKeyPem)], [r1.publicKey, r2.publicKey, r3.publicKey], 2)
  assert.equal(verdict.ok, false, '单根先手必须被挡（否则一把沦陷的根就能锁死全网）')
  assert.equal(verdict.reason, 'insufficient-root-signatures')
})

test('F7 负控④ 同一个签名**复制两份** ⇒ 按公钥去重后只有 1 票 ⇒ 拒', () => {
  const root = generateAuthorityKey()
  const doc = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), serial: 1, revoked: [] }
  const sig = signRootSet(doc, root.privateKeyPem)
  const duplicated = verifyRootSet(doc, [sig, sig], [root.publicKey, generateAuthorityKey().publicKey], 2)
  assert.equal(duplicated.ok, false, '同一签名复制两份**不得**凑出 2 票')
  assert.equal(duplicated.reason, 'insufficient-root-signatures')
  // 换一把**真的另一把根**来签 ⇒ 2 票 ⇒ 过（证明上面拒的不是"恒拒"）
  const other = generateAuthorityKey()
  const both = verifyRootSet(doc, [sig, signRootSet(doc, other.privateKeyPem)], [root.publicKey, other.publicKey], 2)
  assert.equal(both.ok, true, '两把不同的根合签 ⇒ 必须过')
})

test('F8 🔴 负控（T-7）阈值分母 = `effectiveRoots.length` ⇒ 撤掉其余所有根**仍需 2 票**', () => {
  const rogue = generateAuthorityKey()
  // 场景：**沦陷的那把根自己是唯一签名人**（`envRoots` 里只有它自己 + 两个它想撤的根）。
  const good2 = generateAuthorityKey()
  const envRoots = [rogue.publicKey, good2.publicKey]
  // 它签一份"撤掉 good2"的声明 ⇒ 候选签名者只剩它自己。
  // 🔴 若分母用**候选数**：min(K, 1) = 1 ⇒ 它**一票就够了** ⇒ 单根先手把网络锁死。
  // ✅ 分母用 **effectiveRoots.length = 2** ⇒ 需要 2 票，它只有 1 票 ⇒ 拒。
  const doc = {
    version: 1,
    network: OPS_NETWORK,
    issuedAt: new Date(NOW).toISOString(),
    serial: 1,
    revoked: [good2.publicKey],
  }
  const solo = verifyRootSet(doc, [signRootSet(doc, rogue.privateKeyPem)], envRoots, 2)
  assert.equal(solo.ok, false, '单根撤掉其余所有根**必须**被拒（分母 = effectiveRoots.length = 2，⛔ 不是候选数 1）')
  assert.equal(solo.reason, 'insufficient-root-signatures')
  // 被撤的那把**根本没资格投票**：它自己签的也不算
  const selfSig = signRootSet(doc, good2.privateKeyPem)
  assert.equal(verifyRootSet(doc, [selfSig], envRoots, 2).ok, false, '被撤者不得为自己那份声明投票')
  // 对照：**不动被撤集合**（`revoked: []`）的两把合签 ⇒ 2 票 ⇒ 过（证明上面拒的不是"恒拒"）
  const neutral = { ...doc, revoked: [] }
  const both = verifyRootSet(
    neutral,
    [signRootSet(neutral, rogue.privateKeyPem), signRootSet(neutral, good2.privateKeyPem)],
    envRoots,
    2,
  )
  assert.equal(both.ok, true, '两把不同的根合签（无人被撤）⇒ 必须过')
})

test('F9 撤根装载：**有效根集 = env − revoked**，且被撤的根签的名单此后被拒', async (t) => {
  const r1 = generateAuthorityKey()
  const r2 = generateAuthorityKey()
  const r3 = generateAuthorityKey()
  const signer = generateAuthorityKey()
  // ⚠️ **三把根**（不是两把）：`K=2` 的副作用就是"根集合下限 = 2 把"——用两把根去撤其中一把，
  // 被撤者不能投票 ⇒ 候选只剩 1 把 ⇒ 1 票 < 2 ⇒ **撤不掉**。这是设计的**已知副作用**
  // （设计件 §3.2："`K` 事实上是根集合下限的旋钮"），⇒ 本测试按设计取 3 把。
  const envRoots = [r1.publicKey, r2.publicKey, r3.publicKey]
  const dir = mkdtempSync(join(tmpdir(), 'dshs-roset-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const rosetFile = join(dir, 'rootset.json')
  const guard = new OverlaySerialGuard({ file: join(dir, 'state.json') })

  // 未配撤根文件 ⇒ 有效根集 = env，**且不报错**（合法形态，G6 可单独灰度）
  const none = await loadRootSet({ file: '', envRoots, minSigs: 2, serialGuard: guard })
  assert.deepEqual(none.roots, envRoots)
  assert.equal(none.error, undefined, '没配撤根 = 无撤根，⛔ 不是错误')

  // 配了撤根：**两把好根（r1、r2）合签**撤掉 r3 ⇒ 票数 = 2（r3 被撤，无权投票）
  const doc = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), serial: 1, revoked: [r3.publicKey] }
  const roset = rootSetOf(doc, [r1.privateKeyPem, r2.privateKeyPem])
  // 多签文件形状 = `{doc, sigs:[…]}`（复数）；`readSignedFile` 读出 `sigs` 后由 `loadRootSet` 交给
  // `verifyRootSet`。⛔ **不要**在这里顺手调 `writeSignedFile`（那是单签形状，会把文件覆盖掉 ⇒
  // `no-signature`，本测试第一版就踩了这个坑）。
  writeFileSync(rosetFile, JSON.stringify({ doc: roset.doc, sigs: roset.sigs }, null, 2))
  const r = await loadRootSet({ file: rosetFile, envRoots, minSigs: 2, serialGuard: guard })
  assert.equal(r.error, undefined, `撤根声明必须被接受，实测：${r.error}`)
  assert.deepEqual(r.roots, [r1.publicKey, r2.publicKey], '有效根集必须剔除被撤的 r3')

  // ② 被撤根 r3 签的名单 ⇒ 用 effective 验 ⇒ 拒；未被撤的 r1 照旧有效
  const set = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), serial: 1, signers: [signer.publicKey] }
  const rejected = verifySignerSet(set, signSignerSet(set, r3.privateKeyPem), r.roots)
  assert.equal(rejected.ok, false)
  assert.equal(rejected.reason, 'signature-mismatch', '撤根之后，被撤者签的名单必须被拒')
  assert.equal(verifySignerSet(set, signSignerSet(set, r1.privateKeyPem), r.roots).ok, true, '撤根不得牵连别的根')

  // ③ 阈值不足（只有 r1 一把签，而要 2 票）⇒ 拒，⛔ 不回落到 env
  const solo = { ...doc, serial: 2 }
  writeFileSync(rosetFile, JSON.stringify({ doc: solo, sigs: [signRootSet(solo, r1.privateKeyPem)] }, null, 2))
  const bad = await loadRootSet({ file: rosetFile, envRoots, minSigs: 2, serialGuard: guard })
  assert.match(bad.error ?? '', /rootset-rejected: insufficient-root-signatures/, '阈值不足必须具名拒')
  assert.equal(bad.roots, undefined, '⛔ 拒的时候不得给出任何根集（不许回落到 env ⇒ 那等于被撤的根复活）')

  // ④ 反向操作：发一份 `revoked: []` 且序号**更高**的声明 ⇒ r3 复活（撤根是**可逆**的）
  const restore = { ...doc, serial: 3, revoked: [] }
  writeFileSync(
    rosetFile,
    JSON.stringify({ doc: restore, sigs: [signRootSet(restore, r1.privateKeyPem), signRootSet(restore, r2.privateKeyPem)] }, null, 2),
  )
  const back = await loadRootSet({ file: rosetFile, envRoots, minSigs: 2, serialGuard: guard })
  assert.equal(back.error, undefined, `恢复声明必须被接受，实测：${back.error}`)
  assert.deepEqual(back.roots, envRoots, '`revoked: []` + 更高序号 ⇒ 有效根集重新包含 r3（可逆，⛔ 不需删文件）')
})

test('F10 撤根序号：重放更旧的撤根声明 ⇒ `stale-serial`（G6 与 G1 是同一套判据）', async (t) => {
  const r1 = generateAuthorityKey()
  const r2 = generateAuthorityKey()
  const r3 = generateAuthorityKey()
  const envRoots = [r1.publicKey, r2.publicKey, r3.publicKey]
  const dir = mkdtempSync(join(tmpdir(), 'dshs-roset-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const rosetFile = join(dir, 'rootset.json')
  const guard = new OverlaySerialGuard({ file: join(dir, 'state.json') })
  // 两把好根（r1、r2）合签 —— 与 F9 同款拓扑（被撤的 r3 无权投票）
  const sign = (d) => [signRootSet(d, r1.privateKeyPem), signRootSet(d, r2.privateKeyPem)]
  const base = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString() }
  const put = (d) => writeFileSync(rosetFile, JSON.stringify({ doc: d, sigs: sign(d) }, null, 2))
  const load = () => loadRootSet({ file: rosetFile, envRoots, minSigs: 2, serialGuard: guard })

  put({ ...base, serial: 5, revoked: [r3.publicKey] })
  assert.equal((await load()).error, undefined, 'serial=5 的撤根声明先接受')
  // 撤销**之前**的旧声明（若被接受 ⇒ r3 复活 ⇒ 撤根被抹掉）
  put({ ...base, serial: 4, revoked: [] })
  const replay = await load()
  assert.match(replay.error ?? '', /rootset-rejected: stale-serial/, '重放旧的撤根声明 ⇒ 必须具名 stale-serial')
  assert.equal(replay.roots, undefined, '被拒时不得给出根集（否则撤根被旧声明抹掉）')
})

test('F11 负控⑤ 含分隔符的构造输入 ⇒ 解析阶段即拒（`bad-document`）', () => {
  const auth = buildAuthority()
  const base = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString() }
  // 往 hosts 项里塞换行：若解析器放行，`hosts.join(',')` 之后就能伪造出载荷段
  assert.equal(parseRevocationList({ ...base, hosts: ['w106\nw47'], nodeKeys: [] }), undefined, '带换行的 hostId ⇒ 拒')
  // 往 signers 项里塞换行：`normalizePublicKey` 解析不出来 ⇒ 整份拒
  assert.equal(parseSignerSet({ ...base, signers: [`${auth.signer.publicKey}\nx`] }), undefined, '带换行的公钥 ⇒ 拒')
  // 往撤根项里塞换行：同上
  assert.equal(parseRootSet({ ...base, serial: 1, revoked: [`${auth.root.publicKey}\nx`] }), undefined, '带换行的根公钥 ⇒ 拒')
  // 对照：干净的那一份必须解析得出来（否则上面三条可能只是"恒拒"）
  assert.notEqual(parseRevocationList({ ...base, hosts: ['w106'], nodeKeys: [] }), undefined)
  assert.notEqual(parseSignerSet({ ...base, signers: [auth.signer.publicKey] }), undefined)
})

test('F12 `serial` 显式写成坏值 ⇒ `bad-document`；**缺失** ⇒ 兼容（不是错误）', () => {
  const auth = buildAuthority()
  const base = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), signers: [auth.signer.publicKey] }
  for (const bad of [0, -1, 2.5, '3', Number.MAX_SAFE_INTEGER + 2]) {
    assert.equal(parseSignerSet({ ...base, serial: bad }), undefined, `serial=${JSON.stringify(bad)} 必须被拒（bad-document）`)
  }
  assert.equal(parseSignerSet(base)?.serial, 0, '缺失 ⇒ 视为 0（老格式兼容，⛔ 不是错误）')
  assert.equal(parseSignerSet({ ...base, serial: 1 })?.serial, 1, 'serial=1 是合法起点（0 保留给老文档）')
})

test('F13 吊销清单序号：重放撤销之前的旧清单 ⇒ `revocations-rejected: stale-serial`（G1 第三份文档）', async (t) => {
  const auth = buildAuthority()
  const dir = mkdtempSync(join(tmpdir(), 'dshs-rev-'))
  t.after(() => rmSync(dir, { recursive: true, force: true }))
  const revFile = join(dir, 'revocations.json')
  const guard = new OverlaySerialGuard({ file: join(dir, 'state.json') })
  const put = (doc) => writeSignedFile(revFile, doc, signRevocations(doc, auth.signer.privateKeyPem))
  const load = () => loadRevocations({ file: revFile, trustedSignerKeys: [auth.signer.publicKey], serialGuard: guard })
  const base = { version: 1, network: OPS_NETWORK, issuedAt: new Date(NOW).toISOString(), nodeKeys: [] }

  // 先接受"撤了 w106"的那份（serial=2）
  put({ ...base, serial: 2, hosts: ['w106'] })
  const ok = await load()
  assert.equal(ok.error, undefined, `serial=2 的撤销清单必须过，实测：${ok.error}`)
  assert.deepEqual(ok.list?.hosts, ['w106'])
  // 再重放**撤销之前**的旧清单（serial=1，hosts=[]）⇒ 必须拒（否则已撤节点重新被放行）
  put({ ...base, serial: 1, hosts: [] })
  const replay = await load()
  assert.match(replay.error ?? '', /stale-serial/, `重放旧清单必须具名 stale-serial，实测：${replay.error}`)
  assert.equal(replay.list, undefined, '被拒时不得给出清单（⛔ 拒绝 ≠ 回退）')
})