@woosh/meep-engine 3.29.0 → 3.31.0

package/src/format/texture/basis/transcode/fit_endpoints.js

@@ -12,6 +12,17 @@
  */
 const MAX_ITERATIONS = 3;
 
+/**
+ * Scratch for {@link fit_endpoints}' iteration: the weight each selector is to be reproduced at, and the
+ * endpoints as they stood before the last solve, for the did-anything-move test.
+ *
+ * Module-static rather than per call because `fit_endpoints` runs once per unique (endpoint entry,
+ * selector span) pairing of a transcode and neither it nor {@link solve_endpoints} re-enters it.
+ */
+const scratch_weight_of_selector = new Int32Array(4);
+const scratch_previous_low = new Uint8Array(3);
+const scratch_previous_high = new Uint8Array(3);
+
 /**
  * Every `[min, max]` span of selector values a block can use, as pairs.
  *
@@ -74,6 +85,12 @@ function selector_range_index(min, max) {
  * It stays because it is cheap beside the template build and because those levels are real, not
  * because it is what closes the gap to the reference transcoder.
  *
+ * The normal-equations solve itself is {@link solve_endpoints}; this is the assign-and-resolve loop
+ * around it. The two used to carry the same solve character for character — the same `sum_aa`/`sum_ab`/
+ * `sum_bb` accumulation, the same determinant, the same `1e-6` singularity threshold and the same two
+ * closed-form expressions per channel — with one caller each, so a change to the conditioning, the
+ * threshold or the clamping was two edits that no fixture would have noticed only half of.
+ *
  * @param {Uint8Array} low three channels, seeded with a guess and overwritten with the fit
  * @param {Uint8Array} high three channels, likewise
  * @param {Uint8Array} colors twelve bytes, the block's four `[r, g, b]` colours
@@ -98,60 +115,37 @@ export function fit_endpoints(low, high, colors, weights, min_selector, max_sele
         return;
     }
 
-    const assigned = new Int32Array(4);
-
     for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
         for (let selector = min_selector; selector <= max_selector; selector++) {
-            assigned[selector] = nearest_weight(low, high, weights, colors, selector * 3);
-        }
-
-        let sum_aa = 0;
-        let sum_ab = 0;
-        let sum_bb = 0;
+            const assigned = nearest_weight(low, high, weights, colors, selector * 3);
 
-        for (let selector = min_selector; selector <= max_selector; selector++) {
-            const b = weights[assigned[selector]] / 64;
-            const a = 1 - b;
+            scratch_weight_of_selector[selector] = weights[assigned];
+        }
 
-            sum_aa += a * a;
-            sum_ab += a * b;
-            sum_bb += b * b;
+        for (let c = 0; c < 3; c++) {
+            scratch_previous_low[c] = low[c];
+            scratch_previous_high[c] = high[c];
         }
 
-        const determinant = sum_aa * sum_bb - sum_ab * sum_ab;
+        const solved = solve_endpoints(
+            low, high, colors, scratch_weight_of_selector, min_selector, max_selector
+        );
 
-        // singular when every colour in the span was assigned the same weight; the fit is done
-        if (Math.abs(determinant) < 1e-6) {
+        if (!solved) {
+            /*
+             Singular — every colour in the span was assigned the same weight. The fit is done, and the
+             endpoints are left exactly as they came in, which is what the solve does on that path too.
+            */
             return;
         }
 
         let moved = false;
 
         for (let c = 0; c < 3; c++) {
-            let sum_ap = 0;
-            let sum_bp = 0;
-
-            for (let selector = min_selector; selector <= max_selector; selector++) {
-                const b = weights[assigned[selector]] / 64;
-                const a = 1 - b;
-                const p = colors[selector * 3 + c];
-
-                sum_ap += a * p;
-                sum_bp += b * p;
-            }
-
-            const solved_low = (sum_bb * sum_ap - sum_ab * sum_bp) / determinant;
-            const solved_high = (sum_aa * sum_bp - sum_ab * sum_ap) / determinant;
-
-            const next_low = clamp_round(solved_low);
-            const next_high = clamp_round(solved_high);
-
-            if (next_low !== low[c] || next_high !== high[c]) {
+            if (low[c] !== scratch_previous_low[c] || high[c] !== scratch_previous_high[c]) {
                 moved = true;
+                break;
             }
-
-            low[c] = next_low;
-            high[c] = next_high;
         }
 
         if (!moved) {

package/src/generation/filtering/numeric/CellFilterCache.d.ts

@@ -17,6 +17,23 @@ export class CellFilterCache extends CellFilterUnaryOperation {
      * @type {number}
      */
     scale: number;
+    /**
+     * Cache texels per grid cell, along each axis.
+     *
+     * Derived from the cache's ACTUAL size rather than from {@link scale}, because the size is
+     * rounded to whole texels — `scale` is a public constructor parameter and nothing stops a
+     * caller passing 1.5. The same pair, derived the same way,
+     * `AbstractCellFilterSampleGridLayer` caches for the same reason.
+     *
+     * @type {number}
+     * @private
+     */
+    private __u_scale;
+    /**
+     * @type {number}
+     * @private
+     */
+    private __v_scale;
     initialize(grid: any, seed: any): void;
 }
 import { CellFilterUnaryOperation } from "../core/CellFilterUnaryOperation.js";

package/src/generation/filtering/numeric/CellFilterCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAKA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAW3B;IA5BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAmBV,uCAgBC;CAKJ;yCAxDwC,qCAAqC"}
+{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAKA;IAkCI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAW3B;IA/CD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;;OAUG;IACH,kBAAc;IAEd;;;OAGG;IACH,kBAAc;IAmBd,uCAqBC;CAcJ;yCAzFwC,qCAAqC"}

package/src/generation/filtering/numeric/CellFilterCache.js

@@ -18,6 +18,25 @@ export class CellFilterCache extends CellFilterUnaryOperation {
      */
     scale = 1;
 
+    /**
+     * Cache texels per grid cell, along each axis.
+     *
+     * Derived from the cache's ACTUAL size rather than from {@link scale}, because the size is
+     * rounded to whole texels — `scale` is a public constructor parameter and nothing stops a
+     * caller passing 1.5. The same pair, derived the same way,
+     * `AbstractCellFilterSampleGridLayer` caches for the same reason.
+     *
+     * @type {number}
+     * @private
+     */
+    __u_scale = 1;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    __v_scale = 1;
+
     /**
      *
      * @param {CellFilter} source
@@ -41,8 +60,10 @@ export class CellFilterCache extends CellFilterUnaryOperation {
         const g_w = grid.width;
         const g_h = grid.height;
 
-        const target_w = this.scale * g_w;
-        const target_h = this.scale * g_h;
+        // whole texels: `scale` is a public parameter and a fractional one would otherwise hand
+        // `resize` a non-integer size
+        const target_w = Math.max(1, Math.round(this.scale * g_w));
+        const target_h = Math.max(1, Math.round(this.scale * g_h));
 
         const cache = this.__cache;
 
@@ -51,9 +72,21 @@ export class CellFilterCache extends CellFilterUnaryOperation {
         // the source has already been initialized by `super.initialize`, so this must not go through
         // `populateSampler2DFromCellFilter` (which would re-initialize it with seed 0)
         write_cell_filter_to_sampler2d(cache, this.source, grid);
+
+        this.__u_scale = target_w / g_w;
+        this.__v_scale = target_h / g_h;
     }
 
     execute(grid, x, y, rotation) {
-        return this.__cache.sampleChannelBilinear(x, y, 0);
+        /*
+         The cache holds `scale` texels per grid cell — that is what
+         `write_cell_filter_to_sampler2d` writes, texel t carrying grid t/scale — so the read has to
+         be scaled to match. Sampling at the raw grid coordinate read the wrong mapping at any
+         scale but 1: a ramp returning `x` over an 8x8 grid cached at scale 2 answered
+         0, 0.5, 1, 1.5 for grid 0..3, and at scale below 1 it ran off the end of the cache and
+         clamped. `scale` is presented as a quality knob, so the first author to turn it up got a
+         silently rescaled field with no error anywhere.
+        */
+        return this.__cache.sampleChannelBilinear(x * this.__u_scale, y * this.__v_scale, 0);
     }
 }

package/src/generation/grid/actions/ContinuousGridCellActionSetTerrainObstacle.d.ts

@@ -4,6 +4,15 @@ export class ContinuousGridCellActionSetTerrainObstacle extends ContinuousGridCe
      * @type {GridObstacle}
      */
     obstacle: GridObstacle;
+    /**
+     * Where the obstacle's owner stands on the generation grid, so a cell can be put into the
+     * obstacle's own space.
+     * @type {{x: number, y: number}}
+     */
+    position: {
+        x: number;
+        y: number;
+    };
     /**
      *
      * @type {CellFilter}

package/src/generation/grid/actions/ContinuousGridCellActionSetTerrainObstacle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContinuousGridCellActionSetTerrainObstacle.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/actions/ContinuousGridCellActionSetTerrainObstacle.js"],"names":[],"mappings":"AAMA;IACI;;;OAGG;IACH,UAFU,YAAY,CAEN;IAEhB;;;OAGG;IACH,sBAA2C;IAE3C,iDAcC;IAED,iFAYC;CACJ;yCAhDwC,+BAA+B;yBAG/C,+CAA+C"}
+{"version":3,"file":"ContinuousGridCellActionSetTerrainObstacle.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/actions/ContinuousGridCellActionSetTerrainObstacle.js"],"names":[],"mappings":"AAcA;IACI;;;OAGG;IACH,UAFU,YAAY,CAEN;IAEhB;;;;OAIG;IACH,UAFU;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAEd;IAElB;;;OAGG;IACH,sBAA2C;IAE3C,iDAiCC;IAED,iFASC;CACJ;yCA/EwC,+BAA+B;yBAG/C,+CAA+C"}

package/src/generation/grid/actions/ContinuousGridCellActionSetTerrainObstacle.js

@@ -3,6 +3,14 @@ import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
 import { assert } from "../../../core/assert.js";
 import GridObstacle from "../../../engine/grid/obstacle/GridObstacle.js";
 import { CellFilterLiteralFloat } from "../../filtering/numeric/CellFilterLiteralFloat.js";
+import GridPosition from "../../../engine/grid/position/GridPosition.js";
+import { grid_obstacle_write_grid_point } from "./grid_obstacle_write_grid_point.js";
+
+/**
+ * A terrain that carries no {@link GridPosition} stands here.
+ * @type {{x: number, y: number}}
+ */
+const ORIGIN = Object.freeze({ x: 0, y: 0 });
 
 export class ContinuousGridCellActionSetTerrainObstacle extends ContinuousGridCellAction {
     /**
@@ -11,6 +19,13 @@ export class ContinuousGridCellActionSetTerrainObstacle extends ContinuousGridCe
      */
     obstacle = null;
 
+    /**
+     * Where the obstacle's owner stands on the generation grid, so a cell can be put into the
+     * obstacle's own space.
+     * @type {{x: number, y: number}}
+     */
+    position = ORIGIN;
+
     /**
      *
      * @type {CellFilter}
@@ -31,6 +46,25 @@ export class ContinuousGridCellActionSetTerrainObstacle extends ContinuousGridCe
         assert.defined(obstacle, 'obstacle');
 
         this.obstacle = obstacle;
+
+        // Where the terrain stands on the generation grid. An obstacle is addressed in its OWN
+        // space, so a cell at grid (x, y) is at (x - position) in it — which the sibling action
+        // that writes an obstacle has always subtracted and this one did not, so the two disagreed
+        // about the coordinate frame while being interchangeable to a rule. A terrain at the origin
+        // is the common case and is why it went unnoticed.
+        const position = ecd.getComponent(cp.entity, GridPosition);
+
+        // a terrain that carries no position stands at the origin, which is what every grid without
+        // one means
+        this.position = position === undefined ? ORIGIN : position;
+
+        // `execute` evaluates this on every cell, and a filter that has not been initialized is
+        // undefined behaviour by CellFilter's own protocol — a sampling filter holds a null
+        // sampler until then, a noise filter a null generator. It survived only because the
+        // default threshold is a literal, which needs nothing; the moment a theme makes the
+        // threshold data-driven — which is the whole reason this field is a filter and not a
+        // number — it throws. The sibling that writes an obstacle does this already.
+        this.threshold.ensureInitialized(grid, seed);
     }
 
     execute(ecd, grid, x, y, rotation, strength) {
@@ -39,11 +73,8 @@ export class ContinuousGridCellActionSetTerrainObstacle extends ContinuousGridCe
         const v = strength.execute(grid, x, y, rotation);
 
 
-        if (v > t) {
-            this.obstacle.writePoint(x, y, 1);
-        } else {
-            this.obstacle.writePoint(x, y, 0);
-        }
-
+        // through the obstacle's own space, and rejected when it falls outside — the sibling
+        // action's conversion, which this one used to skip entirely
+        grid_obstacle_write_grid_point(this.obstacle, this.position, x, y, v > t ? 1 : 0);
     }
 }

package/src/generation/grid/actions/ContinuousGridCellActionWriteObstacle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContinuousGridCellActionWriteObstacle.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/actions/ContinuousGridCellActionWriteObstacle.js"],"names":[],"mappings":"AAOA;IA2CI;;;;;;;OAOG;IACH;QAL+B,QAAQ;QACZ,SAAS,EAAzB,MAAM;QACY,OAAO;QACxB,qCAAqC,CAahD;IA7DD;;;OAGG;IACH,qBAA0C;IAE1C,kBAAc;IAEd;;;OAGG;IACH,oBAFU,YAAY,CAEI;IAE1B;;;OAGG;IACH,oBAFU,YAAY,CAEI;IAItB;;;;;OAKG;IACH,gEAFa;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,QAAQ,EAAE,YAAY,CAAA;KAAC,CAa3D;IAwBL,iDAsBC;IAED,iFA0BC;CACJ;yCA1HwC,+BAA+B;yBAG/C,+CAA+C;yBAC/C,+CAA+C"}
+{"version":3,"file":"ContinuousGridCellActionWriteObstacle.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/actions/ContinuousGridCellActionWriteObstacle.js"],"names":[],"mappings":"AAQA;IA2CI;;;;;;;OAOG;IACH;QAL+B,QAAQ;QACZ,SAAS,EAAzB,MAAM;QACY,OAAO;QACxB,qCAAqC,CAahD;IA7DD;;;OAGG;IACH,qBAA0C;IAE1C,kBAAc;IAEd;;;OAGG;IACH,oBAFU,YAAY,CAEI;IAE1B;;;OAGG;IACH,oBAFU,YAAY,CAEI;IAItB;;;;;OAKG;IACH,gEAFa;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,QAAQ,EAAE,YAAY,CAAA;KAAC,CAa3D;IAwBL,iDAsBC;IAED,iFAYC;CACJ;yCA7GwC,+BAA+B;yBAI/C,+CAA+C;yBAC/C,+CAA+C"}

package/src/generation/grid/actions/ContinuousGridCellActionWriteObstacle.js

@@ -1,4 +1,5 @@
 import { ContinuousGridCellAction } from "./ContinuousGridCellAction.js";
+import { grid_obstacle_write_grid_point } from "./grid_obstacle_write_grid_point.js";
 import { CellFilterLiteralFloat } from "../../filtering/numeric/CellFilterLiteralFloat.js";
 import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
 import GridPosition from "../../../engine/grid/position/GridPosition.js";
@@ -94,30 +95,16 @@ export class ContinuousGridCellActionWriteObstacle extends ContinuousGridCellAct
     }
 
     execute(ecd, grid, x, y, rotation, strength) {
-        //get index of the obstacle cell
-        const tp = this.targetGridPosition;
-
-        const local_x = x - tp.x;
-        const local_y = y - tp.y;
-
-        if (local_x < 0 || local_y < 0) {
-            // out of bounds
-            return;
-        }
-
-        const to = this.targetGridObstacle;
-
-        if (local_x >= to.size.x || local_y >= to.size.y) {
-            // out of bounds
-            return;
-        }
-
         const v = this.obstacle.execute(grid, x, y, rotation);
 
-
         const isObstacle = v > this.threshold;
 
-
-        to.writePoint(local_x, local_y, isObstacle ? 1 : 0);
+        // the conversion into the obstacle's own space and the rejection of anything outside it,
+        // which both actions that write an obstacle go through
+        grid_obstacle_write_grid_point(
+            this.targetGridObstacle, this.targetGridPosition,
+            x, y,
+            isObstacle ? 1 : 0
+        );
     }
 }

package/src/generation/grid/actions/grid_obstacle_write_grid_point.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Write one cell of a {@link GridObstacle} addressed in GENERATION-GRID coordinates.
+ *
+ * An obstacle is not laid over the generation grid one-to-one: it belongs to an entity that stands
+ * somewhere on the grid, so a cell at grid `(x, y)` is at `(x - position.x, y - position.y)` in the
+ * obstacle's own space, and the obstacle may be smaller than the grid at either end.
+ *
+ * `GridObstacle.writePoint` does neither: it indexes `y * size.x + x` with no range test, so an
+ * out-of-range write either lands on a different row or is dropped — silently, both ways.
+ * Navigation obstacles are the one generated artefact a player feels immediately, as "I cannot walk
+ * there and nothing is in the way", so the conversion and the rejection live in one place that both
+ * actions writing an obstacle go through.
+ *
+ * @param {GridObstacle} obstacle
+ * @param {Vector2|{x:number, y:number}} position where the obstacle's owner stands on the grid
+ * @param {number} x generation-grid coordinate
+ * @param {number} y
+ * @param {number} value
+ * @returns {boolean} whether the cell was inside the obstacle and was written
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function grid_obstacle_write_grid_point(obstacle: GridObstacle, position: Vector2 | {
+    x: number;
+    y: number;
+}, x: number, y: number, value: number): boolean;
+//# sourceMappingURL=grid_obstacle_write_grid_point.d.ts.map

package/src/generation/grid/actions/grid_obstacle_write_grid_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid_obstacle_write_grid_point.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/actions/grid_obstacle_write_grid_point.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iFATW,UAAQ;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,KAC5B,MAAM,KACN,MAAM,SACN,MAAM,GACJ,OAAO,CAsBnB"}

package/src/generation/grid/actions/grid_obstacle_write_grid_point.js

@@ -0,0 +1,41 @@
+/**
+ * Write one cell of a {@link GridObstacle} addressed in GENERATION-GRID coordinates.
+ *
+ * An obstacle is not laid over the generation grid one-to-one: it belongs to an entity that stands
+ * somewhere on the grid, so a cell at grid `(x, y)` is at `(x - position.x, y - position.y)` in the
+ * obstacle's own space, and the obstacle may be smaller than the grid at either end.
+ *
+ * `GridObstacle.writePoint` does neither: it indexes `y * size.x + x` with no range test, so an
+ * out-of-range write either lands on a different row or is dropped — silently, both ways.
+ * Navigation obstacles are the one generated artefact a player feels immediately, as "I cannot walk
+ * there and nothing is in the way", so the conversion and the rejection live in one place that both
+ * actions writing an obstacle go through.
+ *
+ * @param {GridObstacle} obstacle
+ * @param {Vector2|{x:number, y:number}} position where the obstacle's owner stands on the grid
+ * @param {number} x generation-grid coordinate
+ * @param {number} y
+ * @param {number} value
+ * @returns {boolean} whether the cell was inside the obstacle and was written
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function grid_obstacle_write_grid_point(obstacle, position, x, y, value) {
+    const local_x = x - position.x;
+    const local_y = y - position.y;
+
+    if (local_x < 0 || local_y < 0) {
+        return false;
+    }
+
+    const size = obstacle.size;
+
+    if (local_x >= size.x || local_y >= size.y) {
+        return false;
+    }
+
+    obstacle.writePoint(local_x, local_y, value);
+
+    return true;
+}

package/src/generation/grid/generation/GridTaskDensityMarkerDistribution.d.ts

@@ -29,7 +29,21 @@ export class GridTaskDensityMarkerDistribution extends GridTaskGenerator {
      */
     private __seed;
     /**
+     * How many markers a tile attempts, estimated by sampling the density field.
      *
+     * The generation seed is threaded in because this used to draw from
+     * seededRandom(this.__seed + 91234) alone, and __seed is only ever set by the optional fourth
+     * argument to from, defaults to 0, and build never touches it. So the two RNG lineages inside
+     * one task answered to different seeds: every world seed got the same sample offsets and the
+     * marker budget per tile was a function of the terrain alone — vegetation and prop density
+     * being this task most visible output, and the one part of it the world seed could not move.
+     * The mirror image was a construction-time argument that changed marker counts across the
+     * whole map while leaving every other subsystem seed alone.
+     *
+     * __seed stays what its name says: an offset on top of the generation seed, the way
+     * CellFilterSimplexNoise uses its own.
+     *
+     * @param {number} seed the generation seed
      * @param {GridData} grid
      * @param {number} x0
      * @param {number} y0
@@ -37,7 +51,7 @@ export class GridTaskDensityMarkerDistribution extends GridTaskGenerator {
      * @param {number} y1
      * @returns {number}
      */
-    estimateTapCount(grid: GridData, x0: number, y0: number, x1: number, y1: number): number;
+    estimateTapCount(seed: number, grid: GridData, x0: number, y0: number, x1: number, y1: number): number;
     /**
      *
      * @param {number} seed

package/src/generation/grid/generation/GridTaskDensityMarkerDistribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridTaskDensityMarkerDistribution.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/generation/GridTaskDensityMarkerDistribution.js"],"names":[],"mappings":"AAgBA;IA4BI;;;;;;OAMG;IACH,2EAHW,eAAe,SACf,MAAM,qCAgBhB;IA/CD;;;OAGG;IACH,oBAAe;IAEf;;;OAGG;IACH,kCAAc;IAEd;;;OAGG;IACH,OAFU,eAAe,CAES;IAElC;;;;OAIG;IACH,eAAW;IA2BX;;;;;;;;OAQG;IACH,qCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqFlB;IAED;;;;;;;;;OASG;IACH,kBARW,MAAM,sBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA6IhB;IAGD,qBAEC;IAED,iDA2EC;CACJ;kCA5XiC,yBAAyB;gCAT3B,gDAAgD;iBAI/D,oCAAoC;sBAC/B,yCAAyC"}
+{"version":3,"file":"GridTaskDensityMarkerDistribution.d.ts","sourceRoot":"","sources":["../../../../../src/generation/grid/generation/GridTaskDensityMarkerDistribution.js"],"names":[],"mappings":"AAgBA;IA4BI;;;;;;OAMG;IACH,2EAHW,eAAe,SACf,MAAM,qCAgBhB;IA/CD;;;OAGG;IACH,oBAAe;IAEf;;;OAGG;IACH,kCAAc;IAEd;;;OAGG;IACH,OAFU,eAAe,CAES;IAElC;;;;OAIG;IACH,eAAW;IA2BX;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,uBARW,MAAM,sBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqFlB;IAED;;;;;;;;;OASG;IACH,kBARW,MAAM,sBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA6IhB;IAGD,qBAEC;IAED,iDA2EC;CACJ;kCA1YiC,yBAAyB;gCAT3B,gDAAgD;iBAI/D,oCAAoC;sBAC/B,yCAAyC"}

package/src/generation/grid/generation/GridTaskDensityMarkerDistribution.js

@@ -67,7 +67,21 @@ export class GridTaskDensityMarkerDistribution extends GridTaskGenerator {
 
 
     /**
+     * How many markers a tile attempts, estimated by sampling the density field.
      *
+     * The generation seed is threaded in because this used to draw from
+     * seededRandom(this.__seed + 91234) alone, and __seed is only ever set by the optional fourth
+     * argument to from, defaults to 0, and build never touches it. So the two RNG lineages inside
+     * one task answered to different seeds: every world seed got the same sample offsets and the
+     * marker budget per tile was a function of the terrain alone — vegetation and prop density
+     * being this task most visible output, and the one part of it the world seed could not move.
+     * The mirror image was a construction-time argument that changed marker counts across the
+     * whole map while leaving every other subsystem seed alone.
+     *
+     * __seed stays what its name says: an offset on top of the generation seed, the way
+     * CellFilterSimplexNoise uses its own.
+     *
+     * @param {number} seed the generation seed
      * @param {GridData} grid
      * @param {number} x0
      * @param {number} y0
@@ -75,8 +89,8 @@ export class GridTaskDensityMarkerDistribution extends GridTaskGenerator {
      * @param {number} y1
      * @returns {number}
      */
-    estimateTapCount(grid, x0, y0, x1, y1) {
-        const random = seededRandom(this.__seed + 91234);
+    estimateTapCount(seed, grid, x0, y0, x1, y1) {
+        const random = seededRandom(seed + this.__seed + 91234);
 
         /*
             for tap count we ween 3 things:
@@ -291,7 +305,7 @@ export class GridTaskDensityMarkerDistribution extends GridTaskGenerator {
 
                 random.setCurrentSeed(seed);
 
-                iterationLimit = this.estimateTapCount(grid, x0, y0, x1, y1);
+                iterationLimit = this.estimateTapCount(seed, grid, x0, y0, x1, y1);
                 iteration = 0;
 
                 assert.isNumber(iterationLimit, 'iterationLimit');

package/src/generation/markers/actions/MarkerNodeProcessingRuleSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkerNodeProcessingRuleSet.d.ts","sourceRoot":"","sources":["../../../../../src/generation/markers/actions/MarkerNodeProcessingRuleSet.js"],"names":[],"mappings":"AAIA;IACI;;;OAGG;IACH,UAFU,sBAAsB,CAElB;IAEd;;;;;OAKG;IACH,8DAFW,MAAM,QAoBhB;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;OAKG;IACH,iFA+CC;IAED;;;;;;OAMG;IACH,2DAHW,MAAM,GACJ,IAAI,CA0ChB;CACJ;iBApJgB,oCAAoC"}
+{"version":3,"file":"MarkerNodeProcessingRuleSet.d.ts","sourceRoot":"","sources":["../../../../../src/generation/markers/actions/MarkerNodeProcessingRuleSet.js"],"names":[],"mappings":"AAIA;IACI;;;OAGG;IACH,UAFU,sBAAsB,CAElB;IAEd;;;;;OAKG;IACH,8DAFW,MAAM,QAoBhB;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;OAKG;IACH,iFA8DC;IAED;;;;;;OAMG;IACH,2DAHW,MAAM,GACJ,IAAI,CA0ChB;CACJ;iBAnKgB,oCAAoC"}

package/src/generation/markers/actions/MarkerNodeProcessingRuleSet.js

@@ -70,7 +70,22 @@ export class MarkerNodeProcessingRuleSet {
                 continue;
             }
 
-            let _node = node;
+            /*
+             A COPY, always.
+
+             This used to start at the live object out of grid.markers, which was invisible while a
+             rule had transformers — every MarkerNodeTransformer in this package clones before it
+             writes — and wrong the moment one did not. An action, or the entity processors under
+             it, then wrote through to the grid: MarkerNodeEntityProcessorClingToTerrain calls
+             setTranslation and setRotation on node.transform, which is how an absolute terrain
+             height reaches the placed entity, so the write is right and the object it landed on was
+             not. The marker was permanently moved to the terrain surface for everything that read
+             grid.markers afterwards, and for any later non-consuming rule.
+
+             One small object copy per matching rule, which is not where this subsystem spends its
+             time, and it makes the value semantics the same whether a rule has transformers or not.
+            */
+            let _node = node.clone();
 
             //perform node transformation
             const transformers = rule.transformers;

package/src/generation/placement/action/GridCellActionWriteFilterToLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridCellActionWriteFilterToLayer.d.ts","sourceRoot":"","sources":["../../../../../src/generation/placement/action/GridCellActionWriteFilterToLayer.js"],"names":[],"mappings":"AAIA;IAqBI;;;;OAIG;IACH,mBAHW,MAAM,wDAahB;IAlCD;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,SAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,gBAAe;IAuBf,uCAaC;IAED,wDA0BC;CACJ;+BAtF8B,qBAAqB"}
+{"version":3,"file":"GridCellActionWriteFilterToLayer.d.ts","sourceRoot":"","sources":["../../../../../src/generation/placement/action/GridCellActionWriteFilterToLayer.js"],"names":[],"mappings":"AAIA;IAqBI;;;;OAIG;IACH,mBAHW,MAAM,wDAahB;IAlCD;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,SAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,gBAAe;IAuBf,uCAoBC;IAED,wDA0BC;CACJ;+BA7F8B,qBAAqB"}

package/src/generation/placement/action/GridCellActionWriteFilterToLayer.js

@@ -56,7 +56,14 @@ export class GridCellActionWriteFilterToLayer extends GridCellAction {
         this.__layer = layer;
 
 
-        this.filter.initialize(data, seed);
+        /*
+         Finalize, then go through the guarded entry point — `CellFilter`'s documented protocol.
+         Calling `initialize` directly re-runs the hook on this node alone: `super.initialize`
+         reaches children through `ensureInitialized`, so re-initializing with a new seed rebuilt
+         the top of the graph against it and left every sub-expression on the old one.
+        */
+        this.filter.finalize();
+        this.filter.ensureInitialized(data, seed);
     }
 
     execute(data, x, y, rotation) {

package/src/generation/theme/TerrainTheme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainTheme.d.ts","sourceRoot":"","sources":["../../../../src/generation/theme/TerrainTheme.js"],"names":[],"mappings":"AAIA;IACI;;;OAGG;IACH,OAFU,kBAAkB,CAEjB;IAGX;;;;OAIG;IACH,iCAFW,MAAM,QAkBhB;CACJ"}
+{"version":3,"file":"TerrainTheme.d.ts","sourceRoot":"","sources":["../../../../src/generation/theme/TerrainTheme.js"],"names":[],"mappings":"AAIA;IACI;;;OAGG;IACH,OAFU,kBAAkB,CAEjB;IAGX;;;;OAIG;IACH,iCAFW,MAAM,QAqChB;CACJ"}

package/src/generation/theme/TerrainTheme.js

@@ -24,12 +24,31 @@ export class TerrainTheme {
 
         const random = seededRandom(seed);
 
+        /*
+         Finalize the whole set first, then go through the guarded entry point — which is the
+         protocol `CellFilter` documents, in both halves.
+
+         Calling `initialize` directly re-runs the subclass hook unconditionally, and only on the
+         node it is called on: `super.initialize` reaches children through `ensureInitialized`, so
+         they keep the flag they already have. A theme initialized a second time — a new world from
+         the same theme objects — therefore rebuilt its top-level noise fields against the new seed
+         while every shared sub-expression kept the old one, and two rules pointing at the SAME
+         top-level filter left both of them reading whichever seed was initialized last.
+
+         Finalizing the set before any of it is initialized answers both: the flags are clear, so a
+         new seed takes everywhere, and the guard then holds for the rest of the pass so a shared
+         node is built exactly once. The per-rule draw is unchanged, so no rule's seed moves.
+        */
+        for (let i = 0; i < n; i++) {
+            rules[i].filter.finalize();
+        }
+
         for (let i = 0; i < n; i++) {
             const rule = rules[i];
 
             const ruleSeed = randomSeed(random);
 
-            rule.filter.initialize(grid, ruleSeed);
+            rule.filter.ensureInitialized(grid, ruleSeed);
         }
     }
 }