@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/libraries/sand/src/sand-world.js

@@ -0,0 +1,3382 @@
+import { FLAG_ANCHORED, FLAG_POPPED, FLAG_SPARK, FLAG_UPDATED, FLAG_UPDATED_BIT, pack, packCell, SHADE_MASK, unpack } from "./cell.js";
+import { DEFAULT_GRAVITY, DEFAULT_TEMP, FIELD } from "./fields.js";
+import { FluidGrid } from "./fluid-grid.js";
+import { IS_ACID_IMMUNE, IS_FIRE, IS_HOT, MAT_DENSITY, MAT_FLAGS, MAT_FLAMMABLE, MAT_GAS, MAT_GRAVITY, MAT_GRAVITY_DIR, MAT_HAS_REACTIONS, MAT_LIFETIME, MAT_LIQUID, MAT_SOLID, Material } from "./materials.js";
+import { PARTICLE_TYPES, ParticleSystem } from "./particles.js";
+import { SandRNG } from "./rng.js";
+import { RuleEngine } from "./rules/rule-engine.js";
+export { MAT_GRAVITY, MAT_GRAVITY_DIR } from "./materials.js";
+function initialLifetime(mat) {
+    return MAT_LIFETIME[mat];
+}
+/** Ticks a Gravel cell must remain stationary (and stably supported) before
+ *  re-settling to Stone. Long so mined debris stays loose and collectible for
+ *  a while instead of visibly snapping back to solid stone within a second.
+ *  At 60Hz, 600 ticks ≈ 10 seconds. */
+export const GRAVEL_SETTLE_TICKS = 600;
+/** Settle ticks used when a Gravel/Stone is disturbed by adjacent gravel
+ *  movement. Short so the cell re-settles quickly if still supported, but
+ *  gives it time to start falling if gravel flowed out from under it. */
+export const GRAVEL_DISTURB_SETTLE_TICKS = 2;
+// 4-neighbor offsets for disturbAdjacent
+const DIR_DX = [0, 0, -1, 1];
+const DIR_DY = [-1, 1, 0, 0];
+export class SandWorld {
+    W;
+    H;
+    grid;
+    // Per-cell physics fields: 4 bytes per cell [gravity:u8, temp:u8, windX:i8, windY:i8]
+    fields;
+    frame = 0;
+    // --- Strip mode (multi-threaded sand step) ---
+    // When strip mode is enabled, this SandWorld only processes cells in
+    // [stripStartX, stripEndX). It can READ the full grid (backed by SAB) but
+    // only WRITES to cells in [writeXMin, writeXMax). Cross-strip writes are
+    // skipped (trySwap/tryShove return false), and the coordinator's boundary
+    // cleanup pass handles them after all workers finish.
+    // Defaults: full grid (no restriction) — zero overhead when strip mode is off.
+    stripStartX = 0;
+    stripEndX = 0; // set to W in constructor
+    writeXMin = 0;
+    writeXMax = 0; // set to W in constructor
+    // Fast xorshift32 PRNG — replaces Math.random() in hot loops.
+    rng;
+    // Data-driven rule engine — replaces hardcoded if-else in applyReactions().
+    ruleEngine;
+    // Particle system for explosion visuals (flying debris, blast rings).
+    particles;
+    // Global impulse settings (not spatial)
+    horizontalImpulseChance = 0.02;
+    horizontalImpulseStrength = 1;
+    // Interlace mode: process every Nth row per frame (halves movement cost
+    // for low-end devices). The row offset alternates each frame so all rows
+    // are processed over N frames. Default 1 = disabled (process all rows).
+    interlaceScale = 1;
+    interlaceEnabled = false;
+    // Additional flag bits (in the flags byte, bits 16-23) that consumers want
+    // preserved across the per-frame FLAG_UPDATED clear in buildActiveListAndClearFlags.
+    // The physics engine only uses bits 0-3 and 5 (shade 0-1, FLAG_UPDATED 2,
+    // FLAG_SPARK 3, FLAG_POPPED 5); bits 4, 6-7 are available for game-specific
+    // flags (e.g. a game's FLAG_DETACHED at bit 4).
+    // Set this mask so those bits survive the clear. Defaults to 0 (no extra bits).
+    preserveFlagsMask = 0;
+    // Flag bits OR'd into the flags of cells disturbed by disturbAdjacent()
+    // (Stone→LooseStone conversions when gravel flows out from under them).
+    // Disturbed cells also get FLAG_UPDATED, but applyAging clears FLAG_UPDATED
+    // before the chunk-world's expireWakeTicks() can detect them in frozen
+    // chunks. Setting a persistent flag here (e.g. a game's FLAG_DETACHED)
+    // ensures expireWakeTicks can re-activate frozen chunks that contain
+    // disturbed cells. Defaults to 0 (no extra flags). Must be a subset of
+    // preserveFlagsMask so the flag survives the per-frame clear.
+    disturbedFlags = 0;
+    // --- Reusable per-frame buffers (avoid allocations in hot paths) ---
+    // fireSources: marks cells that are fire/lava at the start of applyCombustion.
+    // visitedFrame: frame-tagged marker used in place of per-frame Sets for the
+    //   ignitedFuse / ignitedOil de-duplication. A cell is "visited this frame"
+    //   when visitedFrame[i] === this.frame. Shared between the fuse and
+    //   burning-oil passes — safe because the two passes target different
+    //   materials (Fuse vs Oil), so a cell marked in one pass is guarded out by
+    //   the material-type check in the other before the visited check runs.
+    fireSources;
+    visitedFrame;
+    // Separate frame-tagged visited array for C4 flood-fill (detonateC4).
+    // Avoids clobbering the combustion pass's visitedFrame and avoids
+    // allocating a Set on every detonation.
+    visitedC4Frame;
+    // Separate frame-tagged visited array for antimatter annihilation flood-fill.
+    // Avoids clobbering the C4 / combustion visited arrays.
+    visitedAntimatterFrame;
+    // --- Sparse active-cell tracking ---
+    // activeCells holds the grid indices of all non-empty cells. activeCount is
+    // the number of valid entries. Rebuilt each frame (twice — once at the start
+    // to replace the FLAG_UPDATED clear scan, once before applyAging to capture
+    // cells created by combustion/reactions). Iterating the active list is
+    // O(active) instead of O(W*H) — a massive win when the grid is mostly empty.
+    activeCells;
+    activeCount = 0;
+    // --- Active Y bounds ---
+    // min/max rows that contain non-empty cells. The movement pass only
+    // iterates [minActiveY, maxActiveY] instead of [0, H-1]. For a sparse
+    // grid (e.g. a 50-cell-tall sand pile in a 512×512 world), this cuts
+    // movement from O(W*H) to O(W*activeHeight).
+    minActiveY = 0;
+    maxActiveY = 0;
+    // --- Chunk dirty bitmap ---
+    // 1 bit per CHUNK_SIZE×CHUNK_SIZE block. Set when a cell in that chunk
+    // changes. The movement pass skips chunks that aren't dirty, avoiding
+    // scanning large empty regions within the active Y bounds.
+    static CHUNK_SIZE = 16;
+    numChunksX = 0;
+    numChunksY = 0;
+    chunkDirty;
+    // --- Coarse-grid fluid simulation ---
+    // Replaces the old per-cell wind field system. Provides pressure relaxation
+    // and sustained airflow at 1/4 resolution. Per-cell wind is sampled from
+    // this grid via bilinear interpolation in tryMove().
+    fluid;
+    // --- Chunk freeze support ---
+    // Optional per-cell skip mask (length = W*H). When set, cells whose skipMask
+    // entry is non-zero are excluded from the active-cell list and the movement
+    // pass — they are "frozen" and do not participate in the simulation this
+    // frame. Used by the game's chunk world to skip inactive (frozen) chunks.
+    // null = no skipping (backward compatible with the original single-grid sim).
+    skipMask = null;
+    // Per-column active cell count — SAB-backed when multi-threaded.
+    // Written by each worker during buildActiveListAndClearFlags (only its own
+    // strip's columns). Read by the coordinator after all workers finish to
+    // rebalance strip boundaries for load balancing.
+    histogram = null;
+    // Per-cell "deferred move" marker (length = W*H, SAB-backed when
+    // multi-threaded). Set by movement functions (trySwap/tryFlow/etc.) when a
+    // move is blocked SOLELY by the strip write guard — i.e. the destination is
+    // in an adjacent strip and the move would have been valid if not for the
+    // guard. The coordinator's boundary cleanup pass reads this to know which
+    // cells need a cross-strip move attempt, and clears it after processing.
+    //
+    // Without this, the boundary cleanup would re-run the FULL tryMove on every
+    // boundary cell — re-rolling friction/flicker/impulse RNG gates and giving
+    // boundary cells a second movement chance that interior cells don't get.
+    // This caused "fast falling" artifacts at strip boundaries: sand in boundary
+    // columns fell ~1.3× faster because edge friction (30% skip/frame) was
+    // effectively rolled twice (9% skip).
+    //
+    // null = no deferred tracking (single-threaded / non-SAB mode — no boundary
+    // cleanup needed).
+    deferredMask = null;
+    // When true, tryMove is running in the boundary cleanup pass. This skips all
+    // RNG-based movement gates (friction, gas flicker, horizontal impulse, wind)
+    // — those already had their chance during the worker pass — and only
+    // processes cells marked in deferredMask. Write bounds are restricted to the
+    // adjacent strip so only cross-strip moves are attempted.
+    boundaryPass = false;
+    constructor(w, h, options) {
+        this.W = w;
+        this.H = h;
+        const cells = w * h;
+        this.rng = new SandRNG();
+        this.ruleEngine = new RuleEngine();
+        this.particles = new ParticleSystem(512);
+        this.fluid = new FluidGrid(w, h);
+        // Grid + fields can be backed by a SharedArrayBuffer for multi-threaded
+        // sand step. When SAB is provided, all workers share the same grid data.
+        // Otherwise, regular ArrayBuffer (single-threaded, tests, backward compat).
+        if (options?.sab) {
+            const gridBytes = cells * 4;
+            this.grid = new Uint32Array(options.sab, options.gridOffset ?? 0, cells);
+            this.fields = new Uint8Array(options.sab, options.fieldsOffset ?? gridBytes, cells * 4);
+            // Optional SAB-backed skip mask — shared between coordinator and workers.
+            if (options.skipMaskOffset !== undefined) {
+                this.skipMask = new Uint8Array(options.sab, options.skipMaskOffset, cells);
+            }
+            // Optional SAB-backed deferred-move mask — shared between workers and
+            // the coordinator. Each worker writes only to its own strip's cells
+            // (the source cell of a blocked move is always within the strip), so
+            // there are no races. The coordinator reads it in the boundary cleanup.
+            if (options.deferredMaskOffset !== undefined) {
+                this.deferredMask = new Uint8Array(options.sab, options.deferredMaskOffset, cells);
+            }
+            // Optional SAB-backed per-column active cell histogram — used by the
+            // coordinator to rebalance strip boundaries for load balancing.
+            // Each worker writes only to its own strip's columns (no races).
+            if (options.histogramOffset !== undefined) {
+                this.histogram = new Uint32Array(options.sab, options.histogramOffset, w);
+            }
+        }
+        else {
+            this.grid = new Uint32Array(cells);
+            this.fields = new Uint8Array(cells * 4);
+        }
+        // Strip mode defaults: full grid (no restriction). Set by SandStepPool
+        // when creating per-worker SandWorld instances.
+        this.stripStartX = 0;
+        this.stripEndX = w;
+        this.writeXMin = 0;
+        this.writeXMax = w;
+        // Per-worker local arrays (not shared — each worker has its own)
+        this.fireSources = new Uint8Array(cells);
+        this.visitedFrame = new Uint32Array(cells);
+        this.visitedC4Frame = new Uint32Array(cells);
+        this.visitedAntimatterFrame = new Uint32Array(cells);
+        this.activeCells = new Uint32Array(cells);
+        this.activeCount = 0;
+        // Chunk dirty bitmap — 1 byte per chunk (not bit-packed for simplicity).
+        this.numChunksX = Math.ceil(w / SandWorld.CHUNK_SIZE);
+        this.numChunksY = Math.ceil(h / SandWorld.CHUNK_SIZE);
+        this.chunkDirty = new Uint8Array(this.numChunksX * this.numChunksY);
+        // Initialize fields to defaults
+        for (let i = 0; i < cells * 4; i += 4) {
+            this.fields[i + FIELD.GRAVITY] = DEFAULT_GRAVITY;
+            this.fields[i + FIELD.TEMP] = DEFAULT_TEMP;
+        }
+        if (!options?.skipStoneFloor) {
+            // Stone floor
+            for (let x = 0; x < w; x++) {
+                for (let y = h - 4; y < h; y++) {
+                    this.grid[y * w + x] = pack({ mat: Material.Stone, lifetime: 0, flags: 0 });
+                }
+            }
+            // Mark the stone floor chunks as dirty so the first movement pass processes them.
+            this.minActiveY = h - 4;
+            this.maxActiveY = h - 1;
+            for (let cy = 0; cy < this.numChunksY; cy++) {
+                for (let cx = 0; cx < this.numChunksX; cx++) {
+                    this.chunkDirty[cy * this.numChunksX + cx] = 1;
+                }
+            }
+        }
+    }
+    /** Configure strip mode for multi-threaded sand step. */
+    setStripBounds(stripStartX, stripEndX) {
+        this.stripStartX = stripStartX;
+        this.stripEndX = stripEndX;
+        this.writeXMin = stripStartX;
+        this.writeXMax = stripEndX;
+    }
+    /** Check if a cell at X coordinate can be written (within write bounds). */
+    canWriteX(x) {
+        return x >= this.writeXMin && x < this.writeXMax;
+    }
+    /** Check if a grid index can be written (within strip write bounds). */
+    canWriteIdx(idx) {
+        const x = idx % this.W;
+        return x >= this.writeXMin && x < this.writeXMax;
+    }
+    /** Get the active Y bounds [minY, maxY] — used by SandStepPool for boundary cleanup. */
+    getActiveYBounds() {
+        return { minY: this.minActiveY, maxY: this.maxActiveY };
+    }
+    /** Re-seed the PRNG for deterministic test mode. */
+    reseed(seed) {
+        this.rng.reseed(seed);
+    }
+    /** PRNG accessor for the rule engine. */
+    getRng() {
+        return this.rng;
+    }
+    /** Active cell list accessor for the rule engine. */
+    getActiveCells() {
+        return this.activeCells;
+    }
+    /** Active cell count accessor for the rule engine. */
+    getActiveCount() {
+        return this.activeCount;
+    }
+    /** Particle system accessor for the worker to transfer to SAB. */
+    getParticles() {
+        return this.particles;
+    }
+    /** Mark the chunk containing (x, y) as dirty. Called on every cell write. */
+    markChunkDirty(x, y) {
+        const cx = (x / SandWorld.CHUNK_SIZE) | 0;
+        const cy = (y / SandWorld.CHUNK_SIZE) | 0;
+        this.chunkDirty[cy * this.numChunksX + cx] = 1;
+        // Update Y bounds — the movement pass only scans [minActiveY, maxActiveY].
+        if (y < this.minActiveY)
+            this.minActiveY = y;
+        if (y > this.maxActiveY)
+            this.maxActiveY = y;
+    }
+    // --- Field accessors ---
+    // gravity: u8 0-255, 128 = 1.0×. Returns multiplier 0-2.
+    getGravity(x, y) {
+        if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+            return 1.0;
+        return this.fields[(y * this.W + x) * 4 + FIELD.GRAVITY] / 128;
+    }
+    // temp: u8 0-255, 128 = 1.0. Returns 0-2.
+    getTemperature(x, y) {
+        if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+            return 1.0;
+        return this.fields[(y * this.W + x) * 4 + FIELD.TEMP] / 128;
+    }
+    // Wind velocity from the coarse-grid fluid simulation. Returns cells/frame.
+    getWindX(x, y) {
+        if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+            return 0;
+        return this.fluid.sampleVelX(x, y);
+    }
+    getWindY(x, y) {
+        if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+            return 0;
+        return this.fluid.sampleVelY(x, y);
+    }
+    // --- Field painting ---
+    paintField(cx, cy, fieldType, value, radius) {
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                if ((x - cx) * (x - cx) + (y - cy) * (y - cy) > radius * radius)
+                    continue;
+                if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+                    continue;
+                this.fields[(y * this.W + x) * 4 + fieldType] = value & 0xff;
+            }
+        }
+    }
+    paintFieldLine(x0, y0, x1, y1, fieldType, value, radius) {
+        const dx = Math.abs(x1 - x0);
+        const dy = Math.abs(y1 - y0);
+        const sx = x0 < x1 ? 1 : -1;
+        const sy = y0 < y1 ? 1 : -1;
+        let err = dx - dy;
+        let x = x0, y = y0;
+        while (true) {
+            this.paintField(x, y, fieldType, value, radius);
+            if (x === x1 && y === y1)
+                break;
+            const e2 = 2 * err;
+            if (e2 > -dy) {
+                err -= dy;
+                x += sx;
+            }
+            if (e2 < dx) {
+                err += dx;
+                y += sy;
+            }
+        }
+    }
+    getCell(x, y) {
+        if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+            return { mat: Material.Empty, lifetime: 0, flags: 0 };
+        return unpack(this.grid[y * this.W + x]);
+    }
+    setCell(x, y, cell) {
+        if (x < 0 || x >= this.W || y < 0 || y >= this.H)
+            return;
+        this.grid[y * this.W + x] = pack(cell);
+    }
+    paintMaterial(cx, cy, mat, radius) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const r2 = radius * radius;
+        const lt = initialLifetime(mat);
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            if (y < 0 || y >= H)
+                continue;
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                if (x < 0 || x >= W)
+                    continue;
+                const ddx = x - cx, ddy = y - cy;
+                if (ddx * ddx + ddy * ddy > r2)
+                    continue;
+                const curMat = grid[y * W + x] & 0xff;
+                if (curMat === Material.Stone || curMat === Material.Wall)
+                    continue;
+                grid[y * W + x] = packCell(mat, lt, this.rng.randomShade());
+                this.markChunkDirty(x, y);
+            }
+        }
+    }
+    paintLine(x0, y0, x1, y1, mat, radius) {
+        const dx = Math.abs(x1 - x0);
+        const dy = Math.abs(y1 - y0);
+        const sx = x0 < x1 ? 1 : -1;
+        const sy = y0 < y1 ? 1 : -1;
+        let err = dx - dy;
+        let x = x0, y = y0;
+        while (true) {
+            this.paintMaterial(x, y, mat, radius);
+            if (x === x1 && y === y1)
+                break;
+            const e2 = 2 * err;
+            if (e2 > -dy) {
+                err -= dy;
+                x += sx;
+            }
+            if (e2 < dx) {
+                err += dx;
+                y += sy;
+            }
+        }
+    }
+    igniteLine(x0, y0, x1, y1, radius) {
+        const dx = Math.abs(x1 - x0);
+        const dy = Math.abs(y1 - y0);
+        const sx = x0 < x1 ? 1 : -1;
+        const sy = y0 < y1 ? 1 : -1;
+        let err = dx - dy;
+        let x = x0, y = y0;
+        while (true) {
+            this.ignite(x, y, radius);
+            if (x === x1 && y === y1)
+                break;
+            const e2 = 2 * err;
+            if (e2 > -dy) {
+                err -= dy;
+                x += sx;
+            }
+            if (e2 < dx) {
+                err += dx;
+                y += sy;
+            }
+        }
+    }
+    ignite(cx, cy, radius) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const r2 = radius * radius;
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            if (y < 0 || y >= H)
+                continue;
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                if (x < 0 || x >= W)
+                    continue;
+                const ddx = x - cx, ddy = y - cy;
+                if (ddx * ddx + ddy * ddy > r2)
+                    continue;
+                const mat = grid[y * W + x] & 0xff;
+                if (!(MAT_FLAGS[mat] & MAT_FLAMMABLE))
+                    continue;
+                // Fuse gets FuseFire (yellow, stays put, deterministic spread)
+                if (mat === Material.Fuse) {
+                    grid[y * W + x] = packCell(Material.FuseFire, 15, this.rng.randomShade());
+                }
+                else if (mat === Material.Oil) {
+                    // Oil only ignites if exposed (has an empty/gas neighbor so fire
+                    // can reach it). Buried oil stays inert.
+                    if (!this.isExposed(x, y))
+                        continue;
+                    // Oil → BurningOil (flows like oil, slow decay, slow spread)
+                    grid[y * W + x] = packCell(Material.BurningOil, MAT_LIFETIME[Material.BurningOil], this.rng.randomShade());
+                }
+                else {
+                    grid[y * W + x] = packCell(Material.Fire, 30, this.rng.randomShade());
+                }
+                this.markChunkDirty(x, y);
+            }
+        }
+    }
+    // ===========================================================================
+    // Main step
+    // ===========================================================================
+    step() {
+        this.frame++;
+        const W = this.W, H = this.H;
+        // Pass 1: Clear FLAG_UPDATED (preserving shade + spark bits) AND build the
+        // active-cell list in a single full-grid scan. This replaces the old
+        // separate FLAG_UPDATED clear loop — the scan is very cheap (bit-and +
+        // comparison per cell, no unpack or MATERIALS lookup).
+        this.buildActiveListAndClearFlags();
+        // Pass 2-3: Reactions iterate only the active list (O(active) instead of
+        // O(W*H)). Cells created during these passes won't be in the active list —
+        // same semantics as the old full-grid scan (one pass per frame).
+        // Pass 2: Data-driven rule engine (replaces the old applyReactions()).
+        this.ruleEngine.execute(this);
+        // Pass 3: Special reactions (complex logic not yet migrated to rules).
+        this.applySpecialReactions();
+        // Pass 4: Movement — must iterate in spatial order (bottom-to-top,
+        // alternating L/R) for correct falling-sand physics. We skip empty rows
+        // outside [minActiveY, maxActiveY] and empty chunks within those bounds.
+        // In interlace mode, we process every Nth row (offset by frame % N) to
+        // halve movement cost on low-end devices.
+        // Strip mode: iterate only [stripStartX, stripEndX) in the X dimension.
+        const leftToRight = this.frame % 2 === 0;
+        const chunkSize = SandWorld.CHUNK_SIZE;
+        const numChunksX = this.numChunksX;
+        const chunkDirty = this.chunkDirty;
+        const interlace = this.interlaceEnabled ? this.interlaceScale : 1;
+        const interlaceOffset = this.frame % interlace;
+        const moveX0 = this.stripStartX;
+        const moveX1 = this.stripEndX;
+        for (let y = this.maxActiveY; y >= this.minActiveY; y--) {
+            // Interlace: skip rows not in this frame's subset
+            if (interlace > 1 && (y % interlace) !== interlaceOffset)
+                continue;
+            // Skip entire rows that are in non-dirty chunks.
+            const chunkY = (y / chunkSize) | 0;
+            const rowBase = chunkY * numChunksX;
+            let rowHasDirty = false;
+            for (let cx = 0; cx < numChunksX; cx++) {
+                if (chunkDirty[rowBase + cx]) {
+                    rowHasDirty = true;
+                    break;
+                }
+            }
+            if (!rowHasDirty)
+                continue;
+            if (leftToRight) {
+                for (let x = moveX0; x < moveX1; x++) {
+                    if (!chunkDirty[rowBase + ((x / chunkSize) | 0)])
+                        continue;
+                    this.tryMove(x, y);
+                }
+            }
+            else {
+                for (let x = moveX1 - 1; x >= moveX0; x--) {
+                    if (!chunkDirty[rowBase + ((x / chunkSize) | 0)])
+                        continue;
+                    this.tryMove(x, y);
+                }
+            }
+        }
+        // Pass 5: Combustion — builds fireSources from the active list.
+        this.applyCombustion();
+        // Rebuild active list to capture cells created/destroyed by reactions,
+        // movement, and combustion. Uses the Y bounds from Pass 1 (expanded by a
+        // margin) to avoid a full O(W*H) grid scan — cells can only move a few
+        // positions per frame, so the active Y range can't expand beyond that.
+        this.buildActiveList();
+        // Pass 6: Aging — iterates the rebuilt active list.
+        this.applyAging();
+        // Pass 7: Fluid grid step — pressure relaxation + velocity update.
+        // Skipped entirely when no impulses/pressure exist (dirty flag).
+        this.fluid.step();
+        // Pass 8: Update explosion particles.
+        this.particles.update();
+    }
+    /**
+     * Boundary cleanup movement pass — used by SandStepPool after all strip
+     * workers finish. Re-runs tryMove on the specified columns so cross-strip
+     * writes (which were skipped by write guards during the parallel step) get
+     * a chance to execute.
+     *
+     * When boundaryPass is true on this world, tryMove only processes cells
+     * marked in deferredMask (cells whose cross-strip move was blocked by the
+     * write guard) and skips all RNG-based movement gates. The caller must set
+     * writeXMin/writeXMax to the adjacent strip's bounds so only cross-strip
+     * moves are attempted.
+     *
+     * This is a movement-only pass — reactions, combustion, and aging already
+     * ran in the workers. We only handle the cross-strip movement writes that
+     * were skipped at the boundaries.
+     */
+    runBoundaryMovement(cols, minY, maxY, leftToRight) {
+        // Sort columns in the iteration order matching the main movement pass.
+        const sorted = cols.slice().sort((a, b) => leftToRight ? a - b : b - a);
+        for (let y = maxY; y >= minY; y--) {
+            sorted.forEach((x) => {
+                this.tryMove(x, y);
+            });
+        }
+    }
+    /**
+     * Build the active-cell list (indices of all non-empty cells) and clear
+     * FLAG_UPDATED in a single pass. Merges the old separate FLAG_UPDATED clear
+     * loop with active-list construction. Also detects non-zero wind fields so
+     * that externally-set wind (e.g. by tests or future field-painting code) is
+     * detected even when applyImpulse wasn't called.
+     *
+     * Static solids (MAT_GRAVITY_DIR === 0: Stone, Wall, Dirt, etc.) are
+     * excluded from the active list and chunkDirty bitmap. They can never move,
+     * have no reactions, and no lifetimes — including them bloats the active
+     * list to ~300k cells in a terrain-heavy world, making every active-list
+     * iteration (ruleEngine, applySpecialReactions, applyAging, applyCombustion)
+     * 5-10× slower. The tryMove loop also benefits: chunks with only static
+     * solids aren't marked dirty, so the loop skips them entirely instead of
+     * visiting every cell just to early-return at gravityDir === 0.
+     *
+     * FLAG_UPDATED is still cleared for ALL cells (including static solids) —
+     * the clearMask operation is outside the filter and runs unconditionally.
+     */
+    buildActiveListAndClearFlags() {
+        const grid = this.grid;
+        const fields = this.fields;
+        const active = this.activeCells;
+        const W = this.W, H = this.H;
+        const clearMask = ~((0xff & ~(SHADE_MASK | FLAG_SPARK | FLAG_ANCHORED | FLAG_POPPED | this.preserveFlagsMask)) << 16);
+        const skip = this.skipMask;
+        const chunkDirty = this.chunkDirty;
+        const numChunksX = this.numChunksX;
+        const chunkSize = SandWorld.CHUNK_SIZE;
+        // Strip mode: only scan [stripStartX, stripEndX) in the X dimension.
+        // Flag clearing covers [stripStartX-1, stripEndX+1) to handle halo cells
+        // at strip boundaries (overlap ensures all flags are cleared).
+        const sx0 = this.stripStartX;
+        const sx1 = this.stripEndX;
+        const clearX0 = sx0 > 0 ? sx0 - 1 : 0;
+        const clearX1 = sx1 < W ? sx1 + 1 : W;
+        // Reset chunk dirty bitmap and Y bounds — rebuilt from the scan.
+        chunkDirty.fill(0);
+        // Per-column active cell histogram — clear our strip's columns then
+        // count during the scan. SAB-backed; each worker only writes its own
+        // columns so there are no races. The coordinator reads it after all
+        // workers finish to rebalance strip boundaries.
+        const histogram = this.histogram;
+        if (histogram !== null) {
+            for (let x = sx0; x < sx1; x++)
+                histogram[x] = 0;
+        }
+        // Clear the deferred-move mask for this strip's columns. Each worker only
+        // clears its own strip (no cross-strip writes). The mask is set during the
+        // movement pass and read by the coordinator's boundary cleanup after all
+        // workers finish.
+        const deferred = this.deferredMask;
+        let minY = H, maxY = 0;
+        let count = 0;
+        for (let y = 0; y < H; y++) {
+            const rowBase = y * W;
+            // Clear flags for the extended range (strip + 1-cell halo)
+            for (let x = clearX0; x < clearX1; x++) {
+                grid[rowBase + x] &= clearMask;
+            }
+            // Build active list only for the strip range
+            for (let x = sx0; x < sx1; x++) {
+                const i = rowBase + x;
+                if (deferred !== null)
+                    deferred[i] = 0;
+                if (grid[i] !== 0 && !(skip !== null && skip[i] !== 0)) {
+                    const mat = grid[i] & 0xff;
+                    // Static solids (gravityDir=0) are included if their lifetime field
+                    // is non-zero (loosened by mining — lifetime is the settle timer).
+                    if (MAT_GRAVITY_DIR[mat] === 0 && !MAT_HAS_REACTIONS[mat]) {
+                        if (((grid[i] >> 8) & 0xff) === 0)
+                            continue;
+                    }
+                    active[count++] = i;
+                    if (y < minY)
+                        minY = y;
+                    if (y > maxY)
+                        maxY = y;
+                    const cx = (x / chunkSize) | 0;
+                    const cy = (y / chunkSize) | 0;
+                    chunkDirty[cy * numChunksX + cx] = 1;
+                    if (histogram !== null)
+                        histogram[x]++;
+                }
+            }
+        }
+        this.activeCount = count;
+        this.minActiveY = minY;
+        this.maxActiveY = maxY;
+    }
+    /** Build the active-cell list without clearing flags (for mid-frame rebuild).
+     *  Like buildActiveListAndClearFlags, excludes static solids (gravityDir=0)
+     *  from the active list and chunkDirty bitmap.
+     *
+     *  Optimized: only scans rows within [minActiveY - margin, maxActiveY + margin]
+     *  instead of the full grid. The margin covers cells that moved during the
+     *  movement pass (particles move at most ~5 cells/frame; reactions affect
+     *  only 8-connected neighbors). This reduces the scan from O(W*H) to
+     *  O(W * activeHeight) — typically a 2-4x speedup. */
+    buildActiveList() {
+        const grid = this.grid;
+        const active = this.activeCells;
+        const W = this.W, H = this.H;
+        const skip = this.skipMask;
+        const chunkDirty = this.chunkDirty;
+        const numChunksX = this.numChunksX;
+        const chunkSize = SandWorld.CHUNK_SIZE;
+        // Reset chunk dirty bitmap and Y bounds — rebuilt from the scan.
+        chunkDirty.fill(0);
+        let minY = H, maxY = 0;
+        let count = 0;
+        // Only scan rows near the Pass 1 active Y range. Cells can move at most
+        // ~5 cells per frame (liquid flow) and reactions affect 8-connected
+        // neighbors (1 cell). A margin of 8 covers all cases with room to spare.
+        const margin = 8;
+        const startY = Math.max(0, this.minActiveY - margin);
+        const endY = Math.min(H - 1, this.maxActiveY + margin);
+        for (let y = startY; y <= endY; y++) {
+            const rowBase = y * W;
+            for (let x = this.stripStartX; x < this.stripEndX; x++) {
+                const i = rowBase + x;
+                if (grid[i] !== 0 && !(skip !== null && skip[i] !== 0)) {
+                    const mat = grid[i] & 0xff;
+                    if (MAT_GRAVITY_DIR[mat] === 0 && !MAT_HAS_REACTIONS[mat]) {
+                        if (((grid[i] >> 8) & 0xff) === 0)
+                            continue;
+                    }
+                    active[count++] = i;
+                    if (y < minY)
+                        minY = y;
+                    if (y > maxY)
+                        maxY = y;
+                    const cx = (x / chunkSize) | 0;
+                    const cy = (y / chunkSize) | 0;
+                    chunkDirty[cy * numChunksX + cx] = 1;
+                }
+            }
+        }
+        this.activeCount = count;
+        this.minActiveY = minY;
+        this.maxActiveY = maxY;
+    }
+    tryMove(x, y) {
+        const W = this.W, H = this.H;
+        const idx = y * W + x;
+        const packed = this.grid[idx];
+        if (packed === 0)
+            return;
+        // Frozen cells (chunk freeze optimization) do not initiate movement.
+        const skip = this.skipMask;
+        if (skip !== null && skip[idx] !== 0)
+            return;
+        // Inline unpack — avoid allocating a Cell object on every cell visit
+        const mat = packed & 0xff;
+        if (mat === Material.Empty)
+            return;
+        const flags = (packed >> 16) & 0xff;
+        if (flags & FLAG_UPDATED)
+            return;
+        // Boundary cleanup pass: only process cells whose cross-strip move was
+        // deferred by the write guard during the worker pass. Cells that didn't
+        // attempt a cross-strip move (friction-blocked, obstacle-blocked, or
+        // already moved) have no deferred marker and are skipped — this prevents
+        // the cleanup from re-rolling RNG gates and giving boundary cells an
+        // unfair second movement chance.
+        if (this.boundaryPass) {
+            const deferred = this.deferredMask;
+            if (deferred === null || deferred[idx] === 0)
+                return;
+        }
+        // Spark-flagged fire (visual flames emitted by BurningOil) rises straight
+        // up without horizontal drift — the fire should stay above its fuel source
+        // (the BurningOil cell), not scatter sideways. Horizontal wind, impulse,
+        // and gas drift are skipped for these particles.
+        const isSparkFire = mat === Material.Fire && (flags & FLAG_SPARK) !== 0;
+        // Typed-array lookups instead of MATERIALS[mat]?.property
+        const gravityDir = MAT_GRAVITY_DIR[mat];
+        // Static solids (gravityDir === 0: Stone, Wall, Concrete) are frozen
+        // UNLESS their lifetime field is non-zero (set by mining as a settle
+        // timer). This lets mined Stone fall as Stone — no material conversion.
+        // The lifetime field is repurposed as both the "loosened" flag and the
+        // settle timer: lifetime > 0 = loosened (can fall, will re-freeze when
+        // it lands); lifetime === 0 = frozen static solid.
+        if (gravityDir === 0) {
+            const lifetime = (packed >> 8) & 0xff;
+            if (lifetime === 0)
+                return;
+            // Duplicator stores the locked material id in its lifetime field, but
+            // it must NEVER fall — it's a permanent static solid. Skip the
+            // "loosened static solid" fall path entirely for Duplicator.
+            // Void is also a permanent static solid that must never fall.
+            if (mat === Material.Duplicator || mat === Material.Void)
+                return;
+            // Loosened static solid — fall downward (default direction)
+        }
+        else {
+            // Normal falling material — check gravity field below
+        }
+        // FuseFire stays put so it can deterministically spread to adjacent fuse
+        // cells. Without this, the fire gas floats away before it can propagate.
+        if (mat === Material.FuseFire)
+            return;
+        // Anchored fire (FLAG_ANCHORED) stays put on the fuel surface (e.g. wax)
+        // so it can keep spreading to adjacent fuel. Without this, the fire gas
+        // rises and drifts away before it can propagate.
+        if (mat === Material.Fire && (flags & FLAG_ANCHORED) !== 0)
+            return;
+        // BurningOil flows like a liquid (gravity: 1, density: 0.8). The
+        // burning-oil pass in applyCombustion handles controlled spread to
+        // adjacent oil cells, and visual flames are emitted as separate Fire
+        // particles (FLAG_SPARK) above the BurningOil — those rise straight up
+        // (wind/diagonal movement skipped for spark fire) so they don't scatter
+        // even when the BurningOil itself flows.
+        // Inline field reads — avoid 4× bounds-checked method calls per cell.
+        // tryMove is only called within [0,W)×[0,H) so bounds checks are redundant.
+        const fi = idx * 4;
+        const gravity = this.fields[fi + FIELD.GRAVITY] / 128;
+        // Sample wind from the coarse-grid fluid simulation (bilinear interpolation).
+        const windX = this.fluid.sampleVelX(x, y);
+        const windY = this.fluid.sampleVelY(x, y);
+        // Apply gravity multiplier — at 0 gravity, nothing falls
+        if (gravity <= 0)
+            return;
+        const matFlags = MAT_FLAGS[mat];
+        // For loosened static solids (gravityDir=0 but lifetime>0), fall downward.
+        const dy = gravityDir !== 0 ? gravityDir : 1;
+        const isLiquid = (matFlags & MAT_LIQUID) !== 0;
+        const isGas = (matFlags & MAT_GAS) !== 0;
+        const matGravity = MAT_GRAVITY[mat];
+        // In the boundary cleanup pass, skip all RNG-based movement gates (wind,
+        // friction, gas flicker, horizontal impulse). These already had their
+        // chance during the worker pass — re-rolling them would give boundary
+        // cells an unfair second movement attempt. The cell is only here because
+        // a cross-strip move was deferred by the write guard; we attempt only
+        // gravity/diagonal/flow moves into the adjacent strip.
+        if (!this.boundaryPass) {
+            // --- Wind: apply horizontal/vertical force from the fluid grid ---
+            // The fluid grid provides float velocities; scale to cell-frame units.
+            // A velocity of ~1.0 means "move every frame" (100% chance).
+            // Spark fire (visual flames from BurningOil/fuse) skips wind entirely —
+            // the emit impulse gives it a fixed horizontal component at birth, and
+            // sampling that back here moves it diagonally (up-left/up-right) in a
+            // straight streak for its whole short life. Sparks rise straight up via
+            // gas gravity instead. The upward impulse still pushes neighboring
+            // smoke/gas up via the fluid grid; it just doesn't steer the spark itself.
+            // BurningOil also skips wind — its own spark emission creates upward wind
+            // in the fluid grid above it, which would blow the BurningOil itself
+            // upward off the oil surface. BurningOil flows via gravity only (sinks,
+            // spreads horizontally on the oil surface).
+            const windMag = Math.abs(windX) + Math.abs(windY);
+            if (!isSparkFire && mat !== Material.BurningOil && windMag > 0.05) {
+                const wdx = windX > 0 ? 1 : windX < 0 ? -1 : 0;
+                const wdy = windY > 0 ? 1 : windY < 0 ? -1 : 0;
+                // Scale chance with wind magnitude: 1.0 = 100% move chance.
+                const windChance = Math.min(1, windMag);
+                if (this.rng.random() < windChance) {
+                    // Strong wind can shove into occupied cells (displace liquids/gases)
+                    if (windMag >= 1.5) {
+                        if (this.tryShove(x, y, x + wdx, y + wdy, packed))
+                            return;
+                    }
+                    else {
+                        if (this.trySwap(x, y, x + wdx, y + wdy, packed, mat, matGravity, isGas))
+                            return;
+                    }
+                }
+            }
+            // --- Edge friction ---
+            const hasLeft = x > 0 && this.grid[y * W + (x - 1)] !== 0;
+            const hasRight = x < W - 1 && this.grid[y * W + (x + 1)] !== 0;
+            const isExterior = !hasLeft || !hasRight;
+            // Honey: very thick — high friction, barely flows
+            if (mat === Material.Honey && isExterior && this.rng.random() < 0.7)
+                return;
+            // Tar: extremely viscous — even higher friction than honey, oozes slowly.
+            if (mat === Material.Tar && isExterior && this.rng.random() < 0.85)
+                return;
+            // Exterior particles have a chance to skip falling (friction).
+            if (isExterior && !isGas) {
+                const frictionChance = 0.3 / Math.max(1, matGravity);
+                if (this.rng.random() < frictionChance)
+                    return;
+            }
+            // --- Gas flicker: random chance to not move at all ---
+            // Prevents gasses from rising in uniform horizontal lines. Each particle
+            // has a chance to "flicker" in place, creating organic, non-uniform spread.
+            if (isGas) {
+                const flickerChance = (mat === Material.Fire || mat === Material.FuseFire) ? 0.35 : 0.25;
+                if (this.rng.random() < flickerChance)
+                    return;
+            }
+            // --- Density-scaled horizontal impulse ---
+            // Lighter materials (low gravity) get more impulse; denser materials get less.
+            // Sand (gravity 1) → full impulse, Water (gravity 2) → half, Lava (gravity 3) → third
+            // Gasses (fire/smoke/steam) also get impulse so they drift sideways while rising.
+            // Spark fire (visual flames from BurningOil) skips this — no horizontal drift.
+            if (this.horizontalImpulseChance > 0 && !isSparkFire) {
+                const scaledChance = this.horizontalImpulseChance / Math.max(1, matGravity);
+                if (this.rng.random() < scaledChance) {
+                    const nudgeDir = this.rng.random() < 0.5 ? -1 : 1;
+                    const nudge = nudgeDir * Math.max(1, Math.round(this.horizontalImpulseStrength));
+                    if (this.trySwap(x, y, x + nudge, y + dy, packed, mat, matGravity, isGas))
+                        return;
+                }
+            }
+        } // end if (!this.boundaryPass)
+        // 1. Try gravity direction
+        if (this.trySwap(x, y, x, y + dy, packed, mat, matGravity, isGas)) {
+            if (mat === Material.Gravel && ((packed >> 8) & 0xff) !== GRAVEL_DISTURB_SETTLE_TICKS)
+                this.disturbAdjacent(x, y);
+            return;
+        }
+        // Rubber: bouncy — try to bounce upward when blocked from below
+        if (mat === Material.Rubber) {
+            // Check if we're resting on something (can't fall)
+            const belowY = y + dy;
+            const blocked = belowY < 0 || belowY >= H || this.grid[belowY * W + x] !== 0;
+            if (blocked) {
+                // Bounce: try to move up or sideways
+                if (this.rng.random() < 0.5) {
+                    if (this.trySwap(x, y, x, y - dy, packed, mat, matGravity, isGas))
+                        return;
+                }
+                const bounceDir = this.rng.random() < 0.5 ? -1 : 1;
+                if (this.trySwap(x, y, x + bounceDir * 2, y, packed, mat, matGravity, isGas))
+                    return;
+                if (this.trySwap(x, y, x + bounceDir, y, packed, mat, matGravity, isGas))
+                    return;
+            }
+        }
+        // Diagonal movement (gravity direction + horizontal). Spark fire (visual
+        // flames from BurningOil) skips this — if it can't rise straight up, it
+        // stays put and decays via lifetime rather than sliding sideways.
+        if (!isSparkFire) {
+            const dir = this.rng.random() < 0.5 ? -1 : 1;
+            if (this.trySwap(x, y, x + dir, y + dy, packed, mat, matGravity, isGas)) {
+                if (mat === Material.Gravel && ((packed >> 8) & 0xff) !== GRAVEL_DISTURB_SETTLE_TICKS)
+                    this.disturbAdjacent(x, y);
+                return;
+            }
+            if (this.trySwap(x, y, x - dir, y + dy, packed, mat, matGravity, isGas)) {
+                if (mat === Material.Gravel && ((packed >> 8) & 0xff) !== GRAVEL_DISTURB_SETTLE_TICKS)
+                    this.disturbAdjacent(x, y);
+                return;
+            }
+        }
+        // Gravel: flows horizontally like a liquid when unsupported, but settles
+        // firmly in place when supported from below. Unlike a true liquid, gravel
+        // only flows when there's empty space below the adjacent cell (it "spills"
+        // downhill), and stops as soon as it's resting on something. This creates
+        // realistic pile behavior — gravel spreads into low spots then freezes.
+        if (mat === Material.Gravel) {
+            // Only "real" gravel (from mining, lifetime=GRAVEL_SETTLE_TICKS or 0)
+            // disturbs adjacent Stone when it moves. Freshly-disturbed Stone that
+            // became Gravel (lifetime=GRAVEL_DISTURB_SETTLE_TICKS) does NOT disturb
+            // — otherwise each falling disturbed cell would disturb its neighbors,
+            // which would become Gravel, fall, disturb THEIR neighbors, causing an
+            // unbounded cascade of stone destruction across the map.
+            const canDisturb = ((packed >> 8) & 0xff) !== GRAVEL_DISTURB_SETTLE_TICKS;
+            const flowDir = this.rng.random() < 0.5 ? -1 : 1;
+            if (this.tryGravelFlow(x, y, flowDir)) {
+                if (canDisturb)
+                    this.disturbAdjacent(x, y);
+                return;
+            }
+            if (this.tryGravelFlow(x, y, -flowDir)) {
+                if (canDisturb)
+                    this.disturbAdjacent(x, y);
+                return;
+            }
+            // Gravel is settled (supported below, can't spread) — stop moving.
+            return;
+        }
+        if (isLiquid) {
+            // Buoyancy: a less-dense liquid rises through a denser liquid above it.
+            // This is the mirror of the "heavy liquid sinks through lighter liquid
+            // below" code at the end of tryMove. Without active rising, oil dropped
+            // into water spreads horizontally at the bottom but never reaches the
+            // surface — the passive sinking mechanism is too slow because the
+            // bottom-to-top movement pass lets oil spread sideways before the water
+            // above gets a chance to sink through it.
+            if (dy > 0) {
+                const above = y - 1;
+                if (above >= 0) {
+                    const aboveIdx = above * W + x;
+                    const abovePacked = this.grid[aboveIdx];
+                    if (abovePacked !== 0) {
+                        const aboveMat = abovePacked & 0xff;
+                        if (!((abovePacked >> 16) & FLAG_UPDATED) &&
+                            (MAT_FLAGS[aboveMat] & MAT_LIQUID) &&
+                            MAT_DENSITY[aboveMat] > MAT_DENSITY[mat]) {
+                            this.grid[aboveIdx] = packed | FLAG_UPDATED_BIT;
+                            this.grid[idx] = abovePacked | FLAG_UPDATED_BIT;
+                            return;
+                        }
+                    }
+                }
+            }
+            const flowDir = this.rng.random() < 0.5 ? -1 : 1;
+            if (this.tryFlow(x, y, flowDir, 5))
+                return;
+            if (this.tryFlow(x, y, -flowDir, 5))
+                return;
+            // Density-based horizontal spread: a less-dense liquid (e.g. oil) can
+            // push through a denser liquid (e.g. water) to spread across its
+            // surface. Without this, oil rises to the top of water in a column but
+            // can't spread sideways because tryFlow only enters empty cells.
+            if (this.tryDensityFlow(x, y, flowDir, mat, packed))
+                return;
+            if (this.tryDensityFlow(x, y, -flowDir, mat, packed))
+                return;
+        }
+        // Gas: wider horizontal drift (up to 3 cells) for organic spread.
+        if (isGas) {
+            const driftDir = this.rng.random() < 0.5 ? -1 : 1;
+            if (this.tryFlow(x, y, driftDir, 3))
+                return;
+            if (this.tryFlow(x, y, -driftDir, 3))
+                return;
+        }
+        // 5. Liquids: sink through gas below (heavy liquid displaces light gas upward)
+        if (isLiquid && dy > 0) {
+            const below = y + 1;
+            if (below < H) {
+                const belowIdx = below * W + x;
+                const belowPacked = this.grid[belowIdx];
+                if (belowPacked !== 0) {
+                    const belowMat = belowPacked & 0xff;
+                    const belowFlags = MAT_FLAGS[belowMat];
+                    // Heavy liquid sinks through a lighter gas or a less-dense liquid.
+                    // Density is a separate property from gravity (movement speed):
+                    // mercury (13.5) sinks through water (1.0), lava (3.0) through
+                    // water, honey (1.4) through water, etc.
+                    if (!((belowPacked >> 16) & FLAG_UPDATED) &&
+                        ((belowFlags & MAT_GAS) || ((belowFlags & MAT_LIQUID) && MAT_DENSITY[mat] > MAT_DENSITY[belowMat]))) {
+                        this.grid[belowIdx] = packed | FLAG_UPDATED_BIT;
+                        this.grid[idx] = belowPacked | FLAG_UPDATED_BIT;
+                        return;
+                    }
+                }
+            }
+        }
+        // Glitter: suspends in water (tries to float up when in water)
+        if (mat === Material.Glitter) {
+            if (y + 1 < H && (this.grid[(y + 1) * W + x] & 0xff) === Material.Water) {
+                // Stay suspended — don't sink further
+                if (this.rng.random() < 0.8)
+                    return;
+            }
+        }
+    }
+    /**
+     * Try to move/swap the cell at (x,y) into (nx,ny).
+     *
+     * The caller (tryMove) passes the already-read `srcPacked` plus pre-fetched
+     * srcMat/srcGravity/srcIsGas so the source cell is not re-read or re-unpacked
+     * on every call — tryMove calls this up to ~6 times per cell. The moved cell
+     * is written with FLAG_UPDATED set via a direct bit-OR on `srcPacked` (no
+     * object spread / re-pack).
+     */
+    trySwap(x, y, nx, ny, srcPacked, srcMat, srcGravity, srcIsGas) {
+        const W = this.W, H = this.H;
+        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+            return false;
+        // Strip mode write guard: don't write to cells outside our strip.
+        // The coordinator's boundary cleanup handles deferred cross-strip moves.
+        if (nx < this.writeXMin || nx >= this.writeXMax) {
+            // Mark the source cell as deferred so the boundary cleanup knows to
+            // re-attempt this cross-strip move. Only set during the worker pass
+            // (not during the boundary cleanup itself).
+            if (!this.boundaryPass) {
+                const dm = this.deferredMask;
+                if (dm !== null)
+                    dm[y * W + x] = 1;
+            }
+            return false;
+        }
+        const destIdx = ny * W + nx;
+        const srcIdx = y * W + x;
+        const destPacked = this.grid[destIdx];
+        if (destPacked === 0) {
+            // Empty: simple move
+            this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+            this.grid[srcIdx] = 0;
+            return true;
+        }
+        // Non-gas displacing gas: solids and liquids are denser than gas, so a
+        // falling (or rising) solid/liquid pushes the gas aside and the gas swaps
+        // into the source cell. Without this, smoke/steam would block sand and
+        // water from falling — the gas has no gravity-driven way to yield. A gas
+        // that already moved this frame is left alone (it will yield next frame).
+        if (!srcIsGas) {
+            const destMat = destPacked & 0xff;
+            if ((MAT_FLAGS[destMat] & MAT_GAS) && !((destPacked >> 16) & FLAG_UPDATED)) {
+                this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+                this.grid[srcIdx] = destPacked | FLAG_UPDATED_BIT;
+                return true;
+            }
+        }
+        // Gas-to-gas displacement: a lighter gas (higher gravity for upward, i.e.
+        // rises faster) can push through a slower gas. This lets fire (gravity 4)
+        // rise through smoke (gravity 3) so they separate instead of mixing.
+        // Without this, smoke from a bottom-up burn would overtake the fire front
+        // and suffocate it (fire trapped below its own smoke, can't reach fuel).
+        if (srcIsGas) {
+            const destMat = destPacked & 0xff;
+            if ((MAT_FLAGS[destMat] & MAT_GAS) && srcGravity > MAT_GRAVITY[destMat]) {
+                // Swap: source moves to dest, dest moves to source
+                this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+                this.grid[srcIdx] = destPacked | FLAG_UPDATED_BIT;
+                return true;
+            }
+        }
+        // Solid-liquid density displacement: a denser material sinks through a
+        // less-dense one. Sand (density 2.0) sinks through water (1.0) but not
+        // through mercury (13.5). Water (1.0) sinks through wood (0.6), making
+        // wood float. Only applies to solid-liquid pairs — solids don't flow
+        // through each other, and gas displacement is handled above. Structural
+        // barriers (static solids with density >= 2.0, e.g. stone/wall/concrete)
+        // are immovable — nothing sinks through them regardless of density.
+        if (!srcIsGas) {
+            const destMat = destPacked & 0xff;
+            const destFlags = MAT_FLAGS[destMat];
+            if ((destFlags & (MAT_SOLID | MAT_LIQUID)) && !((destPacked >> 16) & FLAG_UPDATED)) {
+                const srcIsSolid = (MAT_FLAGS[srcMat] & MAT_SOLID) !== 0;
+                const destIsSolid = (destFlags & MAT_SOLID) !== 0;
+                // One must be solid, the other liquid (not solid-solid or liquid-liquid).
+                // Structural barriers (static + dense) are immovable. A loosened
+                // static solid (lifetime > 0, set by mining) is NOT a barrier — it
+                // can fall, so other cells can sink through it.
+                const destIsBarrier = destIsSolid && MAT_GRAVITY_DIR[destMat] === 0 &&
+                    MAT_DENSITY[destMat] >= 2.0 &&
+                    ((destPacked >> 8) & 0xff) === 0;
+                if (srcIsSolid !== destIsSolid &&
+                    !destIsBarrier &&
+                    MAT_DENSITY[srcMat] > MAT_DENSITY[destMat]) {
+                    this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+                    this.grid[srcIdx] = destPacked | FLAG_UPDATED_BIT;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Like trySwap, but can also displace liquids/gases: if the destination is
+     * occupied by a liquid or gas, the two cells swap (the pushed particle moves
+     * into the source cell). Solids and walls block the shove. Used by strong
+     * wind/impulse forces to push particles through dense media.
+     *
+     * The caller passes the already-read `srcPacked` so the source is not
+     * re-read; the moved cell is written via a direct bit-OR (no spread/re-pack).
+     */
+    tryShove(x, y, nx, ny, srcPacked) {
+        const W = this.W, H = this.H;
+        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+            return false;
+        // Strip mode write guard
+        if (nx < this.writeXMin || nx >= this.writeXMax) {
+            if (!this.boundaryPass) {
+                const dm = this.deferredMask;
+                if (dm !== null)
+                    dm[y * W + x] = 1;
+            }
+            return false;
+        }
+        const destIdx = ny * W + nx;
+        const srcIdx = y * W + x;
+        const destPacked = this.grid[destIdx];
+        // Empty destination: normal swap
+        if (destPacked === 0) {
+            this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+            this.grid[srcIdx] = 0;
+            return true;
+        }
+        // Occupied: only displace liquids/gases (not solids, walls, or already-updated cells)
+        const destMat = destPacked & 0xff;
+        const destFlags = MAT_FLAGS[destMat];
+        if (!(destFlags & (MAT_LIQUID | MAT_GAS)))
+            return false;
+        if ((destPacked >> 16) & FLAG_UPDATED)
+            return false;
+        // Swap the two cells
+        this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+        this.grid[srcIdx] = destPacked | FLAG_UPDATED_BIT;
+        return true;
+    }
+    tryFlow(x, y, dir, maxSteps) {
+        const W = this.W, H = this.H;
+        const srcIdx = y * W + x;
+        // Read the source once and pre-compute the moved value (FLAG_UPDATED set).
+        // The old code re-unpacked the source twice per move via
+        // `pack({ ...unpack(packed), flags: unpack(packed).flags | FLAG_UPDATED })`.
+        const movedPacked = this.grid[srcIdx] | FLAG_UPDATED_BIT;
+        for (let step = 1; step <= maxSteps; step++) {
+            const nx = x + dir * step;
+            if (nx < 0 || nx >= W)
+                return false;
+            // Strip mode write guard
+            if (nx < this.writeXMin || nx >= this.writeXMax) {
+                if (!this.boundaryPass) {
+                    const dm = this.deferredMask;
+                    if (dm !== null)
+                        dm[srcIdx] = 1;
+                }
+                return false;
+            }
+            const destIdx = y * W + nx;
+            if (this.grid[destIdx] !== 0)
+                return false;
+            const belowY = y + 1;
+            if (belowY < H) {
+                const belowIdx = belowY * W + nx;
+                if (this.grid[belowIdx] === 0) {
+                    this.grid[belowIdx] = movedPacked;
+                    this.grid[srcIdx] = 0;
+                    return true;
+                }
+            }
+            if (step === maxSteps) {
+                this.grid[destIdx] = movedPacked;
+                this.grid[srcIdx] = 0;
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Density-based horizontal flow for liquids: a less-dense liquid can swap
+     * with an adjacent denser liquid. This lets oil (density 0.8) spread across
+     * the surface of water (density 1.0). Without this, oil rises to the top of
+     * water in a vertical column but can't spread horizontally because tryFlow
+     * only moves into empty cells, and the adjacent cells at the surface are
+     * water, not empty.
+     *
+     * Only fires when the source is strictly less dense than the destination
+     * (so same-density liquids don't churn). Solids, gases, and already-updated
+     * cells are not displaced.
+     */
+    tryDensityFlow(x, y, dir, srcMat, srcPacked) {
+        const W = this.W;
+        const nx = x + dir;
+        if (nx < 0 || nx >= W)
+            return false;
+        // Strip mode write guard
+        if (nx < this.writeXMin || nx >= this.writeXMax) {
+            if (!this.boundaryPass) {
+                const dm = this.deferredMask;
+                if (dm !== null)
+                    dm[y * W + x] = 1;
+            }
+            return false;
+        }
+        const destIdx = y * W + nx;
+        const destPacked = this.grid[destIdx];
+        if (destPacked === 0)
+            return false; // empty — tryFlow already handled this
+        const destMat = destPacked & 0xff;
+        // Only displace liquids (not solids, gases, or already-updated cells)
+        if (!(MAT_FLAGS[destMat] & MAT_LIQUID))
+            return false;
+        if ((destPacked >> 16) & FLAG_UPDATED)
+            return false;
+        // Source must be strictly less dense than destination
+        if (MAT_DENSITY[srcMat] >= MAT_DENSITY[destMat])
+            return false;
+        // Swap: less-dense liquid moves sideways, denser liquid takes its place
+        this.grid[destIdx] = srcPacked | FLAG_UPDATED_BIT;
+        this.grid[y * W + x] = destPacked | FLAG_UPDATED_BIT;
+        return true;
+    }
+    /**
+     * When a gravel cell vacates position (x, y), disturb adjacent Stone and
+     * LooseStone cells so they don't float in the air when their support flows
+     * away.
+     *
+     * - Stone (re-settled or natural) → gravity field set + short settle timer
+     *   in the lifetime field, so it falls as Stone if unsupported. No material
+     *   conversion — it stays Stone and re-freezes (gravity cleared) when it
+     *   lands.
+     * - LooseStone (legacy cells from old saves) → settle timer reset to the
+     *   short disturbed value, gravity ensured, so it keeps falling instead of
+     *   re-settling prematurely.
+     *
+     * The disturbed settle timer is GRAVEL_DISTURB_SETTLE_TICKS (2 ticks). If the
+     * cell is still supported after gravel moves, it re-settles (gravity cleared)
+     * in 2 ticks. If gravel removed its support, the cell starts falling
+     * (FLAG_UPDATED keeps the timer reset to 2 via applyAging) and won't settle
+     * until it lands.
+     */
+    disturbAdjacent(x, y) {
+        const W = this.W, H = this.H;
+        // Check 4-neighbors (the cell above is most critical — it lost support)
+        // Set disturbedFlags (in addition to FLAG_UPDATED) so the chunk-world's
+        // expireWakeTicks can detect disturbed cells in frozen chunks even after
+        // applyAging clears FLAG_UPDATED. disturbedFlags is persistent (included
+        // in preserveFlagsMask by the game).
+        const extra = this.disturbedFlags | FLAG_UPDATED;
+        for (let i = 0; i < 4; i++) {
+            const nx = x + DIR_DX[i];
+            const ny = y + DIR_DY[i];
+            if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                continue;
+            // Strip mode write guard: skip neighbors outside our write bounds.
+            if (nx < this.writeXMin || nx >= this.writeXMax)
+                continue;
+            const nIdx = ny * W + nx;
+            const nPacked = this.grid[nIdx];
+            if (nPacked === 0)
+                continue;
+            const nMat = nPacked & 0xff;
+            const nFlags = (nPacked >> 16) & 0xff;
+            const nFi = nIdx * 4;
+            if (nMat === Material.Stone) {
+                // Set gravity field + settle timer so Stone falls as Stone if
+                // unsupported. No material conversion. Re-freezes when it lands.
+                this.grid[nIdx] = (nMat & 0xff) | ((GRAVEL_DISTURB_SETTLE_TICKS & 0xff) << 8) | (((nFlags | extra) & 0xff) << 16);
+                this.fields[nFi + FIELD.GRAVITY] = DEFAULT_GRAVITY;
+            }
+            else if (nMat === Material.LooseStone) {
+                // Legacy LooseStone (old saves): reset settle timer to short value
+                const shade = nFlags & SHADE_MASK;
+                this.grid[nIdx] = packCell(Material.LooseStone, GRAVEL_DISTURB_SETTLE_TICKS, shade | extra);
+                this.fields[nFi + FIELD.GRAVITY] = DEFAULT_GRAVITY;
+            }
+        }
+    }
+    /**
+     * Gravel flow: like liquid flow, but gravel only moves horizontally to an
+     * adjacent cell if that cell is empty AND the cell below the destination is
+     * also empty (i.e. it "spills downhill" into a low spot). If the destination
+     * at the same level is empty but supported below, gravel still moves there
+     * (spreading along a flat surface), but only for a limited distance so it
+     * forms realistic piles rather than spreading infinitely like water.
+     *
+     * This creates the "flows like a liquid but settles in place" behavior:
+     * gravel pours into gaps, spreads to fill low spots, then stops once it's
+     * resting on something with no downhill path.
+     */
+    tryGravelFlow(x, y, dir) {
+        const W = this.W, H = this.H;
+        const srcIdx = y * W + x;
+        const movedPacked = this.grid[srcIdx] | FLAG_UPDATED_BIT;
+        // Step 1: try to spill into the adjacent cell at the same level
+        const nx = x + dir;
+        if (nx < 0 || nx >= W)
+            return false;
+        // Strip mode write guard
+        if (nx < this.writeXMin || nx >= this.writeXMax) {
+            if (!this.boundaryPass) {
+                const dm = this.deferredMask;
+                if (dm !== null)
+                    dm[srcIdx] = 1;
+            }
+            return false;
+        }
+        const destIdx = y * W + nx;
+        if (this.grid[destIdx] !== 0)
+            return false;
+        // Check if there's a drop below the destination (downhill spill).
+        // If so, gravel falls into the gap — this is the primary flow mode.
+        const belowY = y + 1;
+        if (belowY < H) {
+            const belowDestIdx = belowY * W + nx;
+            if (this.grid[belowDestIdx] === 0) {
+                // Downhill: gravel spills into the gap and falls
+                this.grid[belowDestIdx] = movedPacked;
+                this.grid[srcIdx] = 0;
+                return true;
+            }
+        }
+        // Same-level spread: gravel moves to an adjacent empty cell that's
+        // supported below. Limit spread distance to 2 cells so gravel forms
+        // piles rather than spreading infinitely like a liquid.
+        // Only spread if the gravel is NOT supported directly below (i.e. it's
+        // on an edge and could fall off). This prevents gravel on a flat floor
+        // from spreading forever.
+        const srcBelowIdx = (y + 1) * W + x;
+        const srcSupported = (y + 1 >= H) || this.grid[srcBelowIdx] !== 0;
+        if (srcSupported) {
+            // Gravel is supported below — only spread if the destination is also
+            // NOT supported (gravel flows off the edge of a pile).
+            if (belowY < H) {
+                const belowDestIdx = belowY * W + nx;
+                if (this.grid[belowDestIdx] !== 0) {
+                    // Destination is supported too — no flow needed, gravel settles
+                    return false;
+                }
+            }
+        }
+        // Spread to the adjacent cell
+        this.grid[destIdx] = movedPacked;
+        this.grid[srcIdx] = 0;
+        return true;
+    }
+    // ===========================================================================
+    // Special reactions for new materials
+    // ===========================================================================
+    applySpecialReactions() {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const fields = this.fields;
+        const active = this.activeCells;
+        const count = this.activeCount;
+        // Strip mode write bounds — neighbor writes outside this range are skipped.
+        const wxMin = this.writeXMin, wxMax = this.writeXMax;
+        for (let a = 0; a < count; a++) {
+            const idx = active[a];
+            const packed = grid[idx];
+            if (packed === 0)
+                continue; // cell was destroyed earlier this frame
+            const mat = packed & 0xff;
+            if (mat === Material.Empty)
+                continue;
+            const lifetime = (packed >> 8) & 0xff;
+            const flags = (packed >> 16) & 0xff;
+            // Inline field read — no bounds check needed (idx is always valid)
+            const fi = idx * 4;
+            const temp = fields[fi + FIELD.TEMP] / 128;
+            const x = idx % W;
+            const y = (idx / W) | 0;
+            // --- Antimatter: on contact with any non-empty, non-antimatter,
+            // non-wall, non-duplicator material, annihilates the ENTIRE contiguous
+            // antimatter cluster PLUS all contiguous other material (8-connected
+            // flood-fill through non-empty cells). Wall and Duplicator are barriers
+            // (not annihilated, flood-fill stops at them). Empty cells stop the
+            // flood-fill. A fire explosion marks the contact point. ---
+            if (mat === Material.Antimatter) {
+                // Find a contact neighbor (the trigger for annihilation).
+                let contactX = -1, contactY = -1;
+                for (let dy = -1; dy <= 1 && contactX < 0; dy++) {
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx, ny = y + dy;
+                        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat !== Material.Empty && nMat !== Material.Antimatter &&
+                            nMat !== Material.Wall && nMat !== Material.Duplicator &&
+                            nMat !== Material.Void) {
+                            contactX = nx;
+                            contactY = ny;
+                            break;
+                        }
+                    }
+                }
+                if (contactX >= 0) {
+                    this.annihilateAntimatter(x, y, contactX, contactY);
+                }
+                continue;
+            }
+            // --- Plasma: damages everything around, decays quickly ---
+            if (mat === Material.Plasma) {
+                for (let dy = -1; dy <= 1; dy++) {
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx, ny = y + dy;
+                        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat !== Material.Empty && nMat !== Material.Plasma && nMat !== Material.Wall) {
+                            if (this.rng.random() < 0.3) {
+                                grid[ny * W + nx] = packCell(Material.Fire, 10, this.rng.randomShade());
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Mystery (???): oscillating reaction ---
+            // Changes color/behavior in a sine wave pattern based on frame count
+            if (mat === Material.Mystery) {
+                const phase = Math.sin(this.frame * 0.1 + x * 0.3 + y * 0.2);
+                if (phase > 0.9 && this.rng.random() < 0.1) {
+                    // Emit plasma occasionally (same X, always in strip)
+                    if (y > 0 && grid[(y - 1) * W + x] === 0) {
+                        grid[(y - 1) * W + x] = packCell(Material.Plasma, 20, this.rng.randomShade());
+                    }
+                }
+                if (phase < -0.9 && this.rng.random() < 0.05) {
+                    // Absorb nearby particles
+                    const MYSTERY_DIRS = [1, 0, -1, 0, 0, 1, 0, -1]; // [dx0,dy0, dx1,dy1, ...]
+                    const di = Math.floor(this.rng.random() * 4) * 2;
+                    const dx = MYSTERY_DIRS[di], dy = MYSTERY_DIRS[di + 1];
+                    const nx = x + dx, ny = y + dy;
+                    if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax) {
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat !== Material.Empty && nMat !== Material.Wall && nMat !== Material.Mystery) {
+                            grid[ny * W + nx] = 0;
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Gasoline: slowly vaporizes into gas vapor ---
+            if (mat === Material.Gasoline) {
+                if (this.rng.random() < 0.005) {
+                    // Same X as source, always in strip
+                    if (y > 0 && grid[(y - 1) * W + x] === 0) {
+                        grid[(y - 1) * W + x] = packCell(Material.GasVapor, 200, this.rng.randomShade());
+                        // Small chance to consume the gasoline
+                        if (this.rng.random() < 0.3)
+                            grid[idx] = 0;
+                    }
+                }
+                continue;
+            }
+            // --- Salt + Water → Brine ---
+            if (mat === Material.Salt) {
+                // Single 8-neighbor scan for water + snow
+                let waterNi = -1, hasSnow = false;
+                for (let dy = -1; dy <= 1; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat === Material.Water) {
+                            waterNi = ny * W + nx;
+                        }
+                        else if (nMat === Material.Snow) {
+                            hasSnow = true;
+                        }
+                    }
+                }
+                if (waterNi >= 0 && this.rng.random() < 0.1) {
+                    grid[idx] = packCell(Material.Brine, 0, this.rng.randomShade());
+                    grid[waterNi] = packCell(Material.Brine, 0, this.rng.randomShade());
+                    continue;
+                }
+                // Salt dissolves snow: 1 salt grain melts up to 10 snow cells nearby
+                if (hasSnow) {
+                    // Remove the salt grain
+                    grid[idx] = 0;
+                    // Dissolve up to 10 snow cells in a radius
+                    let dissolved = 0;
+                    for (let ry = y - 3; ry <= y + 3 && dissolved < 10; ry++) {
+                        for (let rx = x - 3; rx <= x + 3 && dissolved < 10; rx++) {
+                            if (rx < 0 || rx >= W || ry < 0 || ry >= H)
+                                continue;
+                            if (rx < wxMin || rx >= wxMax)
+                                continue;
+                            const ridx = ry * W + rx;
+                            if ((grid[ridx] & 0xff) === Material.Snow) {
+                                grid[ridx] = packCell(Material.Water, 0, this.rng.randomShade());
+                                dissolved++;
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // High temp: salt → molten salt (destructive liquid)
+                if (temp > 1.8 && this.rng.random() < 0.02) {
+                    grid[idx] = packCell(Material.MoltenSalt, 0, this.rng.randomShade());
+                    continue;
+                }
+            }
+            // --- Molten Salt: destroys neighbors, cools to salt in low temp ---
+            if (mat === Material.MoltenSalt) {
+                if (temp < 0.5 && this.rng.random() < 0.05) {
+                    grid[idx] = packCell(Material.Salt, 0, this.rng.randomShade());
+                    continue;
+                }
+                // Single 8-neighbor scan for water + dry ice
+                let waterNi = -1, dryIceNi = -1;
+                for (let dy = -1; dy <= 1; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat === Material.Water) {
+                            waterNi = ny * W + nx;
+                        }
+                        else if (nMat === Material.DryIce) {
+                            dryIceNi = ny * W + nx;
+                        }
+                    }
+                }
+                // Contact with water → violent impulse explosion (steam pressure, not destruction)
+                if (waterNi >= 0) {
+                    this.applyImpulse(x, y, 6, 100);
+                    // Convert water to steam, molten salt cools to salt
+                    grid[waterNi] = packCell(Material.Steam, 80, this.rng.randomShade());
+                    if (this.rng.random() < 0.3) {
+                        grid[idx] = packCell(Material.Salt, 0, this.rng.randomShade());
+                    }
+                    continue;
+                }
+                // Contact with dry ice → violent impulse explosion (thermal shock)
+                if (dryIceNi >= 0) {
+                    this.applyImpulse(x, y, 6, 100);
+                    // Consume the dry ice, cool molten salt to salt
+                    grid[dryIceNi] = 0;
+                    if (this.rng.random() < 0.5) {
+                        grid[idx] = packCell(Material.Salt, 0, this.rng.randomShade());
+                    }
+                    continue;
+                }
+                // Ignite flammable neighbors on contact (molten salt is very hot)
+                for (let dy = -1; dy <= 1; dy++) {
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx, ny = y + dy;
+                        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        const ni = ny * W + nx;
+                        const nMat = grid[ni] & 0xff;
+                        if ((MAT_FLAGS[nMat] & MAT_FLAMMABLE) && this.rng.random() < 0.15) {
+                            if (nMat === Material.Oil) {
+                                // Oil needs air exposure to ignite — molten salt touching
+                                // buried oil heats it but can't sustain a flame without oxygen.
+                                if (!this.isExposed(nx, ny))
+                                    continue;
+                                grid[ni] = packCell(Material.BurningOil, MAT_LIFETIME[Material.BurningOil], this.rng.randomShade());
+                            }
+                            else {
+                                grid[ni] = packCell(Material.Fire, 30, this.rng.randomShade());
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Concrete Powder + Water → Concrete ---
+            if (mat === Material.ConcretePowder) {
+                let waterNi = -1;
+                for (let dy = -1; dy <= 1; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.Water) {
+                            waterNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                    if (waterNi >= 0)
+                        break;
+                }
+                if (waterNi >= 0 && this.rng.random() < 0.2) {
+                    grid[idx] = packCell(Material.Concrete, 0, this.rng.randomShade());
+                    // Consume the water
+                    grid[waterNi] = 0;
+                    continue;
+                }
+            }
+            // --- Snow: melts to water when in contact with hot materials or at
+            // high ambient temperature. Hot neighbors: fire, fusefire, burning
+            // oil, lava, molten salt, plasma. ---
+            if (mat === Material.Snow) {
+                // Single 8-neighbor scan using IS_HOT lookup table
+                let hasHot = false;
+                for (let dy = -1; dy <= 1 && !hasHot; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (IS_HOT[grid[ny * W + nx] & 0xff]) {
+                            hasHot = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasHot) {
+                    // Direct contact with a hot material — melts quickly.
+                    if (this.rng.random() < 0.3) {
+                        grid[idx] = packCell(Material.Water, 0, this.rng.randomShade());
+                        continue;
+                    }
+                }
+                else if (temp > 1.3 && this.rng.random() < (temp - 1.3) * 0.05) {
+                    // High ambient temperature — melts gradually.
+                    grid[idx] = packCell(Material.Water, 0, this.rng.randomShade());
+                    continue;
+                }
+            }
+            // --- Dry Ice: sublimates into CO2 gas (smoke-like, no water) ---
+            if (mat === Material.DryIce) {
+                if (this.rng.random() < 0.02) {
+                    if (y > 0 && grid[(y - 1) * W + x] === 0) {
+                        grid[(y - 1) * W + x] = packCell(Material.Smoke, 60, this.rng.randomShade());
+                        if (this.rng.random() < 0.5)
+                            grid[idx] = 0;
+                    }
+                }
+                continue;
+            }
+            // --- Liquid Nitrogen: cools neighbors, slowly evaporates into cold vapor ---
+            if (mat === Material.LiquidNitrogen) {
+                // Cool down nearby fire/lava
+                for (let dy = -1; dy <= 1; dy++) {
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx, ny = y + dy;
+                        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                            continue;
+                        const ni = ny * W + nx;
+                        const nMat = grid[ni] & 0xff;
+                        if (IS_HOT[nMat]) {
+                            grid[ni] = nMat === Material.Lava
+                                ? packCell(Material.Stone, 0, this.rng.randomShade())
+                                : 0;
+                        }
+                    }
+                }
+                // Slowly evaporate into ColdVapor — a visible white-ish gas that
+                // doesn't rise (cold vapor is denser than air) and dissipates over
+                // ~30 seconds. Low probability so the liquid phase lasts a while
+                // before converting. Previously converted to Steam (which condensed
+                // to Water) or dissipated directly to empty (invisible).
+                if (this.rng.random() < 0.005) {
+                    grid[idx] = packCell(Material.ColdVapor, 255, this.rng.randomShade());
+                }
+                continue;
+            }
+            // --- Seed: grows into tree on dirt, progressively from the bottom up ---
+            // lifetime === 0: a normal falling seed. When it lands on dirt/grass,
+            //   it plants a Root and spawns a "growing tip" seed above with
+            //   lifetime = trunkHeight.
+            // lifetime > 0: a growing tip. Each frame it places TreeWood at its
+            //   current position and moves one cell up (lifetime - 1). When
+            //   lifetime reaches 1 or the cell above is blocked, it places the
+            //   leaf canopy and is consumed — the tree is fully grown.
+            if (mat === Material.Seed) {
+                if (lifetime > 0) {
+                    // Growing tip — place TreeWood at current position
+                    grid[idx] = packCell(Material.TreeWood, 0, this.rng.randomShade());
+                    if (lifetime > 1 && y > 0 && grid[(y - 1) * W + x] === 0) {
+                        // Grow one cell higher next frame
+                        grid[(y - 1) * W + x] = packCell(Material.Seed, lifetime - 1, this.rng.randomShade());
+                    }
+                    else {
+                        // Reached target height or blocked — grow leaf canopy here
+                        this.growCanopy(x, y);
+                    }
+                    continue;
+                }
+                // Falling seed — check if it landed on dirt/grass
+                if (y + 1 < H) {
+                    const belowMat = grid[(y + 1) * W + x] & 0xff;
+                    if (belowMat === Material.Dirt || belowMat === Material.Grass) {
+                        if (this.rng.random() < 0.05) {
+                            // Plant root and start growing upward
+                            grid[idx] = packCell(Material.Root, 0, this.rng.randomShade());
+                            const trunkHeight = 8 + Math.floor(this.rng.random() * 8);
+                            if (y > 0 && grid[(y - 1) * W + x] === 0) {
+                                grid[(y - 1) * W + x] = packCell(Material.Seed, trunkHeight, this.rng.randomShade());
+                            }
+                            else {
+                                // Can't grow upward (blocked at base) — just grow a canopy
+                                this.growCanopy(x, y);
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Grass: spreads on top of dirt ---
+            if (mat === Material.Grass) {
+                if (y + 1 < H && (grid[(y + 1) * W + x] & 0xff) === Material.Dirt) {
+                    // Spread sideways on dirt surface
+                    if (this.rng.random() < 0.02) {
+                        const dir = this.rng.random() < 0.5 ? -1 : 1;
+                        const nx = x + dir;
+                        if (nx >= 0 && nx < W) {
+                            if (y + 1 < H && (grid[(y + 1) * W + nx] & 0xff) === Material.Dirt && grid[y * W + nx] === 0) {
+                                grid[y * W + nx] = packCell(Material.Grass, 0, this.rng.randomShade());
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Nanobots: randomly move around and slowly eat through materials ---
+            if (mat === Material.Nanobots) {
+                // Pick a random direction to move/eat (inline the 8 dirs to avoid array alloc)
+                const NANOBOT_DIRS = [1, 0, -1, 0, 0, 1, 0, -1, 1, 1, -1, -1, 1, -1, -1, 1];
+                const di = Math.floor(this.rng.random() * 8) * 2;
+                const dx = NANOBOT_DIRS[di], dy = NANOBOT_DIRS[di + 1];
+                const nx = x + dx, ny = y + dy;
+                if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax) {
+                    const ni = ny * W + nx;
+                    const nMat = grid[ni] & 0xff;
+                    if (nMat === Material.Empty) {
+                        // Move into empty space
+                        grid[ni] = packCell(mat, lifetime, flags | FLAG_UPDATED);
+                        grid[idx] = 0;
+                    }
+                    else if (nMat !== Material.Nanobots && nMat !== Material.Wall &&
+                        nMat !== Material.Antimatter) {
+                        // Eat through the material — slowly destroy it (5% chance per frame)
+                        if (this.rng.random() < 0.05) {
+                            grid[ni] = 0;
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Magic Powder: random color flicker, explodes on flesh, decays like fire ---
+            if (mat === Material.MagicPowder) {
+                // Random shade flicker each frame (independent per particle, no spatial pattern)
+                if (this.rng.random() < 0.5) {
+                    const newShade = Math.floor(this.rng.random() * 4);
+                    grid[idx] = packCell(mat, lifetime, (flags & ~SHADE_MASK) | newShade | FLAG_UPDATED);
+                }
+                // Explodes on contact with flesh
+                let hasFlesh = false;
+                for (let dy = -1; dy <= 1 && !hasFlesh; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.Flesh) {
+                            hasFlesh = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasFlesh && this.rng.random() < 0.3) {
+                    this.explode(x, y, 4);
+                    continue;
+                }
+                // Emit fireflies in a random direction (not always upward)
+                if (this.rng.random() < 0.02) {
+                    const dx = Math.floor(this.rng.random() * 3) - 1;
+                    const dy = Math.floor(this.rng.random() * 3) - 1;
+                    const nx = x + dx, ny = y + dy;
+                    if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax && grid[ny * W + nx] === 0) {
+                        grid[ny * W + nx] = packCell(Material.Fireflies, 255, this.rng.randomShade());
+                    }
+                }
+                continue;
+            }
+            // --- Popcorn: pops like fireworks near fire/lava/molten salt or high heat ---
+            if (mat === Material.Popcorn) {
+                // Already-popped popcorn (FLAG_POPPED) never pops again — prevents an
+                // infinite creation loop where scattered popcorn re-triggers the pop
+                // reaction and spawns ever more popcorn.
+                if (flags & FLAG_POPPED)
+                    continue;
+                // Single 8-neighbor scan using IS_HOT lookup table
+                let hasHot = temp > 1.3;
+                for (let dy = -1; dy <= 1 && !hasHot; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (IS_HOT[grid[ny * W + nx] & 0xff]) {
+                            hasHot = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasHot && this.rng.random() < 0.3) {
+                    // Fireworks pop: radial impulse + scatter popcorn particles outward.
+                    // All resulting popcorn (scattered + original) is marked FLAG_POPPED
+                    // so it won't pop again — each kernel pops exactly once.
+                    this.applyImpulse(x, y, 4, 60);
+                    // Scatter popcorn particles in random directions (marked FLAG_POPPED)
+                    const POPCORN_DIRS = [-1, -1, 0, -1, 1, -1, -1, 0, 1, 0, -1, 1, 0, 1, 1, 1];
+                    for (let di = 0; di < 16; di += 2) {
+                        if (this.rng.random() < 0.6) {
+                            const nx = x + POPCORN_DIRS[di], ny = y + POPCORN_DIRS[di + 1];
+                            if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax && grid[ny * W + nx] === 0) {
+                                grid[ny * W + nx] = packCell(Material.Popcorn, 0, FLAG_POPPED | this.rng.randomShade());
+                            }
+                        }
+                    }
+                    // Mark the original kernel as popped so it doesn't re-pop next frame.
+                    grid[idx] = packCell(Material.Popcorn, 0, (flags & ~FLAG_UPDATED) | FLAG_POPPED);
+                    // Sometimes launch a popped popcorn particle upward
+                    if (this.rng.random() < 0.5 && y > 0 && grid[(y - 1) * W + x] === 0) {
+                        grid[(y - 1) * W + x] = packCell(Material.Popcorn, 0, FLAG_POPPED | this.rng.randomShade());
+                    }
+                }
+                continue;
+            }
+            // --- Dynamite: detonated by fire or fuse, chain-detonates connected sticks ---
+            if (mat === Material.Dynamite) {
+                // Single 8-neighbor scan for fire-class + fuse
+                let hasFireOrFuse = false;
+                for (let dy = -1; dy <= 1 && !hasFireOrFuse; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (IS_FIRE[nMat] || nMat === Material.Fuse) {
+                            hasFireOrFuse = true;
+                            break;
+                        }
+                    }
+                }
+                // 100% trigger chance — dynamite is unstable, it should detonate
+                // immediately when lit, not sit there for frames while fire spreads.
+                if (hasFireOrFuse) {
+                    this.detonateDynamite(x, y);
+                }
+                continue;
+            }
+            // --- C4: only detonates when a burning fuse is adjacent.
+            // C4 itself burns like wax (flammable, slow burn) but does NOT explode from fire alone.
+            // Chain-detonates all connected C4 via flood fill. ---
+            if (mat === Material.C4) {
+                // C4 only detonates when adjacent to FuseFire (fire from a burning fuse).
+                // Regular fire does NOT trigger C4 — only fuse fire does.
+                let fuseBurning = false;
+                for (let dy = -1; dy <= 1 && !fuseBurning; dy++) {
+                    for (let dx = -1; dx <= 1 && !fuseBurning; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx, ny = y + dy;
+                        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.FuseFire) {
+                            fuseBurning = true;
+                            break;
+                        }
+                    }
+                }
+                if (fuseBurning && this.rng.random() < 0.3) {
+                    this.detonateC4(x, y);
+                }
+                continue;
+            }
+            // --- Acid: eats adjacent materials, 50% consumed per eat ---
+            // Each frame, acid scans its 8 neighbors for a non-immune material.
+            // If found, it destroys the neighbor and has a 50% chance of being
+            // consumed itself. This gives a ~2:1 ratio (2 material eaten per 1
+            // acid consumed), so 1000 sand + 1000 acid → ~500 acid remaining.
+            // Acid does NOT eat: Empty, Wall, Acid, Base. Base is handled by the
+            // neutralization reaction (base section below).
+            if (mat === Material.Acid) {
+                // First: check for adjacent Base — neutralization takes priority
+                // (acid + base → salt + steam). Fast reaction — 50% chance per frame.
+                let baseNi = -1;
+                for (let dy = -1; dy <= 1 && baseNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.Base) {
+                            baseNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (baseNi >= 0 && this.rng.random() < 0.5) {
+                    // Neutralization: acid + base → salt + steam
+                    grid[idx] = packCell(Material.Salt, 0, this.rng.randomShade());
+                    grid[baseNi] = packCell(Material.Steam, 80, this.rng.randomShade());
+                    continue;
+                }
+                // Otherwise: eat an adjacent non-immune material
+                if (this.rng.random() < 0.15) {
+                    // Pick a random neighbor to eat (avoids eating all 8 at once)
+                    const eatDir = Math.floor(this.rng.random() * 8);
+                    const EAT_DX = [-1, 0, 1, -1, 1, -1, 0, 1];
+                    const EAT_DY = [-1, -1, -1, 0, 0, 1, 1, 1];
+                    const nx = x + EAT_DX[eatDir];
+                    const ny = y + EAT_DY[eatDir];
+                    if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax) {
+                        const ni = ny * W + nx;
+                        const nMat = grid[ni] & 0xff;
+                        if (!IS_ACID_IMMUNE[nMat]) {
+                            // Eat the neighbor
+                            grid[ni] = 0;
+                            // 50% chance the acid is consumed by the reaction
+                            if (this.rng.random() < 0.5) {
+                                grid[idx] = 0;
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Base: neutralizes acid on contact (acid + base → salt + steam) ---
+            // Mirrors the acid-side check so the reaction triggers from either
+            // material's perspective. Without this, if only acid checks for base,
+            // a base cell surrounded by acid might not react if none of the acid
+            // cells happen to scan it this frame.
+            if (mat === Material.Base) {
+                let acidNi = -1;
+                for (let dy = -1; dy <= 1 && acidNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.Acid) {
+                            acidNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (acidNi >= 0 && this.rng.random() < 0.5) {
+                    // Neutralization: base + acid → steam + salt
+                    grid[idx] = packCell(Material.Steam, 80, this.rng.randomShade());
+                    grid[acidNi] = packCell(Material.Salt, 0, this.rng.randomShade());
+                    continue;
+                }
+            }
+            // --- Flour: dust explosion when suspended near fire ---
+            if (mat === Material.Flour) {
+                let hasFire = false;
+                for (let dy = -1; dy <= 1 && !hasFire; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (IS_FIRE[grid[ny * W + nx] & 0xff]) {
+                            hasFire = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasFire && this.rng.random() < 0.15) {
+                    this.explode(x, y, 3);
+                }
+                continue;
+            }
+            // --- Hydrogen: explodes near fire ---
+            if (mat === Material.Hydrogen) {
+                let hasFire = false;
+                for (let dy = -1; dy <= 1 && !hasFire; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (IS_FIRE[grid[ny * W + nx] & 0xff]) {
+                            hasFire = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasFire && this.rng.random() < 0.3) {
+                    this.explode(x, y, 4);
+                }
+                continue;
+            }
+            // --- Glitter: suspends in water, floats in air ---
+            // (handled in tryMove via low gravity — no special reaction needed)
+            // --- Fireflies: random flicker + organic flight, spread out (no buoyancy) ---
+            if (mat === Material.Fireflies) {
+                // Flicker: each firefly independently picks a random shade each frame.
+                // Uses cell.lifetime as a per-particle phase seed so neighbors don't sync.
+                if (this.rng.random() < 0.5) {
+                    const newShade = Math.floor(this.rng.random() * 4);
+                    grid[idx] = packCell(mat, lifetime, (flags & ~SHADE_MASK) | newShade | FLAG_UPDATED);
+                }
+                // Flight: pure random walk in all 8 directions + occasional darts.
+                // No gravity/buoyancy — they spread out evenly in all directions.
+                if (this.rng.random() < 0.7) {
+                    let dx, dy;
+                    if (this.rng.random() < 0.2) {
+                        // Dart: 2-3 cell jump for organic burst movement
+                        dx = Math.floor(this.rng.random() * 7) - 3;
+                        dy = Math.floor(this.rng.random() * 7) - 3;
+                    }
+                    else {
+                        // Normal: 1-cell step in any of 8 directions (uniform)
+                        dx = Math.floor(this.rng.random() * 3) - 1;
+                        dy = Math.floor(this.rng.random() * 3) - 1;
+                    }
+                    const nx = x + dx, ny = y + dy;
+                    if (nx >= 0 && nx < W && ny >= 0 && ny < H && grid[ny * W + nx] === 0) {
+                        grid[ny * W + nx] = packCell(mat, lifetime, flags | FLAG_UPDATED);
+                        grid[idx] = 0;
+                    }
+                }
+                continue;
+            }
+            // --- Toast: made from bread near fire (future), burns like wood ---
+            // --- Wax: slow burning (handled by combustion + aging) ---
+            // --- Rubber: bouncy (handled in tryMove) ---
+            // ===============================================================
+            // Game-specific reactions
+            // Minimal physical reactions; most "mixing" is analyzer-driven
+            // effect-vector math in the game, not cell transforms here.
+            // ===============================================================
+            // --- Ether + Fire → EtherealVapor (glowing gas byproduct) ---
+            if (mat === Material.Ether) {
+                let fireNi = -1;
+                for (let dy = -1; dy <= 1 && fireNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if (IS_FIRE[grid[ny * W + nx] & 0xff]) {
+                            fireNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (fireNi >= 0 && this.rng.random() < 0.3) {
+                    grid[idx] = packCell(Material.EtherealVapor, 120, this.rng.randomShade());
+                    grid[fireNi] = packCell(Material.Smoke, 40, this.rng.randomShade());
+                    continue;
+                }
+                // High temp: ether evaporates to ethereal vapor
+                if (temp > 1.4 && this.rng.random() < (temp - 1.4) * 0.03) {
+                    grid[idx] = packCell(Material.EtherealVapor, 120, this.rng.randomShade());
+                    continue;
+                }
+            }
+            // --- Sulfur + Water → corrosive reaction (produces AlchemicalSlag slowly) ---
+            if (mat === Material.Sulfur) {
+                let waterNi = -1;
+                for (let dy = -1; dy <= 1 && waterNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.Water) {
+                            waterNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (waterNi >= 0 && temp > 1.0 && this.rng.random() < 0.04) {
+                    grid[idx] = packCell(Material.AlchemicalSlag, 0, this.rng.randomShade());
+                    grid[waterNi] = 0; // consume the water
+                    continue;
+                }
+            }
+            // --- Blood + BoneDust → necrotic reaction (slow, produces Slag) ---
+            if (mat === Material.Blood) {
+                let boneNi = -1;
+                for (let dy = -1; dy <= 1 && boneNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.BoneDust) {
+                            boneNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (boneNi >= 0 && this.rng.random() < 0.02) {
+                    grid[idx] = packCell(Material.AlchemicalSlag, 0, this.rng.randomShade());
+                    grid[boneNi] = 0;
+                    continue;
+                }
+            }
+            // --- MushroomSpores + Water → grows into Plant (mild toxic reaction) ---
+            if (mat === Material.MushroomSpores) {
+                let waterNi = -1;
+                for (let dy = -1; dy <= 1 && waterNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        if ((grid[ny * W + nx] & 0xff) === Material.Water) {
+                            waterNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (waterNi >= 0 && this.rng.random() < 0.03) {
+                    grid[idx] = packCell(Material.Plant, 0, this.rng.randomShade());
+                    continue;
+                }
+            }
+            // --- PhoenixFeather near fire/lava: glows brighter, resists burning ---
+            // (flammable but long burnTime already set; here we just let it shimmer)
+            // --- DragonScale: very dense, sinks through liquids (handled by density) ---
+            // --- LiquidShadow + light source (fire/plasma) → dissipates to smoke ---
+            if (mat === Material.LiquidShadow) {
+                let lightNi = -1;
+                for (let dy = -1; dy <= 1 && lightNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat === Material.Fire || nMat === Material.Plasma || nMat === Material.StarShard) {
+                            lightNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (lightNi >= 0 && this.rng.random() < 0.08) {
+                    grid[idx] = packCell(Material.Smoke, 80, this.rng.randomShade());
+                    continue;
+                }
+            }
+            // --- VoidEssence + any organic (Blood/Flesh/Plant) → violent annihilation ---
+            if (mat === Material.VoidEssence) {
+                let organicNi = -1;
+                for (let dy = -1; dy <= 1 && organicNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat === Material.Blood || nMat === Material.Flesh || nMat === Material.Plant ||
+                            nMat === Material.TrollBlood) {
+                            organicNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (organicNi >= 0 && this.rng.random() < 0.05) {
+                    grid[organicNi] = 0;
+                    grid[idx] = packCell(Material.AlchemicalSlag, 0, this.rng.randomShade());
+                    this.applyImpulse(x, y, 3, 40);
+                    continue;
+                }
+            }
+            // --- TimeSand + high temp → brief plasma flash (reality-bending) ---
+            if (mat === Material.TimeSand && temp > 1.6 && this.rng.random() < 0.02) {
+                grid[idx] = packCell(Material.Plasma, 20, this.rng.randomShade());
+                continue;
+            }
+            // --- StarShard: emits fireflies when in contact with ether/ethereal vapor ---
+            if (mat === Material.StarShard) {
+                let etherNi = -1;
+                for (let dy = -1; dy <= 1 && etherNi < 0; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat === Material.Ether || nMat === Material.EtherealVapor) {
+                            etherNi = ny * W + nx;
+                            break;
+                        }
+                    }
+                }
+                if (etherNi >= 0 && this.rng.random() < 0.04) {
+                    // Emit a firefly into a random empty neighbor
+                    const rdx = Math.floor(this.rng.random() * 3) - 1;
+                    const rdy = Math.floor(this.rng.random() * 3) - 1;
+                    const ex = x + rdx, ey = y + rdy;
+                    if (ex >= 0 && ex < W && ey >= 0 && ey < H && ex >= wxMin && ex < wxMax && grid[ey * W + ex] === 0) {
+                        grid[ey * W + ex] = packCell(Material.Fireflies, 255, this.rng.randomShade());
+                    }
+                }
+            }
+            // --- Spore: floating mold spore. Germinates into Mold when adjacent to
+            // a food material (wood/plant/leaf/tree wood/root/grass). The spore is
+            // consumed (becomes Mold at its current position). Otherwise it drifts
+            // as a gas (handled by tryMove) and slowly dissipates via lifetime. ---
+            if (mat === Material.Spore) {
+                let hasFood = false;
+                for (let dy = -1; dy <= 1 && !hasFood; dy++) {
+                    const ny = y + dy;
+                    if (ny < 0 || ny >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx;
+                        if (nx < 0 || nx >= W)
+                            continue;
+                        const nMat = grid[ny * W + nx] & 0xff;
+                        if (nMat === Material.Wood || nMat === Material.Plant || nMat === Material.Leaf ||
+                            nMat === Material.TreeWood || nMat === Material.Root || nMat === Material.Grass) {
+                            hasFood = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasFood && this.rng.random() < 0.2) {
+                    grid[idx] = packCell(Material.Mold, 0, this.rng.randomShade());
+                    continue;
+                }
+                continue;
+            }
+            // --- Mold: grows on wood/plant/leaf/tree wood/root/grass. Spreads very
+            // slowly to an adjacent food cell (converts it to Mold). When no food
+            // remains adjacent, releases a spore cloud into surrounding empty cells
+            // and dies (clears to empty). Static solid (gravityDir=0) kept in the
+            // active list via MAT_HAS_REACTIONS. ---
+            if (mat === Material.Mold) {
+                // Collect food neighbors + empty/gas neighbors (for spore release).
+                let foodNi = -1;
+                let foodCount = 0;
+                let emptyCount = 0;
+                const MOLD_DIRS = [1, 0, -1, 0, 0, 1, 0, -1, 1, 1, -1, -1, 1, -1, -1, 1];
+                for (let di = 0; di < 16; di += 2) {
+                    const nx = x + MOLD_DIRS[di], ny = y + MOLD_DIRS[di + 1];
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    if (nx < wxMin || nx >= wxMax)
+                        continue;
+                    const ni = ny * W + nx;
+                    const nMat = grid[ni] & 0xff;
+                    if (nMat === Material.Wood || nMat === Material.Plant || nMat === Material.Leaf ||
+                        nMat === Material.TreeWood || nMat === Material.Root || nMat === Material.Grass) {
+                        foodCount++;
+                        if (foodNi < 0)
+                            foodNi = ni;
+                    }
+                    else if (nMat === Material.Empty || (MAT_FLAGS[nMat] & MAT_GAS)) {
+                        emptyCount++;
+                    }
+                }
+                if (foodCount > 0) {
+                    // Spread slowly: ~2% chance per frame to convert one food neighbor
+                    // to Mold. At 60fps that's ~0.8 seconds per spread step — slow
+                    // enough to be visible as creeping growth, fast enough to spread
+                    // across a food block in reasonable time.
+                    if (foodNi >= 0 && this.rng.random() < 0.02) {
+                        grid[foodNi] = packCell(Material.Mold, 0, this.rng.randomShade());
+                    }
+                }
+                else if (emptyCount > 0) {
+                    // No food left — release a spore cloud and die. Spawn a few Spore
+                    // particles into surrounding empty/gas cells, then clear self.
+                    for (let di = 0; di < 16; di += 2) {
+                        if (this.rng.random() < 0.6) {
+                            const nx = x + MOLD_DIRS[di], ny = y + MOLD_DIRS[di + 1];
+                            if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                                continue;
+                            if (nx < wxMin || nx >= wxMax)
+                                continue;
+                            const ni = ny * W + nx;
+                            const nMat = grid[ni] & 0xff;
+                            if (nMat === Material.Empty || (MAT_FLAGS[nMat] & MAT_GAS)) {
+                                grid[ni] = packCell(Material.Spore, MAT_LIFETIME[Material.Spore], this.rng.randomShade());
+                            }
+                        }
+                    }
+                    grid[idx] = 0;
+                }
+                continue;
+            }
+            // --- Glitch: randomly swaps places with a neighboring non-empty cell.
+            // Any non-empty neighbor (any material except Empty) is a valid swap
+            // target. The swapped-in material takes the glitch's old position and
+            // vice versa. Falls like a normal solid when it can't swap. ---
+            if (mat === Material.Glitch) {
+                if (this.rng.random() < 0.3) {
+                    // Pick a random 8-direction and swap with whatever is there.
+                    const GLITCH_DIRS = [1, 0, -1, 0, 0, 1, 0, -1, 1, 1, -1, -1, 1, -1, -1, 1];
+                    const di = Math.floor(this.rng.random() * 8) * 2;
+                    const nx = x + GLITCH_DIRS[di], ny = y + GLITCH_DIRS[di + 1];
+                    if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax) {
+                        const ni = ny * W + nx;
+                        const nPacked = grid[ni];
+                        if (nPacked !== 0 && !((nPacked >> 16) & FLAG_UPDATED)) {
+                            // Swap: glitch moves to neighbor, neighbor moves to glitch's spot.
+                            // Both marked FLAG_UPDATED so neither is reprocessed this frame.
+                            grid[ni] = packed | FLAG_UPDATED_BIT;
+                            grid[idx] = nPacked | FLAG_UPDATED_BIT;
+                            continue;
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Duplicator: static solid that clones the first material to touch
+            // it. The locked material id is stored in the lifetime field
+            // (0 = not yet locked). Each frame, if locked, it spawns the locked
+            // material into an adjacent empty cell. Does not move, does not react
+            // otherwise (acid-immune, skipped by antimatter). ---
+            if (mat === Material.Duplicator) {
+                const locked = lifetime; // 0 = not locked; otherwise = material id
+                if (locked === 0) {
+                    // Not yet locked — scan neighbors for a material to lock onto.
+                    // Skip Empty, Wall, other Duplicators, Antimatter (would be
+                    // catastrophically destructive), Acid, and Base — the duplicator
+                    // should not react with these at all (like Wall). Cloning acid
+                    // would spread corrosion through the duplicator; cloning base is
+                    // equally undesirable.
+                    for (let dy = -1; dy <= 1; dy++) {
+                        for (let dx = -1; dx <= 1; dx++) {
+                            if (dx === 0 && dy === 0)
+                                continue;
+                            const nx = x + dx, ny = y + dy;
+                            if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                                continue;
+                            if (nx < wxMin || nx >= wxMax)
+                                continue;
+                            const nMat = grid[ny * W + nx] & 0xff;
+                            if (nMat !== Material.Empty && nMat !== Material.Wall &&
+                                nMat !== Material.Duplicator && nMat !== Material.Antimatter &&
+                                nMat !== Material.Acid && nMat !== Material.Base) {
+                                // Lock onto this material (store its id in the lifetime field).
+                                grid[idx] = packCell(Material.Duplicator, nMat, flags & ~FLAG_UPDATED);
+                                break;
+                            }
+                        }
+                        if (((grid[idx] >> 8) & 0xff) !== 0)
+                            break;
+                    }
+                }
+                else {
+                    // Locked — spawn the locked material into an adjacent empty cell,
+                    // and slowly propagate the lock to adjacent unlocked Duplicators.
+                    // Low chance per frame so it produces a steady trickle, not a flood.
+                    if (this.rng.random() < 0.15) {
+                        const DUP_DIRS = [1, 0, -1, 0, 0, 1, 0, -1, 1, 1, -1, -1, 1, -1, -1, 1];
+                        const di = Math.floor(this.rng.random() * 8) * 2;
+                        const nx = x + DUP_DIRS[di], ny = y + DUP_DIRS[di + 1];
+                        if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax) {
+                            const ni = ny * W + nx;
+                            if (grid[ni] === 0) {
+                                const spawnMat = locked;
+                                grid[ni] = packCell(spawnMat, MAT_LIFETIME[spawnMat], this.rng.randomShade());
+                            }
+                        }
+                    }
+                    // Propagate lock to adjacent unlocked Duplicators — same low chance
+                    // so the lock creeps across a duplicator cluster slowly.
+                    if (this.rng.random() < 0.15) {
+                        const PROP_DIRS = [1, 0, -1, 0, 0, 1, 0, -1];
+                        const di = Math.floor(this.rng.random() * 4) * 2;
+                        const nx = x + PROP_DIRS[di], ny = y + PROP_DIRS[di + 1];
+                        if (nx >= 0 && nx < W && ny >= 0 && ny < H && nx >= wxMin && nx < wxMax) {
+                            const ni = ny * W + nx;
+                            const nPacked = grid[ni];
+                            // Only lock an adjacent Duplicator that is NOT yet locked
+                            // (lifetime === 0). Don't overwrite an existing lock — a
+                            // duplicator that already locked onto a different material
+                            // keeps its own lock.
+                            if ((nPacked & 0xff) === Material.Duplicator &&
+                                ((nPacked >> 8) & 0xff) === 0) {
+                                grid[ni] = packCell(Material.Duplicator, locked, nPacked >> 16 & 0xff);
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // --- Void: a static solid that swallows up any material that touches
+            // it. Each frame, every adjacent non-empty cell (except Wall, other
+            // Void, and Duplicator — those are permanent barriers) is destroyed
+            // (set to empty). The void itself is never consumed. Acid-immune,
+            // antimatter barrier, never falls. MAT_HAS_REACTIONS keeps it active. ---
+            if (mat === Material.Void) {
+                for (let dy = -1; dy <= 1; dy++) {
+                    for (let dx = -1; dx <= 1; dx++) {
+                        if (dx === 0 && dy === 0)
+                            continue;
+                        const nx = x + dx, ny = y + dy;
+                        if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                            continue;
+                        if (nx < wxMin || nx >= wxMax)
+                            continue;
+                        const ni = ny * W + nx;
+                        const nMat = grid[ni] & 0xff;
+                        // Swallow everything except Empty, Wall, Void, Duplicator, and
+                        // Antimatter (those are permanent — void doesn't eat itself or
+                        // other exotic barriers).
+                        if (nMat !== Material.Empty && nMat !== Material.Wall &&
+                            nMat !== Material.Void && nMat !== Material.Duplicator &&
+                            nMat !== Material.Antimatter) {
+                            grid[ni] = 0;
+                        }
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    /**
+     * Apply a radial impulse: immediately shoves particles outward from (cx, cy)
+     * and sets per-cell wind fields for ongoing push. This pushes particles away
+     * without destroying them. The fluid grid handles velocity decay via its step().
+     *
+     * Immediate displacement: process rings from outermost to innermost so outer
+     * particles move first, creating space for inner ones. Each particle is
+     * shoved one cell radially outward (displacing liquids/gases via tryShove).
+     *
+     * Wind field: sets radial wind with linear falloff for continued push over
+     * the next several frames.
+     */
+    applyImpulse(cx, cy, radius, strength) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const fields = this.fields;
+        // --- Phase 1: Immediate radial displacement (outer ring → inner ring) ---
+        // Process from the outermost ring inward so outer particles shove out first,
+        // creating space for inner particles to follow.
+        for (let ring = radius; ring >= 1; ring--) {
+            for (let y = cy - ring; y <= cy + ring; y++) {
+                for (let x = cx - ring; x <= cx + ring; x++) {
+                    // Only process cells on the current ring boundary (skip inner cells)
+                    const dx = x - cx, dy = y - cy;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+                    if (Math.round(dist) !== ring)
+                        continue;
+                    if (x < 0 || x >= W || y < 0 || y >= H)
+                        continue;
+                    const idx = y * W + x;
+                    const packed = grid[idx];
+                    if (packed === 0)
+                        continue;
+                    const flags = (packed >> 16) & 0xff;
+                    if (flags & FLAG_UPDATED)
+                        continue;
+                    // Don't move walls or static solids
+                    const mat = packed & 0xff;
+                    if (mat === Material.Wall || mat === Material.Stone)
+                        continue;
+                    // Shove one step radially outward
+                    const stepX = dx === 0 ? 0 : dx > 0 ? 1 : -1;
+                    const stepY = dy === 0 ? 0 : dy > 0 ? 1 : -1;
+                    this.tryShove(x, y, x + stepX, y + stepY, packed);
+                }
+            }
+        }
+        // --- Phase 2: Apply impulse to the fluid grid for ongoing push ---
+        // The fluid grid handles pressure relaxation and velocity decay, replacing
+        // the old per-cell wind field system.
+        this.fluid.applyImpulse(cx, cy, radius, 0, 0); // pressure impulse for shockwave
+        // Radial velocity impulse — each cell gets pushed outward
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                if (x < 0 || x >= W || y < 0 || y >= H)
+                    continue;
+                const dx = x - cx, dy = y - cy;
+                const dist = Math.sqrt(dx * dx + dy * dy);
+                if (dist > radius || dist < 0.5)
+                    continue;
+                const falloff = 1 - dist / radius;
+                const mag = strength * falloff * 0.02; // scale to fluid grid velocity units
+                const ux = dx / dist, uy = dy / dist;
+                this.fluid.applyImpulse(x, y, 1, ux * mag, uy * mag);
+            }
+        }
+    }
+    /** Create an explosion: fire + smoke in a radius */
+    explode(cx, cy, radius) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const wxMin = this.writeXMin, wxMax = this.writeXMax;
+        for (let y = cy - radius; y <= cy + radius; y++) {
+            for (let x = cx - radius; x <= cx + radius; x++) {
+                const dist = (x - cx) * (x - cx) + (y - cy) * (y - cy);
+                if (dist > radius * radius)
+                    continue;
+                if (x < 0 || x >= W || y < 0 || y >= H)
+                    continue;
+                // Strip mode write guard — explosions don't cross strip boundaries.
+                // The coordinator's boundary cleanup re-runs explosions that span strips.
+                if (x < wxMin || x >= wxMax)
+                    continue;
+                const mat = grid[y * W + x] & 0xff;
+                if (mat === Material.Wall)
+                    continue;
+                // Don't destroy C4 or Dynamite in the blast — let detonateC4 /
+                // detonateDynamite handle chain reactions via flood-fill.
+                if (mat === Material.C4 || mat === Material.Dynamite)
+                    continue;
+                if (dist < radius * radius * 0.3) {
+                    // Core: fire
+                    grid[y * W + x] = packCell(Material.Fire, 20, this.rng.randomShade());
+                }
+                else {
+                    // Outer: smoke or empty
+                    if (this.rng.random() < 0.5) {
+                        grid[y * W + x] = packCell(Material.Smoke, 60, this.rng.randomShade());
+                    }
+                    else {
+                        grid[y * W + x] = 0;
+                    }
+                }
+            }
+        }
+        // --- Spawn explosion particles ---
+        // Projectile particles: flying debris in all directions
+        const numProjectiles = Math.min(8, 3 + radius);
+        for (let i = 0; i < numProjectiles; i++) {
+            const angle = (i / numProjectiles) * Math.PI * 2 + this.rng.random() * 0.5;
+            const speed = 1 + this.rng.random() * 2;
+            this.particles.spawn(cx, cy, PARTICLE_TYPES.PROJECTILE, 0xffaa3300, // orange-red
+            1 + this.rng.random(), Math.cos(angle) * speed, Math.sin(angle) * speed, 20 + Math.floor(this.rng.random() * 20));
+        }
+        // Circle particles: expanding blast rings
+        const numCircles = Math.min(3, 1 + Math.floor(radius / 2));
+        for (let i = 0; i < numCircles; i++) {
+            this.particles.spawn(cx, cy, PARTICLE_TYPES.CIRCLE, 0xffff6600, // bright orange
+            radius * 0.5, 0, 0, 15 + i * 5);
+        }
+    }
+    /** Annihilate antimatter: flood-fill all 8-connected non-empty cells from
+     *  the antimatter cluster at (ax, ay) through the contacted material at
+     *  (cx, cy). Destroys every connected non-empty cell except Wall and
+     *  Duplicator (which act as barriers and are left intact). Empty cells
+     *  stop the flood-fill. A fire explosion marks the contact point.
+     *
+     *  This implements "eliminates all contiguous antimatter and all contiguous
+     *  other material, except empty" — the entire connected non-empty region
+     *  touching the antimatter cluster is annihilated. */
+    annihilateAntimatter(ax, ay, cx, cy) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const visited = this.visitedAntimatterFrame;
+        const frame = this.frame;
+        const wxMin = this.writeXMin, wxMax = this.writeXMax;
+        // Flood-fill from the antimatter seed cell through all 8-connected
+        // non-empty cells. Wall and Duplicator are barriers (skipped, not
+        // destroyed). Empty cells are not traversed.
+        const stack = [ay * W + ax];
+        const cells = [];
+        while (stack.length > 0) {
+            const idx = stack.pop();
+            if (visited[idx] === frame)
+                continue;
+            visited[idx] = frame;
+            const px = idx % W;
+            const py = (idx / W) | 0;
+            const m = grid[idx] & 0xff;
+            // Stop at empty, wall, duplicator, or void (barriers)
+            if (m === Material.Empty || m === Material.Wall || m === Material.Duplicator ||
+                m === Material.Void)
+                continue;
+            cells.push(idx);
+            // Push 8 neighbors (only those within write bounds — cross-strip
+            // annihilation is handled by the coordinator's boundary cleanup)
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const nx = px + dx, ny = py + dy;
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    if (nx < wxMin || nx >= wxMax)
+                        continue;
+                    stack.push(ny * W + nx);
+                }
+            }
+        }
+        // Annihilate every cell in the connected region.
+        for (let i = 0; i < cells.length; i++) {
+            grid[cells[i]] = 0;
+        }
+        // Fire explosion at the contact point (visual + ignites nearby flammables).
+        this.explode(cx, cy, 3);
+    }
+    /** Detonate C4 at (cx, cy) and flood-fill all connected C4 for chain reaction */
+    detonateC4(cx, cy) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        // Collect all connected C4 cells (8-connected flood fill).
+        // Use a frame-tagged visited array instead of allocating a Set every call.
+        // We use a dedicated visitedC4Frame array to avoid clobbering the
+        // combustion pass's visitedFrame.
+        const visited = this.visitedC4Frame;
+        const frame = this.frame;
+        const stack = [cy * W + cx];
+        const c4Cells = [];
+        while (stack.length > 0) {
+            const idx = stack.pop();
+            if (visited[idx] === frame)
+                continue;
+            visited[idx] = frame;
+            const px = idx % W;
+            const py = (idx / W) | 0;
+            if ((grid[idx] & 0xff) !== Material.C4)
+                continue;
+            c4Cells.push(idx);
+            // Check 8 neighbors
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const nx = px + dx, ny = py + dy;
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    stack.push(ny * W + nx);
+                }
+            }
+        }
+        // Explode each C4 cell
+        for (let i = 0; i < c4Cells.length; i++) {
+            const idx = c4Cells[i];
+            const px = idx % W;
+            const py = (idx / W) | 0;
+            this.explode(px, py, 8);
+        }
+    }
+    /** Detonate Dynamite at (cx, cy) and flood-fill all connected Dynamite for
+     *  chain reaction. Collects all 8-connected Dynamite cells, explodes once at
+     *  the center of mass (radius scaled to the cluster size), then consumes all
+     *  cells. Exploding once instead of per-cell avoids massive lag on large
+     *  dynamite clusters. */
+    detonateDynamite(cx, cy) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const visited = this.visitedC4Frame;
+        const frame = this.frame;
+        const stack = [cy * W + cx];
+        const dynoCells = [];
+        while (stack.length > 0) {
+            const idx = stack.pop();
+            if (visited[idx] === frame)
+                continue;
+            visited[idx] = frame;
+            const px = idx % W;
+            const py = (idx / W) | 0;
+            if ((grid[idx] & 0xff) !== Material.Dynamite)
+                continue;
+            dynoCells.push(idx);
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const nx = px + dx, ny = py + dy;
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    stack.push(ny * W + nx);
+                }
+            }
+        }
+        if (dynoCells.length === 0)
+            return;
+        // Explode once at the center of mass. Radius scales with cluster size
+        // (6 base + 1 per extra stick, capped at 12) so a single big blast
+        // covers the whole cluster — much cheaper than N separate explosions.
+        let sumX = 0, sumY = 0;
+        for (let i = 0; i < dynoCells.length; i++) {
+            sumX += dynoCells[i] % W;
+            sumY += (dynoCells[i] / W) | 0;
+        }
+        const centerX = Math.round(sumX / dynoCells.length);
+        const centerY = Math.round(sumY / dynoCells.length);
+        const radius = Math.min(12, 6 + dynoCells.length - 1);
+        this.explode(centerX, centerY, radius);
+        // Consume all dynamite cells — explode() skips them, so we must destroy
+        // them explicitly. Convert to fire so the blast looks right.
+        for (let i = 0; i < dynoCells.length; i++) {
+            grid[dynoCells[i]] = packCell(Material.Fire, 20, this.rng.randomShade());
+        }
+    }
+    /** Grow a leaf canopy around (x, y) — the top of the tree trunk.
+     *  Called when the growing seed tip reaches its target height or is blocked. */
+    growCanopy(x, y) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const wxMin = this.writeXMin, wxMax = this.writeXMax;
+        const canopyRadius = 3 + Math.floor(this.rng.random() * 2);
+        for (let dy = -canopyRadius; dy <= 0; dy++) {
+            for (let dx = -canopyRadius; dx <= canopyRadius; dx++) {
+                const lx = x + dx, ly = y + dy - canopyRadius;
+                if (lx < 0 || lx >= W || ly < 0 || ly >= H)
+                    continue;
+                if (lx < wxMin || lx >= wxMax)
+                    continue;
+                const dist = dx * dx + dy * dy;
+                if (dist > canopyRadius * canopyRadius)
+                    continue;
+                if (grid[ly * W + lx] !== 0)
+                    continue;
+                if (this.rng.random() < 0.7) {
+                    grid[ly * W + lx] = packCell(Material.Leaf, 0, this.rng.randomShade());
+                }
+            }
+        }
+    }
+    findNeighbor(x, y, mat) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        for (let dy = -1; dy <= 1; dy++) {
+            for (let dx = -1; dx <= 1; dx++) {
+                if (dx === 0 && dy === 0)
+                    continue;
+                const nx = x + dx, ny = y + dy;
+                if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                    continue;
+                if ((grid[ny * W + nx] & 0xff) === mat)
+                    return { x: nx, y: ny };
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a cell is "exposed" — has at least one neighbor that is empty
+     * or a gas (so fire/heat can reach it). Used to prevent buried oil from
+     * igniting when it's encased in solid/liquid material.
+     */
+    isExposed(x, y) {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        for (let dy = -1; dy <= 1; dy++) {
+            for (let dx = -1; dx <= 1; dx++) {
+                if (dx === 0 && dy === 0)
+                    continue;
+                const nx = x + dx, ny = y + dy;
+                if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                    continue;
+                const nMat = grid[ny * W + nx] & 0xff;
+                if (nMat === Material.Empty)
+                    return true;
+                if (MAT_FLAGS[nMat] & MAT_GAS)
+                    return true;
+            }
+        }
+        return false;
+    }
+    applyCombustion() {
+        const W = this.W, H = this.H;
+        const grid = this.grid;
+        const fields = this.fields;
+        const active = this.activeCells;
+        const count = this.activeCount;
+        // Strip mode write bounds
+        const wxMin = this.writeXMin, wxMax = this.writeXMax;
+        // Snapshot which cells are fire/lava at the start of this pass.
+        // Only these cells can spread fire — newly ignited cells wait until next frame.
+        // This prevents instant cascade through fuse/gunpowder chains in a single pass.
+        // (Reused per-frame buffer — avoids a Uint8Array allocation every step.)
+        // Build from the active list instead of scanning the full grid.
+        const fireSources = this.fireSources;
+        // Only clear the entries we'll use (the active cells). The rest are already 0
+        // from the previous frame's clear, but to be safe we clear all active entries.
+        for (let a = 0; a < count; a++)
+            fireSources[active[a]] = 0;
+        let fireCount = 0;
+        for (let a = 0; a < count; a++) {
+            const idx = active[a];
+            const m = grid[idx] & 0xff;
+            if (m === Material.Fire || m === Material.FuseFire || m === Material.BurningOil || m === Material.Lava) {
+                fireSources[idx] = 1;
+                fireCount++;
+            }
+        }
+        // Early-out: no fire sources means no combustion spread, fuse burn, or
+        // burning-oil passes needed.
+        if (fireCount === 0)
+            return;
+        // --- Fire spread pass ---
+        // Iterate only the fire-source cells (from the active list) instead of
+        // scanning the full grid.
+        for (let a = 0; a < count; a++) {
+            const idx = active[a];
+            if (!fireSources[idx])
+                continue;
+            const srcPacked = grid[idx];
+            const srcMat = srcPacked & 0xff;
+            // Spark-flagged fire (visual flames emitted by BurningOil/fuse) does NOT
+            // ignite oil — the burning-oil pass handles controlled oil-to-oil spread.
+            // Without this, the visual flames would ignite adjacent oil in all 8
+            // directions (including diagonals), causing the fire to "burst" outward
+            // instead of creeping slowly from the ignition site.
+            const srcIsSpark = srcMat === Material.Fire && ((srcPacked >> 16) & FLAG_SPARK) !== 0;
+            const x = idx % W;
+            const y = (idx / W) | 0;
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const nx = x + dx, ny = y + dy;
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    if (nx < wxMin || nx >= wxMax)
+                        continue;
+                    const ni = ny * W + nx;
+                    const nMat = grid[ni] & 0xff;
+                    if (!(MAT_FLAGS[nMat] & MAT_FLAMMABLE))
+                        continue;
+                    if (nMat === Material.Gunpowder) {
+                        grid[ni] = packCell(Material.Fire, 15, this.rng.randomShade());
+                        continue;
+                    }
+                    // Gas vapor and hydrogen: explosive
+                    if (nMat === Material.GasVapor || nMat === Material.Hydrogen) {
+                        grid[ni] = packCell(Material.Fire, 20, this.rng.randomShade());
+                        this.explode(nx, ny, 3);
+                        continue;
+                    }
+                    // Flour: dust explosion
+                    if (nMat === Material.Flour) {
+                        this.explode(nx, ny, 3);
+                        continue;
+                    }
+                    // Dynamite: chain detonate via flood-fill (same as applySpecialReactions)
+                    if (nMat === Material.Dynamite) {
+                        this.detonateDynamite(nx, ny);
+                        continue;
+                    }
+                    const baseChance = srcMat === Material.Lava ? 0.1 : 0.08;
+                    // Rubber is hard to ignite — low continual burn/spread chance.
+                    // Oil is a slow-burning liquid fuel: low per-frame spread chance
+                    // so the flame creeps gradually across the surface rather than
+                    // flashing instantly. BurningOil→oil spread is handled by the
+                    // dedicated burning-oil pass below (with decay-linked chance),
+                    // so skip oil neighbors here when the source is BurningOil.
+                    // Spark-flagged fire (visual flames from BurningOil) also skips
+                    // oil — only "real" fire sources (lava, regular fire from burning
+                    // wood/gunpowder, etc.) can ignite oil via this pass.
+                    if ((srcMat === Material.BurningOil || srcIsSpark) && nMat === Material.Oil)
+                        continue;
+                    // Oil needs air exposure to ignite — fire/lava touching buried oil
+                    // heats it but can't sustain a flame without oxygen.
+                    if (nMat === Material.Oil && !this.isExposed(nx, ny))
+                        continue;
+                    const matMult = nMat === Material.Rubber ? 0.3 :
+                        nMat === Material.Oil ? 0.3 :
+                            nMat === Material.Wax ? 2.5 : // wax spreads fire extremely fast
+                                1.0;
+                    // Per-cell temperature scales fire spread rate (inline field read)
+                    const nTemp = fields[ni * 4 + FIELD.TEMP] / 128;
+                    const chance = baseChance * nTemp * matMult;
+                    if (this.rng.random() < chance) {
+                        // Fuse gets FuseFire (yellow, stays put, deterministic spread)
+                        if (nMat === Material.Fuse) {
+                            grid[ni] = packCell(Material.FuseFire, 15, this.rng.randomShade());
+                        }
+                        else if (nMat === Material.Oil) {
+                            // Oil → BurningOil (stays put, slow decay, slow spread)
+                            grid[ni] = packCell(Material.BurningOil, MAT_LIFETIME[Material.BurningOil], this.rng.randomShade());
+                        }
+                        else if (nMat === Material.Wax) {
+                            // Wax burns very slowly — long fire lifetime + FLAG_ANCHORED so
+                            // the flame stays put on the wax surface and keeps spreading.
+                            grid[ni] = packCell(Material.Fire, 200, FLAG_ANCHORED | this.rng.randomShade());
+                        }
+                        else {
+                            grid[ni] = packCell(Material.Fire, 30, this.rng.randomShade());
+                        }
+                    }
+                }
+            }
+        }
+        // --- Deterministic fuse burn ---
+        // FuseFire deterministically ignites ALL adjacent fuse cells when its
+        // lifetime drops to the threshold. The fire has a short lifetime
+        // (FUSE_FIRE_LIFETIME) so the flame trail is brief. The burn speed is
+        // controlled by the lifetime: each cell burns for FUSE_FIRE_LIFETIME frames
+        // before passing the flame onward.
+        //
+        // FuseFire is a separate material (Material.FuseFire) so it's reliably
+        // identified even at the end of the trail where all adjacent fuse has been
+        // consumed. No flag bits needed.
+        //
+        // To prevent single-frame cascades, we use a frame-tagged visited array
+        // (this.visitedFrame) instead of allocating a Set every step. A cell is
+        // "visited this frame" when visitedFrame[i] === this.frame.
+        const FUSE_FIRE_LIFETIME = 15;
+        const FUSE_SPREAD_THRESHOLD = 3;
+        const frame = this.frame;
+        const visitedFrame = this.visitedFrame;
+        for (let a = 0; a < count; a++) {
+            const idx = active[a];
+            const packed = grid[idx];
+            const mat = packed & 0xff;
+            if (mat !== Material.FuseFire)
+                continue;
+            const lifetime = (packed >> 8) & 0xff;
+            if (lifetime === 0)
+                continue;
+            const x = idx % W;
+            const y = (idx / W) | 0;
+            // Emit sparks every frame — small fire particles that fly upward with
+            // random spread. Sparks use Material.Fire (red) so they're visually
+            // distinct from the yellow fuse fire and fly freely (FuseFire is
+            // anchored, Fire is not).
+            for (let s = 0; s < 3; s++) {
+                if (this.rng.random() < 0.5) {
+                    const sx = x + Math.floor(this.rng.random() * 3) - 1;
+                    const sy = y - 1 - Math.floor(this.rng.random() * 2); // 1-2 cells above
+                    if (sx >= 0 && sx < W && sy >= 0 && sy < H && sx >= wxMin && sx < wxMax && grid[sy * W + sx] === 0) {
+                        // Sparks: very short lifetime, expire to empty (not smoke) so they
+                        // don't accumulate and suffocate the burn when going upward.
+                        grid[sy * W + sx] = packCell(Material.Fire, 6, this.rng.randomShade() | FLAG_SPARK);
+                        // Upward impulse only — sparks rise straight up (wind is skipped for
+                        // spark fire in tryMove). The impulse still pushes neighboring
+                        // smoke/gas upward via the fluid grid. No horizontal drift: a fixed
+                        // at-birth drift caused sparks to streak diagonally up-left/up-right.
+                        this.fluid.applyImpulse(sx, sy, 2, 0, -0.8); // strong upward
+                    }
+                }
+            }
+            // Spread to adjacent fuse cells only when near end of lifetime
+            if (lifetime > FUSE_SPREAD_THRESHOLD)
+                continue;
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const nx = x + dx, ny = y + dy;
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    if (nx < wxMin || nx >= wxMax)
+                        continue;
+                    const ni = ny * W + nx;
+                    if (visitedFrame[ni] === frame)
+                        continue;
+                    if ((grid[ni] & 0xff) === Material.Fuse) {
+                        grid[ni] = packCell(Material.FuseFire, FUSE_FIRE_LIFETIME, this.rng.randomShade());
+                        visitedFrame[ni] = frame;
+                    }
+                }
+            }
+        }
+        // --- Burning oil pass ---
+        // BurningOil flows like a liquid (gravity: 1, density: 0.8) on the oil
+        // surface. Each frame it:
+        //   1. Emits normal Fire particles upward (visual flames that rise and
+        //      decay to smoke like regular fire).
+        //   2. Slowly spreads to adjacent oil. The spread chance scales with
+        //      decay progress — early in its life it barely spreads, but as it
+        //      burns down the chance increases, so the fire creeps outward
+        //      gradually rather than flashing instantly.
+        // The ignitedOil de-dup uses the same frame-tagged visitedFrame array as
+        // the fuse pass above. Safe to share: the two passes target different
+        // materials (Fuse vs Oil), so a cell marked in one pass is guarded out by
+        // the material-type check in the other before the visited check runs.
+        const BURNING_OIL_LIFETIME = MAT_LIFETIME[Material.BurningOil];
+        for (let a = 0; a < count; a++) {
+            const idx = active[a];
+            const packed = grid[idx];
+            const mat = packed & 0xff;
+            if (mat !== Material.BurningOil)
+                continue;
+            const lifetime = (packed >> 8) & 0xff;
+            const x = idx % W;
+            const y = (idx / W) | 0;
+            // Emit fire particles above: visual flames that rise from the burning
+            // oil surface with slight horizontal variation for a natural look.
+            // Marked with FLAG_SPARK so they:
+            //   1. Expire to empty (not smoke) — smoke would accumulate and
+            //      suffocate the burn. The BurningOil itself already produces smoke
+            //      when it decays.
+            //   2. Are skipped by the fire spread pass for oil ignition (see below)
+            //      — the burning-oil pass handles controlled oil-to-oil spread.
+            //      Without this, the visual flames would ignite adjacent oil in all
+            //      directions (including diagonals), causing the fire to "burst"
+            //      instead of creeping slowly outward.
+            //   3. Skip diagonal rising in tryMove (isSparkFire) — they rise straight
+            //      up or drift horizontally via gas drift, but don't shoot off in
+            //      diagonal directions.
+            for (let s = 0; s < 2; s++) {
+                if (this.rng.random() < 0.4) {
+                    const sx = x + Math.floor(this.rng.random() * 3) - 1; // -1, 0, or +1
+                    const sy = y - 1 - Math.floor(this.rng.random() * 2); // 1-2 cells above
+                    if (sx >= 0 && sx < W && sy >= 0 && sy < H && sx >= wxMin && sx < wxMax && grid[sy * W + sx] === 0) {
+                        grid[sy * W + sx] = packCell(Material.Fire, 20, this.rng.randomShade() | FLAG_SPARK);
+                        // Upward impulse only — sparks rise straight up (wind is skipped for
+                        // spark fire in tryMove). The impulse still pushes neighboring
+                        // smoke/gas upward via the fluid grid. No horizontal drift: a fixed
+                        // at-birth drift caused sparks to streak diagonally up-left/up-right.
+                        this.fluid.applyImpulse(sx, sy, 2, 0, -0.5);
+                    }
+                }
+            }
+            // Spread to adjacent oil: slow chance that increases with decay.
+            // decayProgress goes 0→1 as lifetime goes 200→0.
+            const decayProgress = 1 - (lifetime / BURNING_OIL_LIFETIME);
+            const spreadChance = 0.02 + 0.04 * decayProgress; // 2% early → 6% late
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    if (dx === 0 && dy === 0)
+                        continue;
+                    const nx = x + dx, ny = y + dy;
+                    if (nx < 0 || nx >= W || ny < 0 || ny >= H)
+                        continue;
+                    if (nx < wxMin || nx >= wxMax)
+                        continue;
+                    const ni = ny * W + nx;
+                    if (visitedFrame[ni] === frame)
+                        continue;
+                    // Oil only ignites if it has air exposure (empty/gas neighbor) —
+                    // burning oil flowing into buried oil won't ignite it without oxygen.
+                    if ((grid[ni] & 0xff) === Material.Oil && this.isExposed(nx, ny) && this.rng.random() < spreadChance) {
+                        grid[ni] = packCell(Material.BurningOil, BURNING_OIL_LIFETIME, this.rng.randomShade());
+                        visitedFrame[ni] = frame;
+                    }
+                }
+            }
+        }
+        // Clear fireSources for the active cells we marked (so next frame's
+        // buildActiveListAndClearFlags doesn't inherit stale marks). We only
+        // touch the active cells — the rest are already 0.
+        for (let a = 0; a < count; a++)
+            fireSources[active[a]] = 0;
+    }
+    applyAging() {
+        const grid = this.grid;
+        const active = this.activeCells;
+        const count = this.activeCount;
+        for (let a = 0; a < count; a++) {
+            const i = active[a];
+            const packed = grid[i];
+            if (packed === 0)
+                continue; // cell was destroyed earlier this frame
+            // Inline unpack — avoid allocating a Cell object
+            let mat = packed & 0xff;
+            let lifetime = (packed >> 8) & 0xff;
+            let flags = (packed >> 16) & 0xff;
+            // Gravel (and legacy LooseStone): re-settle to Stone when stationary AND
+            // supported by stable ground. The lifetime field is a settle timer, set
+            // when the stone is dislodged by mining (GRAVEL_SETTLE_TICKS) or disturbed
+            // by adjacent gravel movement (GRAVEL_DISTURB_SETTLE_TICKS). When the
+            // cell moves (FLAG_UPDATED), the timer keeps its current value. When
+            // stationary, the timer only counts down if the cell is supported from
+            // below by a STABLE material — otherwise it's floating and must not
+            // re-settle (it needs to keep trying to fall). This prevents Gravel from
+            // freezing mid-air when friction or random chance prevents it from moving
+            // for a few ticks.
+            //
+            // Stable support = a solid that won't move out from under us:
+            //   - Static solids (gravityDir === 0: Stone, Wall, Concrete) with
+            //     lifetime === 0 (not loosened).
+            //   - Gravity-affected solids (ore, dirt, etc.) at rest: gravity field
+            //     === 0 (not falling) and lifetime === 0 (not loosened/decaying).
+            // Liquids, gases, and loosened/falling cells are NOT stable support —
+            // they can flow or fall away, leaving re-settled stone floating.
+            //
+            // LooseStone (mat 63) is kept in the condition for backwards compat with
+            // old saves that still contain LooseStone cells; no new LooseStone is
+            // created — all stone-debris conversions produce Gravel.
+            // Stone (mat 3) is included: when a Stone cell's gravity field is set
+            // (by mining), it falls. When it lands and is stably supported, it
+            // re-freezes (gravity field cleared) — no material conversion needed.
+            if (mat === Material.Gravel || mat === Material.LooseStone || mat === Material.Stone) {
+                if (!(flags & FLAG_UPDATED) && lifetime > 0) {
+                    // Check if supported from below by a stable cell or grid boundary.
+                    // A cell is stable support if it won't move out from under us:
+                    //   - Static solids (gravityDir === 0: Stone, Wall, Concrete) with
+                    //     lifetime === 0 (not loosened by mining).
+                    //   - Gravity-affected solids (gravityDir !== 0 but solid: ore,
+                    //     dirt, etc.) that are at rest — gravity field === 0 (not
+                    //     falling) and lifetime === 0 (not loosened/decaying). Ore is
+                    //     generated with gravity=0 so it stays embedded until mined;
+                    //     without this, stone resting on ore never settles because ore
+                    //     has gravityDir=1.
+                    // Liquids, gases, and loosened/falling cells do NOT count — they
+                    // can move out from under us.
+                    const belowIdx = i + this.W;
+                    let supported;
+                    if (belowIdx >= this.grid.length) {
+                        supported = true; // grid boundary = stable floor
+                    }
+                    else {
+                        const belowPacked = this.grid[belowIdx];
+                        if (belowPacked === 0) {
+                            supported = false;
+                        }
+                        else {
+                            const belowMat = belowPacked & 0xff;
+                            const belowLifetime = (belowPacked >> 8) & 0xff;
+                            if (MAT_GRAVITY_DIR[belowMat] === 0) {
+                                // Static solid — stable if not loosened
+                                supported = belowLifetime === 0;
+                            }
+                            else if (MAT_FLAGS[belowMat] & MAT_SOLID) {
+                                // Gravity-affected solid at rest — stable if not falling
+                                // (gravity field cleared) and not loosened/decaying.
+                                supported = this.fields[belowIdx * 4 + FIELD.GRAVITY] === 0 &&
+                                    belowLifetime === 0;
+                            }
+                            else {
+                                // Liquid/gas — never stable support
+                                supported = false;
+                            }
+                        }
+                    }
+                    if (supported) {
+                        lifetime--;
+                        if (lifetime === 0) {
+                            // Re-settle: convert back to Stone (static, no gravity).
+                            // For Gravel/LooseStone: change material to Stone.
+                            // For Stone: just clear the lifetime (already Stone, now frozen).
+                            // Also clear FLAG_DETACHED so the renderer stops drawing the
+                            // warm tint + amber outline, and the cell re-freezes (no longer
+                            // collectible / unfrozen). Without this, re-settled stone stays
+                            // visually distinct from original stone and gets absorbed into
+                            // the player's inventory when walked near.
+                            mat = Material.Stone;
+                            lifetime = 0;
+                            flags &= ~0x10; // clear FLAG_DETACHED (bit 4 of flags byte)
+                        }
+                    }
+                    // If not stably supported, don't count down — keep trying to fall
+                }
+                const newFlags = flags & ~FLAG_UPDATED;
+                const newPacked = (mat & 0xff) | ((lifetime & 0xff) << 8) | ((newFlags & 0xff) << 16);
+                if (newPacked !== packed)
+                    grid[i] = newPacked;
+                continue;
+            }
+            if (lifetime > 0) {
+                // Randomized decay: fire/smoke/steam sometimes skip a tick so
+                // individual particles last variable amounts of time.
+                if (mat === Material.Fire) {
+                    // Anchored fire (from wax) decays very slowly so the flame
+                    // persists and keeps spreading. Normal fire decays fast.
+                    if (flags & FLAG_ANCHORED) {
+                        if (this.rng.random() < 0.15)
+                            lifetime--;
+                    }
+                    else {
+                        if (this.rng.random() < 0.7)
+                            lifetime--;
+                    }
+                }
+                else if (mat === Material.FuseFire) {
+                    // FuseFire decays deterministically for consistent burn speed
+                    lifetime--;
+                }
+                else if (mat === Material.BurningOil) {
+                    // BurningOil decays very slowly so the fire sits on the oil surface
+                    // for a long time, giving it time to spread to neighbors gradually.
+                    if (this.rng.random() < 0.15)
+                        lifetime--;
+                }
+                else if (mat === Material.Smoke) {
+                    if (this.rng.random() < 0.8)
+                        lifetime--;
+                }
+                else if (mat === Material.Steam) {
+                    if (this.rng.random() < 0.75)
+                        lifetime--;
+                }
+                else if (mat === Material.MagicPowder) {
+                    if (this.rng.random() < 0.7)
+                        lifetime--;
+                }
+                else if (mat === Material.ColdVapor) {
+                    // Cold vapor dissipates very slowly — ~30 seconds at 60fps.
+                    // lifetime 255 / 0.14 chance ≈ 1800 frames ≈ 30s.
+                    if (this.rng.random() < 0.14)
+                        lifetime--;
+                }
+                else if (mat === Material.Seed) {
+                    // Growing seeds (lifetime > 0) manage their own lifetime in the
+                    // seed growth reaction — don't decrement here.
+                }
+                else if (mat === Material.Duplicator) {
+                    // Duplicator's lifetime field stores the locked material id (0 = not
+                    // locked). It must NOT decay — the lock is permanent. Don't decrement.
+                }
+                else {
+                    lifetime--;
+                }
+                if (lifetime === 0) {
+                    if (mat === Material.Fire) {
+                        // Sparks and anchored fire (wax) expire to empty, not smoke.
+                        // Sparks: marked with FLAG_SPARK (bit 3).
+                        // Anchored fire: marked with FLAG_ANCHORED (bit 4) — smoke would
+                        // accumulate and suffocate the spreading flame.
+                        if (flags & (FLAG_SPARK | FLAG_ANCHORED)) {
+                            grid[i] = 0;
+                            continue;
+                        }
+                        mat = Material.Smoke;
+                        lifetime = 120;
+                    }
+                    else if (mat === Material.FuseFire) {
+                        // FuseFire expires to empty (not smoke) — smoke would accumulate
+                        // below the rising fire and suffocate the burn trail.
+                        grid[i] = 0;
+                        continue;
+                    }
+                    else if (mat === Material.BurningOil) {
+                        // BurningOil expires to smoke — the oil is consumed.
+                        mat = Material.Smoke;
+                        lifetime = 60;
+                    }
+                    else if (mat === Material.Smoke) {
+                        grid[i] = 0;
+                        continue;
+                    }
+                    else if (mat === Material.Steam) {
+                        if (this.rng.random() < 0.7) {
+                            mat = Material.Water;
+                            lifetime = 0;
+                        }
+                        else {
+                            grid[i] = 0;
+                            continue;
+                        }
+                    }
+                    else if (mat === Material.GasVapor) {
+                        // Expired vapor → empty
+                        grid[i] = 0;
+                        continue;
+                    }
+                    else if (mat === Material.ColdVapor) {
+                        // Cold vapor fully dissipated → empty
+                        grid[i] = 0;
+                        continue;
+                    }
+                    else if (mat === Material.Hydrogen) {
+                        grid[i] = 0;
+                        continue;
+                    }
+                    else if (mat === Material.Spore) {
+                        // Spore that never germinated dissipates to empty.
+                        grid[i] = 0;
+                        continue;
+                    }
+                    else if (mat === Material.Plasma) {
+                        // Plasma → fire then smoke
+                        mat = Material.Fire;
+                        lifetime = 15;
+                    }
+                    else if (mat === Material.Fireflies) {
+                        // Fireflies don't expire (lifetime stays at max)
+                        lifetime = 255;
+                    }
+                    else if (mat === Material.Nanobots) {
+                        lifetime = 255;
+                    }
+                    else if (mat === Material.Wood || mat === Material.Plant || mat === Material.Oil ||
+                        mat === Material.Flesh || mat === Material.Leaf || mat === Material.TreeWood ||
+                        mat === Material.Root || mat === Material.Grass || mat === Material.Toast ||
+                        mat === Material.Plastic || mat === Material.Wax || mat === Material.Fuse ||
+                        mat === Material.Rubber || mat === Material.C4 || mat === Material.Glitter ||
+                        mat === Material.MagicPowder) {
+                        mat = Material.Smoke;
+                        lifetime = 60;
+                    }
+                }
+            }
+            // Clear FLAG_UPDATED and write back. Only write if the packed value
+            // actually changed — avoids unnecessary memory writes when nothing
+            // happened (e.g. static solids with lifetime=0).
+            const newFlags = flags & ~FLAG_UPDATED;
+            const newPacked = (mat & 0xff) | ((lifetime & 0xff) << 8) | ((newFlags & 0xff) << 16);
+            if (newPacked !== packed) {
+                grid[i] = newPacked;
+            }
+        }
+    }
+}