0.2.6-dev: port PR #416 by Cromemadnd — at every round start the own board's pieces replay their Start clip and landing sound one after another in deployment order (the maintainer's confirmation from official play, 2026-10-13), and a purchase or a move onto / across the board plays them too ([ASSUMED], the PR author's account); one sound per landing, idle prep pieces only, the round marked once the view took the sequence, own board only, timers cleared when prep mode ends and on destroy; DESIGN §31.8; golden: unchanged

test/render/deploy-replay.test.js

@@ -0,0 +1,203 @@
+// test/render/deploy-replay.test.js — PR #416 by @Cromemadnd, ported in 0.2.6 (DESIGN §31.8): a prep piece that lands —
+// the round start's replay of the own board, a purchase, a move onto or across the board — plays its Start clip again
+// with its landing sound (render/units.js UnitView.land → ctx.audio.deployCue), once per landing. Headless fake PIXI
+// (test/render/fakepixi.js). The schedule itself (render/app.js replayDeploys, screens/game.js) runs in the browser check
+// test/ui/deploy-replay.e2e.test.js; the order and the due rule are test/ui/deploy-replay.test.js.
+// Run: node --test test/render/deploy-replay.test.js
+
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { installFakePixi, fakeViewCtx } from './fakepixi.js';
+import { presetCamera } from '../../public/js/render/projection.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+let fake, UnitView, START_CLIP_FALLBACK;
+before(async () => {
+  fake = installFakePixi();
+  ({ UnitView, START_CLIP_FALLBACK } = await import('../../public/js/render/units.js'));
+});
+after(() => fake.restore());
+
+const cam = presetCamera('prep', { width: 1280, height: 720 });
+const ANIMS = ['Idle', 'Start', 'Die', 'Attack'];
+
+/**
+ * A prep (or battle) view of an operator whose model loads when `ready()` is called (`instant`: at once). `start` = the
+ * Start clip's length in the manifest entry (null: the model has no Start clip). Every deployCue is recorded.
+ */
+function rig({ prep = true, side = 'ally', kind = 'op', start = 1, instant = true, info = {} } = {}) {
+  let resolve = null;
+  const anims = { idle: 'Idle', deploy: start == null ? 'Idle' : 'Start', die: 'Die', attack: { begin: null, loop: 'Attack', end: null } };
+  const animations = { Idle: 1, Die: 1, Attack: 1, ...(start == null ? {} : { Start: start }) };
+  const entry = { skel: '/op.skel', atlas: '/op.atlas', textures: ['/op.png'], anims, animations };
+  const data = { animations: ANIMS.filter((n) => start != null || n !== 'Start').map((name) => ({ name })) };
+  const assets = {
+    spineEntry: () => entry, hasBack: () => false,
+    spine: { acquire: () => (instant ? Promise.resolve(data) : new Promise((r) => { resolve = () => r(data); })), release() {} },
+  };
+  const cues = [];
+  const audio = { deployCue: (u, key) => { cues.push({ ...u, key }); return true; } };
+  const ctx = fakeViewCtx(fake.P, { assets, cam: () => cam, audio });
+  const v = new UnitView(ctx, { id: 'p:7', uid: 7, side, kind, defId: 'chess_char_x', spine: 'char_x', tier: 3, x: 5, y: 10, maxHp: 1, dir: 'RIGHT', ...info }, { prep });
+  const tick = async () => { await new Promise((r) => setImmediate(r)); await new Promise((r) => setImmediate(r)); };
+  return { v, cues, advance: (dt) => v.update(dt, cam, dt), ready: async () => { resolve?.(); await tick(); }, tick };
+}
+
+/** Run `fn` with performance.now() reading `t` ms (the landing window is real time). */
+function at(t, fn) {
+  const perf = globalThis.performance;
+  const now = perf.now;
+  perf.now = () => t;
+  try { return fn(); } finally { perf.now = now; }
+}
+
+describe('UnitView.land — the Start clip again and the landing sound, once (PR #416)', () => {
+  test('an idle prep piece lands: Start plays and its landing sound is asked for once, with the piece as the key', async () => {
+    const h = rig();
+    await h.tick();
+    assert.ok(h.v.actor, 'the model is up');
+    h.advance(0.5);
+    assert.equal(h.v.actor.mode, 'base');
+    assert.equal(h.v.land(), true);
+    assert.equal(h.v.actor.mode, 'deploy', 'the Start clip plays');
+    assert.equal(h.v.fadeIn, 0, 'and the piece fades in with it, like a deploy');
+    assert.deepEqual(h.cues, [{ def: 'char_x', defId: 'chess_char_x', kind: 'op', key: 'p:7' }], 'the model id picks the sound, the kind its class');
+    h.v.destroy();
+  });
+
+  test('a second trigger of the same landing changes nothing and sounds nothing; after the clip a new landing plays again', async () => {
+    const h = rig();
+    await h.tick();
+    assert.equal(h.v.land(), true);                 // e.g. bought …
+    h.advance(0.4);
+    assert.equal(h.v.land(), false, '… then moved onto the board while its Start still plays');
+    assert.equal(h.v.actor.mode, 'deploy');
+    assert.ok(Math.abs(h.v.actor.deployElapsed() - 0.4) < 1e-9, 'the clip is not restarted');
+    assert.equal(h.cues.length, 1, 'one landing, one sound');
+    // the round start's replay reaching a piece put down a moment before: the same
+    assert.equal(h.v.deploying(), true);
+    h.advance(0.7);                                   // the 1 s clip is over
+    assert.equal(h.v.actor.mode, 'base');
+    at(globalThis.performance.now() + 5000, () => {
+      assert.equal(h.v.deploying(), false);
+      assert.equal(h.v.land(), true, 'a later landing (another move) plays again');
+    });
+    assert.equal(h.cues.length, 2);
+    h.v.destroy();
+  });
+
+  test('a landing asked before the model has loaded sounds at once and continues by the time gone (0.2.3); no second sound at load', async () => {
+    const h = rig({ instant: false });
+    assert.equal(h.v.actor, null);
+    assert.equal(h.v.land(), true);
+    assert.equal(h.cues.length, 1, 'the sound belongs to the landing, not to the model');
+    h.advance(0.3);
+    assert.equal(h.v.land(), false, 'still landing (owed to the model)');
+    await h.ready();
+    assert.equal(h.v.actor.mode, 'deploy');
+    assert.ok(Math.abs(h.v.actor.deployElapsed() - 0.3) < 1e-9, 'Start continues where the time says');
+    assert.equal(h.cues.length, 1);
+    h.v.destroy();
+  });
+
+  test('a model without a Start clip and a view without a model still land once per clip length', async () => {
+    const h = rig({ start: null });
+    await h.tick();
+    const t0 = 1000;
+    at(t0, () => assert.equal(h.v.land(), true));
+    assert.equal(h.v.actor.mode, 'base', 'nothing to play');
+    at(t0 + 500, () => assert.equal(h.v.land(), false, 'the landing still owns the clip length'));
+    at(t0 + START_CLIP_FALLBACK * 1000 + 1, () => assert.equal(h.v.land(), true));
+    assert.equal(h.cues.length, 2);
+    h.v.destroy();
+    // no manifest entry at all: the fallback length
+    const ctx = fakeViewCtx(fake.P, { assets: null, cam: () => cam, audio: { deployCue: () => true } });
+    const bare = new UnitView(ctx, { id: 'p:8', uid: 8, side: 'ally', kind: 'op', defId: 'chess_char_y', x: 5, y: 10, maxHp: 1 }, { prep: true });
+    assert.equal(bare._startDur(), START_CLIP_FALLBACK);
+    at(t0, () => assert.equal(bare.land(), true));
+    at(t0 + 200, () => assert.equal(bare.land(), false));
+    bare.destroy();
+  });
+
+  test('never pulls a unit out of a battle, an attack, a death or a drag into the Start clip', async () => {
+    // a battle unit (the sim's own 'deploy' events go through onDeploy, which stays silent here)
+    const b = rig({ prep: false });
+    await b.tick();
+    b.advance(0.5);
+    assert.equal(b.v.land(), false);
+    assert.equal(b.v.actor.mode, 'base');
+    b.v.onDeploy();
+    assert.equal(b.v.actor.mode, 'deploy', 'a battle deploy still plays Start');
+    assert.equal(b.cues.length, 0, 'and asks for no sound: audio.handleBattleEvents sounds battle deploys');
+    b.v.destroy();
+    // attacking, dying, dead, lifted, an enemy
+    const a = rig();
+    await a.tick();
+    a.advance(0.5);
+    a.v.onAttack(null, 1, 'none');
+    assert.equal(a.v.actor.mode, 'attack');
+    assert.equal(a.v.land(), false, 'attacking');
+    a.v.die();
+    assert.equal(a.v.land(), false, 'dying');
+    a.v.destroy();
+    assert.equal(a.v.land(), false, 'destroyed');
+    const l = rig();
+    await l.tick();
+    l.v.lift = 0.3;
+    assert.equal(l.v.land(), false, 'lifted by a drag');
+    l.v.lift = 0;
+    assert.equal(l.v.land(), true);
+    l.v.destroy();
+    const e = rig({ side: 'enemy', kind: 'enemy' });
+    await e.tick();
+    assert.equal(e.v.land(), false, 'an enemy (the pen) never lands');
+    e.v.destroy();
+    assert.equal(a.cues.length + e.cues.length, 0);
+    // a hidden tab: nothing would show it, and the clip and the suspended audio would play it stale on return
+    const hid = rig();
+    await hid.tick();
+    globalThis.document.hidden = true;
+    try { assert.equal(hid.v.land(), false, 'hidden'); } finally { delete globalThis.document.hidden; }
+    assert.equal(hid.v.actor.mode, 'base');
+    assert.equal(hid.cues.length, 0);
+    assert.equal(hid.v.land(), true, 'shown again');
+    hid.v.destroy();
+  });
+
+  test('a summon piece lands with its own class; a landing sound that throws never stops the clip', async () => {
+    const t = rig({ kind: 'token', info: { defId: 'token_10000_silent_healrb', spine: 'token_10000_silent_healrb' } });
+    await t.tick();
+    assert.equal(t.v.land(), true);
+    assert.deepEqual(t.cues[0], { def: 'token_10000_silent_healrb', defId: 'token_10000_silent_healrb', kind: 'token', key: 'p:7' });
+    t.v.destroy();
+    const h = rig();
+    await h.tick();
+    h.v.ctx.audio = { deployCue: () => { throw new Error('no audio'); } };
+    assert.equal(h.v.land(), true);
+    assert.equal(h.v.actor.mode, 'deploy');
+    h.v.ctx.audio = null;
+    h.v.destroy();
+  });
+});
+
+test('render/app.js wiring: landings in setPrep, the replay schedule, its timers cleared when prep mode ends and on destroy', () => {
+  const src = readFileSync(path.join(ROOT, 'public/js/render/app.js'), 'utf8');
+  // a purchase (an operator new on the bench), a merge's elite, a piece put on a board tile it was not on
+  assert.match(src, /if \(e\.piece\.kind === 'chess'\) landPiece\(v, 'buy'\);/);
+  assert.match(src, /landPiece\(v, 'merge'\);/);
+  assert.match(src, /if \(was && e\.area === 'board' && \(was\.area !== 'board' \|\| was\.row !== e\.row \|\| was\.col !== e\.col\)[^\n]*landPiece\(v, 'board'\);/);
+  assert.match(src, /const prevAt = new Map\(prepPieces\.map\(\(p\) => \[p\.uid, p\]\)\);/, 'compared with the last state of this prep, not a rebuild');
+  // the replay: prep mode only, the same view, the tab shown, one turn after the other; cancelled by enterBattle,
+  // enterPrepMode and destroy
+  assert.match(src, /function replayDeploys\(uids, gap = DEPLOY_REPLAY_MS\) \{\s*if \(destroyed \|\| mode !== 'prep'/);
+  assert.match(src, /if \(destroyed \|\| mode !== 'prep'\) return;\s*const \{ uid, v \} = queue\[i\+\+\];\s*if \(!globalThis\.document\?\.hidden && views\.get\('p:' \+ uid\) === v\) landPiece\(v, 'round'\);\s*if \(i < queue\.length\) replayTimer = setTimeout\(turn, step\);/);
+  const body = (name) => src.slice(src.indexOf(name), src.indexOf(name) + 900);
+  assert.match(body('function enterBattle(meta)'), /cancelReplay\(\);/);
+  assert.match(body('function enterPrepMode()'), /cancelReplay\(\);/);
+  assert.match(body('    destroy() {\n      if (destroyed) return;'), /cancelReplay\(\);/);
+  assert.match(src, /audio: opts\.audio \|\| null,/, 'the views reach the audio manager');
+});

test/render/playtest6-promote.test.js

@@ -83,6 +83,7 @@ test('render/app.js plays the promotion cue instead of the deploy flash for a me
   assert.match(src, /import \{ promotionsOf \} from '\.\/promote\.js';/);
   assert.match(src, /const before = prepPieces\.length \? prepPieces : promoBase;[\s\S]{0,80}promotionsOf\(before, list, \(id\) => data\.chess\(id\)\)/, 'compared with the previous state');
   assert.match(src, /if \(prepPieces\.length\) promoBase = prepPieces;\s*prepPieces = \[\];/, 'a battle keeps the last prep state: a merge between two preps is cued too (QA 6b)');
-  assert.match(src, /if \(promoFrom\.has\(e\.uid\)\) \{[\s\S]{0,400}fx\.promote\(v,[\s\S]{0,400}\} else if \(e\.area === 'board' && prevBoard\.size && !prevBoard\.has\(e\.uid\)\) \{ v\.onDeploy\?\.\(\); fx\.deploy\(v\); \}/);
+  // (the elite and a new board piece land — the Start clip and its landing sound, PR #416 — and only the latter flashes)
+  assert.match(src, /if \(promoFrom\.has\(e\.uid\)\) \{[\s\S]{0,400}fx\.promote\(v,[\s\S]{0,400}\} else if \(e\.area === 'board' && prevBoard\.size && !prevBoard\.has\(e\.uid\)\) \{ landPiece\(v, 'board'\); fx\.deploy\(v\); \}/);
   assert.match(src, /promotions,/, 'the cue log is exposed on view.debug (E2E)');
 });

test/ui/deploy-replay.e2e.test.js

@@ -0,0 +1,142 @@
+// Browser check of the round start's deploy replay (PR #416 by @Cromemadnd, DESIGN §31.8) on the mock harness
+// (public/dev/game-mock.html) in headless Chrome (puppeteer-core + the system Chrome); opt-in, ~15 s:
+//   SP_E2E=1 node --test test/ui/deploy-replay.e2e.test.js
+//
+// From a settled battle to 回合开始 of the next round, the real game screen (screens/game.js) and Pixi field view
+// (render/app.js) replay the own board's pieces one after another in deployment order — operators by column from the
+// left, top to bottom within a column (sim Battle.start) — each with one landing sound (audio.deployCue, spied); the
+// same round never again (a re-pushed state, the 休整期 that follows), the next round once more. In the 休整期 a purchase
+// lands the bought operator; a move onto the board while that Start still plays sounds nothing more; a later move to
+// another tile lands again; turning in place does not. No console / page errors.
+
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+
+const CHROME = process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const ENABLED = process.env.SP_E2E === '1' && existsSync(CHROME);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** The deployment order, written out independently of ui/gameLogic deployOrder: operators, then summons; col asc, row desc. */
+const expectedOrder = (board) => board.filter((p) => p && (p.kind === 'chess' || p.kind === 'token'))
+  .sort((a, b) => (a.kind === 'chess' ? 0 : 1) - (b.kind === 'chess' ? 0 : 1) || a.col - b.col || b.row - a.row)
+  .map((p) => p.uid);
+
+describe('the round start replays the own board\'s Start clips in deployment order', { skip: !ENABLED && 'set SP_E2E=1 (and have Chrome) to run' }, () => {
+  let srv;
+  let browser;
+  let base;
+  before(async () => {
+    const { startServer } = await import('../../server/index.js');
+    const puppeteer = (await import('puppeteer-core')).default;
+    srv = await startServer({ port: 0, host: '127.0.0.1', quiet: true });
+    await srv.assetIndex?.whenReady();
+    base = `http://127.0.0.1:${srv.port}`;
+    browser = await puppeteer.launch({ executablePath: CHROME, headless: true, args: ['--no-sandbox'] });
+  });
+  after(async () => {
+    await browser?.close();
+    await srv?.close();
+  });
+
+  test('SETTLE → 回合开始: one landing per piece, in order and 50 ms apart; once per round; purchases and moves land once', async () => {
+    const page = await browser.newPage();
+    await page.setViewport({ width: 1600, height: 900 });
+    const problems = [];
+    page.on('console', (m) => { if (m.type() === 'error') problems.push(`console: ${m.text()}`); });
+    page.on('pageerror', (e) => problems.push(`pageerror: ${e.message}`));
+    await page.goto(`${base}/dev/game-mock.html?shot=1&render=engine&phase=SETTLE`, { waitUntil: 'networkidle0', timeout: 60000 });
+    await page.waitForFunction(() => globalThis.__SP_VIEW__?.kind === 'engine' && globalThis.__SP_VIEW__.raw.mode === 'battle', { timeout: 20000 });
+    // spy on the landing sound (the view's ctx.audio is this very manager) and stop the mock battle's stream
+    await page.evaluate(async () => {
+      const { audio } = await import('/js/audio.js');
+      const cues = globalThis.__cues = [];
+      const real = audio.deployCue.bind(audio);
+      audio.deployCue = (info, key) => { cues.push({ key, at: performance.now() }); return real(info, key); };
+    });
+    const landings = (why) => page.evaluate((w) => globalThis.__SP_VIEW__.raw.debug.landings.filter((l) => !w || l.why === w).map((l) => ({ ...l })), why);
+    const toPhase = (phase, round) => page.evaluate((ph, r) => globalThis.__MOCK__.mutate((S) => {
+      if (S.battle?.timer) clearInterval(S.battle.timer);
+      S.battle = null;
+      S.pub.phase = ph; S.pub.round = r; S.pub.deadline = Date.now() + (ph === 'ROUND_START' ? 2000 : 60000);
+      S.priv.ready = false;
+    }), phase, round);
+
+    // ---- 回合开始 of round 7: the board replays in deployment order
+    const board = await page.evaluate(() => JSON.parse(JSON.stringify(globalThis.__MOCK__.S().priv.board)));
+    const order = expectedOrder(board);
+    assert.ok(order.length >= 5, `the mock board has pieces (${order.length})`);
+    const t0 = await page.evaluate(() => performance.now());
+    await toPhase('ROUND_START', 7);
+    await page.waitForFunction((n) => globalThis.__SP_VIEW__.raw.debug.landings.filter((l) => l.why === 'round').length >= n, { timeout: 5000 }, order.length);
+    // the last piece's Start is playing right now (on its model, or owed to one still loading)
+    const lastPlaying = await page.evaluate((uid) => globalThis.__SP_VIEW__.raw.debug.views.get(`p:${uid}`)?.deploying(), order.at(-1));
+    const round7 = await landings('round');
+    assert.deepEqual(round7.map((l) => l.uid), order, 'every operator once, in deployment order (by column from the left, top to bottom)');
+    assert.equal(await page.evaluate(() => globalThis.__SP_VIEW__.raw.mode), 'prep');
+    assert.ok(round7[0].at >= t0, 'scheduled by this round start');
+    for (let i = 1; i < round7.length; i++) {
+      const gap = round7[i].at - round7[i - 1].at;
+      assert.ok(gap >= 35 && gap < 400, `one after another, ~50 ms apart (${gap.toFixed(1)} ms between #${i - 1} and #${i})`);
+    }
+    assert.equal(lastPlaying, true, 'the piece is in its Start clip when it lands');
+    const cues7 = await page.evaluate(() => globalThis.__cues.map((c) => c.key));
+    assert.deepEqual(cues7, order.map((uid) => `p:${uid}`), 'one landing sound per piece, in the same order');
+
+    // ---- the same round again: a re-pushed state (a reconnect's resync, a re-render) and the 休整期 that follows replay nothing
+    await page.evaluate(() => { globalThis.__MOCK__.pushPublic(); globalThis.__MOCK__.mutate(() => {}); });
+    await sleep(600);
+    await toPhase('PREP', 7);
+    await sleep(800);
+    assert.equal((await landings('round')).length, order.length, 'round 7 replayed once');
+    assert.equal(await page.evaluate(() => globalThis.__cues.length), order.length, 'and sounded once per piece');
+
+    // ---- a purchase lands the bought operator; a move onto the board during its Start sounds nothing more
+    const slot = await page.evaluate(() => globalThis.__MOCK__.S().priv.shop.slots.findIndex((s) => s && s.kind === 'chess' && !s.sold));
+    assert.ok(slot >= 0, 'the shop offers an operator');
+    await page.evaluate(() => globalThis.__MOCK__.mutate((S) => { S.priv.funds = 99; }));
+    await page.evaluate(async (i) => { const { net } = await import('/js/net.js'); await net.request('g.buy', { slot: i }); }, slot);
+    await page.waitForFunction(() => globalThis.__SP_VIEW__.raw.debug.landings.some((l) => l.why === 'buy'), { timeout: 4000 });
+    const bought = (await landings('buy')).at(-1).uid;
+    const inHand = await page.evaluate((uid) => globalThis.__MOCK__.S().priv.hand.some((p) => p && p.uid === uid), bought);
+    assert.ok(inHand, 'the landing is the bought piece on the bench');
+    const free = await page.evaluate(() => {
+      const S = globalThis.__MOCK__.S();
+      const used = new Set(S.priv.board.map((p) => `${p.row},${p.col}`));
+      const dt = S.stage.deployTiles.normal;
+      return [...dt.melee, ...dt.rangedOnly].filter(([r, c]) => !used.has(`${r},${c}`)).slice(0, 2);
+    });
+    assert.equal(free.length, 2, 'two free deploy tiles');
+    const move = (uid, [row, col], dir = 'RIGHT') => page.evaluate(async (u, r, c, d) => {
+      const { net } = await import('/js/net.js');
+      await net.request('g.move', { uid: u, to: { area: 'board', row: r, col: c }, dir: d });
+    }, uid, row, col, dir);
+    const cuesOf = (uid) => page.evaluate((k) => globalThis.__cues.filter((c) => c.key === k).length, `p:${uid}`);
+    await move(bought, free[0]);
+    await sleep(300);
+    assert.equal(await page.evaluate((uid) => globalThis.__MOCK__.S().priv.board.some((p) => p.uid === uid), bought), true, 'it is on the board');
+    assert.equal(await cuesOf(bought), 1, 'bought and moved within one Start clip: one landing sound');
+    // a later move to another tile lands again; turning in place does not
+    await sleep(1400);
+    await move(bought, free[1]);
+    await page.waitForFunction((uid) => globalThis.__SP_VIEW__.raw.debug.landings.some((l) => l.why === 'board' && l.uid === uid), { timeout: 4000 }, bought);
+    assert.equal(await cuesOf(bought), 2, 'a move to another tile is a new landing');
+    await sleep(1400);
+    await move(bought, free[1], 'UP');
+    await sleep(600);
+    assert.equal(await cuesOf(bought), 2, 'turning in place is no landing');
+    assert.equal((await landings('round')).length, order.length, 'the 休整期 never replays the round start');
+
+    // ---- the next round replays again (with the bought operator in its place in the order)
+    await toPhase('SETTLE', 7);
+    await sleep(300);
+    const board8 = await page.evaluate(() => JSON.parse(JSON.stringify(globalThis.__MOCK__.S().priv.board)));
+    await toPhase('ROUND_START', 8);
+    const order8 = expectedOrder(board8);
+    await page.waitForFunction((n) => globalThis.__SP_VIEW__.raw.debug.landings.filter((l) => l.why === 'round').length >= n, { timeout: 5000 }, order.length + order8.length);
+    const round8 = (await landings('round')).slice(order.length).map((l) => l.uid);
+    assert.deepEqual(round8, order8, 'round 8 replays its board in deployment order');
+    await page.close();
+    assert.deepEqual(problems, []);
+  });
+});

test/ui/deploy-replay.test.js

@@ -0,0 +1,130 @@
+// test/ui/deploy-replay.test.js — PR #416 by @Cromemadnd, ported in 0.2.6 (DESIGN §31.8): the round start replays the own
+// board's Start clips in deployment order (ui/gameLogic deployOrder / roundStartReplay — the maintainer's confirmation from
+// official play, 2026-10-13), and a landing sounds like the piece's battle deployment through the SFX channel
+// (public/js/audio.js deployCue). The view side is test/render/deploy-replay.test.js, the browser check
+// test/ui/deploy-replay.e2e.test.js.
+// Run: node --test test/ui/deploy-replay.test.js
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { deployOrder, roundStartReplay } from '../../public/js/ui/gameLogic.js';
+import { AudioManager, deploySfxUrl } from '../../public/js/audio.js';
+import { PHASE } from '../../shared/constants.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const manifest = JSON.parse(readFileSync(path.join(ROOT, 'data', 'assets.json'), 'utf8'));
+const chess = (uid, row, col, extra = {}) => ({ uid, kind: 'chess', id: `chess_${uid}`, row, col, ...extra });
+
+describe('deployOrder — the order the battle deploys the board (Battle.start)', () => {
+  test('operators by column from the left, top to bottom within a column, then the summons the same way; no items', () => {
+    // board rows 9 (bottom) … 12 (top), cols 2 … 10; given in reading order, as m.private sends it (server board.js boardOrder)
+    const board = [
+      chess(1, 12, 5), chess(2, 12, 2), { uid: 3, kind: 'token', id: 'token_a', row: 12, col: 3 }, chess(4, 11, 2),
+      { uid: 5, kind: 'item', id: 'chess_item_6_03_m', row: 10, col: 4 }, chess(6, 10, 5), chess(7, 9, 3),
+      { uid: 8, kind: 'token', id: 'token_b', row: 9, col: 2 },
+    ];
+    assert.deepEqual(deployOrder(board), [2, 4, 7, 1, 6, 8, 3]);
+    // the same rule the client's merge target uses (gameLogic mergeTarget: col asc, then row desc)
+    assert.deepEqual(deployOrder([chess(1, 9, 4), chess(2, 12, 4), chess(3, 10, 3)]), [3, 2, 1]);
+  });
+
+  test('junk and missing fields are left out; an empty or absent board is no order', () => {
+    assert.deepEqual(deployOrder(null), []);
+    assert.deepEqual(deployOrder([]), []);
+    assert.deepEqual(deployOrder([null, 'x', { uid: 1, kind: 'chess', row: 10 }, { kind: 'chess', row: 10, col: 3 }, chess(9, 10, 3)]), [9]);
+  });
+});
+
+describe('roundStartReplay — once per round, in 回合开始, on the own board', () => {
+  const board = [chess(11, 12, 6), chess(12, 9, 2)];
+  const base = { phase: PHASE.ROUND_START, round: 7, replayed: 6, ownBoard: true, board };
+
+  test('due in 回合开始 of a round not replayed yet: its pieces in deployment order', () => {
+    assert.deepEqual(roundStartReplay(base), { round: 7, uids: [12, 11] });
+  });
+
+  test('not again for the same round (a reconnect, a re-render); not in another phase', () => {
+    assert.equal(roundStartReplay({ ...base, replayed: 7 }), null);
+    for (const phase of [PHASE.PREP, PHASE.SP_DRAFT, PHASE.SETTLE, PHASE.COMBAT, PHASE.BATTLE_CHECK, null]) {
+      assert.equal(roundStartReplay({ ...base, phase }), null, String(phase));
+    }
+    assert.equal(roundStartReplay({ ...base, round: null }), null);
+  });
+
+  test('only the viewer\'s own board: a scouted teammate, a spectator seat or an eliminated player gets none', () => {
+    assert.equal(roundStartReplay({ ...base, ownBoard: false }), null);
+  });
+
+  test('an empty board (or a private state not here yet) schedules nothing — and marks nothing, so a board that arrives later in 回合开始 still plays', () => {
+    assert.equal(roundStartReplay({ ...base, board: [] }), null);
+    assert.equal(roundStartReplay({ ...base, board: undefined }), null);
+    assert.deepEqual(roundStartReplay({ ...base, replayed: null }), { round: 7, uids: [12, 11] });
+  });
+
+  test('screens/game.js asks after the wiring effect and marks the round only once the view took the sequence', () => {
+    const src = readFileSync(path.join(ROOT, 'public/js/screens/game.js'), 'utf8');
+    const wiring = src.indexOf('}, [view, showPrep, priv, editable, field, combat, mode, watchingOther, watching, holdSeq]);');
+    const replay = src.indexOf('const plan = roundStartReplay(');
+    assert.ok(wiring > 0 && replay > wiring, 'the replay effect runs after setPrep in the same commit');
+    assert.match(src, /roundStartReplay\(\{ phase, round: pub\?\.round, replayed: replayedRef\.current, ownBoard: showPrep && alive && !spectator, board: priv\?\.board \}\)/);
+    assert.match(src, /if \(plan && view && view\.replayDeploys\?\.\(plan\.uids\) > 0\) replayedRef\.current = plan\.round;/);
+    assert.doesNotMatch(src, /deployPiece|deploySequence/, 'no landing at the wheel\'s confirm: the state that shows the move lands the piece once');
+    const host = readFileSync(path.join(ROOT, 'public/js/ui/fieldHost.js'), 'utf8');
+    assert.match(host, /'stripesUnder', 'replayDeploys'\]/, 'an optional view method (the simplified board has none)');
+  });
+});
+
+describe('AudioManager.deployCue — the landing sound', () => {
+  const OWN = Object.keys(manifest.audio.sfx.units).find((k) => k.startsWith('char_') && typeof manifest.audio.sfx.units[k].born === 'string');
+  const PLAIN = Object.keys(manifest.chars).find((k) => !manifest.audio.sfx.units[k]?.born);
+  const rig = (o = {}) => {
+    const a = new AudioManager({ win: null, getManifest: () => manifest, random: () => 0, ...o });
+    a.ctx = {};                                    // unlocked
+    const played = [];
+    a._play = (url, opt) => { played.push({ url, ...opt }); };
+    return { a, played };
+  };
+
+  test('the sound of the piece\'s battle deployment: its own ON_UNIT_BORN file, else b_char_set / b_char_tokenset, limited per piece', () => {
+    assert.ok(OWN && PLAIN, 'the manifest has operators with and without an own deploy sound');
+    const { a, played } = rig();
+    assert.equal(a.deployCue({ def: OWN, defId: 'chess_x', kind: 'op' }, 'p:3'), true);
+    assert.equal(a.deployCue({ def: PLAIN, defId: 'chess_y', kind: 'op' }, 'p:4'), true);
+    assert.equal(a.deployCue({ def: 'token_10000_silent_healrb', defId: 'token_10000_silent_healrb', kind: 'token' }, 'p:5'), true);
+    assert.deepEqual(played.map((p) => p.url), [
+      manifest.audio.sfx.units[OWN].born, manifest.audio.sfx.battle.deploy,
+      deploySfxUrl(manifest, { def: 'token_10000_silent_healrb', defId: 'token_10000_silent_healrb', kind: 'token', side: 'ally' }),
+    ]);
+    assert.equal(played[2].url, manifest.audio.sfx.units.token_10000_silent_healrb?.born ?? manifest.audio.sfx.battle.tokenDeploy, 'a summon: the token sound');
+    assert.deepEqual(played.map((p) => [p.limited, p.unitKey]), [[true, 'land:p:3'], [true, 'land:p:4'], [true, 'land:p:5']], 'the battle limiter: ≤ 2 copies of one sound, a cooldown per piece');
+    assert.equal(played[1].volume, 0.5, 'the generic file at the battle deploy\'s gain');
+    assert.ok(played[0].volume > 0 && played[0].volume <= 0.8, 'an own file at its bank gain');
+  });
+
+  test('a piece without a sound, an enemy model, no manifest: nothing, never a throw', () => {
+    const { a, played } = rig({ getManifest: () => ({ audio: { sfx: { battle: {}, units: {} } } }) });
+    assert.equal(a.deployCue({ def: 'char_x', kind: 'op' }, 1), false);
+    const none = rig({ getManifest: () => null });
+    assert.equal(none.a.deployCue({ def: 'char_x', kind: 'op' }, 1), false);
+    assert.equal(none.a.deployCue(null, 1), false);
+    assert.equal(played.length + none.played.length, 0);
+  });
+
+  test('the SFX volume and mute apply: muted or at 0 nothing is even fetched', () => {
+    const a = new AudioManager({ win: null, getManifest: () => manifest, random: () => 0 });
+    a.ctx = {};
+    const fetched = [];
+    a._buffer = (url) => { fetched.push(url); return Promise.resolve(null); };
+    a.setVolumes({ sfx: 0.8, muted: true });
+    a.deployCue({ def: PLAIN, kind: 'op' }, 'p:1');
+    a.setVolumes({ sfx: 0, muted: false });
+    a.deployCue({ def: PLAIN, kind: 'op' }, 'p:2');
+    assert.deepEqual(fetched, []);
+    a.setVolumes({ sfx: 0.8, muted: false });
+    a.deployCue({ def: PLAIN, kind: 'op' }, 'p:3');
+    assert.deepEqual(fetched, [manifest.audio.sfx.battle.deploy]);
+  });
+});