@bongos/core 1.17.1 → 1.17.2

package/tests/terrain_picker.mjs

@@ -1,298 +0,0 @@
-// tests/terrain_picker.mjs
-//
-// Verify the autotile picker only sees the ground grid — objects on top
-// of a cell must NOT change which tile the picker selects for that cell
-// or its neighbors. This is the core invariant of the ground-object
-// split (ADR 0012): an object overlay never pollutes ground rendering.
-//
-// Also exercises the basic dispatch shape: each render strategy
-// (single / blob47 / path16) returns the expected kind of result.
-//
-// Run:  node tests/terrain_picker.mjs
-
-import { strict as assert } from 'node:assert';
-import {
-  TERRAIN,
-  OBJECT,
-  TERRAIN_RENDER,
-  OBJECT_RENDER,
-  pickAutotileIndex,
-  pickObjectAutotileIndex,
-  neighborsAt,
-} from '../modules/game/public/game/world/terrain.js';
-import { cellTransform } from '../modules/game/public/game/world/tilePalette.js';
-
-let passed = 0;
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ok  ${name}`);
-    passed++;
-  } catch (e) {
-    console.error(`  FAIL ${name}: ${e.message}`);
-    process.exitCode = 1;
-  }
-}
-
-// Build a tiny ground grid for picker tests. 5×5 with grass center,
-// sand on the south edge — same shape as the V1 grass↔sand transition.
-//
-//   g g g g g
-//   g g g g g
-//   g g g g g
-//   s s s s s
-//   s s s s s
-function makeGroundGrid() {
-  const G = TERRAIN.GRASS, S = TERRAIN.SAND;
-  return [
-    [G, G, G, G, G],
-    [G, G, G, G, G],
-    [G, G, G, G, G],
-    [S, S, S, S, S],
-    [S, S, S, S, S],
-  ];
-}
-
-// ---------- dispatch shape ------------------------------------------------------
-
-test('TERRAIN_RENDER covers all 4 ground terrains', () => {
-  for (const t of Object.values(TERRAIN)) {
-    assert.ok(TERRAIN_RENDER[t], `missing TERRAIN_RENDER for ${t}`);
-  }
-});
-
-test('grass dispatches blob47, sea dispatches single, marble_path dispatches path16', () => {
-  assert.equal(TERRAIN_RENDER[TERRAIN.GRASS].strategy, 'blob47');
-  assert.equal(TERRAIN_RENDER[TERRAIN.SAND].strategy,  'blob47');
-  assert.equal(TERRAIN_RENDER[TERRAIN.SEA].strategy,   'single');
-  assert.equal(TERRAIN_RENDER[TERRAIN.MARBLE_PATH].strategy, 'path16');
-});
-
-test('every blob47/path16 entry declares family + fallbackTile', () => {
-  for (const [t, cfg] of Object.entries(TERRAIN_RENDER)) {
-    if (cfg.strategy === 'blob47' || cfg.strategy === 'path16') {
-      assert.ok(cfg.family, `${t} missing family`);
-      assert.ok(cfg.fallbackTile, `${t} missing fallbackTile`);
-    }
-  }
-});
-
-// ---------- ground-only invariant ----------------------------------------------
-
-test('neighborsAt returns 8 neighbors from the ground grid', () => {
-  const g = makeGroundGrid();
-  // (2, 1) is deep interior of the grass band — rows 0..2 are grass.
-  const n = neighborsAt(g, 2, 1);
-  for (const dir of ['NW','N','NE','W','E','SW','S','SE']) {
-    assert.equal(n[dir], TERRAIN.GRASS, `neighbor ${dir} should be grass`);
-  }
-});
-
-test('neighborsAt returns null for off-grid neighbors', () => {
-  const g = makeGroundGrid();
-  const n = neighborsAt(g, 0, 0);
-  assert.equal(n.NW, null);
-  assert.equal(n.N,  null);
-  assert.equal(n.W,  null);
-  assert.equal(n.NE, null); // off-top
-  assert.equal(n.SW, null); // off-left
-  assert.equal(n.E,  TERRAIN.GRASS);
-  assert.equal(n.S,  TERRAIN.GRASS);
-  assert.equal(n.SE, TERRAIN.GRASS);
-});
-
-test('grass cell deep in interior picks the all-interior tile (max byte)', () => {
-  const g = makeGroundGrid();
-  const idx = pickAutotileIndex(TERRAIN.GRASS, neighborsAt(g, 2, 1));
-  // All 8 grass neighbors → byte 0xFF → maps to the canonical tile for
-  // "all neighbors same." For the standard 47-blob lookup this is one
-  // specific index; we just assert it's a valid 0..46 value and it
-  // matches what we get for OTHER fully-interior grass cells.
-  const idx2 = pickAutotileIndex(TERRAIN.GRASS, neighborsAt(g, 2, 0));
-  // (2, 0) has off-grid N/NW/NE — those count as not-grass. So idx
-  // and idx2 should DIFFER (different boundary configs).
-  assert.ok(Number.isInteger(idx) && idx >= 0 && idx < 47, `idx out of range: ${idx}`);
-  assert.notEqual(idx, idx2, 'interior cell should differ from top-edge cell');
-});
-
-test('grass cell at south edge of grass band picks a south-boundary tile', () => {
-  const g = makeGroundGrid();
-  // (2, 2) — last row of grass; south neighbors are sand
-  const idx = pickAutotileIndex(TERRAIN.GRASS, neighborsAt(g, 2, 2));
-  // (2, 1) — interior of grass band
-  const idxInterior = pickAutotileIndex(TERRAIN.GRASS, neighborsAt(g, 2, 1));
-  assert.notEqual(idx, idxInterior, 'south-edge cell must differ from interior');
-});
-
-test('marble_path picker is path16 (returns 0..15)', () => {
-  const path = TERRAIN.MARBLE_PATH;
-  // Lone path cell, no neighbors are also path
-  const idxLone = pickAutotileIndex(path, { N: TERRAIN.GRASS, W: TERRAIN.GRASS, E: TERRAIN.GRASS, S: TERRAIN.GRASS });
-  assert.equal(idxLone, 0, 'isolated path node = 0');
-  // Cross junction
-  const idxCross = pickAutotileIndex(path, { N: path, W: path, E: path, S: path });
-  assert.equal(idxCross, 15, 'cross junction = 0b1111 = 15');
-});
-
-test('sea cell (single strategy) returns null from picker', () => {
-  // 'single' terrains don't go through the autotile picker — caller
-  // dispatches them directly to the legacy single-tile path. The
-  // picker returns null to signal "not my problem."
-  const idx = pickAutotileIndex(TERRAIN.SEA, {
-    NW: TERRAIN.SEA, N: TERRAIN.SEA, NE: TERRAIN.SEA,
-    W:  TERRAIN.SEA,                  E:  TERRAIN.SEA,
-    SW: TERRAIN.SEA, S: TERRAIN.SEA, SE: TERRAIN.SEA,
-  });
-  assert.equal(idx, null, 'single-strategy terrain returns null');
-});
-
-// ---------- the headline invariant: objects do not affect picker --------------
-
-test('OBJECT-LAYER INVARIANT: picker only sees ground; objects must be passed via a separate grid', () => {
-  // The picker takes the GROUND grid. We can't reach inside and verify
-  // it ignores objects (they're not part of its API). Instead, verify
-  // that two ground configs with IDENTICAL ground but different object
-  // overlays produce identical picker output — by construction.
-  //
-  // (This test really enforces the invariant by demonstrating the
-  // CALLING PATTERN: the renderer must pass `map.ground`, never
-  // `map.objects`. The picker has no object-layer knob.)
-  const g = makeGroundGrid();
-  const idxA = pickAutotileIndex(TERRAIN.GRASS, neighborsAt(g, 2, 2));
-
-  // Imagine an alternate world where every cell of g has a rock OBJECT
-  // on top. The picker still receives only the ground grid → identical
-  // tile selection.
-  const idxB = pickAutotileIndex(TERRAIN.GRASS, neighborsAt(g, 2, 2));
-
-  assert.equal(idxA, idxB, 'object overlays must NOT change picker output');
-});
-
-// ---------- ADR 0013: object-layer autotile dispatch --------------------------
-
-test('OBJECT_RENDER supports single + path16 strategies; PATH_MARBLE is path16', () => {
-  // Every legacy entry must declare strategy='single' explicitly OR
-  // accept the short-form `{ tile: '...' }` (back-compat).
-  for (const [oid, cfg] of Object.entries(OBJECT_RENDER)) {
-    const strat = cfg.strategy || 'single';
-    assert.ok(['single', 'path16', 'blob47'].includes(strat),
-              `unknown strategy ${strat} for ${oid}`);
-    if (strat === 'path16' || strat === 'blob47') {
-      assert.ok(cfg.family,       `${oid} missing family`);
-      assert.ok(cfg.fallbackTile, `${oid} missing fallbackTile`);
-    }
-  }
-  assert.equal(OBJECT_RENDER[OBJECT.PATH_MARBLE].strategy, 'path16');
-  assert.equal(OBJECT_RENDER[OBJECT.PATH_MARBLE].family,   'marble_path');
-});
-
-test('pickObjectAutotileIndex: empty cell + single-strategy objects return null', () => {
-  // Empty cell.
-  assert.equal(pickObjectAutotileIndex(null, {}), null);
-  // ROCK is single-strategy → no autotile index.
-  assert.equal(
-    pickObjectAutotileIndex(OBJECT.ROCK,
-      { N: null, W: null, E: null, S: null }), null,
-  );
-});
-
-test('pickObjectAutotileIndex: PATH_MARBLE neighbors → path16 dispatch', () => {
-  const P = OBJECT.PATH_MARBLE;
-  // Isolated path = byte 0 (no connections).
-  const lone = pickObjectAutotileIndex(P, { N: null, W: null, E: null, S: null });
-  assert.equal(lone, 0, 'isolated path object = path16 index 0');
-  // Cross junction = 0b1111 = 15.
-  const cross = pickObjectAutotileIndex(P, { N: P, W: P, E: P, S: P });
-  assert.equal(cross, 15, '4-way path object = path16 index 15');
-  // Vertical strip (N+S) = 0b1001 = 9.
-  const vert = pickObjectAutotileIndex(P, { N: P, W: null, E: null, S: P });
-  assert.equal(vert, 0b1001, 'N+S vertical strip = 9');
-});
-
-test('OBJECT-LAYER AUTOTILE INVARIANT: object autotile sees only objects', () => {
-  // Same calling pattern enforcement as the ground invariant: caller
-  // must pass `map.objects` neighbors, not `map.ground`. A grass-on-sand
-  // boundary in the ground grid has no effect on a path object's tile.
-  const P = OBJECT.PATH_MARBLE;
-  // Build a 5×5 objects grid: vertical path strip down column 2.
-  const _ = null;
-  const objects = [
-    [_, _, P, _, _],
-    [_, _, P, _, _],
-    [_, _, P, _, _],
-    [_, _, P, _, _],
-    [_, _, P, _, _],
-  ];
-  // Cell (2, 2) — middle of the strip. N and S are PATH_MARBLE; W, E, corners empty.
-  const n = neighborsAt(objects, 2, 2);
-  assert.equal(n.N, P);
-  assert.equal(n.S, P);
-  assert.equal(n.W, null);
-  assert.equal(n.E, null);
-  const idx = pickObjectAutotileIndex(P, n);
-  assert.equal(idx, 0b1001, 'middle of N-S strip should pick vertical-straight');
-  // Cell (2, 0) — top of strip. Only S is path; N is off-grid.
-  const idxTop = pickObjectAutotileIndex(P, neighborsAt(objects, 2, 0));
-  assert.equal(idxTop, 0b0001, 'top end-cap = S only');
-  // Cell (2, 4) — bottom of strip. Only N is path.
-  const idxBot = pickObjectAutotileIndex(P, neighborsAt(objects, 2, 4));
-  assert.equal(idxBot, 0b1000, 'bottom end-cap = N only');
-});
-
-// ---------- D.4-T2: cellTransform determinism -----------------------------------
-
-test('cellTransform returns an object with flipX, flipY, angle fields', () => {
-  const t = cellTransform(0, 0);
-  assert.ok('flipX' in t, 'missing flipX');
-  assert.ok('flipY' in t, 'missing flipY');
-  assert.ok('angle' in t, 'missing angle');
-  assert.equal(typeof t.flipX, 'boolean');
-  assert.equal(typeof t.flipY, 'boolean');
-  assert.equal(typeof t.angle, 'number');
-});
-
-test('cellTransform is deterministic: same (x,y) always returns the same values', () => {
-  const coords = [[0,0],[1,0],[0,1],[5,7],[12,3],[0,15],[7,7],[3,11]];
-  for (const [x, y] of coords) {
-    const a = cellTransform(x, y);
-    const b = cellTransform(x, y);
-    assert.equal(a.flipX, b.flipX, `flipX mismatch at (${x},${y})`);
-    assert.equal(a.flipY, b.flipY, `flipY mismatch at (${x},${y})`);
-    assert.equal(a.angle, b.angle, `angle mismatch at (${x},${y})`);
-  }
-});
-
-test('cellTransform produces variation across cells (not all identical)', () => {
-  const signatures = new Set();
-  for (let x = 0; x < 8; x++) {
-    for (let y = 0; y < 8; y++) {
-      const t = cellTransform(x, y);
-      signatures.add(`${t.flipX}|${t.flipY}|${t.angle}`);
-    }
-  }
-  assert.ok(signatures.size >= 2, `expected variation across cells, got ${signatures.size} distinct transforms`);
-});
-
-test('cellTransform uses a different hash from interior-variant selection (cells differ)', () => {
-  // The two hashes should produce different distributions so that flip/rotation
-  // and variant selection don't always correlate. Verify they produce different
-  // orderings for the same 4x4 patch.
-  const transformSigs = [];
-  for (let x = 0; x < 4; x++) {
-    for (let y = 0; y < 4; y++) {
-      const t = cellTransform(x, y);
-      transformSigs.push(`${x},${y}:${Number(t.flipX)}${Number(t.flipY)}`);
-    }
-  }
-  // Just verify the function ran without error and produced a non-trivial result.
-  assert.equal(transformSigs.length, 16, '4x4 patch has 16 cells');
-});
-
-// ---------- summary -------------------------------------------------------------
-
-if (process.exitCode !== 1) {
-  console.log(`\n[terrain_picker] OK — ${passed} tests passed`);
-} else {
-  console.error(`\n[terrain_picker] FAIL — see output above`);
-  process.exit(1);
-}

package/tests/turn_in_place.mjs

@@ -1,280 +0,0 @@
-// tests/turn_in_place.mjs
-//
-// Turn-in-place (#1057): quick-tap a direction to face it without stepping;
-// hold past the threshold to walk as before. Exercises the pure movement
-// helpers (Phaser-free, DB-free) that drive Player.update:
-//   - decideMove(dir, facing, heldMs, threshold) — the tap-vs-hold rule.
-//   - readDirectionFromInput(moveKeys) — WASD + arrow key resolution.
-// Plus a frame-by-frame simulation proving a real tap never steps and a
-// real hold does.
-//
-// Run:  node tests/turn_in_place.mjs
-
-import { strict as assert } from 'node:assert';
-import {
-  decideMove,
-  readDirectionFromInput,
-  TURN_TAP_MS,
-  DIRS,
-} from '../modules/game/public/game/player/movement.js';
-
-let passed = 0;
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ok  ${name}`);
-    passed++;
-  } catch (e) {
-    console.error(`  FAIL ${name}: ${e.message}`);
-    process.exitCode = 1;
-  }
-}
-
-// A Phaser Key stand-in — readDirectionFromInput only reads these two props.
-const key = (isDown, timeDown = 0) => ({ isDown, timeDown });
-const NONE = key(false);
-
-// ---------- decideMove: the tap-vs-hold rule -----------------------------
-
-test('quick tap of a NEW direction turns, never steps (even if heldMs is large)', () => {
-  // A fresh press in a new direction always pivots first and never steps the
-  // same frame — so a quick tap of a new direction can only ever face it.
-  assert.deepEqual(decideMove('left', 'down', 5, TURN_TAP_MS), { turn: true, step: false });
-  assert.deepEqual(decideMove('up', 'down', 9999, TURN_TAP_MS), { turn: true, step: false });
-});
-
-test('already facing + held below threshold = no-op (a quick tap is just a look)', () => {
-  assert.deepEqual(decideMove('down', 'down', 0, TURN_TAP_MS), { turn: false, step: false });
-  assert.deepEqual(decideMove('down', 'down', TURN_TAP_MS - 1, TURN_TAP_MS), { turn: false, step: false });
-});
-
-test('already facing + held at/over threshold = step (walk)', () => {
-  assert.deepEqual(decideMove('down', 'down', TURN_TAP_MS, TURN_TAP_MS), { turn: false, step: true });
-  assert.deepEqual(decideMove('right', 'right', TURN_TAP_MS + 500, TURN_TAP_MS), { turn: false, step: true });
-});
-
-test('no direction held = nothing', () => {
-  assert.deepEqual(decideMove(null, 'down', 9999, TURN_TAP_MS), { turn: false, step: false });
-});
-
-test('threshold sits in the task-specified 120-150ms band', () => {
-  assert.ok(TURN_TAP_MS >= 120 && TURN_TAP_MS <= 150, `TURN_TAP_MS=${TURN_TAP_MS}`);
-});
-
-// ---------- readDirectionFromInput: WASD + arrow bindings ----------------
-
-const dirKeys = (over) => ({
-  up: [NONE, NONE], down: [NONE, NONE], left: [NONE, NONE], right: [NONE, NONE], ...over,
-});
-
-test('nothing held resolves to null', () => {
-  assert.equal(readDirectionFromInput(dirKeys({})), null);
-});
-
-test('WASD drives direction (W = up)', () => {
-  const sel = readDirectionFromInput(dirKeys({ up: [key(true, 100), NONE] }));
-  assert.equal(sel.dir, 'up');
-  assert.equal(sel.t, 100);
-});
-
-test('arrow keys drive the same direction (#1057 added arrow bindings)', () => {
-  // second slot in each direction array is the cursor (arrow) key
-  const sel = readDirectionFromInput(dirKeys({ right: [NONE, key(true, 250)] }));
-  assert.equal(sel.dir, 'right');
-  assert.equal(sel.t, 250);
-});
-
-test('WASD + arrow for one direction use the most-recent press time', () => {
-  const sel = readDirectionFromInput(dirKeys({ down: [key(true, 100), key(true, 400)] }));
-  assert.equal(sel.dir, 'down');
-  assert.equal(sel.t, 400);
-});
-
-test('most-recently-pressed direction wins', () => {
-  const sel = readDirectionFromInput(dirKeys({
-    up:   [key(true, 100), NONE],
-    left: [key(true, 200), NONE],
-  }));
-  assert.equal(sel.dir, 'left');
-});
-
-test('opposing keys cancel (W+S held = no direction)', () => {
-  assert.equal(readDirectionFromInput(dirKeys({
-    up:   [key(true, 100), NONE],
-    down: [key(true, 110), NONE],
-  })), null);
-});
-
-test('opposing pair cancels but a third direction still resolves', () => {
-  const sel = readDirectionFromInput(dirKeys({
-    left:  [key(true, 100), NONE],
-    right: [key(true, 110), NONE],
-    up:    [key(true, 90), NONE],
-  }));
-  assert.equal(sel.dir, 'up');
-});
-
-test('equal timeDown breaks ties deterministically (up before left)', () => {
-  const sel = readDirectionFromInput(dirKeys({
-    up:   [key(true, 100), NONE],
-    left: [key(true, 100), NONE],
-  }));
-  assert.equal(sel.dir, 'up');
-});
-
-// ---------- frame-by-frame: a real tap vs a real hold --------------------
-
-// Drive the same decision loop Player.update runs, over a sequence of
-// frames. Each frame: resolve the held direction, compute heldMs = now - t,
-// decide, and apply (turn updates facing; step counts a tile move).
-function simulate(frames, startFacing = 'down') {
-  let facing = startFacing;
-  let steps = 0;
-  let turns = 0;
-  for (const f of frames) {
-    const sel = readDirectionFromInput(f.keys);
-    if (!sel) continue;
-    const { turn, step } = decideMove(sel.dir, facing, f.now - sel.t, TURN_TAP_MS);
-    if (turn) { facing = sel.dir; turns++; continue; }
-    if (step) { steps++; }
-  }
-  return { facing, steps, turns };
-}
-
-test('a quick tap of a new direction turns once and never steps', () => {
-  const pressedAt = 1000;
-  const held = (now) => dirKeys({ left: [key(true, pressedAt), NONE] });
-  // Press at 1000, sampled at 1000 and 1050, then released before 130ms.
-  const r = simulate([
-    { now: 1000, keys: held(1000) },
-    { now: 1050, keys: held(1050) },
-    { now: 1100, keys: dirKeys({}) }, // released (~100ms tap)
-  ]);
-  assert.equal(r.facing, 'left');
-  assert.equal(r.turns, 1);
-  assert.equal(r.steps, 0); // pure turn-in-place — no tile change
-});
-
-test('a quick tap while already facing that way is a no-op (no step)', () => {
-  const r = simulate([
-    { now: 1000, keys: dirKeys({ down: [key(true, 1000), NONE] }) },
-    { now: 1060, keys: dirKeys({ down: [key(true, 1060), NONE] }) },
-    { now: 1090, keys: dirKeys({}) }, // released (~90ms tap)
-  ], 'down');
-  assert.equal(r.facing, 'down');
-  assert.equal(r.turns, 0);
-  assert.equal(r.steps, 0);
-});
-
-test('holding a direction walks (turn then step past the threshold)', () => {
-  const pressedAt = 1000;
-  const r = simulate([
-    { now: 1000, keys: dirKeys({ left: [key(true, pressedAt), NONE] }) }, // turn
-    { now: 1050, keys: dirKeys({ left: [key(true, pressedAt), NONE] }) }, // still in tap window
-    { now: 1000 + TURN_TAP_MS + 10, keys: dirKeys({ left: [key(true, pressedAt), NONE] }) }, // step
-  ]);
-  assert.equal(r.facing, 'left');
-  assert.equal(r.turns, 1);
-  assert.equal(r.steps, 1);
-});
-
-test('holding the direction you already face walks after the threshold (no extra turn)', () => {
-  const pressedAt = 2000;
-  const r = simulate([
-    { now: 2000, keys: dirKeys({ up: [key(true, pressedAt), NONE] }) }, // within tap window: nothing
-    { now: 2000 + TURN_TAP_MS + 5, keys: dirKeys({ up: [key(true, pressedAt), NONE] }) }, // step
-  ], 'up');
-  assert.equal(r.turns, 0);
-  assert.equal(r.steps, 1);
-});
-
-// DIRS sanity — Player.update derives the target tile from these.
-test('DIRS deltas are the four cardinal unit steps', () => {
-  assert.deepEqual(DIRS.up, { dx: 0, dy: -1 });
-  assert.deepEqual(DIRS.down, { dx: 0, dy: 1 });
-  assert.deepEqual(DIRS.left, { dx: -1, dy: 0 });
-  assert.deepEqual(DIRS.right, { dx: 1, dy: 0 });
-});
-
-// ---------- integration: the real Player class with Phaser/DB mocks ------
-//
-// Player.js is Phaser-free at module load (it only touches the API at
-// runtime), so we can drive the real update() loop with light mocks and
-// assert the wiring: a pure turn sends 'turn' and changes NO position; a
-// held press sends 'move' and steps exactly one tile.
-
-const { Player } = await import('../modules/game/public/game/player/Player.js');
-
-function makePlayer() {
-  const sprite = {
-    x: 0, y: 0,
-    setOrigin() { return this; },
-    setDepth() { return this; },
-    setTexture() { return this; },
-    setFlipX() { return this; },
-    setPosition(x, y) { this.x = x; this.y = y; return this; },
-  };
-  const sent = [];
-  const scene = {
-    add: { image: () => sprite },
-    textures: { exists: () => false }, // canvas-fallback path in spriteTextureFor
-    isBlocked: () => false,
-    // Synchronous tween: fire onComplete immediately so the step settles
-    // within the same call (real Phaser tweens take STEP_MS).
-    tweens: { add: (cfg) => { if (cfg.onComplete) cfg.onComplete(); } },
-  };
-  const player = new Player(scene, 10, 10);
-  player.attachRoom({ send: (type, msg) => sent.push({ type, msg }) });
-  return { player, sent };
-}
-
-const keysFor = (dir, t) => dirKeys({ [dir]: [key(true, t), NONE] });
-
-test('integration: quick tap of a new direction → faces it, sends turn, NO position change', () => {
-  const { player, sent } = makePlayer();
-  assert.equal(player.facing, 'down');
-  player.update(keysFor('left', 1000), 1000); // press; dir != facing → turn
-  assert.equal(player.facing, 'left');
-  assert.equal(player.gridX, 10);
-  assert.equal(player.gridY, 10); // zero position change — the headline acceptance
-  assert.deepEqual(sent, [{ type: 'turn', msg: { dir: 'left' } }]);
-});
-
-test('integration: tap while already facing that way → no message, no move', () => {
-  const { player, sent } = makePlayer(); // starts facing down
-  player.update(keysFor('down', 2000), 2000 + 50); // held 50ms < threshold
-  assert.equal(player.gridX, 10);
-  assert.equal(player.gridY, 10);
-  assert.deepEqual(sent, []);
-});
-
-test('integration: holding past the threshold → sends move and steps one tile', () => {
-  const { player, sent } = makePlayer(); // facing down
-  // Already facing 'down'; hold past threshold → one step down (+1 y).
-  player.update(keysFor('down', 3000), 3000 + TURN_TAP_MS + 10);
-  assert.equal(player.gridY, 11);
-  assert.equal(player.gridX, 10);
-  assert.deepEqual(sent, [{ type: 'move', msg: { dir: 'down' } }]);
-});
-
-test('integration: turn frame never steps even when the key is already held long', () => {
-  const { player, sent } = makePlayer(); // facing down
-  // First time we see 'left' it differs from facing → must turn only, never
-  // step, regardless of how long the (newly-resolved) key reads as held.
-  player.update(keysFor('left', 100), 100 + 5000);
-  assert.equal(player.facing, 'left');
-  assert.equal(player.gridX, 10);
-  assert.equal(player.gridY, 10);
-  assert.deepEqual(sent, [{ type: 'turn', msg: { dir: 'left' } }]);
-});
-
-test('integration: blocked tile → faces direction but does not step', () => {
-  const { player, sent } = makePlayer();
-  player.scene.isBlocked = () => true;
-  player.facing = 'up'; // pretend already facing up
-  player.update(keysFor('up', 4000), 4000 + TURN_TAP_MS + 10); // would step, but blocked
-  assert.equal(player.gridY, 10); // unchanged
-  assert.deepEqual(sent, []); // beginWalk (which sends 'move') never reached
-});
-
-console.log(`\nturn_in_place: ${passed} passed`);