semif-api-rocm

test_roomself.cjs (17960B)

---

 // Run: node --test test_roomself.cjs
 // The self-learning puzzle room: same turn-based grid as room-rules.js with
 // every line of how-to-play prose stripped, an "insufficient" escape hatch
 // that plans at ANY plurality threshold, and a /plan trigger when the step
 // budget runs out.
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const vm = require('node:vm');
 const R = require('../semif-api/src/semif_api/web/room-rules.js');
 
 // room-self-rules.js reads the RoomRules and Planner globals at load time.
 global.RoomRules = R;
 global.Planner = { INSUFFICIENT_ID: 'insufficient' };
 const SR = require('../semif-api/src/semif_api/web/room-self-rules.js');
 
 const layout = R.makeLayout(1);
 const fresh = () => R.newState(layout);
 
 // planner.js runs in the browser as a global; load it in a VM sandbox to test
 // the trigger policy without a DOM.
 function loadPlanner() {
   const src = fs.readFileSync(require.resolve('../semif-api/src/semif_api/web/planner.js'), 'utf8');
   const sandbox = { fetch: () => { throw Error('no network in tests'); } };
   vm.createContext(sandbox);
   vm.runInContext(src + '\nthis.exports = Planner;', sandbox);
   return sandbox.exports;
 }
 
 test('neutral FPP state keeps only observations, no rules or advice', () => {
   const state = fresh();
   const text = SR.stateText(state, layout, 'fpp');
   // All four adjacent cells are described, unconditionally; the state opens
   // with egocentric labels and no compass line of any kind.
   for (const dir of ['Ahead', 'Right', 'Behind', 'Left']) {
     assert.match(text, new RegExp(`^${dir}: (open floor|a wall|the key|a locked door|the exit)$`, 'm'));
   }
   assert.doesNotMatch(text, /You face|north|east|south|west/i);
   assert.match(text, /^In view: .+\.$/m);
   assert.match(text, /You carry: no key/);
   assert.ok(text.includes(`Steps taken: 0/${R.MAX_STEPS}`));
   assert.doesNotMatch(text, /Recent events|No events yet/);   // no action history in the observation
   // Everything below is how-to-play prose this demo must never send:
   assert.doesNotMatch(text, /Reach the exit|most progress|locked door blocks|find the key|step forward into|Hint:/i);
 });
 
 test('neutral FPP state reflects actions through carry status and steps', () => {
   let state = R.turn(fresh(), 'right');                  // now facing EAST
   let text = SR.stateText(state, layout, 'fpp');
   // No action history in the observation: only the world's own facts change.
   assert.doesNotMatch(text, /turned right/);
   // Walk into the key cell if reachable from start; otherwise any forward.
   const r = R.forward(state, layout);
   state = r.state;
   text = SR.stateText(state, layout, 'fpp');
   assert.ok(text.includes(`Steps taken: 2/${R.MAX_STEPS}`));
   if (r.outcome === 'key') assert.match(text, /You carry: the key/);
 });
 
 test('adjacency lines describe all four cells in egocentric directions', () => {
   // Hand-built 11x9: player at (2,2) facing EAST; wall north (left), key
   // south (right), exit west (behind), open floor ahead.
   const grid = Array.from({ length: R.H }, (_, y) =>
     Array.from({ length: R.W }, (_, x) =>
       (x === 0 || y === 0 || x === R.W - 1 || y === R.H - 1) ? "#" : "."));
   grid[1][2] = "#"; grid[3][2] = "K"; grid[2][1] = "E";
   const L = { grid: grid.map((r) => r.join("")), start: { x: 2, y: 2 },
               key: { x: 2, y: 3 }, exit: { x: 1, y: 2 }, doorRow: 2, seed: 0 };
   const state = R.turn(R.newState(L), 'right');          // facing EAST
   const text = SR.stateText(state, L, 'fpp');
   assert.match(text, /^Ahead: open floor$/m);
   assert.match(text, /^Right: the key$/m);
   assert.match(text, /^Behind: the exit$/m);
   assert.match(text, /^Left: a wall$/m);
   // The cone line is separate: nothing ahead falls inside the 120° cone.
   assert.match(text, /^In view: nothing\.$/m);
   // Carried key: its cell reads as open floor.
   assert.match(SR.stateText({ ...state, hasKey: true }, L, 'fpp'), /^Right: open floor$/m);
 });
 
 test('adjacency lines name the locked and open door; open field is all floor', () => {
   const grid = Array.from({ length: R.H }, (_, y) =>
     Array.from({ length: R.W }, (_, x) =>
       (x === 0 || y === 0 || x === R.W - 1 || y === R.H - 1) ? "#" : "."));
   grid[2][3] = "D";
   const L = { grid: grid.map((r) => r.join("")), start: { x: 2, y: 2 },
               key: { x: 1, y: 1 }, exit: { x: 8, y: 6 }, doorRow: 2, seed: 0 };
   const facing = R.turn(R.newState(L), 'right');         // door directly ahead (east)
   assert.match(SR.stateText(facing, L, 'fpp'), /^Ahead: a locked door$/m);
   const opened = SR.stateText({ ...facing, doorOpen: true }, L, 'fpp');
   assert.match(opened, /^Ahead: open floor$/m);          // an opened door is just floor
   // An open field: every direction explicitly described, none omitted.
   const L2 = { ...L, grid: L.grid.map((r, y) => y === 2 ? r.replace("D", ".") : r) };
   const text2 = SR.stateText(R.turn(R.newState(L2), 'right'), L2, 'fpp');
   for (const dir of ['Ahead', 'Right', 'Behind', 'Left']) {
     assert.match(text2, new RegExp(`^${dir}: open floor$`, 'm'));
   }
 });
 
 test('In view lists only FOV-visible objects, bearing only, nearest first', () => {
   // Player at (5,5) facing NORTH (dir 0): key just left of ahead, door just
   // right of ahead, exit further ahead-left with a clear line past the key —
   // all inside the 120° cone.
   const grid = Array.from({ length: R.H }, (_, y) =>
     Array.from({ length: R.W }, (_, x) =>
       (x === 0 || y === 0 || x === R.W - 1 || y === R.H - 1) ? "#" : "."));
   grid[2][4] = "K"; grid[2][6] = "D"; grid[1][3] = "E";
   const L = { grid: grid.map((r) => r.join("")), start: { x: 5, y: 5 },
               key: { x: 4, y: 2 }, exit: { x: 3, y: 1 }, doorRow: 2, seed: 0 };
   const north = R.newState(L);   // dir 0 = NORTH
   assert.deepEqual(R.visibleObjects(north, L), [
     { name: "the key", bearing: "ahead" },
     { name: "a locked door", bearing: "ahead" },
     { name: "the exit", bearing: "ahead-left" },
   ]);
   // Facing SOUTH everything is behind the view plane: the empty form.
   const south = { ...north, dir: 2 };
   assert.deepEqual(R.visibleObjects(south, L), []);
   assert.match(SR.stateText(south, L, 'fpp'), /^In view: nothing\.$/m);
   // Carried key leaves the view.
   const carrying = { ...north, hasKey: true };
   assert.deepEqual(R.visibleObjects(carrying, L), [
     { name: "a locked door", bearing: "ahead" },
     { name: "the exit", bearing: "ahead-left" },
   ]);
   // A ~63° bearing with a clear line of sight is still outside the 120°
   // cone's ±60° edge.
   const g = L.grid.map((r) => r.split(""));
   g[3][9] = "K";
   const L3 = { ...L, grid: g.map((r) => r.join("")), key: { x: 9, y: 3 } };
   assert.deepEqual(R.visibleObjects(R.newState(L3), L3), [
     { name: "a locked door", bearing: "ahead" },
     { name: "the exit", bearing: "ahead-left" },
   ]);
   // …and a 45° diagonal now falls INSIDE the widened cone.
   const g4 = L.grid.map((r) => r.split(""));
   g4[2][8] = "K";
   const L4 = { ...L, grid: g4.map((r) => r.join("")), key: { x: 8, y: 2 } };
   const v4 = R.visibleObjects(R.newState(L4), L4);
   assert.ok(v4.some((o) => o.name === "the key" && o.bearing === "ahead-right"));
 });
 
 test('Known line gives bearings to discovered POIs that are out of view', () => {
   // Player (5,5) facing NORTH; door (5,2) and exit (5,1) behind the wall at
   // (5,4); key at (9,7), out of the cone behind-right. (Same fixture as the
   // occlusion test.)
   const grid = Array.from({ length: R.H }, (_, y) =>
     Array.from({ length: R.W }, (_, x) =>
       (x === 0 || y === 0 || x === R.W - 1 || y === R.H - 1) ? "#" : "."));
   grid[2][5] = "D"; grid[1][5] = "E"; grid[4][5] = "#"; grid[7][9] = "K";
   const L = { grid: grid.map((r) => r.join("")), start: { x: 5, y: 5 },
               key: { x: 9, y: 7 }, exit: { x: 5, y: 1 }, doorRow: 2, seed: 0 };
   const state = R.newState(L);
   const all = new Set(["key", "door", "exit"]);
   // Nothing discovered yet: the explicit empty form.
   assert.match(SR.stateText(state, L, 'fpp', new Set()), /^Known: nothing\.$/m);
   // All discovered, all out of view: bearings, nearest first. Door and exit
   // sit dead ahead of the player — exact cardinal alignments read "directly
   // X" — and the wall at (5,4) blocks the line to both, so they say so.
   assert.match(SR.stateText(state, L, 'fpp', all),
     /^Known: a locked door directly ahead \(blocked\); the exit directly ahead \(blocked\); the key behind-right\.$/m);
   // Wall gone: the door is now in view, so In view owns it — no double entry.
   const g2 = L.grid.map((r) => r.split("")); g2[4][5] = ".";
   const L2 = { ...L, grid: g2.map((r) => r.join("")) };
   // The exit's line now passes the LOCKED door: still blocked. The key's
   // line is clear — an unblocked bearing is a guaranteed walkable straight
   // line.
   assert.match(SR.stateText(state, L2, 'fpp', all),
     /^Known: the exit directly ahead \(blocked\); the key behind-right\.$/m);
   // Door open: it is no longer a POI; the exit shows through it (in view).
   assert.match(SR.stateText({ ...state, doorOpen: true }, L2, 'fpp', all),
     /^Known: the key behind-right\.$/m);
   // Carried key: present-check drops it even though it was discovered.
   assert.match(SR.stateText({ ...state, hasKey: true }, L, 'fpp', all),
     /^Known: a locked door directly ahead \(blocked\); the exit directly ahead \(blocked\)\.$/m);
 });
 
 test('corner graze behind the locked door does not leak the exit (default seed)', () => {
   // Regression: on seed 1, standing east of the door facing it, the ray to
   // the exit's center passed exactly through the grid corner shared by the
   // door cell and the wall cell behind it. The DDA tie-break stepped into
   // the open diagonal past both blockers, and the strict dist < entry
   // comparison let the epsilon-equal graze slip through — the exit showed
   // in view through two sets of walls. Corner grazes now block.
   const L = R.makeLayout(1);
   let door;
   for (let y = 0; y < R.H; y++) for (let x = 0; x < R.W; x++)
     if (L.grid[y][x] === "D") door = { x, y };
   assert.ok(door, "seed-1 layout has a door");
   const east = { x: door.x - 4, y: door.y, dir: 1, hasKey: false, doorOpen: false, steps: 0 };
   const names = R.visibleObjects(east, L).map((o) => o.name);
   assert.ok(names.includes("a locked door"), "the door itself is visible: " + names);
   assert.ok(!names.includes("the exit"), "exit must not leak through the graze: " + names);
   // The companion regression: standing ON the key facing the door (it is
   // ahead-left, plainly drawn by the renderer) must discover it. A single
   // center ray is blocked by the corner of (3,4) on this layout; the
   // renderer and the text both treat a cell as visible when any
   // sightline reaches it.
   const onKey = { x: L.key.x, y: L.key.y, dir: 2, hasKey: false, doorOpen: false, steps: 0 };
   const seen = R.visibleObjects(onKey, L);
   const d = seen.find((o) => o.name === "a locked door");
   assert.ok(d, "door discovered while standing on the key: " + JSON.stringify(seen));
   assert.equal(d.bearing, "ahead-left");
 });
 
 test('Known line respects walls and the locked door; an open door is transparent', () => {
   const grid = Array.from({ length: R.H }, (_, y) =>
     Array.from({ length: R.W }, (_, x) =>
       (x === 0 || y === 0 || x === R.W - 1 || y === R.H - 1) ? "#" : "."));
   grid[2][5] = "D"; grid[1][5] = "E"; grid[4][5] = "#";   // wall between player and door
   grid[7][9] = "K";                                       // key behind-right, out of the cone
   const L = { grid: grid.map((r) => r.join("")), start: { x: 5, y: 5 },
               key: { x: 9, y: 7 }, exit: { x: 5, y: 1 }, doorRow: 2, seed: 0 };
   const state = R.newState(L);
   // The door and exit sit behind the wall at (5,4): nothing to see.
   assert.deepEqual(R.visibleObjects(state, L), []);
   // Remove the wall: the locked door occludes the exit behind it.
   const g2 = L.grid.map((r) => r.split(""));
   g2[4][5] = ".";
   const L2 = { ...L, grid: g2.map((r) => r.join("")) };
   assert.deepEqual(R.visibleObjects(state, L2), [
     { name: "a locked door", bearing: "directly ahead" },
   ]);
   // Open the door: it is no longer a POI — the doorway is just floor — and
   // the exit beyond it shows through.
   assert.deepEqual(R.visibleObjects({ ...state, doorOpen: true }, L2), [
     { name: "the exit", bearing: "directly ahead" },
   ]);
 });
 
 
 test('neutral map state keeps the legend and grid but no instructions', () => {
   const text = SR.stateText(fresh(), layout, 'map');
   assert.match(text, /#.: wall/);                       // legend names the wall symbol
   assert.match(text, /locked door/);                   // legend names the door symbol
   assert.ok(text.includes(`Steps taken: 0/${R.MAX_STEPS}`));
   assert.match(text, /^# # #/m);                       // top border row of the grid
   assert.doesNotMatch(text, /Recent events|No events yet/);   // no action history here either
   // Instructional lines from the ruled mapText must be gone:
   assert.doesNotMatch(text, /Reach the exit|Stepping onto the key/i);
 });
 
 test('options are the actions plus the insufficient escape hatch', () => {
   assert.deepEqual(SR.OPTIONS.map((o) => o.id), ['forward', 'left', 'right', 'insufficient']);
   assert.equal(SR.QUESTION, 'What should the player do now?');
   // Descriptions are names only, deliberately — mechanics are the planner's
   // job to discover and state as rules, not ours to pre-chew per decision.
   assert.equal(SR.OPTIONS[0].description, 'Move one step ahead.');
   assert.equal(SR.OPTIONS[1].description, 'Turn in place 90 degrees to the left.');
 });
 
 test('forward is withheld when the faced cell is a no-op', () => {
   // Hand-built 11x9: wall directly north of start, locked door to the east.
   const grid = Array.from({ length: R.H }, (_, y) =>
     Array.from({ length: R.W }, (_, x) =>
       (x === 0 || y === 0 || x === R.W - 1 || y === R.H - 1) ? "#" : "."));
   grid[1][2] = "#"; grid[2][3] = "D";
   const L = { grid: grid.map((r) => r.join("")), start: { x: 2, y: 2 },
               key: { x: 5, y: 5 }, exit: { x: 8, y: 6 }, doorRow: 2, seed: 0 };
   const north = R.newState(L);                          // wall ahead
   assert.ok(!R.optionsFor(north, L).some((o) => o.id === "forward"));
   assert.ok(R.optionsFor(north, L).some((o) => o.id === "left"));
   const east = R.turn(north, 'right');                  // locked door ahead, no key
   assert.ok(!R.optionsFor(east, L).some((o) => o.id === "forward"));
   // Carrying the key: the door is enterable, forward returns.
   assert.ok(R.optionsFor({ ...east, hasKey: true }, L).some((o) => o.id === "forward"));
   // The SL variant always keeps the insufficient escape hatch.
   const sl = SR.optionsFor(north, L).map((o) => o.id);
   assert.deepEqual(sl, ['left', 'right', 'insufficient']);
 });
 
 test('PLAN_GOAL is a single factual statement of the goal', () => {
   assert.match(SR.PLAN_GOAL, /exit/);
   assert.doesNotMatch(SR.PLAN_GOAL, /\n/);   // one line, not an essay
 });
 
 test('planner threshold is a policy knob: 0.99 default, any plurality for the room', () => {
   const Planner = loadPlanner();
   assert.equal(Planner.INSUFFICIENT_THRESHOLD, 0.99);
   const result = (probs) => ({ option_ids: ['forward', 'left', 'right', 'insufficient'], probabilities: probs });
   // Platformer policy: a weak plurality must NOT trigger.
   assert.equal(Planner.triggered(result([0.30, 0.28, 0.27, 0.15])), false);
   assert.equal(Planner.triggered(result([0.001, 0.001, 0.008, 0.99])), true);
   // Room policy (threshold 0): any insufficient plurality triggers.
   assert.equal(Planner.triggered(result([0.28, 0.20, 0.18, 0.34]), 0), true);
   assert.equal(Planner.triggered(result([0.40, 0.30, 0.20, 0.10]), 0), false);
 });
 
 test('demo is hosted as its own tab with the scripts ordered by dependency', () => {
   const html = fs.readFileSync(require.resolve('../semif-api/src/semif_api/web/index.html'), 'utf8');
   assert.match(html, /id="tab-roomself"/);
   assert.match(html, /id="panel-roomself"/);
   assert.match(html, />Platformer SL<\/button>/);       // the platformer SL tab is renamed
   assert.match(html, />Puzzle room SL<\/button>/);
   assert.match(html, /id="rs-cv"/);
   assert.match(html, /id="rs-stats"/);                 // completion-stats pane ships
   assert.match(html, /<textarea id="rs-rules-view"[^>]*class="rules-edit"/);
   assert.match(html, /<script src="planner\.js"><\/script>\s*<script src="self-rules\.js">/);
   assert.match(html, /<script src="room-rules\.js"><\/script>\s*<script src="room\.js"><\/script>\s*<script src="room-self-rules\.js"><\/script>\s*<script src="room-self-game\.js"><\/script>/);
   assert.doesNotMatch(html, /[\x00-\x08\x0B\x0C\x0E-\x1F]/);  // no stray control chars
 });
 
 test('room SL game loop script parses and wires the plan triggers', () => {
   const js = fs.readFileSync(require.resolve('../semif-api/src/semif_api/web/room-self-game.js'), 'utf8');
   new vm.Script(js);   // throws on any syntax error (it is a top-level IIFE)
   assert.match(js, /INSUFFICIENT_P = 0/);              // any plurality plans
   assert.match(js, /Planner\.triggered\(result, INSUFFICIENT_P\)/);
   assert.match(js, /Planner\.context\(SelfRoomRules\.PLAN_GOAL/);
   assert.match(js, /replanAndRetry\("steps"\)/);       // budget exhaustion plans + restarts
   assert.match(js, /replanAndRetry\("insufficient"\)/); // …and so does a confident insufficient
   assert.match(js, /Rules:\\n\$\{learnedRules\}\\n\\n\$\{base\}/); // rules lead
   assert.match(js, /function bareState\(\)/);          // transcript records the BARE state,
   assert.match(js, /pending = \{ state: observed, choice \}/);  // rules reach the planner once, via /plan context
   assert.match(js, /setPlanningStatus/);               // planning status waves
   assert.match(js, /function reset\(\) \{[\s\S]*?clearLog\(\);/);   // reset clears the side pane
   assert.match(js, /rs-state-view/);
 });