@bongos/core 1.17.1 → 1.17.3

package/tests/snapshot_picker.mjs

@@ -1,233 +0,0 @@
-// tests/snapshot_picker.mjs
-//
-// Parity test: verifies that the snapshot renderer's tile-picking logic
-// agrees with the JS runtime autotile pickers for a representative sample
-// of cells in INITIAL_MAP.
-//
-// The snapshot renderer (scripts/snapshots/render-world.mjs) calls the
-// SAME selectBlob47/selectPath16 and neighborsAt functions that the browser
-// client uses — so this test validates that the renderer correctly:
-//   1. Passes the ground grid to ground-layer pickers.
-//   2. Passes the object grid to object-layer pickers.
-//   3. Produces the same tile index as a direct call with the same inputs.
-//
-// If these diverge the in-game render and the snapshot would show different
-// tile choices for the same cell.
-//
-// Usage:
-//   node tests/snapshot_picker.mjs
-
-import { createRequire } from 'node:module';
-import { selectBlob47, selectPath16 } from '../modules/game/public/game/world/autotile.js';
-import {
-  TERRAIN_RENDER,
-  OBJECT_RENDER,
-  neighborsAt,
-} from '../modules/game/public/game/world/terrain.js';
-
-const require = createRequire(import.meta.url);
-const { INITIAL_MAP, WORLD_COLS, WORLD_ROWS, TERRAIN, OBJECT } = require('../modules/game/world/map.js');
-
-let passed = 0;
-let failed = 0;
-
-function assert(condition, msg) {
-  if (condition) {
-    passed++;
-  } else {
-    console.error(`  FAIL: ${msg}`);
-    failed++;
-  }
-}
-
-// ---------- helpers mirrored from render-world.mjs -------------------------
-
-function groundIdx(x, y) {
-  const terrainId = INITIAL_MAP.ground[y][x];
-  const cfg = TERRAIN_RENDER[terrainId];
-  if (!cfg || cfg.strategy === 'single') return null;
-  const neighbors = neighborsAt(INITIAL_MAP.ground, x, y);
-  if (cfg.strategy === 'blob47') return selectBlob47(terrainId, neighbors);
-  if (cfg.strategy === 'path16') {
-    return selectPath16({
-      N: neighbors.N === terrainId ? 1 : 0,
-      W: neighbors.W === terrainId ? 1 : 0,
-      E: neighbors.E === terrainId ? 1 : 0,
-      S: neighbors.S === terrainId ? 1 : 0,
-    });
-  }
-  return null;
-}
-
-function objectIdx(x, y) {
-  const objId = INITIAL_MAP.objects[y][x];
-  if (!objId) return null;
-  const cfg = OBJECT_RENDER[objId];
-  if (!cfg || cfg.strategy === 'single') return null;
-  const neighbors = neighborsAt(INITIAL_MAP.objects, x, y);
-  if (cfg.strategy === 'blob47') return selectBlob47(objId, neighbors);
-  if (cfg.strategy === 'path16') {
-    return selectPath16({
-      N: neighbors.N === objId ? 1 : 0,
-      W: neighbors.W === objId ? 1 : 0,
-      E: neighbors.E === objId ? 1 : 0,
-      S: neighbors.S === objId ? 1 : 0,
-    });
-  }
-  return null;
-}
-
-// ---------- tests -----------------------------------------------------------
-
-console.log('[snapshot_picker] running parity tests…\n');
-
-// 1. All-grass interior cell (0,0 — surrounded by grass on all sides).
-{
-  const idx = groundIdx(1, 1);
-  assert(idx !== null, 'grass interior: should return a blob47 index');
-  assert(idx >= 0 && idx <= 46, `grass interior: index ${idx} out of range 0..46`);
-
-  // Direct call with the same neighbors
-  const neighbors = neighborsAt(INITIAL_MAP.ground, 1, 1);
-  const direct = selectBlob47(INITIAL_MAP.ground[1][1], neighbors);
-  assert(idx === direct, `grass interior: picker returned ${idx}, direct call returned ${direct}`);
-  console.log(`  PASS grass interior (1,1): blob47 idx=${idx}`);
-}
-
-// 2. SEA cell — single-tile strategy, no autotile index.
-{
-  const seaRow = WORLD_ROWS - 1;
-  const terrainId = INITIAL_MAP.ground[seaRow][0];
-  assert(terrainId === TERRAIN.SEA, `row ${seaRow} col 0 should be SEA, got ${terrainId}`);
-  const cfg = TERRAIN_RENDER[terrainId];
-  assert(cfg.strategy === 'single', `sea: expected single strategy, got ${cfg.strategy}`);
-  const idx = groundIdx(0, seaRow);
-  assert(idx === null, `sea: single-tile strategy should return null, got ${idx}`);
-  console.log(`  PASS sea (0,${seaRow}): single tile, no autotile index`);
-}
-
-// 3. Grass→sand boundary cell (first SAND row, leftmost column).
-// At y=6, x=0 the ground is SAND. Its N neighbor is GRASS. The blob47 picker
-// should see a non-all-interior byte and return an edge tile index.
-{
-  const x = 0, y = 6;
-  const terrainId = INITIAL_MAP.ground[y][x];
-  assert(terrainId === TERRAIN.SAND, `(0,6) should be SAND, got ${terrainId}`);
-  const idx = groundIdx(x, y);
-  assert(idx !== null, 'sand boundary: should have autotile index');
-
-  const neighbors = neighborsAt(INITIAL_MAP.ground, x, y);
-  const direct = selectBlob47(terrainId, neighbors);
-  assert(idx === direct, `sand boundary: picker=${idx}, direct=${direct}`);
-  // Sand at (0,6) has grass to the north and sea below, so it's not all-interior.
-  // We just check it produces a valid range.
-  assert(idx >= 0 && idx <= 46, `sand boundary idx ${idx} out of range`);
-  console.log(`  PASS sand boundary (0,6): blob47 idx=${idx}`);
-}
-
-// 4. Rock object — single tile, no autotile index.
-{
-  // Rocks are placed in the grass band (y<6) where the hash hits.
-  // Find the first rock in the map.
-  let rockX = -1, rockY = -1;
-  outer: for (let y = 0; y < 6; y++) {
-    for (let x = 0; x < WORLD_COLS; x++) {
-      if (INITIAL_MAP.objects[y][x] === OBJECT.ROCK) { rockX = x; rockY = y; break outer; }
-    }
-  }
-  assert(rockX >= 0, 'should find at least one rock in the grass band');
-  if (rockX >= 0) {
-    const cfg = OBJECT_RENDER[OBJECT.ROCK];
-    assert(cfg.strategy === 'single', `rock: expected single strategy, got ${cfg.strategy}`);
-    const idx = objectIdx(rockX, rockY);
-    assert(idx === null, `rock (${rockX},${rockY}): single-tile → null, got ${idx}`);
-    console.log(`  PASS rock (${rockX},${rockY}): single tile, no autotile index`);
-  }
-}
-
-// 5. Container panel — single tile, no autotile index.
-{
-  const cx = 13, cy = 8;
-  const panel = INITIAL_MAP.objects[cy][cx];
-  assert(panel && panel.startsWith('container_panel_'), `(13,8) should be a container panel, got ${panel}`);
-  const idx = objectIdx(cx, cy);
-  assert(idx === null, `container panel: single-tile → null, got ${idx}`);
-  console.log(`  PASS container panel (${cx},${cy}): single tile, no autotile index`);
-}
-
-// 6. Marble path — path16 autotile. Cells at (13, 10..13).
-// The path runs N→S at x=13, y=10-13. Middle cells should connect north+south.
-{
-  const x = 13, y = 11; // interior path cell connects N (y=10) and S (y=12)
-  const objId = INITIAL_MAP.objects[y][x];
-  assert(objId === OBJECT.PATH_MARBLE, `(13,11) should be PATH_MARBLE, got ${objId}`);
-
-  const idx = objectIdx(x, y);
-  assert(idx !== null, 'path interior: should have path16 index');
-
-  // Direct call
-  const neighbors = neighborsAt(INITIAL_MAP.objects, x, y);
-  const direct = selectPath16({
-    N: neighbors.N === objId ? 1 : 0,
-    W: neighbors.W === objId ? 1 : 0,
-    E: neighbors.E === objId ? 1 : 0,
-    S: neighbors.S === objId ? 1 : 0,
-  });
-  assert(idx === direct, `path interior: picker=${idx}, direct=${direct}`);
-
-  // N and S neighbors are also PATH_MARBLE at (13,10) and (13,12)
-  assert(neighbors.N === OBJECT.PATH_MARBLE, `path (13,11): N should be PATH_MARBLE`);
-  assert(neighbors.S === OBJECT.PATH_MARBLE, `path (13,11): S should be PATH_MARBLE`);
-  // Expected: N+S connected, W+E not → path16 = 0b1001 = 9
-  const expected = selectPath16({ N: 1, W: 0, E: 0, S: 1 });
-  assert(idx === expected, `path interior: expected N+S connected index ${expected}, got ${idx}`);
-  console.log(`  PASS marble path interior (13,11): path16 idx=${idx} (N+S connected)`);
-}
-
-// 7. Marble path endpoint — top of the path (13,10): connects S only.
-{
-  const x = 13, y = 10;
-  const objId = INITIAL_MAP.objects[y][x];
-  assert(objId === OBJECT.PATH_MARBLE, `(13,10) should be PATH_MARBLE, got ${objId}`);
-
-  const neighbors = neighborsAt(INITIAL_MAP.objects, x, y);
-  // (13,9) is the container door panel — NOT a path marble
-  assert(neighbors.N !== OBJECT.PATH_MARBLE, `path top (13,10): N should not be PATH_MARBLE`);
-  assert(neighbors.S === OBJECT.PATH_MARBLE, `path top (13,10): S should be PATH_MARBLE`);
-
-  const idx = objectIdx(x, y);
-  const expected = selectPath16({ N: 0, W: 0, E: 0, S: 1 });
-  assert(idx === expected, `path top (13,10): expected S-only idx ${expected}, got ${idx}`);
-  console.log(`  PASS marble path top (13,10): path16 idx=${idx} (S only)`);
-}
-
-// 8. Ground layer: no object cell pollutes ground autotile neighbors.
-// The rock at (rockX, rockY) must not affect the ground tile choice for
-// any of its neighbors — picker sees the ground grid only.
-{
-  let rockX = -1, rockY = -1;
-  outer2: for (let y = 0; y < 6; y++) {
-    for (let x = 0; x < WORLD_COLS; x++) {
-      if (INITIAL_MAP.objects[y][x] === OBJECT.ROCK) { rockX = x; rockY = y; break outer2; }
-    }
-  }
-  if (rockX >= 0 && rockX + 1 < WORLD_COLS) {
-    const rightX = rockX + 1;
-    const rightY = rockY;
-    const terrainId = INITIAL_MAP.ground[rightY][rightX];
-    const groundNeighbors = neighborsAt(INITIAL_MAP.ground, rightX, rightY);
-    // The W neighbor of (rightX, rightY) should be a terrain id (grass), not a rock object id.
-    assert(
-      groundNeighbors.W === TERRAIN.GRASS,
-      `ground picks should see ground only: W neighbor of (${rightX},${rightY}) should be GRASS, got ${groundNeighbors.W}`
-    );
-    console.log(`  PASS ground isolation (${rightX},${rightY}): W ground neighbor is ${groundNeighbors.W}, not an object id`);
-  }
-}
-
-// ---------- summary ---------------------------------------------------------
-
-console.log(`\n[snapshot_picker] ${passed} passed, ${failed} failed`);
-if (failed > 0) {
-  process.exit(1);
-}

package/tests/sprite_facing.mjs

@@ -1,35 +0,0 @@
-// tests/sprite_facing.mjs
-//
-// Behavior-preserving refactor check (task 1968, ADR 0113): resolveFacing
-// was extracted out of Player.js's _applyIdleTexture/_applyWalkTexture so
-// the sprite Studio can resolve the right-facing mirror identically to the
-// live game. Pure, Phaser-free — pins the exact mapping both callers rely on.
-//
-// Run:  node tests/sprite_facing.mjs
-
-import { strict as assert } from 'node:assert';
-import { resolveFacing } from '../modules/game/public/game/player/spriteFacing.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;
-  }
-}
-
-test('down/up/left pass through unmirrored', () => {
-  assert.deepEqual(resolveFacing('down'), { sourceDir: 'down', flipX: false });
-  assert.deepEqual(resolveFacing('up'), { sourceDir: 'up', flipX: false });
-  assert.deepEqual(resolveFacing('left'), { sourceDir: 'left', flipX: false });
-});
-
-test('right resolves to the left-facing art, flipped', () => {
-  assert.deepEqual(resolveFacing('right'), { sourceDir: 'left', flipX: true });
-});
-
-console.log(`${passed} passed`);

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);
-}