@bongos/core 1.17.0

package/tests/terrain_picker.mjs

@@ -0,0 +1,298 @@
+// 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/touches_overlap.mjs

@@ -0,0 +1,75 @@
+// tests/touches_overlap.mjs
+//
+// Coverage for touches[] cleanup [5/8] (task 880): the unified, prefix-aware
+// overlap matcher (src/bongos/path-match.touchesOverlap) that claimTask,
+// claimTasksBatch, and the optimizer all share. The bug it fixes: the old
+// Postgres `&&` (exact-element) and JS Set-equality matchers treated
+// ['src/bongos/'] and ['src/bongos/db.js'] as DISJOINT — they are not.
+//
+// Run:  node tests/touches_overlap.mjs
+
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { touchesOverlap, matchOne } = require('../src/bongos/path-match.js');
+
+const tests = [];
+const test = (name, fn) => tests.push({ name, fn });
+
+test('exact-element overlap', () => {
+  assert.equal(touchesOverlap(['src/bongos/db.js'], ['src/bongos/db.js']), true);
+  assert.equal(touchesOverlap(['migrations/'], ['migrations/']), true);
+});
+
+test('dir-prefix overlap — the case the old `&&`/Set matchers MISSED', () => {
+  // ['src/bongos/'] declares the whole dir; ['src/bongos/db.js'] is a file under it.
+  assert.equal(touchesOverlap(['src/bongos/'], ['src/bongos/db.js']), true);
+  // symmetric — order must not matter
+  assert.equal(touchesOverlap(['src/bongos/db.js'], ['src/bongos/']), true);
+  // bare dir (no trailing slash) still treated as a prefix
+  assert.equal(touchesOverlap(['src/bongos'], ['src/bongos/routes/tasks.js']), true);
+});
+
+test('disjoint sets do not overlap', () => {
+  assert.equal(touchesOverlap(['src/bongos/db.js'], ['public/game/main.js']), false);
+  assert.equal(touchesOverlap(['migrations/'], ['art/']), false);
+  // sibling files under a shared ancestor but neither is a prefix of the other
+  assert.equal(touchesOverlap(['src/bongos/db.js'], ['src/bongos/grader.js']), false);
+});
+
+test('partial-segment names are NOT a false prefix', () => {
+  // 'src/bongos' must not match 'src/bongosx/...' — matchOne appends a '/' boundary.
+  assert.equal(touchesOverlap(['src/bongos'], ['src/bongosx/y.js']), false);
+});
+
+test('empty / null inputs never overlap and never throw', () => {
+  assert.equal(touchesOverlap([], ['src/bongos/db.js']), false);
+  assert.equal(touchesOverlap(['src/bongos/db.js'], []), false);
+  assert.equal(touchesOverlap(null, null), false);
+  assert.equal(touchesOverlap(['', null], ['']), false);
+});
+
+test('multi-entry: overlap if ANY pair overlaps', () => {
+  assert.equal(
+    touchesOverlap(['public/x.js', 'src/bongos/'], ['docs/', 'src/bongos/db.js']),
+    true,
+  );
+  assert.equal(
+    touchesOverlap(['public/x.js', 'scripts/a.js'], ['docs/', 'src/bongos/db.js']),
+    false,
+  );
+});
+
+test('built on the same matchOne the conductor uses (contract unchanged)', () => {
+  assert.equal(matchOne('src/bongos/db.js', ['src/bongos/']), 'src/bongos/');
+  assert.equal(matchOne('server.js', ['src/bongos/']), null);
+});
+
+let pass = 0, fail = 0;
+for (const { name, fn } of tests) {
+  try { await fn(); console.log(`PASS  ${name}`); pass++; }
+  catch (e) { console.log(`FAIL  ${name}`); console.log(`      ${e.message}`); fail++; }
+}
+console.log(`\n${pass} passed, ${fail} failed`);
+process.exit(fail === 0 ? 0 : 1);

package/tests/triage_development.mjs

@@ -0,0 +1,140 @@
+// tests/triage_development.mjs
+//
+// Unit tests for the triage development-cache helpers (task 930). Covers the
+// pure parts — path resolution, tolerant parsing of both cache shapes, and
+// block rendering. The interactive walk + API I/O are exercised by a real
+// /idea-triage run, not here.
+//
+// Run:  node tests/triage_development.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const {
+  resolveDevelopmentPath,
+  parseDevelopment,
+  loadDevelopment,
+  formatDevelopment,
+} = require('../scripts/gds/triage.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+// ---------- resolveDevelopmentPath ----------
+
+test('resolveDevelopmentPath: --development <path>', () => {
+  assert.equal(resolveDevelopmentPath(['node', 't.js', '--development', '/tmp/d.json'], {}), '/tmp/d.json');
+});
+
+test('resolveDevelopmentPath: --development=<path>', () => {
+  assert.equal(resolveDevelopmentPath(['node', 't.js', '--development=/tmp/e.json'], {}), '/tmp/e.json');
+});
+
+test('resolveDevelopmentPath: env fallback', () => {
+  assert.equal(resolveDevelopmentPath(['node', 't.js'], { OTB_IDEA_DEVELOPMENT: '/tmp/env.json' }), '/tmp/env.json');
+});
+
+test('resolveDevelopmentPath: flag beats env', () => {
+  assert.equal(
+    resolveDevelopmentPath(['node', 't.js', '--development', '/tmp/flag.json'], { OTB_IDEA_DEVELOPMENT: '/tmp/env.json' }),
+    '/tmp/flag.json',
+  );
+});
+
+test('resolveDevelopmentPath: none → null', () => {
+  assert.equal(resolveDevelopmentPath(['node', 't.js'], {}), null);
+});
+
+// ---------- parseDevelopment ----------
+
+test('parseDevelopment: object-map form keyed by id', () => {
+  const m = parseDevelopment(JSON.stringify({ generated_at: 'x', ideas: { 228: { summary: 's' } } }));
+  assert.equal(m.size, 1);
+  assert.equal(m.get('228').summary, 's');
+});
+
+test('parseDevelopment: bare-array form keyed by idea_id', () => {
+  const m = parseDevelopment(JSON.stringify([{ idea_id: 7, summary: 'a' }, { id: 9, summary: 'b' }]));
+  assert.equal(m.size, 2);
+  assert.equal(m.get('7').summary, 'a');
+  assert.equal(m.get('9').summary, 'b');
+});
+
+test('parseDevelopment: bare {id: block} map', () => {
+  const m = parseDevelopment(JSON.stringify({ 42: { summary: 'z' } }));
+  assert.equal(m.get('42').summary, 'z');
+});
+
+test('parseDevelopment: empty / junk → empty map (no throw)', () => {
+  assert.equal(parseDevelopment('').size, 0);
+  assert.equal(parseDevelopment('   ').size, 0);
+  assert.equal(parseDevelopment('not json{').size, 0);
+  assert.equal(parseDevelopment(JSON.stringify(null)).size, 0);
+});
+
+test('parseDevelopment: skips null/non-object blocks', () => {
+  const m = parseDevelopment(JSON.stringify({ ideas: { 1: null, 2: 'str', 3: { summary: 'ok' } } }));
+  assert.equal(m.size, 1);
+  assert.ok(m.has('3'));
+});
+
+// ---------- loadDevelopment ----------
+
+test('loadDevelopment: null path → empty map', () => {
+  assert.equal(loadDevelopment(null).size, 0);
+});
+
+test('loadDevelopment: missing file → empty map (no throw)', () => {
+  assert.equal(loadDevelopment('/nonexistent/triage-dev-xyz.json').size, 0);
+});
+
+// ---------- formatDevelopment ----------
+
+test('formatDevelopment: empty block → empty string', () => {
+  assert.equal(formatDevelopment(null), '');
+  assert.equal(formatDevelopment({}), '');
+  assert.equal(formatDevelopment('nope'), '');
+});
+
+test('formatDevelopment: renders all sections', () => {
+  const out = formatDevelopment({
+    summary: 'Adds X',
+    integration_surfaces: ['a.js', 'b.js'],
+    open_questions: ['Who owns it?'],
+    challenges: ['Hard bit'],
+    risks: ['Could break Y'],
+    rough_effort: 'M',
+    recommendation: 'promote',
+  });
+  assert.match(out, /summary: Adds X/);
+  assert.match(out, /surfaces: a\.js, b\.js/);
+  assert.match(out, /open questions:/);
+  assert.match(out, /• Who owns it\?/);
+  assert.match(out, /challenges:/);
+  assert.match(out, /risks:/);
+  assert.match(out, /effort: M/);
+  assert.match(out, /recommendation: promote/);
+});
+
+test('formatDevelopment: omits absent sections', () => {
+  const out = formatDevelopment({ summary: 'just a summary' });
+  assert.match(out, /summary: just a summary/);
+  assert.doesNotMatch(out, /open questions:/);
+  assert.doesNotMatch(out, /challenges:/);
+  assert.doesNotMatch(out, /risks:/);
+});
+
+test('formatDevelopment: empty arrays render nothing', () => {
+  const out = formatDevelopment({ summary: 's', open_questions: [], challenges: [''] });
+  assert.doesNotMatch(out, /open questions:/);
+  assert.doesNotMatch(out, /challenges:/);
+});
+
+// ---------- summary ----------
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);