Physics test pass for sand, molten metal and gases; stuck gas finishes, steam is not deleted (t21)

- New test/t_physics.js: heaps, sorting, sinking, world edges; molten copper levelling, setting,
  quenching, slag over copper, cavity filling; smoke, steam, fire, sealed pockets, the top row.
- Gas in a sealed pocket kept its area asleep and never faded or condensed: gas() keeps its area
  awake while it lasts.
- A rain drop or blown grain landing on steam deleted the steam's water: it goes to the clouds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

docs/PROJECT_MAP.md

@@ -226,7 +226,7 @@ Exploration only: never changes grains or the random stream.
 - functions: fogAlloc, fogMark, fogSeen, fogInit, fogLook, fogRevealAround, fogRevealAll
 - variables: FOG, FOG_SENSE, FOG_SENSE_FADE, fog, FW, FH
 
-### src/sim/cells.js (187 lines)
+### src/sim/cells.js (189 lines)
 Cell helpers (setCell, move, enter) and the falling-sand movement of powders, liquids and gases (simMove).
 - functions: setCell, swapCells, move, enter, powder, passable, liquid, gas, simMove
 - variables: SORTP, LSTEP, LFILM
@@ -293,7 +293,7 @@ Trees (background layer), acorns, saplings, and waking freezing water.
 - functions: cutTree, treeHeld, findTreeBases, treeSupportTick, woodRoom, treeFall, coldTick, plantTick, setTreeCell, saplingTick, igniteTree
 - variables: treeBases, saplings, treeDraw
 
-### src/sim/vacuum.js (166 lines)
+### src/sim/vacuum.js (172 lines)
 The vacuum, blowing grains out, grains in flight (flyers), and the flame tool. Material the vacuum would start on at the cursor: a bar, else the nearest loose grain.
 - functions: vacuumTargetAt, toolVacuum, nozzle, toolBlow, flyOpen, depositNear, bagTemp, landFlyer, flyTick, toolIgnite
 - variables: blowRR, FLY_G, FLY_Q
@@ -472,6 +472,7 @@ The frame loop and boot.
 - `test/t_fog.js`: Fog: surface, sight, range, saves and simulation independence.
 - `test/t_furnace_repeat.js`: The starter furnaces keep working when fired again and again without cleaning, however the charge goes in: mixed, ore first with coal on top, or blown in through the vent. Each case plays furnace_play.js, which builds the design and fires it like a player.
 - `test/t_molds.js`: Molds and furnaces stay usable: ingots drop below and keep their stubs, plugs over molds are cleared, spoiled castings can be knocked out, grains never drop through a grate by teleporting, and slag lets the fire breathe.
+- `test/t_physics.js`: Sand and other powders, molten metal and gases: heaps, sorting, sinking, setting, rising and fading. Water has its own suite (t_water.js). Tall worlds keep geothermal heat out of the way.
 - `test/t_pipes.js`: Pipes, pumps and outlets move liquids; the Grinder grinds waste rock for trace ore.
 - `test/t_racks.js`: Rack intake, FIFO storage, gate, removal and saved-state validation.
 - `test/t_smooth.py`: The smooth look: the WebGL pass compiles, draws, falls back cleanly, and the thermal lens still works.

docs/agent-log.md

@@ -4,6 +4,21 @@ What agents have done, newest first. Add an entry for every piece of work: the d
 note or request it was for, what changed, the files touched, the tests run, and anything left
 open or not verified. Keep each entry short; the git history has the details.
 
+## 2026-10-24: t21 phase 2: physics test pass for sand, molten metal and gases (Claude Code, Codex)
+
+- `test/t_physics.js` (41 checks): heaps, digging under a heap, ore sorting through ash, sand
+  sinking in a pond, world edges; molten copper levelling (slower than water), setting, sinking in
+  a pond, slag over copper, filling a cavity; smoke rising and fading (longer under a roof), steam
+  condensing, fire going out, gas in sealed pockets, gas leaving at the top row. Every scenario
+  checks that its areas go back to sleep.
+- Found and fixed: gas stuck in a pocket never finished fading or condensing because its area
+  slept (`gas()` keeps its area awake: steady cost 1.34 -> 1.37 ms/tick); a rain drop or blown
+  grain landing on steam deleted that steam's water (`landFlyer`/`depositNear` in
+  `src/sim/vacuum.js` now send it to the clouds).
+- Found, owner decided: a resting pile never sorts. To follow: piles near the bot keep sorting,
+  and sorting gets quick.
+- Tests: `run_all.py --browser` ALL PASSED; seeds 777 and 77 generate the same worlds.
+
 ## 2026-10-24: t21 phase 1: water test pass, faster pouring, rain spreads (Claude Code, Codex)
 
 - `test/t_water.js` (20 checks): conservation, levelling and sleep, pools pouring off ledges,

src/sim/cells.js

@@ -126,6 +126,8 @@ function liquid(i, x, y, m) {
   }
 }
 function gas(i, x, y, m) {
+  // Even blocked gas must keep aging or condensing until it is gone.
+  awake[(y >> 5) * CW + (x >> 5)] = 3;
   if (m === FIRE) {
     const l = life[i];
     if (l <= 1) { mat[i] = EMPTY; life[i] = 0; wakeXY(x, y); return; }

src/sim/vacuum.js

@@ -108,7 +108,10 @@ function depositNear(m, T, x, y, skip) {
       const xx = x + dx, yy = y + dy;
       if (xx < 0 || yy < 0 || xx >= W || yy >= H) continue;
       const j = yy * W + xx;
-      if (j !== skip && flyOpen(m, j)) { setCell(j, m, T, 0); return true; }
+      if (j !== skip && flyOpen(m, j)) {
+        if (mat[j] === STEAM) absorbSteam(xx); // displaced steam still belongs to the world's water
+        setCell(j, m, T, 0); return true;
+      }
     }
   }
   return false;
@@ -121,7 +124,10 @@ function landFlyer(f, x, y) {
   for (let k = 0; k < 8; k++) {
     const yy = y - k; if (yy < 0) break;
     const j = yy * W + x;
-    if (flyOpen(f.m, j)) { setCell(j, f.m, f.T, 0); return; }
+    if (flyOpen(f.m, j)) {
+      if (mat[j] === STEAM) absorbSteam(x); // landing replaces the gas, so keep its water in the clouds
+      setCell(j, f.m, f.T, 0); return;
+    }
   }
   if (!depositNear(f.m, f.T, x, y)) { if (f.rain) absorbSteam(x); else bagAdd(f.m, 1, true); } // nowhere to go: back into the bag (rain: back into the clouds)
 }

test/t_physics.js

@@ -0,0 +1,212 @@
+// Sand and other powders, molten metal and gases: heaps, sorting, sinking, setting, rising and
+// fading. Water has its own suite (t_water.js). Tall worlds keep geothermal heat out of the way.
+const { load, suite, flatWorld, rect, count, ticks } = require('./harness');
+const { run } = load();
+const { check, done } = suite();
+const started = Date.now();
+const awake = () => run('awake.reduce((n, v) => n + (v > 0), 0)');
+const grains = m => count(run, run(m));
+function world(w = 320, ground = 120) { run('WS = 12345;'); flatWorld(run, w, 600, ground); run('RS = 12345;'); }
+// the top grain row of each column in x0..x1 (ground row if none)
+const tops = (m, x0, x1, ground) => run(`(() => { const a = []; for (let x = ${x0}; x <= ${x1}; x++) { let y = ${ground}; for (let j = 0; j < ${ground}; j++) if (mat[j*W+x] === ${m}) { y = j; break; } a.push(y); } return a; })()`);
+
+// Sand and powders
+// sand poured from one point makes a heap with sloping sides, then lies still
+world();
+for (let k = 0; k < 400; k++) { run('if (mat[40*W+160] === EMPTY) setCell(40*W+160, SAND, AMB[40], 0);'); ticks(run, 2); }
+ticks(run, 1800);
+const heap = tops(run('SAND'), 100, 220, 120), peak = Math.min(...heap), wide = heap.filter(y => y < 120).length;
+check('poured sand makes a sloping heap that lies still', grains('SAND') === 400 && 120 - peak >= 5 && wide >= 12 && wide <= 80 && awake() === 0,
+  `${grains('SAND')} grains, ${120 - peak} high, ${wide} wide, ${awake()} areas awake`);
+// digging out the ground under the heap lets it fall in, and none is lost
+run('for (let y = 120; y < 160; y++) for (let x = 140; x < 180; x++) setCell(y*W+x, EMPTY, AMB[y], 0);');
+ticks(run, 1800);
+check('digging under a heap makes it fall into the hole', grains('SAND') === 400 && count(run, run('SAND'), 140, 120, 179, 159) > 300,
+  `${count(run, run('SAND'), 140, 120, 179, 159)} of ${grains('SAND')} in the hole`);
+asleep('sand after digging');
+// heavy ore works its way down through light ash, slowly, while the pile is being stirred (a
+// working furnace bed is always awake); a pile left at rest goes to sleep and stays as it is
+world();
+rect(run, 150, 100, 151, 119, run('STONE')); rect(run, 170, 100, 171, 119, run('STONE'));
+rect(run, 152, 112, 169, 119, run('ASH')); rect(run, 152, 108, 169, 111, run('CUORE'));
+const oreY = (m) => run(`(() => { let s = 0, n = 0; for (let i = 0; i < N; i++) if (mat[i] === ${m}) { s += (i / W) | 0; n++; } return s / n; })()`);
+const ore0 = oreY(run('CUORE')); ticks(run, 3600); const oreRest = oreY(run('CUORE'));
+check('a resting pile of ore on ash goes to sleep as it is', Math.abs(oreRest - ore0) < 0.5 && awake() === 0, `ore rows ${ore0.toFixed(1)} -> ${oreRest.toFixed(1)}, ${awake()} awake`);
+const stir = n => run(`for (let k = 0; k < ${n}; k++) { if (k % 8 === 0) wakeXY(160, 112); simTick(); }`);
+stir(600); const ore1 = oreY(run('CUORE')); stir(5400); const ore2 = oreY(run('CUORE'));
+check('stirred, heavy ore sinks down through light ash, slowly', ore1 - oreRest < 2 && ore2 - oreRest > 2 && grains('CUORE') === 72 && grains('ASH') === 144,
+  `ore rows ${oreRest.toFixed(1)} -> ${ore1.toFixed(1)} -> ${ore2.toFixed(1)}`);
+ticks(run, 1200); asleep('ore after stirring stops');
+world();
+rect(run, 150, 100, 151, 119, run('STONE')); rect(run, 170, 100, 171, 119, run('STONE'));
+rect(run, 152, 112, 169, 119, run('LDIRT')); rect(run, 152, 104, 169, 111, run('SAND'));
+const sand0 = oreY(run('SAND')); ticks(run, 6000);
+check('sand on dirt (close in weight) stays where it is', Math.abs(oreY(run('SAND')) - sand0) < 0.5, `sand rows ${sand0.toFixed(1)} -> ${oreY(run('SAND')).toFixed(1)}`);
+asleep('a pile of similar weights');
+// sand dropped into a pond sinks, and the water ends up on top
+world();
+rect(run, 150, 90, 151, 119, run('STONE')); rect(run, 190, 90, 191, 119, run('STONE'));
+rect(run, 152, 100, 189, 119, run('WATER')); rect(run, 160, 70, 181, 79, run('SAND'));
+const pond = run('worldWater()'); ticks(run, 3600);
+const sandLow = count(run, run('SAND'), 152, 112, 189, 119), waterHigh = count(run, run('WATER'), 152, 90, 189, 111);
+check('sand dropped in a pond sinks to the bottom, the water ends up on top', grains('SAND') === 220 && run('worldWater()') === pond && sandLow > 200 && waterHigh > 400,
+  `${sandLow} of ${grains('SAND')} sand in the bottom rows, ${waterHigh} water above, water ${pond} -> ${run('worldWater()')}`);
+asleep('a sandy pond');
+// powders against the world's sides and on the bottom row neither leak nor wrap
+world(80);
+rect(run, 0, 60, 5, 79, run('SAND')); rect(run, 74, 60, 79, 79, run('SAND'));
+ticks(run, 1200);
+check('sand piled against the world edges stays in the world', grains('SAND') === 240 && count(run, run('SAND'), 0, 0, 79, 119) === 240, `${grains('SAND')} grains`);
+
+asleep('sand at the world edges');
+world(80, 600); run('AMB.fill(20); temp.fill(20);');
+rect(run, 30, 599, 49, 599, run('SAND')); ticks(run, 600);
+check('sand on the bottom row neither leaks nor wraps', grains('SAND') === 20 && count(run, run('SAND'), 30, 599, 49, 599) === 20 && awake() === 0,
+  `${grains('SAND')}/20 total, ${count(run, run('SAND'), 30, 599, 49, 599)} still on bottom row, ${awake()} awake`);
+// Filters already separate a mixed load in t_conveyors; this checks the grate itself.
+world(80);
+rect(run, 19, 60, 19, 119, run('STONE')); rect(run, 40, 60, 40, 119, run('STONE'));
+run('for (let bx = 5; bx < 10; bx++) placeBlock(BP_GRATE, 0, bx, 25, true);');
+rect(run, 24, 70, 35, 79, run('SAND')); ticks(run, 1200);
+check('sand stays on a grate without slipping through', grains('SAND') === 120 && count(run, run('SAND'), 20, 104, 39, 119) === 0 && awake() === 0,
+  `${grains('SAND')}/120 sand, ${count(run, run('SAND'), 20, 104, 39, 119)} below, ${awake()} awake`);
+// Movement alone keeps the liquids molten and steam gaseous while measuring their flow.
+function motion(n) {
+  run(`for (let k = 0; k < ${n}; k++) { tick++; tickStamp = (tickStamp % 255) + 1; simMove(); for (let c = 0; c < NCH; c++) if (awake[c]) awake[c]--; }`);
+}
+function asleep(name) {
+  check(`${name} settles and its areas sleep`, awake() === 0, `${awake()} awake areas`);
+}
+
+// Molten metal
+const levelTimes = [];
+for (const m of ['WATER', 'MCU']) {
+  world(80);
+  rect(run, 38, 60, 41, 99, run(m));
+  let flatAt = 0;
+  for (let t = 1; t <= 2400; t++) {
+    motion(1);
+    const a = tops(run(m), 0, 79, 120);
+    if (Math.max(...a) - Math.min(...a) <= 2 && Math.max(...a) < 120) { flatAt = t; break; }
+  }
+  levelTimes.push(flatAt); motion(600);
+  const a = tops(run(m), 0, 79, 120), uneven = Math.max(...a) - Math.min(...a);
+  check(`${m === 'MCU' ? 'molten copper' : 'water'} spreads into a level pool without losing grains`, flatAt > 0 && uneven <= 2 && grains(m) === 160 && awake() === 0,
+    `within 2 grains of level after ${flatAt} ticks, final difference ${uneven}, ${grains(m)}/160 grains, ${awake()} awake`);
+}
+check('molten copper takes longer than water to level', levelTimes[1] > levelTimes[0] && levelTimes[0] > 0,
+  `water ${levelTimes[0]} ticks, copper ${levelTimes[1]} ticks`);
+world(80);
+run('for (let x = 30; x < 50; x++) setCell(119*W+x, MCU, FRZ[MCU] + 1, 0);');
+const freezePoint = run('FRZ[MCU]');
+let firstSet = null;
+for (let t = 0; t < 300 && firstSet === null; t++) {
+  ticks(run, 1);
+  firstSet = run('(() => { const i = mat.indexOf(COPPER); return i < 0 ? null : temp[i]; })()');
+}
+ticks(run, 2400);
+check('copper cools below its setting point and keeps all its metal', firstSet !== null && firstSet < freezePoint && grains('COPPER') === 20 && grains('MCU') === 0 && awake() === 0,
+  `first solid ${firstSet}°C, setting point ${freezePoint}°C, ${grains('COPPER')} solid + ${grains('MCU')} molten /20, ${awake()} awake`);
+world(80);
+rect(run, 19, 70, 19, 119, run('STONE')); rect(run, 60, 70, 60, 119, run('STONE'));
+rect(run, 20, 100, 59, 119, run('WATER'));
+run('for (let y = 70; y < 80; y++) for (let x = 38; x < 42; x++) setCell(y*W+x, MCU, 1160, 0);');
+run('WS = -1557203080; weather.wind = 0.3;'); // rain passing through the plume exercises displaced steam
+const quenchWater = run('worldWater()'); let steamPeak = 0;
+for (let t = 0; t < 60; t++) { ticks(run, 5); steamPeak = Math.max(steamPeak, grains('STEAM')); }
+ticks(run, 3600);
+const bottomCopper = count(run, run('COPPER'), 20, 110, 59, 119);
+check('copper poured into a pond sinks, sets and makes steam without losses', bottomCopper === 40 && grains('COPPER') + grains('MCU') === 40 && steamPeak > 0 && run('worldWater()') === quenchWater,
+  `${bottomCopper}/40 copper at bottom, ${grains('COPPER')} solid + ${grains('MCU')} molten, peak ${steamPeak} steam, water ${quenchWater} -> ${run('worldWater()')}`);
+asleep('a quenched copper pond');
+world(80);
+rect(run, 29, 70, 29, 119, run('STONE')); rect(run, 50, 70, 50, 119, run('STONE'));
+run('for (let y = 90; y < 100; y++) for (let x = 30; x < 50; x++) setCell(y*W+x, (x+y)%2 ? MCU : MSLAG, 1300, 0);');
+motion(2400);
+const slagDensity = run('DENS[MSLAG]'), copperDensity = run('DENS[MCU]');
+const upperSlag = count(run, run('MSLAG'), 30, 110, 49, 114), lowerCopper = count(run, run('MCU'), 30, 115, 49, 119);
+// Local density swaps leave small pockets mixed when the pool sleeps.
+check('lighter molten slag mostly floats above molten copper', slagDensity < copperDensity && upperSlag >= 95 && lowerCopper >= 95 && oreY(run('MSLAG')) < oreY(run('MCU')) && grains('MSLAG') === 100 && grains('MCU') === 100,
+  `upper slag ${upperSlag}/100, lower copper ${lowerCopper}/100; densities slag ${slagDensity.toFixed(1)}, copper ${copperDensity}; mean rows slag ${oreY(run('MSLAG')).toFixed(1)}, copper ${oreY(run('MCU')).toFixed(1)}, grains ${grains('MSLAG')} + ${grains('MCU')}`);
+asleep('separated slag and copper');
+// The other mold suites pre-fill their cavities; here the metal must flow in from above.
+world(80);
+run(`addMold('ingot', 8, 27, RSTONE, true);
+  for (let y = 100; y < 108; y++) { setCell(y*W+32, STONE, 20, 0); setCell(y*W+47, STONE, 20, 0); }
+  for (let y = 104; y < 106; y++) for (let x = 33; x < 47; x++) setCell(y*W+x, MCU, 1160, 0);`);
+motion(1200);
+const cavity = run('molds[0].cavs[0].length'), filled = run('molds[0].cavs[0].filter(i => mat[i] === MCU).length');
+check('a copper pour fills every grain of an ingot cavity', filled === cavity && grains('MCU') === 28 && awake() === 0,
+  `${filled}/${cavity} cavity filled, ${grains('MCU')}/28 total, ${awake()} awake`);
+
+// Landing must keep steam it displaces, for both the direct and nearby fallback paths.
+for (const nearby of [false, true]) {
+  world(80);
+  rect(run, 39, 90, 39, 90, run('STEAM'));
+  run('flyers.push({ m: WATER, T: 20 });');
+  const before = run('worldWater()');
+  run(`${nearby ? 'depositNear(WATER, 20, 39, 90)' : 'landFlyer(flyers[0], 39, 90)'}; flyers.pop();`);
+  check(`a rain drop landing in steam keeps both grains${nearby ? ' when finding a nearby space' : ''}`, run('worldWater()') === before && grains('WATER') === 1,
+    `water total ${before} -> ${run('worldWater()')}, ${grains('WATER')} water, ${run('weather.moist.reduce((a,b) => a+b, 0)')} in clouds`);
+  ticks(run, 600); asleep('water after landing in steam');
+}
+
+// Gases
+function chamber() {
+  world(80);
+  rect(run, 19, 60, 60, 60, run('STONE'));
+  rect(run, 19, 60, 19, 119, run('STONE')); rect(run, 60, 60, 60, 119, run('STONE'));
+  run('updateRoof();');
+}
+function smoke() {
+  run('for (let y = 95; y < 100; y++) for (let x = 37; x < 43; x++) { setCell(y*W+x, SMOKE, AMB[y], 0); life[y*W+x] = 220; }');
+}
+const smokeLeft = [];
+for (const sealed of [false, true]) {
+  if (sealed) chamber(); else world(80);
+  smoke(); ticks(run, 30);
+  check(`smoke rises ${sealed ? 'toward a sealed roof' : 'outdoors'}`, oreY(run('SMOKE')) < 85,
+    `mean row ${oreY(run('SMOKE')).toFixed(1)} from 97, ${grains('SMOKE')}/30 smoke`);
+  ticks(run, 90); smokeLeft.push(grains('SMOKE'));
+  ticks(run, sealed ? 7200 : 600);
+  check(`smoke eventually fades ${sealed ? 'under a roof' : 'outdoors'} and sleeps`, grains('SMOKE') === 0 && awake() === 0,
+    `${grains('SMOKE')} smoke, ${awake()} awake`);
+}
+check('a sealed roof holds smoke longer than open air', smokeLeft[1] > smokeLeft[0],
+  `at 120 ticks: outdoors ${smokeLeft[0]}/30, roof ${smokeLeft[1]}/30`);
+chamber();
+run('for (let y = 95; y < 100; y++) for (let x = 37; x < 43; x++) setCell(y*W+x, STEAM, 110, 0);');
+motion(100);
+const roofSteam = count(run, run('STEAM'), 20, 61, 59, 63), steamTops = tops(run('STEAM'), 20, 59, 120);
+const steamWidth = steamTops.filter(y => y === 61).length;
+check('trapped gas spreads along the ceiling without crossing stone', roofSteam >= 25 && steamWidth > 6 && grains('STEAM') === 30 && count(run, run('STEAM'), 20, 61, 59, 119) === 30 && count(run, run('STEAM'), 0, 0, 79, 59) === 0,
+  `${roofSteam}/30 under roof, ${steamWidth} columns along ceiling, ${grains('STEAM')} total, 0 expected above roof: ${count(run, run('STEAM'), 0, 0, 79, 59)}`);
+run('AMB.fill(20); temp.fill(20); for (let x = 20; x < 60; x++) wakeHeatXY(x, 61);');
+ticks(run, 1800);
+check('steam collected under a roof condenses and runs down to the floor', grains('STEAM') === 0 && count(run, run('WATER'), 20, 118, 59, 119) === 30 && awake() === 0,
+  `${grains('STEAM')} steam, ${count(run, run('WATER'), 20, 118, 59, 119)}/30 water at floor, ${awake()} awake`);
+chamber();
+run('for (let x = 30; x < 50; x++) { setCell(90*W+x, FIRE, 800, 0); life[90*W+x] = 25; }');
+ticks(run, 600);
+const burning = run('flags.reduce((n, f) => n + !!(f & F_BURN), 0)');
+check('fire with no fuel goes out and leaves nothing burning', grains('FIRE') === 0 && burning === 0 && awake() === 0,
+  `${grains('FIRE')} flames, ${burning} burning grains, ${awake()} awake`);
+// Fully blocked gas cannot keep itself awake by moving sideways.
+for (const m of ['SMOKE', 'STEAM', 'FIRE']) {
+  world(80);
+  rect(run, 38, 89, 40, 91, run('STONE'));
+  run(`setCell(90*W+39, ${m}, 20, 0); life[90*W+39] = ${m === 'SMOKE' ? 10 : 25};`);
+  ticks(run, 1200);
+  check(`${m.toLowerCase()} in a sealed one-grain pocket finishes changing and sleeps`, grains(m) === 0 && awake() === 0 && (m !== 'STEAM' || grains('WATER') === 1),
+    `${grains(m)} gas left, ${grains('WATER')} water, ${awake()} awake`);
+}
+for (const m of ['SMOKE', 'STEAM', 'FIRE']) {
+  world(80);
+  run(`for (const x of [0, 40, W-1]) { setCell(x, ${m}, 110, 0); life[x] = 25; }`);
+  ticks(run, 10);
+  check(`${m.toLowerCase()} on the top row leaves cleanly`, grains(m) === 0 && awake() === 0 && (m !== 'STEAM' || run('worldWater()') === 3),
+    `${grains(m)} gas left, ${awake()} awake, water total ${run('worldWater()')}`);
+}
+
+console.log(`Physics suite time: ${Date.now() - started} ms`);
+done();