新增：模拟一致性检查页（/dev/sim-check.html），任意设备的浏览器重放黄金结果的整套战斗，逐帧与 Node 比较

.gitignore

@@ -43,3 +43,5 @@ desktop.ini
 .idea/
 .vscode/
 .claude/
+# tools/sim-check.mjs: the corpus and its Node traces for /dev/sim-check.html
+public/dev/simcheck/data/

CONTRIBUTING.md

@@ -45,6 +45,12 @@ RENDER_E2E=1 node --test 'test/render/*.browser.test.js'         # 渲染
 SIM_E2E=1 node --test 'test/sim/*.browser.test.js'               # 浏览器里的战斗模拟
 ```
 
+改了模拟（`server/sim/`）之后，可以检查各浏览器算出的战斗和服务器是否仍然逐位一致：`node tools/sim-check.mjs`
+在 Node 里记录黄金结果的整套战斗，然后在任意设备（包括手机）的浏览器里打开服务器的 `/dev/sim-check.html` 重放比较；
+加 `--engines chromium,firefox,webkit` 直接在无界面的浏览器里跑（Firefox 和 WebKit 需要先装 playwright）。不一致时
+页面指出从哪一帧开始、是结果、画面还是状态不同，`--diff` 用下载的数据找出第一个不同的单位和字段。细节见 docs/SIM.md
+「11. Tools」。
+
 **黄金结果**（[test/golden/README.md](test/golden/README.md)）：只重构、不改玩法的提交不能改变
 `test/golden/*.json`；有意改变玩法时运行 `npm run golden:update`，把新文件和改动放在同一个提交里，并在提交说明里写清
 哪些场景变了、为什么。
@@ -110,6 +116,8 @@ SIM_E2E=1 node --test 'test/sim/*.browser.test.js'               # 浏览器里
   are opt-in: `SP_E2E=1`, `SP_REAL_E2E=1` (needs downloaded art), `RENDER_E2E=1`, `SIM_E2E=1` (a local Chrome,
   `CHROME_PATH`). A refactor never changes `test/golden/*.json`; an intended gameplay change runs
   `npm run golden:update` and commits the digests with the change, naming the scenarios that moved.
+  After a sim change, `node tools/sim-check.mjs` checks that browsers still give the server's bits: it traces the golden
+  battle corpus in Node; `/dev/sim-check.html` replays it on any device (`--engines chromium,firefox,webkit` headless).
 - **Fidelity**: the official tables (`.cache/gamedata/excel/`) and PRTS (including the 备注 notes) are the sources;
   numbers come from the blackboards. Anything no source settles is marked `[ASSUMED]` in the code and the pull
   request; owner decisions are cited with their date; deliberate deviations are the owner's call and go into the design

docs/SIM.md

@@ -1496,6 +1496,26 @@ skill × module, every bond at its threshold and at 999 layers, every leader fie
 reduced to digests in `test/golden/*.json`; `test/golden.test.js` fails, naming the scenario and the field, when a
 digest moves. A refactor must leave them unchanged; `npm run golden:update` records an intended gameplay change.
 
+Cross-engine check (`tools/sim-check.mjs`, `public/dev/sim-check.html`): a browser simulates its battles and the server
+re-simulates them (SP_VERIFY, takeovers), so every engine must give the bits Node gives. `node tools/sim-check.mjs`
+builds the golden battle corpus (roster, bonds, fields, standins, diy — 267 BattleSpecs) and traces it in Node into
+`public/dev/simcheck/data/` (git-ignored, about a minute): after every tick the state (battle time, RNG state and per
+unit alive / removed / deployed, x, y, hp, atkCd, SP, the five element gauges, damage dealt / taken, healing, blocking
+count) hashed to the exact IEEE-754 bits, one hash per 30 ticks; every 30 ticks `b.snapshot()` (what viewers are sent);
+every 150 ticks the deep state (every value reachable from the units, the definitions and buffs.js's process-wide `seq`
+left out); and `resultDigest(b.result())`. `/dev/sim-check.html` — on any device that reaches the server, a phone
+included — runs the corpus (or its fast subset, or a family) with the client's own loader (`loadBrowserSim`) and
+compares block by block: a battle that parts is reported with the first ticks that differ, the level (the outcome, the
+snapshot, the state, or the hidden state only), and a download of that block's state vectors;
+`node tools/sim-check.mjs --diff <file>` replays the same ticks in Node and names the first unit and field that differ
+(with both values' bits). `--engines chromium,firefox,webkit [--subset fast|all|<family>]` runs the page headless after
+the trace (Firefox and WebKit through the `playwright` package when it is installed, `npx playwright install firefox
+webkit`; Chrome through puppeteer-core otherwise) and exits 1 on a difference. The tracing, comparison and page
+(`public/dev/simcheck/core.js`, `ui.js`, `node.mjs`) have no dependency on this repository; `stronghold.js` is the part
+that knows the sim. At 0.2.4 all 267 battles are bit-identical in Chrome 154, Firefox 157 and WebKit 27.2; with
+`Math.hypot` put back into `detmath.js hypot`, 25 of the 55 fast battles part in Firefox and 27 in WebKit, the first at
+tick 569 of `roster-004` (an enemy's `y`, one ulp).
+
 ## 12. Data notes (simdata.js)
 
 Defs are normalised from data/*.json (DATA.md) with research JSON as a fallback. Chess: `stats {maxHp, atk, def, res, aspd,

public/dev/sim-check.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="color-scheme" content="dark" />
+  <title>Sim check · 卫戍协议：盟约</title>
+  <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Crect width='24' height='24' fill='%230c0f0e'/%3E%3Cpath fill='%234ed8af' d='M5 3h3v2h2V3h4v2h2V3h3v5l-2 2v7l2 2v2H5v-2l2-2v-7L5 8z'/%3E%3C/svg%3E" />
+  <link rel="stylesheet" href="/fonts/fonts.css" />
+  <link rel="stylesheet" href="/css/theme.css" />
+  <style>
+    /* The check (simcheck/ui.js) in the game's tokens (css/theme.css): green-grey panels, mint, gold / red for the
+       differences. A long scrolling page, fit for a phone. */
+    html, body { margin: 0; min-height: 100%; background: var(--bg-0); }
+    #app { --sc-bg: var(--bg-0); --sc-panel: var(--bg-1); --sc-fg: var(--text-hi); --sc-muted: var(--text-lo); --sc-line: var(--line);
+      --sc-accent: var(--mint-500); --sc-ok: var(--mint-500); --sc-warn: var(--gold-2); --sc-bad: var(--red-premium);
+      --sc-font: var(--font-cjk); --sc-mono: var(--font-mono); }
+  </style>
+</head>
+<body>
+  <main id="app"><p style="color:var(--text-lo);padding:16px">正在载入战斗模拟…</p></main>
+  <script type="module" src="./sim-check.js"></script>
+</body>
+</html>

public/dev/sim-check.js

@@ -0,0 +1,45 @@
+// The cross-engine check page (docs/SIM.md「Cross-engine check」): this browser runs the golden battle corpus with the
+// client's own sim loader (public/js/battle/runner.js loadBrowserSim) and compares every tick with the Node reference
+// that `node tools/sim-check.mjs` wrote to /dev/simcheck/data/ — any device on the LAN can open it from the server.
+import { mountCheck } from './simcheck/ui.js';
+import { strongholdAdapter, scenariosOf } from './simcheck/stronghold.js';
+
+const app = document.getElementById('app');
+const get = async (url) => {
+  const r = await fetch(url, { cache: 'no-cache' });
+  if (!r.ok) throw Object.assign(new Error(`${r.status} ${url}`), { missing: r.status === 404 });
+  return r.json();
+};
+
+try {
+  const [doc, reference, { loadBrowserSim }, { APP_VERSION }] = await Promise.all([
+    get('/dev/simcheck/data/specs.json'), get('/dev/simcheck/data/reference.json'), import('/js/battle/runner.js'), import('/shared/constants.js'),
+  ]);
+  const { spec, ds } = await loadBrowserSim();
+  const scenarios = scenariosOf(doc);
+  const FAMILIES = [['roster', '干员'], ['bonds', '盟约'], ['fields', '首领战场与联防'], ['standins', '补位'], ['diy', '自选']];
+  const stale = reference.made && reference.made.version && reference.made.version !== APP_VERSION;
+  mountCheck(app, {
+    project: 'Stronghold Protocol',
+    title: '模拟一致性检查',
+    subtitle: '在这台设备的浏览器里运行黄金结果的整套战斗，逐帧与服务器（Node）的结果比较。浏览器自己模拟战斗、服务器再复算校验，两边必须逐位一致。'
+      + (stale ? `<br><b style="color:var(--gold-2)">参考数据由 ${reference.made.version} 生成，这台服务器是 ${APP_VERSION}：请在服务器上重新运行 node tools/sim-check.mjs。</b>` : ''),
+    adapter: strongholdAdapter({ spec, ds, doc }),
+    scenarios,
+    subsets: [
+      { id: 'fast', label: '快速（黄金结果的快速子集）', pick: (sc) => sc.fast },
+      { id: 'all', label: '全部', pick: () => true },
+      ...FAMILIES.map(([id, label]) => ({ id, label, pick: (sc) => sc.family === id })),
+    ],
+    reference,
+    info: [['游戏版本', APP_VERSION]],
+  });
+} catch (e) {
+  app.innerHTML = '';
+  const p = document.createElement('p');
+  p.style.cssText = 'color:var(--text-md);padding:16px;max-width:760px;margin:0 auto;font:14px/1.6 var(--font-cjk)';
+  p.textContent = e.missing
+    ? '还没有参考数据：请在服务器的目录里运行 node tools/sim-check.mjs（生成 public/dev/simcheck/data/），然后刷新这个页面。'
+    : `载入失败：${e && e.message || e}`;
+  app.appendChild(p);
+}

public/dev/simcheck/core.js

@@ -0,0 +1,212 @@
+// simcheck — whether a deterministic simulation gives the same bits in every JavaScript engine: the server's Node and
+// the players' browsers (Chrome / Edge, Firefox, Safari, on desktops and phones). A run of one scenario is traced:
+//   state   the simulation's observable numbers after every tick (the adapter's state(): positions, HP, timers …),
+//           hashed to their exact IEEE-754 bits; each block of `every` ticks keeps one hash of its ticks' hashes
+//   view    what a viewer is shown (the adapter's view(): a wire snapshot), hashed at the end of every block and at the
+//           end of the run
+//   deep    the hidden state (the adapter's deep(): every value reachable from the units), hashed every `deepEvery`
+//           ticks (a multiple of `every`; the walk is costly) and at the end of the run
+//   result  the outcome's digest (the adapter's result())
+// A run elsewhere is compared with a reference run (Node) block by block: the first block that differs, at any level,
+// says when the two parted; a dump of that block's state vectors from both sides then names the first field that
+// differs (diffDumps).
+//
+// Integer operations only (Math.imul, shifts) over the numbers' bits: the hashes are the same in every engine. NaN is
+// hashed as one value (engines may keep different NaN payloads).
+//
+// Written for Stronghold Protocol (GPL-3.0-or-later) and Duel Channel (AGPL-3.0-or-later) by the same author, and kept
+// the same in both. No dependencies; Node and browsers.
+
+const DV = new DataView(new ArrayBuffer(8));
+const rotl = (x, r) => (x << r) | (x >>> (32 - r));
+// murmur3's block mix and finaliser
+function mix(h, k) {
+  k = Math.imul(k, 0xcc9e2d51); k = rotl(k, 15); k = Math.imul(k, 0x1b873593);
+  h ^= k; h = rotl(h, 13);
+  return (Math.imul(h, 5) + 0xe6546b64) | 0;
+}
+function fmix(h) {
+  h ^= h >>> 16; h = Math.imul(h, 0x85ebca6b); h ^= h >>> 13; h = Math.imul(h, 0xc2b2ae35); h ^= h >>> 16;
+  return h >>> 0;
+}
+// the kind of an object by its tag, not instanceof: a simulation may run in another realm (a Node VM context) than the
+// hashing code, with its own Map / Set constructors
+const tag = (v) => Object.prototype.toString.call(v);
+const isList = (v) => Array.isArray(v) || (ArrayBuffer.isView(v) && tag(v) !== '[object DataView]');
+const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+
+/** A 32-bit hash fed with words, numbers (their bits), strings and plain values. */
+class Hash {
+  constructor(seed = 0x9747b28c) { this.h = seed | 0; this.n = 0; }
+  word(w) { this.h = mix(this.h, w | 0); this.n++; return this; }
+  num(x) {
+    if (x !== x) return this.word(0x7ff80000).word(0);
+    DV.setFloat64(0, x, true);
+    return this.word(DV.getUint32(0, true)).word(DV.getUint32(4, true));
+  }
+  str(s) { this.word(0x5354 ^ s.length); for (let i = 0; i < s.length; i++) this.word(s.charCodeAt(i)); return this; }
+  // null / undefined / booleans / numbers / strings / arrays / plain objects (keys in their own order, which is the
+  // order the same code created them in, in any engine)
+  value(v, depth = 0) {
+    if (v === null || v === undefined) return this.word(v === null ? 0x6e756c6c : 0x756e6466);
+    switch (typeof v) {
+      case 'number': return this.num(v);
+      case 'string': return this.str(v);
+      case 'boolean': return this.word(v ? 0x74727565 : 0x66616c73);
+      case 'bigint': return this.str(v.toString());
+      case 'object': break;
+      default: return this.word(0x66756e63);
+    }
+    if (depth > 32) return this.word(0x64656570);
+    if (isList(v)) { this.word(0x41525259 ^ v.length); for (const x of v) this.value(x, depth + 1); return this; }
+    const keys = Object.keys(v);
+    this.word(0x4f424a54 ^ keys.length);
+    for (const k of keys) { this.str(k); this.value(v[k], depth + 1); }
+    return this;
+  }
+  done() { return fmix(this.h ^ this.n); }
+}
+
+const hex = (u) => (u >>> 0).toString(16).padStart(8, '0');
+/** The hash of a list of numbers (a state vector). */
+function hashNumbers(v) { const h = new Hash(); for (let i = 0; i < v.length; i++) h.num(v[i]); return h.done(); }
+/** The hash of any plain value. */
+function hashValue(v) { return new Hash().value(v).done(); }
+
+/**
+ * The hash of everything reachable from roots: own properties (non-enumerable too, data properties only), arrays,
+ * typed arrays, Maps, Sets; another root met on the way counts as its index, an object met twice counts once, the keys
+ * in `skip` are left out (references back to shared definitions, process-wide counters …).
+ * @param {object[]} roots @param {{ skip?: Iterable<string>, maxDepth?: number }} [o]
+ */
+function deepHash(roots, { skip = [], maxDepth = 8 } = {}) {
+  const idx = new Map(roots.map((r, i) => [r, i])), seen = new Set(), skipped = new Set(skip), h = new Hash();
+  const walk = (v, depth) => {
+    if (v === null || v === undefined) { h.word(7); return; }
+    const t = typeof v;
+    if (t === 'number') { h.num(v); return; }
+    if (t === 'string') { h.str(v); return; }
+    if (t === 'boolean') { h.word(v ? 3 : 5); return; }
+    if (t !== 'object' || depth > maxDepth) return;
+    if (depth > 0 && idx.has(v)) { h.word(0x55550000 + idx.get(v)); return; }
+    if (seen.has(v)) { h.word(11); return; }
+    seen.add(v);
+    if (isList(v)) { h.word(v.length); for (const x of v) walk(x, depth + 1); return; }
+    const kind = tag(v);
+    if (kind === '[object Map]') { h.word(v.size); for (const [k, x] of v) { walk(k, depth + 1); walk(x, depth + 1); } return; }
+    if (kind === '[object Set]') { h.word(v.size); for (const x of v) walk(x, depth + 1); return; }
+    for (const k of Object.getOwnPropertyNames(v)) {
+      if (skipped.has(k)) continue;
+      const d = Object.getOwnPropertyDescriptor(v, k);
+      if (!d || !('value' in d) || typeof d.value === 'function') continue;
+      h.str(k); walk(d.value, depth + 1);
+    }
+  };
+  for (const r of roots) walk(r, 0);
+  return h.done();
+}
+
+/**
+ * A run of one scenario, traced as it goes; advance() runs it for a time budget (a page stays responsive), finish()
+ * gives the trace. The adapter:
+ *   start(scenario) → run;  step(run) → true when a tick was simulated, false when the run is over;
+ *   state(run) → number[] (after every tick);  labels?(run) → string[] (the names of state's entries, for dumps);
+ *   view?(run) → plain value;  deep?(run) → uint32;  result(run) → string;  maxTicks? (a runaway guard)
+ * dump: [first, last] ticks whose state vectors (and labels) are kept.
+ */
+function tracer(adapter, scenario, { every = 30, deepEvery = every * 5, dump = null } = {}) {
+  const run = adapter.start(scenario), max = adapter.maxTicks || 1e6;
+  let t = 0, block = new Hash(), over = false;
+  const blocks = [], views = [], deeps = [], dumps = {};
+  const sample = (end) => {
+    if (adapter.view) views.push(hashValue(adapter.view(run)));
+    if (adapter.deep && (end || t % deepEvery === 0)) deeps.push(adapter.deep(run) >>> 0);
+  };
+  return {
+    get ticks() { return t; },
+    get done() { return over; },
+    advance(budgetMs = Infinity) {
+      const until = budgetMs === Infinity ? Infinity : now() + budgetMs;
+      while (!over) {
+        if (t >= max || !adapter.step(run)) {
+          over = true;
+          if (t % every) { blocks.push(block.done()); sample(true); } else if (adapter.deep && t % deepEvery) deeps.push(adapter.deep(run) >>> 0);
+          break;
+        }
+        t++;
+        const s = adapter.state(run);
+        block.word(hashNumbers(s));
+        if (dump && t >= dump[0] && t <= dump[1]) dumps[t] = { state: Array.from(s, (x) => (x !== x ? 'NaN' : x)), labels: adapter.labels ? adapter.labels(run) : null };
+        if (t % every === 0) { blocks.push(block.done()); block = new Hash(); sample(false); }
+        if ((t & 31) === 0 && now() > until) break;
+      }
+      return over;
+    },
+    finish() {
+      while (!over) this.advance();
+      return { ticks: t, blocks: blocks.map(hex).join(''), views: views.map(hex).join(''), deeps: deeps.map(hex).join(''), result: String(adapter.result(run)), ...(dump ? { dumps } : {}) };
+    },
+  };
+}
+/** A whole run's trace (see tracer). */
+function trace(adapter, scenario, opts) { return tracer(adapter, scenario, opts).finish(); }
+
+const firstDiff = (a = '', b = '') => {
+  const n = Math.max(a.length, b.length);
+  for (let i = 0; i < n; i += 8) if (a.slice(i, i + 8) !== b.slice(i, i + 8)) return i / 8;
+  return -1;
+};
+/**
+ * A trace against its reference. ok, or: `at` — where they first parted (level 'state' / 'view' / 'deep', the block,
+ * its ticks [from, to]); `result` — the outcomes differ; `ticks` — the runs' lengths differ. The level whose difference
+ * shows first is the one reported — by the tick it is seen at (a block's or a sample's last tick; a deep sample covers
+ * deepEvery ticks), the finer level on a tie; a run whose state never differs but whose view does still counts.
+ */
+function compare(ref, got, every = 30, deepEvery = every * 5) {
+  if (!ref) return { ok: false, missing: true };
+  let at = null;
+  for (const level of ['state', 'view', 'deep']) {
+    const key = level === 'state' ? 'blocks' : level === 'view' ? 'views' : 'deeps', span = level === 'deep' ? deepEvery : every;
+    const i = firstDiff(ref[key], got[key]);
+    if (i < 0) continue;
+    const to = Math.min((i + 1) * span, Math.max(ref.ticks, got.ticks));
+    if (!at || to < at.to) at = { level, block: i, from: i * span + 1, to };
+  }
+  const result = ref.result !== got.result, ticks = ref.ticks !== got.ticks;
+  return { ok: !at && !result && !ticks, at, result, ticks: ticks ? [ref.ticks, got.ticks] : null };
+}
+/** How bad a comparison is, for sorting and summaries: 3 the outcome differs, 2 what viewers see, 1 only inside. */
+function severity(c) {
+  if (c.ok) return 0;
+  if (c.missing || c.result || c.ticks) return 3;
+  return c.at && c.at.level !== 'deep' ? 2 : 1;
+}
+
+const bitsOf = (x) => {
+  if (x === 'NaN') return 'NaN';
+  DV.setFloat64(0, x, true);
+  return hex(DV.getUint32(4, true)) + hex(DV.getUint32(0, true));
+};
+/**
+ * Two dumps of the same ticks (tracer `dump`) compared field by field: the differences in tick order, each with the
+ * tick, the entry's index and label, both values and their bits. Stops after `limit`.
+ */
+function diffDumps(a, b, limit = 20) {
+  const out = [];
+  const ticks = [...new Set([...Object.keys(a || {}), ...Object.keys(b || {})])].map(Number).sort((x, y) => x - y);
+  for (const t of ticks) {
+    const x = a[t], y = b[t];
+    if (!x || !y) { out.push({ tick: t, index: -1, label: x ? 'missing on the other side' : 'missing in the reference' }); if (out.length >= limit) break; continue; }
+    const n = Math.max(x.state.length, y.state.length);
+    for (let i = 0; i < n && out.length < limit; i++) {
+      const p = x.state[i], q = y.state[i];
+      if (p === q || (p !== undefined && q !== undefined && bitsOf(p) === bitsOf(q))) continue;
+      out.push({ tick: t, index: i, label: (x.labels && x.labels[i]) || (y.labels && y.labels[i]) || `#${i}`, ref: p, got: q, refBits: p === undefined ? '' : bitsOf(p), gotBits: q === undefined ? '' : bitsOf(q) });
+    }
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+const VERSION = 1;
+export { VERSION, Hash, hex, hashNumbers, hashValue, deepHash, tracer, trace, compare, severity, diffDumps };

public/dev/simcheck/node.mjs

@@ -0,0 +1,102 @@
+// simcheck's Node side: the reference (every scenario traced in Node, core.js), headless runs of the check page in
+// several engines, and the field-by-field comparison of a dump a browser downloaded with Node's run of the same ticks.
+// Engines: Playwright's chromium / firefox / webkit when the `playwright` package is installed (its browsers fetched
+// with `npx playwright install firefox webkit`), else a local Chrome through puppeteer-core ($CHROME_PATH or the usual
+// install paths).
+//
+// Written for Stronghold Protocol (GPL-3.0-or-later) and Duel Channel (AGPL-3.0-or-later) by the same author, and kept
+// the same in both.
+import { existsSync, readFileSync } from 'node:fs';
+import { tracer, diffDumps, VERSION } from './core.js';
+
+/**
+ * Trace every scenario in Node: the reference a page compares with.
+ * @param {object} adapter @param {{ id: string }[]} scenarios
+ * @param {{ every?: number, project: string, made?: object, onProgress?: (i: number, n: number, id: string) => void }} o
+ */
+export function buildReference(adapter, scenarios, { every = 30, deepEvery = every * 5, project, made = {}, onProgress } = {}) {
+  const out = {};
+  scenarios.forEach((sc, i) => {
+    if (onProgress) onProgress(i, scenarios.length, sc.id);
+    const { ticks, blocks, views, deeps, result } = tracer(adapter, sc, { every, deepEvery }).finish();
+    out[sc.id] = { ticks, blocks, views, deeps, result };
+  });
+  return { simcheck: VERSION, project, every, deepEvery, made: { engine: `Node ${process.version}`, date: new Date().toISOString().slice(0, 10), ...made }, scenarios: out };
+}
+
+const CHROMES = [process.env.CHROME_PATH, 'C:/Program Files/Google/Chrome/Application/chrome.exe', 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser'];
+async function tryImport(name) { try { return await import(name); } catch { return null; } }
+
+/**
+ * Open the check page (url, with ?auto=1 and the subset) in each engine and wait for its results.
+ * @param {string} url @param {string[]} engines 'chromium' | 'firefox' | 'webkit' | 'chrome' (a local Chrome)
+ * @returns {Promise<Record<string, { version?: string, status: string, summary?: object, results?: object[], report?: string, error?: string }>>}
+ */
+export async function runEngines(url, engines, { timeoutMs = 30 * 60000, log = () => {} } = {}) {
+  const pw = await tryImport('playwright'), pp = pw ? null : await tryImport('puppeteer-core');
+  const out = {};
+  for (const name of engines) {
+    let browser = null;
+    try {
+      if (pw && pw[name === 'chrome' ? 'chromium' : name]) {
+        const type = pw[name === 'chrome' ? 'chromium' : name], exe = CHROMES.find((p) => p && existsSync(p));
+        // chromium / chrome: Playwright's own build when it is installed, else the local Chrome
+        try { browser = await type.launch(name === 'chrome' && exe ? { executablePath: exe } : {}); } catch (e) {
+          if (type !== pw.chromium || !exe) throw e;
+          browser = await type.launch({ executablePath: exe });
+        }
+      } else if (pp && (name === 'chrome' || name === 'chromium')) {
+        const exe = CHROMES.find((p) => p && existsSync(p));
+        if (!exe) throw new Error('no Chrome found: set CHROME_PATH');
+        browser = await (pp.default || pp).launch({ executablePath: exe, headless: true });
+      } else throw new Error(pw ? `playwright has no ${name}` : `${name} needs the playwright package (npm i -D playwright && npx playwright install ${name})`);
+      const page = await browser.newPage();
+      const errors = [];
+      page.on('pageerror', (e) => errors.push(String(e.message || e)));
+      await page.goto(url, { timeout: 120000 });
+      const t0 = Date.now();
+      let last = -1;
+      for (;;) {
+        const st = await page.evaluate(() => { const s = globalThis.__simcheck; return s ? { status: s.status, n: s.results.length } : null; });
+        if (st && (st.status === 'done' || st.status === 'stopped')) break;
+        if (errors.length && !st) throw new Error(errors.join('; '));
+        if (st && st.n !== last && st.n % 25 === 0) { log(`  ${name}: ${st.n}`); last = st.n; }
+        if (Date.now() - t0 > timeoutMs) throw new Error('timed out');
+        await new Promise((r) => setTimeout(r, 1000));
+      }
+      const res = await page.evaluate(() => { const s = globalThis.__simcheck; return { status: s.status, summary: s.summary, results: s.results, report: s.report }; });
+      out[name] = { version: browser.version ? await browser.version() : '', ...res, errors };
+    } catch (e) {
+      out[name] = { status: 'error', error: String(e && e.message || e) };
+    } finally { if (browser) await browser.close().catch(() => {}); }
+  }
+  return out;
+}
+
+/**
+ * A dump a browser downloaded (the page's 下载这一段的状态) against Node's run of the same ticks: the differing entries,
+ * first ones first, as printable lines.
+ * @param {string} file @param {object} adapter @param {{ id: string }[]} scenarios
+ */
+export function diffDumpFile(file, adapter, scenarios, { every = 30, deepEvery = every * 5, limit = 20 } = {}) {
+  const d = JSON.parse(readFileSync(file, 'utf8'));
+  const sc = scenarios.find((s) => s.id === d.id);
+  if (!sc) return [`no scenario ${d.id} here`];
+  const ref = tracer(adapter, sc, { every, deepEvery, dump: d.window }).finish();
+  const diffs = diffDumps(ref.dumps, d.dumps, limit);
+  const lines = [`${d.id}, ticks ${d.window[0]}–${d.window[1]}: Node ${process.version} vs ${d.engine}`];
+  if (!diffs.length) lines.push('  the same in every entry of these ticks (the difference is in what the state vector does not hold: view / deep)');
+  for (const x of diffs) lines.push(x.index < 0 ? `  tick ${x.tick}: ${x.label}` : `  tick ${x.tick} ${x.label}: ${x.ref} (${x.refBits}) vs ${x.got} (${x.gotBits})`);
+  return lines;
+}
+
+/** One line per engine for a console. */
+export function formatEngines(res) {
+  return Object.entries(res).map(([name, r]) => {
+    if (r.status === 'error') return `${name}: error — ${r.error}`;
+    const s = r.summary || {};
+    const bad = (r.results || []).filter((x) => !x.c.ok).map((x) => x.id);
+    return `${name} ${r.version || ''}: ${s.ok}/${s.n} the same${bad.length ? ` — different: ${bad.slice(0, 12).join(', ')}${bad.length > 12 ? ' …' : ''}` : ''}${r.errors && r.errors.length ? ` (page errors: ${r.errors.length})` : ''}`;
+  });
+}

public/dev/simcheck/stronghold.js

@@ -0,0 +1,62 @@
+// Stronghold Protocol's battles for simcheck (core.js): the golden battle corpus — tools/golden.mjs's families roster,
+// bonds, fields, standins and diy (its matches are not single battles) — as BattleSpecs (written by
+// tools/sim-check.mjs), each built with /sim/spec.js createBattleFromSpec as the browser runner does
+// (public/js/battle/runner.js) and stepped tick by tick; a field battle stops at its golden cap like the corpus.
+//   state  after every tick: the battle time, the RNG state and per unit FIELDS (exact bits)
+//   view   b.snapshot(): what viewers are sent
+//   deep   every value reachable from the units, the definitions and the process-wide sequence numbers left out
+//   result resultDigest(b.result()).hash: what the server's SP_VERIFY compares
+// The page (sim-check.js) and the tool (tools/sim-check.mjs) both use it, with the sim and its data loaded their way.
+import { deepHash } from './core.js';
+
+/** The data files the sim reads: public/js/battle/runner.js SIM_DATA_FILES (test/sim/simcheck.test.js keeps them equal). */
+export const SIM_DATA_FILES = Object.freeze(['chess', 'enemies', 'tokens', 'stages', 'waves', 'bonds', 'items', 'garrisons', 'bands', 'effects', 'backups']);
+/** Per unit in the state vector. */
+export const FIELDS = Object.freeze(['alive', 'removed', 'deployed', 'x', 'y', 'hp', 'atkCd', 'sp', 'burn', 'neural', 'necrosis', 'apoptosis', 'erosion',
+  'dmg', 'taken', 'heal', 'blocking']);
+// left out of the deep state: references back to definitions and the battle, and buffs.js's process-wide `seq` (it
+// depends on what ran before in the same page or process)
+const DEEP_SKIP = Object.freeze(['def', 'profile', 'kit', 'battle', 'b', 'seq']);
+const QUIET = Object.freeze({ error() {}, warn() {}, info() {}, debug() {} });
+
+/** The scenario list of a specs document: id, golden family, in the fast subset. */
+export const scenariosOf = (doc) => doc.specs.map((s) => ({ id: s.id, family: s.fam, fast: s.fast }));
+
+/**
+ * @param {{ spec: { createBattleFromSpec: Function, resultDigest: Function }, ds: object, doc: { specs: object[] }, logger?: object }} o
+ *   spec: the /sim/spec.js module; ds: a simdata DataSource over SIM_DATA_FILES; doc: the specs document
+ */
+export function strongholdAdapter({ spec, ds, doc, logger = QUIET }) {
+  const byId = new Map(doc.specs.map((s) => [s.id, s]));
+  return {
+    maxTicks: 200000,
+    start(sc) {
+      const s = byId.get(sc.id);
+      return { b: spec.createBattleFromSpec(s.spec, ds, { logger }), cap: s.cap ?? null };
+    },
+    step(r) {
+      const b = r.b;
+      if (b.finished) return false;
+      if (r.cap != null && b.time >= r.cap - 1e-9) { b.forceEnd('forced'); return false; }
+      b.step();
+      return true;
+    },
+    state(r) {
+      const b = r.b, v = [b.time, b.rng.state() >>> 0];
+      for (const u of b.units) {
+        const e = u.elem || {}, s = u.stats || {};
+        v.push(u.alive ? 1 : 0, u.removed ? 1 : 0, u.deployed ? 1 : 0, u.x, u.y, u.hp, u.atkCd, u.skill && u.skill.sp != null ? u.skill.sp : -1,
+          e.burn ?? 0, e.neural ?? 0, e.necrosis ?? 0, e.apoptosis ?? 0, e.erosion ?? 0, s.dmg ?? 0, s.taken ?? 0, s.heal ?? 0, (u.blocking || []).length);
+      }
+      return v;
+    },
+    labels(r) {
+      const out = ['time', 'rng'];
+      for (const u of r.b.units) { const name = `${u.side === 'enemy' ? 'enemy' : 'ally'} ${u.defId}#${u.id}`; for (const f of FIELDS) out.push(`${name}.${f}`); }
+      return out;
+    },
+    view(r) { return r.b.snapshot(); },
+    deep(r) { return deepHash(r.b.units, { skip: DEEP_SKIP }); },
+    result(r) { return spec.resultDigest(r.b.result()).hash; },
+  };
+}

public/dev/simcheck/ui.js

@@ -0,0 +1,206 @@
+// simcheck's page: runs a corpus of scenarios in this browser, compares every run with the reference made in Node
+// (core.js compare) and says which ones parted, when, and how badly — the outcome, what viewers see, or only the
+// hidden state. For a run that parted, the state vectors of the block where it parted can be downloaded and compared
+// field by field with Node's (the project's tool, `--diff`). The summary can be copied as a report.
+// Plain DOM, no framework; colours from CSS variables (--sc-*), so a page can wear its project's theme. Headless
+// drivers read window.__simcheck ({ status, results, summary, report }) and may pass ?subset=<id>&auto=1 (&only=a,b).
+//
+// Written for Stronghold Protocol (GPL-3.0-or-later) and Duel Channel (AGPL-3.0-or-later) by the same author, and kept
+// the same in both.
+import { tracer, compare, severity, VERSION } from './core.js';
+
+const TEXT = {
+  run: '开始检查', stop: '停止', subset: '范围', scenarios: (n) => `${n} 场`,
+  idle: '准备好了。检查只在本机进行，不会上传任何数据。',
+  running: (i, n, id) => `正在检查 ${i} / ${n}：${id}`, stopped: '已停止', done: (n, t) => `完成：${n} 场，用时 ${t}`,
+  ok: '一致', bad: '不一致', result: '结果不同', view: '画面不同', state: '状态不同', deep: '仅内部状态不同', ticks: '长度不同', missing: '参考里没有',
+  where: (c, hz) => `第 ${(c.at.from / hz).toFixed(1)} 秒起（第 ${c.at.from}–${c.at.to} 帧）${({ state: '状态', view: '画面', deep: '内部状态' })[c.at.level]}不同`,
+  outcome: '结果不同', length: (a, b) => `长度 ${a} → ${b} 帧`,
+  dump: '下载这一段的状态', dumping: '正在记录…',
+  copy: '复制报告', copied: '已复制报告', copyFail: '无法写入剪贴板，请手动复制下面的内容',
+  allOk: '全部一致：这个浏览器算出的战斗与服务器逐位相同。',
+  engine: '这个浏览器', reference: '参考', none: '没有不一致的场次。', error: '运行出错',
+};
+
+const CSS = `
+.sc { --_bg: var(--sc-bg, #101413); --_panel: var(--sc-panel, #171d1b); --_fg: var(--sc-fg, #e6ece9); --_muted: var(--sc-muted, #93a19b);
+  --_line: var(--sc-line, #2a3532); --_accent: var(--sc-accent, #4ed8af); --_ok: var(--sc-ok, #4ed8af); --_warn: var(--sc-warn, #f2c14e);
+  --_bad: var(--sc-bad, #ff6b5e); --_font: var(--sc-font, system-ui, sans-serif); --_mono: var(--sc-mono, ui-monospace, monospace);
+  box-sizing: border-box; max-width: 760px; margin: 0 auto; padding: 16px; color: var(--_fg); font: 14px/1.55 var(--_font); }
+.sc *, .sc *::before, .sc *::after { box-sizing: inherit; }
+.sc h1 { margin: 0 0 4px; font-size: 18px; }
+.sc-sub { margin: 0 0 12px; color: var(--_muted); }
+.sc-info { display: grid; grid-template-columns: max-content 1fr; gap: 2px 12px; margin: 0 0 14px; padding: 10px 12px; background: var(--_panel);
+  border: 1px solid var(--_line); font-size: 13px; }
+.sc-info dt { color: var(--_muted); } .sc-info dd { margin: 0; overflow-wrap: anywhere; }
+.sc-controls { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin: 0 0 12px; }
+.sc button, .sc select { font: inherit; color: var(--_fg); background: var(--_panel); border: 1px solid var(--_line); min-height: 40px; padding: 6px 12px; cursor: pointer; }
+.sc button.sc-primary { border-color: var(--_accent); color: var(--_accent); }
+.sc button:disabled { opacity: .5; cursor: default; }
+.sc-bar { height: 6px; background: var(--_panel); border: 1px solid var(--_line); margin: 0 0 6px; }
+.sc-bar i { display: block; height: 100%; width: 0; background: var(--_accent); transition: width .2s; }
+.sc-status { margin: 0 0 12px; color: var(--_muted); min-height: 1.55em; overflow-wrap: anywhere; }
+.sc-sum { display: flex; flex-wrap: wrap; gap: 6px 16px; margin: 0 0 12px; }
+.sc-sum b { font: 600 18px/1 var(--_mono); margin-left: 4px; }
+.sc-sum .is-ok b { color: var(--_ok); } .sc-sum .is-warn b { color: var(--_warn); } .sc-sum .is-bad b { color: var(--_bad); }
+.sc-list { list-style: none; margin: 0 0 12px; padding: 0; display: grid; gap: 6px; }
+.sc-list li { padding: 8px 10px; background: var(--_panel); border-left: 3px solid var(--_warn); overflow-wrap: anywhere; }
+.sc-list li.is-bad { border-left-color: var(--_bad); }
+.sc-list code { font: 13px var(--_mono); }
+.sc-list button { min-height: 32px; padding: 3px 10px; margin-top: 6px; font-size: 13px; }
+.sc-note { color: var(--_muted); font-size: 13px; }
+.sc-allok { color: var(--_ok); }
+.sc textarea { width: 100%; min-height: 160px; margin-top: 8px; background: var(--_panel); color: var(--_fg); border: 1px solid var(--_line);
+  font: 12px/1.5 var(--_mono); padding: 8px; }
+`;
+
+const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+const clock = (ms) => { const s = Math.round(ms / 1000); return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`; };
+// a task boundary that background tabs do not throttle like timers
+const yieldTask = () => new Promise((r) => { const ch = new MessageChannel(); ch.port1.onmessage = () => r(); ch.port2.postMessage(0); });
+
+/** This browser, briefly: the engine family and version. */
+function engineName() {
+  const ua = (typeof navigator !== 'undefined' && navigator.userAgent) || '';
+  const m = (re) => (ua.match(re) || [])[1];
+  if (m(/Edg\/(\d+)/)) return `Edge ${m(/Edg\/(\d+)/)} (Blink)`;
+  if (m(/Firefox\/(\d+)/)) return `Firefox ${m(/Firefox\/(\d+)/)} (Gecko)`;
+  if (/AppleWebKit/.test(ua) && !/Chrome|Chromium|CriOS/.test(ua)) return `Safari ${m(/Version\/([\d.]+)/) || ''} (WebKit)`.replace('  ', ' ');
+  if (m(/CriOS\/(\d+)/)) return `Chrome iOS ${m(/CriOS\/(\d+)/)} (WebKit)`;
+  if (m(/Chrom(?:e|ium)\/(\d+)/)) return `Chrome ${m(/Chrom(?:e|ium)\/(\d+)/)} (Blink)`;
+  return ua || 'unknown';
+}
+
+async function copyText(text) {
+  try { if (navigator.clipboard && globalThis.isSecureContext) { await navigator.clipboard.writeText(text); return true; } } catch { /* the textarea */ }
+  const ta = document.createElement('textarea');
+  ta.value = text; ta.setAttribute('readonly', ''); ta.style.cssText = 'position:fixed;left:-9999px;top:0;font-size:16px';
+  document.body.appendChild(ta);
+  try { ta.focus(); ta.select(); ta.setSelectionRange(0, text.length); return document.activeElement === ta && !!document.execCommand('copy'); } catch { return false; } finally { ta.remove(); }
+}
+function download(name, text) {
+  const a = document.createElement('a');
+  a.href = URL.createObjectURL(new Blob([text], { type: 'application/json' }));
+  a.download = name;
+  document.body.appendChild(a); a.click(); a.remove();
+  setTimeout(() => URL.revokeObjectURL(a.href), 10000);
+}
+
+/**
+ * Mount the check into root.
+ * @param {HTMLElement} root
+ * @param {{ project: string, title: string, subtitle?: string, adapter: object, scenarios: { id: string, family?: string }[],
+ *   subsets: { id: string, label: string, pick: (sc: object) => boolean }[], reference: { every: number, made?: object,
+ *   scenarios: Record<string, object> }, hz?: number, info?: [string, string][], text?: object }} o
+ */
+function mountCheck(root, o) {
+  const T = { ...TEXT, ...(o.text || {}) }, every = o.reference.every || 30, deepEvery = o.reference.deepEvery || every * 5, hz = o.hz || 30;
+  const q = new URLSearchParams(location.search);
+  if (!document.getElementById('sc-style')) { const st = document.createElement('style'); st.id = 'sc-style'; st.textContent = CSS; document.head.appendChild(st); }
+  const engine = engineName(), made = o.reference.made || {};
+  const info = [[T.engine, engine], [T.reference, [made.engine, made.commit, made.date].filter(Boolean).join(' · ') || '—'], ...(o.info || [])];
+  root.classList.add('sc');
+  root.innerHTML = `<h1>${esc(o.title)}</h1>${o.subtitle ? `<p class="sc-sub">${o.subtitle}</p>` : ''}
+    <dl class="sc-info">${info.map(([k, v]) => `<dt>${esc(k)}</dt><dd>${esc(v)}</dd>`).join('')}</dl>
+    <div class="sc-controls"><label>${esc(T.subset)} <select class="sc-subset">${o.subsets.map((s) =>
+      `<option value="${esc(s.id)}">${esc(s.label)} · ${esc(T.scenarios(o.scenarios.filter(s.pick).length))}</option>`).join('')}</select></label>
+      <button class="sc-primary sc-run">${esc(T.run)}</button><button class="sc-stop" hidden>${esc(T.stop)}</button></div>
+    <div class="sc-bar"><i></i></div><p class="sc-status" role="status">${esc(T.idle)}</p>
+    <div class="sc-sum"></div><ol class="sc-list"></ol>
+    <div class="sc-report" hidden><button class="sc-copy">${esc(T.copy)}</button> <span class="sc-note"></span><textarea readonly hidden></textarea></div>`;
+  const $ = (s) => root.querySelector(s);
+  const sel = $('.sc-subset'), runBtn = $('.sc-run'), stopBtn = $('.sc-stop'), bar = $('.sc-bar i'), status = $('.sc-status');
+  if (q.get('subset') && o.subsets.some((s) => s.id === q.get('subset'))) sel.value = q.get('subset');
+  const state = { status: 'idle', results: [], summary: null, report: '' };
+  globalThis.__simcheck = state;
+  let stop = false;
+
+  const summarize = (list) => {
+    const s = { n: list.length, ok: 0, result: 0, view: 0, state: 0, deep: 0 };
+    for (const r of list) {
+      if (r.c.ok) { s.ok++; continue; }
+      if (r.c.missing || r.c.result || r.c.ticks) s.result++;
+      else s[r.c.at.level]++;
+    }
+    return s;
+  };
+  const describe = (r) => {
+    const c = r.c, parts = [];
+    if (c.missing) return T.missing;
+    if (c.error) return `${T.error}：${c.error}`;
+    if (c.at) parts.push(T.where(c, hz));
+    if (c.result) parts.push(T.outcome);
+    if (c.ticks) parts.push(T.length(c.ticks[0], c.ticks[1]));
+    return parts.join('；');
+  };
+  const render = (list, total, elapsed, current) => {
+    const s = summarize(list);
+    bar.style.width = `${total ? (100 * list.length) / total : 0}%`;
+    $('.sc-sum').innerHTML = [[T.ok, s.ok, 'is-ok'], [T.result, s.result, 'is-bad'], [T.view, s.view, 'is-warn'], [T.state, s.state, 'is-warn'], [T.deep, s.deep, 'is-warn']]
+      .map(([k, v, cls]) => `<span class="${v && cls !== 'is-ok' ? cls : cls === 'is-ok' ? cls : ''}">${esc(k)}<b>${v}</b></span>`).join('');
+    const bad = list.filter((r) => !r.c.ok).sort((a, b) => severity(b.c) - severity(a.c));
+    $('.sc-list').innerHTML = bad.map((r, i) => `<li class="${severity(r.c) === 3 ? 'is-bad' : ''}"><code>${esc(r.id)}</code>${r.family ? ` <span class="sc-note">${esc(r.family)}</span>` : ''}<br>${esc(describe(r))}
+      ${r.c.at ? `<br><button data-i="${i}">${esc(T.dump)}</button>` : ''}</li>`).join('');
+    $('.sc-list').querySelectorAll('button[data-i]').forEach((b) => { b.onclick = () => dumpOne(bad[Number(b.dataset.i)], b); });
+    if (current) status.textContent = T.running(list.length + 1, total, current);
+    state.summary = s;
+    return s;
+  };
+  const reportText = (list, subset, elapsed) => {
+    const s = summarize(list), lines = [
+      `simcheck ${VERSION} · ${o.project}`, `${T.engine}：${engine}`, `UA：${(navigator && navigator.userAgent) || ''}`,
+      `${T.reference}：${info[1][1]}`, `${T.subset}：${subset.label} · ${T.scenarios(list.length)} · ${clock(elapsed)}`,
+      `${T.ok} ${s.ok} · ${T.result} ${s.result} · ${T.view} ${s.view} · ${T.state} ${s.state} · ${T.deep} ${s.deep}`];
+    for (const r of list.filter((x) => !x.c.ok).sort((a, b) => severity(b.c) - severity(a.c))) lines.push(`- ${r.id}：${describe(r)}`);
+    return lines.join('\n');
+  };
+  const dumpOne = async (r, btn) => {
+    const old = btn.textContent;
+    btn.disabled = true; btn.textContent = T.dumping;
+    await yieldTask();
+    const tr = tracer(o.adapter, o.scenarios.find((x) => x.id === r.id), { every, deepEvery, dump: [r.c.at.from, r.c.at.to] });
+    while (!tr.advance(25)) await yieldTask();
+    const got = tr.finish();
+    download(`simcheck-${o.project}-${r.id}-${r.c.at.from}.json`, JSON.stringify({ simcheck: VERSION, project: o.project, id: r.id, window: [r.c.at.from, r.c.at.to],
+      engine, ua: navigator.userAgent, dumps: got.dumps }));
+    btn.disabled = false; btn.textContent = old;
+  };
+
+  const run = async () => {
+    const subset = o.subsets.find((s) => s.id === sel.value) || o.subsets[0];
+    const only = q.get('only') ? new Set(q.get('only').split(',')) : null;
+    const list = o.scenarios.filter((sc) => subset.pick(sc) && (!only || only.has(sc.id)));
+    stop = false; runBtn.disabled = true; sel.disabled = true; stopBtn.hidden = false; $('.sc-report').hidden = true;
+    state.status = 'running'; state.results = [];
+    const t0 = performance.now();
+    for (const sc of list) {
+      if (stop) break;
+      render(state.results, list.length, performance.now() - t0, sc.id);
+      await yieldTask();
+      const t1 = performance.now(), tr = tracer(o.adapter, sc, { every, deepEvery });
+      let ok = true;
+      try { while (!tr.advance(25)) { await yieldTask(); if (stop) { ok = false; break; } } } catch (e) { ok = false; state.results.push({ id: sc.id, family: sc.family, c: { ok: false, missing: false, result: true, at: null, error: String(e && e.message || e) }, ms: 0 }); }
+      if (!ok) continue;
+      const got = tr.finish();
+      state.results.push({ id: sc.id, family: sc.family, c: compare(o.reference.scenarios[sc.id], got, every, deepEvery), ms: performance.now() - t1 });
+    }
+    const elapsed = performance.now() - t0, s = render(state.results, list.length, elapsed, null);
+    status.innerHTML = stop ? esc(T.stopped) : s.ok === s.n ? `<span class="sc-allok">${esc(T.allOk)}</span> ${esc(T.done(s.n, clock(elapsed)))}` : esc(T.done(s.n, clock(elapsed)));
+    if (!state.results.some((r) => !r.c.ok)) $('.sc-list').innerHTML = `<li class="sc-note" style="border-left-color:var(--_ok)">${esc(T.none)}</li>`;
+    state.report = reportText(state.results, subset, elapsed);
+    $('.sc-report').hidden = false;
+    runBtn.disabled = false; sel.disabled = false; stopBtn.hidden = true;
+    state.status = stop ? 'stopped' : 'done';
+  };
+  runBtn.onclick = run;
+  stopBtn.onclick = () => { stop = true; };
+  $('.sc-copy').onclick = async () => {
+    const ok = await copyText(state.report), ta = $('.sc-report textarea');
+    $('.sc-report .sc-note').textContent = ok ? T.copied : T.copyFail;
+    ta.hidden = ok; if (!ok) { ta.value = state.report; ta.focus(); ta.select(); }
+  };
+  if (q.get('auto') === '1') run();
+  return state;
+}
+
+export { mountCheck, engineName };

test/sim/simcheck.test.js

@@ -0,0 +1,60 @@
+// The cross-engine check (tools/sim-check.mjs, public/dev/simcheck — docs/SIM.md「11. Tools」): the hashes are pinned
+// (references made before still compare; the same values as the copy of core.js in 争锋频道 / Duel Channel), a change in
+// one tick is found in its block and named by the dump comparison, the deep walk sees another realm's Map / Set, the
+// check page loads the data files the client loads, and the corpus covers the golden battle families, traces a battle
+// the same whatever ran before it, and ends it with the result digest a plain run gives.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import vm from 'node:vm';
+import { readFileSync } from 'node:fs';
+import { hex, hashNumbers, hashValue, deepHash, trace, tracer, compare, diffDumps } from '../../public/dev/simcheck/core.js';
+import { SIM_DATA_FILES, scenariosOf } from '../../public/dev/simcheck/stronghold.js';
+import { corpusSpecs, nodeAdapter, FAMILIES } from '../../tools/sim-check.mjs';
+import { createBattleFromSpec, resultDigest } from '../../server/sim/spec.js';
+import { DataSource, getDefaultSource } from '../../server/sim/simdata.js';
+
+test('simcheck hashes: pinned values, NaN as one value, −0 apart from 0', () => {
+  assert.equal(hex(hashNumbers([0, -0, 1, 0.1, -2.5e-300, 1e300, NaN, Infinity])), '8b3e38ba');
+  assert.equal(hex(hashValue({ a: [1, 'x', null, true], b: { c: 0.5 } })), 'a024c2ef');
+  assert.equal(hex(hashNumbers([NaN])), hex(hashNumbers([0 / 0])));
+  assert.notEqual(hex(hashNumbers([0])), hex(hashNumbers([-0])));
+  assert.equal(hex(deepHash([{ s: new Set([1, 2]), m: new Map([['k', 3]]), arr: [4.5] }])), '92f56136');
+  const other = vm.runInNewContext('({ s: new Set([1, 2]), m: new Map([["k", 3]]), arr: [4.5] })');
+  assert.equal(hex(deepHash([other])), '92f56136', 'another realm\'s Map / Set');
+});
+
+test('simcheck compare: a one-ulp change at tick 45 is found in its block and named by the dumps', () => {
+  const toy = (bump) => ({
+    start: () => ({ n: 0, x: 0.1 }),
+    step: (r) => { if (r.n >= 100) return false; r.n++; r.x = r.x * 1.01 + 0.1; if (bump && r.n === 45) r.x += r.x * Number.EPSILON; return true; },
+    state: (r) => [r.n, r.x], labels: () => ['n', 'x'], view: (r) => ({ x: Math.round(r.x) }), deep: (r) => hashNumbers([r.x]), result: (r) => String(Math.round(r.x)),
+  });
+  const ref = trace(toy(false), { id: 't' });
+  assert.deepEqual(compare(ref, trace(toy(false), { id: 't' })), { ok: true, at: null, result: false, ticks: null });
+  assert.deepEqual(compare(ref, trace(toy(true), { id: 't' })).at, { level: 'state', block: 1, from: 31, to: 60 });
+  const a = tracer(toy(false), { id: 't' }, { dump: [31, 60] }).finish(), b = tracer(toy(true), { id: 't' }, { dump: [31, 60] }).finish();
+  const d = diffDumps(a.dumps, b.dumps);
+  assert.equal(d[0].tick, 45);
+  assert.equal(d[0].label, 'x');
+});
+
+test('simcheck page: the data files are the browser runner\'s', () => {
+  const src = readFileSync(new URL('../../public/js/battle/runner.js', import.meta.url), 'utf8');
+  const m = /export const SIM_DATA_FILES = Object\.freeze\((\[[^\]]*\])\)/.exec(src);
+  assert.ok(m, 'runner.js SIM_DATA_FILES');
+  assert.deepEqual([...SIM_DATA_FILES], JSON.parse(m[1].replace(/'/g, '"')));
+});
+
+test('simcheck corpus: the golden battle families, a battle traced the same whatever ran before, the plain run\'s result', () => {
+  const doc = { specs: corpusSpecs() }, sc = scenariosOf(doc);
+  assert.deepEqual([...new Set(sc.map((s) => s.family))], [...FAMILIES]);
+  assert.equal(new Set(sc.map((s) => s.id)).size, sc.length);
+  assert.ok(sc.some((s) => s.fast) && sc.some((s) => !s.fast));
+  const pick = sc.filter((s) => s.family === 'bonds')[0], other = sc.filter((s) => s.family === 'roster')[0];
+  const alone = trace(nodeAdapter(doc), pick), ad = nodeAdapter(doc);
+  trace(ad, other);
+  assert.deepEqual(trace(ad, pick), alone);
+  const spec = doc.specs.find((s) => s.id === pick.id).spec;
+  const plain = resultDigest(createBattleFromSpec(spec, new DataSource(getDefaultSource().raw, null), { quiet: true }).runToEnd(200000)).hash;
+  assert.equal(alone.result, plain);
+});

tools/sim-check.mjs

@@ -0,0 +1,85 @@
+// The cross-engine check of the battle sim (docs/SIM.md「Cross-engine check」). A browser simulates its battles and
+// the server re-simulates them (SP_VERIFY, takeovers), so every engine must give the same bits as Node. The golden
+// battle corpus traced in Node is the reference; public/dev/sim-check.html runs the corpus in any browser — a desktop
+// or a phone on the LAN — and compares it tick by tick (public/dev/simcheck: core.js, ui.js, stronghold.js).
+//
+//   node tools/sim-check.mjs                    write public/dev/simcheck/data/specs.json (the corpus's BattleSpecs)
+//                                               and reference.json (their Node traces); git-ignored
+//   node tools/sim-check.mjs --engines chromium,firefox,webkit [--subset fast|all|<family>] [--only id,id]
+//                                               then start the server on a free port and run the page headless in each
+//                                               engine; exit 1 when one differs. Firefox and WebKit need the
+//                                               playwright package (npm i -D playwright && npx playwright install
+//                                               firefox webkit); without it `chrome` runs a local Chrome
+//                                               ($CHROME_PATH) through puppeteer-core
+//   node tools/sim-check.mjs --diff <dump.json> the block a browser downloaded (下载这一段的状态) against Node's run of
+//                                               the same ticks, entry by entry
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
+import * as spec from '../server/sim/spec.js';
+import { DataSource, getDefaultSource } from '../server/sim/simdata.js';
+import { APP_VERSION } from '../shared/constants.js';
+import { scenariosOf as goldenScenarios, isFast } from './golden.mjs';
+import { strongholdAdapter, scenariosOf } from '../public/dev/simcheck/stronghold.js';
+import { buildReference, runEngines, formatEngines, diffDumpFile } from '../public/dev/simcheck/node.mjs';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+export const OUT_DIR = join(ROOT, 'public', 'dev', 'simcheck', 'data');
+export const FAMILIES = Object.freeze(['roster', 'bonds', 'fields', 'standins', 'diy']);
+
+/** The golden battle corpus as BattleSpecs, in the corpus's order; a field battle keeps its cap (golden's forceEnd). */
+export function corpusSpecs(families = FAMILIES) {
+  const specs = [];
+  for (const fam of families) {
+    for (const sc of goldenScenarios(fam)) {
+      specs.push({ id: sc.id, fam, fast: isFast(sc), cap: sc.cap ?? null, spec: spec.buildBattleSpec({
+        battleId: sc.id, fieldId: sc.fieldId ?? 'g', kind: sc.kind, seed: sc.seed, modeId: sc.modeId, round: sc.round, stageId: sc.stageId, rect: sc.rect,
+        timeLimit: sc.timeLimit, players: sc.players, spawns: sc.spawns, routes: sc.routes, flags: sc.flags, enemyOverrides: sc.enemyOverrides ?? {},
+        waveId: sc.waveId ?? null, bossId: sc.bossId ?? null, boss: sc.boss ?? null, content: 'full' }) });
+    }
+  }
+  return specs;
+}
+/** The adapter over Node's sim and data (the same files the browser loads: loadBrowserSim reads data/*.json). */
+export function nodeAdapter(doc) {
+  return strongholdAdapter({ spec, ds: new DataSource(getDefaultSource().raw, null), doc });
+}
+const commit = () => { try { return execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: ROOT, encoding: 'utf8' }).trim(); } catch { return ''; } };
+
+async function main(argv) {
+  const opt = (k) => { const i = argv.indexOf(k); return i >= 0 ? argv[i + 1] : null; };
+  if (opt('--diff')) {
+    const doc = JSON.parse(readFileSync(join(OUT_DIR, 'specs.json'), 'utf8'));
+    for (const line of diffDumpFile(opt('--diff'), nodeAdapter(doc), scenariosOf(doc))) console.log(line);
+    return 0;
+  }
+  const t0 = Date.now();
+  const doc = { simcheck: 1, made: { version: APP_VERSION, commit: commit() }, specs: corpusSpecs() };
+  const scenarios = scenariosOf(doc);
+  let last = 0;
+  const reference = buildReference(nodeAdapter(doc), scenarios, {
+    project: 'stronghold', made: { version: APP_VERSION, commit: doc.made.commit },
+    onProgress: (i, n) => { if (Date.now() - last > 2000) { last = Date.now(); process.stdout.write(`\r  ${i} / ${n}`); } },
+  });
+  mkdirSync(OUT_DIR, { recursive: true });
+  writeFileSync(join(OUT_DIR, 'specs.json'), JSON.stringify(doc));
+  writeFileSync(join(OUT_DIR, 'reference.json'), JSON.stringify(reference));
+  console.log(`\r${scenarios.length} battles traced in ${((Date.now() - t0) / 1000).toFixed(1)} s → public/dev/simcheck/data/ (open /dev/sim-check.html)`);
+
+  const engines = opt('--engines');
+  if (!engines) return 0;
+  const { startServer } = await import('../server/index.js');
+  const srv = await startServer({ port: 0, host: '127.0.0.1', quiet: true });
+  try {
+    const q = new URLSearchParams({ auto: '1', subset: opt('--subset') || 'all' });
+    if (opt('--only')) q.set('only', opt('--only'));
+    const res = await runEngines(`http://127.0.0.1:${srv.port}/dev/sim-check.html?${q}`, engines.split(','), { log: (s) => console.log(s) });
+    for (const line of formatEngines(res)) console.log(line);
+    return Object.values(res).every((r) => r.status === 'done' && r.summary && r.summary.ok === r.summary.n) ? 0 : 1;
+  } finally { await srv.close(); }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1] && existsSync(ROOT)) {
+  main(process.argv.slice(2)).then((code) => process.exit(code), (e) => { console.error(e); process.exit(2); });
+}