@bongos/core 1.17.1 → 1.17.2

package/tests/art_key.mjs

@@ -1,121 +0,0 @@
-// tests/art_key.mjs
-//
-// Unit smoke for modules/art-pipeline/art-key.js (task 1281, moved BV1.R48) — the GDS-delivered SHARED Gemini
-// key for newcomers. Covers the pure entitlement decision (xenos in; thetes+ out;
-// unknown rank fails closed), the env/file key loader, and the describeArtKey
-// payload shape. The route (routes/me.js) + the local sync (fetch-art-key.js) and
-// the pipeline tier (gen_api.py) are exercised by the endpoint smoke + manual
-// resolution check; here we cover the logic without pg or network.
-//
-// Hermetic: the "not configured" cases unset SHARED_ART_GEMINI_KEY and repoint
-// HOME at an empty temp dir so the ~/.config/otb/gemini-shared.json fallback can't
-// resolve to a real operator file on the test machine.
-//
-// Run:  node tests/art_key.mjs
-
-import { strict as assert } from 'node:assert';
-import { createRequire } from 'node:module';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const require = createRequire(import.meta.url);
-const a = require('../modules/art-pipeline/art-key.js');
-const db = require('../modules/lifecycle/db.js');
-
-let passed = 0;
-let failed = 0;
-function t(name, fn) {
-  try { fn(); passed++; console.log(`  PASS  ${name}`); }
-  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
-}
-
-// Run a thunk with SHARED_ART_GEMINI_KEY + HOME forced to known values, restoring
-// both afterward so cases don't leak into each other.
-function withEnv({ key, emptyHome }, fn) {
-  const origKey = process.env.SHARED_ART_GEMINI_KEY;
-  const origHome = process.env.HOME;
-  if (key === null) delete process.env.SHARED_ART_GEMINI_KEY;
-  else if (key !== undefined) process.env.SHARED_ART_GEMINI_KEY = key;
-  if (emptyHome) process.env.HOME = mkdtempSync(join(tmpdir(), 'otb-artkey-'));
-  try { fn(); }
-  finally {
-    if (origKey === undefined) delete process.env.SHARED_ART_GEMINI_KEY;
-    else process.env.SHARED_ART_GEMINI_KEY = origKey;
-    process.env.HOME = origHome;
-  }
-}
-
-console.log('entitlement boundary:');
-
-t('SHARED_ART_KEY_MAX_TIER is the xenos tier (1)', () => {
-  assert.equal(a.SHARED_ART_KEY_MAX_TIER, db.REQUIRES_RANK_TIER.xenos);
-  assert.equal(a.SHARED_ART_KEY_MAX_TIER, 1);
-});
-
-t('xenos is entitled (reason newcomer)', () => {
-  assert.deepEqual(a.entitlementFor('xenos'), { entitled: true, reason: 'newcomer' });
-});
-
-t('thetes / metic / archon are NOT entitled (reason rank_above_newcomer)', () => {
-  for (const rank of ['thetes', 'metic', 'archon']) {
-    assert.deepEqual(a.entitlementFor(rank), { entitled: false, reason: 'rank_above_newcomer' }, rank);
-  }
-});
-
-t('unknown / absent rank fails closed (reason unknown_rank)', () => {
-  for (const rank of [undefined, null, '', 'wizard', 'helot']) {
-    assert.deepEqual(a.entitlementFor(rank), { entitled: false, reason: 'unknown_rank' }, String(rank));
-  }
-});
-
-console.log('\nkey loader (env wins; trimmed):');
-
-t('loadSharedGeminiKey returns the env key, trimmed', () => {
-  withEnv({ key: '  AIza-test-123  ' }, () => {
-    assert.equal(a.loadSharedGeminiKey(), 'AIza-test-123');
-    assert.equal(a.sharedGeminiKeyConfigured(), true);
-  });
-});
-
-t('not configured when env unset and no operator file (empty HOME)', () => {
-  withEnv({ key: null, emptyHome: true }, () => {
-    assert.equal(a.loadSharedGeminiKey(), null);
-    assert.equal(a.sharedGeminiKeyConfigured(), false);
-  });
-});
-
-console.log('\ndescribeArtKey (the GET /me/art-key payload, sans secret):');
-
-t('xenos + configured: entitled, configured, shared_key placeholder is null', () => {
-  withEnv({ key: 'AIza-shared' }, () => {
-    const d = a.describeArtKey({ rank: 'xenos' });
-    assert.equal(d.entitled, true);
-    assert.equal(d.configured, true);
-    assert.equal(d.reason, 'newcomer');
-    assert.equal(d.rank, 'xenos');
-    // The pure describe never embeds the secret — the route attaches it.
-    assert.equal(d.shared_key, null);
-  });
-});
-
-t('thetes: not entitled even when a key is configured (the withdraw signal)', () => {
-  withEnv({ key: 'AIza-shared' }, () => {
-    const d = a.describeArtKey({ rank: 'thetes' });
-    assert.equal(d.entitled, false);
-    assert.equal(d.reason, 'rank_above_newcomer');
-    assert.equal(d.configured, true);
-    assert.equal(d.shared_key, null);
-  });
-});
-
-t('xenos but unconfigured: entitled yet configured=false (sync no-ops)', () => {
-  withEnv({ key: null, emptyHome: true }, () => {
-    const d = a.describeArtKey({ rank: 'xenos' });
-    assert.equal(d.entitled, true);
-    assert.equal(d.configured, false);
-  });
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/tests/day_cycle.mjs

@@ -1,197 +0,0 @@
-// tests/day_cycle.mjs
-//
-// The pure math behind the #639 time-of-day lighting. No Phaser, no DOM — the
-// fx/lighting.js glue is a thin shell over these functions, so getting the
-// math right here is most of the feature.
-//
-// Run:  node tests/day_cycle.mjs
-
-import { strict as assert } from 'node:assert';
-import {
-  DEFAULT_PERIOD_MS,
-  KEYFRAMES,
-  SKY_PHASES,
-  wrap01,
-  phaseFromClock,
-  lerpColor,
-  bracket,
-  tintAt,
-  parseSkyOverride,
-} from '../modules/game/public/game/fx/dayCycle.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;
-  }
-}
-
-const chan = (c) => [(c >> 16) & 0xff, (c >> 8) & 0xff, c & 0xff];
-
-// ---------- wrap01 -------------------------------------------------------
-
-test('wrap01 maps any real into [0,1)', () => {
-  assert.equal(wrap01(0), 0);
-  assert.equal(wrap01(0.5), 0.5);
-  assert.equal(wrap01(1), 0);
-  assert.ok(Math.abs(wrap01(1.25) - 0.25) < 1e-9);
-  assert.ok(Math.abs(wrap01(-0.25) - 0.75) < 1e-9);
-  assert.ok(Math.abs(wrap01(-2.1) - 0.9) < 1e-9);
-});
-
-// ---------- phaseFromClock ----------------------------------------------
-
-test('phaseFromClock is 0 at the epoch and 0.5 at half a period', () => {
-  assert.equal(phaseFromClock(0), 0);
-  assert.equal(phaseFromClock(DEFAULT_PERIOD_MS / 2), 0.5);
-});
-
-test('phaseFromClock wraps each period', () => {
-  assert.equal(phaseFromClock(DEFAULT_PERIOD_MS), 0);
-  assert.ok(Math.abs(phaseFromClock(DEFAULT_PERIOD_MS * 1.25) - 0.25) < 1e-9);
-});
-
-test('phaseFromClock is deterministic — shared across clients by construction', () => {
-  const now = 1_700_000_123_456;
-  assert.equal(phaseFromClock(now), phaseFromClock(now));
-  // Two clients a few seconds apart see ~the same phase (period is minutes).
-  const skew = phaseFromClock(now + 3000) - phaseFromClock(now);
-  assert.ok(Math.abs(skew) < 0.01, `3s skew tiny: ${skew}`);
-});
-
-test('phaseFromClock guards a non-positive period', () => {
-  assert.equal(phaseFromClock(1234, 0), 0);
-  assert.equal(phaseFromClock(1234, -5), 0);
-});
-
-// ---------- lerpColor ----------------------------------------------------
-
-test('lerpColor returns the endpoints at f=0 and f=1', () => {
-  assert.equal(lerpColor(0x000000, 0xffffff, 0), 0x000000);
-  assert.equal(lerpColor(0x000000, 0xffffff, 1), 0xffffff);
-});
-
-test('lerpColor blends channel-by-channel at the midpoint', () => {
-  // (0,128,255) is the per-channel midpoint of black and 0x00ffff... use a
-  // clean case: midpoint of 0x000000 and 0x804020 is (64,32,16).
-  assert.deepEqual(chan(lerpColor(0x000000, 0x804020, 0.5)), [64, 32, 16]);
-});
-
-test('lerpColor clamps f outside [0,1]', () => {
-  assert.equal(lerpColor(0x102030, 0xa0b0c0, -1), 0x102030);
-  assert.equal(lerpColor(0x102030, 0xa0b0c0, 2), 0xa0b0c0);
-});
-
-// ---------- bracket / tintAt --------------------------------------------
-
-test('tintAt hits each keyframe exactly at its phase', () => {
-  for (const kf of KEYFRAMES) {
-    const { color, alpha } = tintAt(kf.t);
-    assert.equal(color, kf.color, `${kf.name}@${kf.t} color`);
-    assert.ok(Math.abs(alpha - kf.alpha) < 1e-9, `${kf.name}@${kf.t} alpha`);
-  }
-});
-
-test('high noon is fully transparent (base art at full strength)', () => {
-  assert.equal(tintAt(SKY_PHASES.midday).alpha, 0);
-  // The whole noon plateau holds at alpha 0.
-  assert.equal(tintAt(0.45).alpha, 0);
-  assert.equal(tintAt(0.50).alpha, 0);
-});
-
-test('golden hour is the warm hero state', () => {
-  const t = tintAt(SKY_PHASES.golden);
-  const [r, g, b] = chan(t.color);
-  assert.ok(r > g && g > b, `amber: r>g>b got ${r},${g},${b}`);
-  assert.ok(t.alpha > 0.3, `visible: ${t.alpha}`);
-  assert.equal(t.name, 'golden');
-});
-
-test('night is a dark blue-dominant tint', () => {
-  const [r, g, b] = chan(tintAt(0).color);
-  assert.ok(b > r && b > g, `blue-dominant: ${r},${g},${b}`);
-  assert.ok(tintAt(0).alpha > 0.5, 'strong');
-});
-
-test('the wrap segment interpolates nightfall → deep night across midnight', () => {
-  // phase 0.94 sits between the 0.88 nightfall keyframe and the 0.00 deep-night
-  // keyframe (read circularly). Alpha must land strictly between the two.
-  const { alpha } = tintAt(0.94);
-  assert.ok(alpha > 0.64 && alpha < 0.72, `between nightfall and deep night: ${alpha}`);
-});
-
-test('bracket picks the wrap segment for late-night phases', () => {
-  const b = bracket(0.95);
-  assert.equal(b.from.t, 0.88);
-  assert.equal(b.to.t, 0.00);
-  assert.ok(b.f > 0 && b.f < 1);
-});
-
-test('tintAt is continuous and total over the whole cycle (no gaps/throws)', () => {
-  let prev = tintAt(0);
-  for (let i = 1; i <= 1000; i++) {
-    const p = i / 1000;
-    const cur = tintAt(p);
-    assert.ok(cur.alpha >= 0 && cur.alpha <= 1, `alpha in range @${p}`);
-    // No discontinuous jump bigger than the largest keyframe-to-keyframe step.
-    assert.ok(Math.abs(cur.alpha - prev.alpha) < 0.05, `smooth @${p}`);
-    prev = cur;
-  }
-});
-
-test('tintAt wraps: phase 1.0 equals phase 0.0', () => {
-  assert.deepEqual(tintAt(1.0), tintAt(0.0));
-  assert.deepEqual(tintAt(1.5), tintAt(0.5));
-});
-
-// ---------- parseSkyOverride --------------------------------------------
-
-test('parseSkyOverride: absent / blank => null (run the live clock)', () => {
-  assert.equal(parseSkyOverride(null), null);
-  assert.equal(parseSkyOverride(undefined), null);
-  assert.equal(parseSkyOverride(''), null);
-  assert.equal(parseSkyOverride('   '), null);
-});
-
-test('parseSkyOverride: mood names (case-insensitive) => their phase', () => {
-  assert.equal(parseSkyOverride('golden'), SKY_PHASES.golden);
-  assert.equal(parseSkyOverride('NIGHT'), SKY_PHASES.night);
-  assert.equal(parseSkyOverride('Dusk'), SKY_PHASES.dusk);
-});
-
-test('parseSkyOverride: raw fractions, wrapped into [0,1)', () => {
-  assert.equal(parseSkyOverride('0.68'), 0.68);
-  assert.equal(parseSkyOverride('0'), 0);
-  assert.ok(Math.abs(parseSkyOverride('1.25') - 0.25) < 1e-9);
-});
-
-test('parseSkyOverride: garbage => null', () => {
-  assert.equal(parseSkyOverride('banana'), null);
-  assert.equal(parseSkyOverride('NaN'), null);
-});
-
-// ---------- data sanity --------------------------------------------------
-
-test('KEYFRAMES are sorted, valid colours, alphas in [0,1]', () => {
-  for (let i = 0; i < KEYFRAMES.length; i++) {
-    const kf = KEYFRAMES[i];
-    assert.ok(kf.t >= 0 && kf.t < 1, `t in [0,1): ${kf.t}`);
-    assert.ok(kf.alpha >= 0 && kf.alpha <= 1, `alpha in [0,1]: ${kf.alpha}`);
-    assert.ok(Number.isInteger(kf.color) && kf.color >= 0 && kf.color <= 0xffffff, 'color 24-bit');
-    if (i > 0) assert.ok(kf.t > KEYFRAMES[i - 1].t, `strictly ascending @${i}`);
-  }
-});
-
-test('SKY_PHASES all resolve into [0,1) and round-trip through tintAt', () => {
-  for (const [name, p] of Object.entries(SKY_PHASES)) {
-    assert.ok(p >= 0 && p < 1, `${name} phase in range`);
-    assert.doesNotThrow(() => tintAt(p), `${name} tints`);
-  }
-});
-
-console.log(`\nday_cycle: ${passed} passed`);

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