@woosh/meep-engine 2.165.7 → 2.167.0

package/src/engine/animation/keyed2/AnimationTrackPlayback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationTrackPlayback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/keyed2/AnimationTrackPlayback.js"],"names":[],"mappings":";AAGA;IACI;;;;;;;;OAQG;IACH,4EAuBC;IAtBG,sBAAkB;IAClB,cAA+B;IAE/B,oBAAoC;IACpC,kBAAgC;IAEhC,uBAAuB;IACvB,8BAA8B;IAE9B,uBAAuB;IACvB,sBAAsB;IAEtB,gBAAmB;IAEnB,4BAA0D;IAG1D;;MAEC;IAKL;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFW,OAAO,QAIjB;IAED,cAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QA2BhB;IAED;;;OAGG;IACH,cAFa,OAAO,CA2CnB;IAED;;;OAGG;IACH,mBAFW,MAAM,QA+BhB;IAED,eAOC;IAED;;;OAGG;IACH,0BAFW,MAAM,EAAE,QA2ClB;CACJ;mBAhPkB,uCAAuC"}
+{"version":3,"file":"AnimationTrackPlayback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/keyed2/AnimationTrackPlayback.js"],"names":[],"mappings":";AAGA;IACI;;;;;;;;OAQG;IACH,4EAuBC;IAtBG,sBAAkB;IAClB,cAA+B;IAE/B,oBAAoC;IACpC,kBAAgC;IAEhC,uBAAuB;IACvB,8BAA8B;IAE9B,uBAAuB;IACvB,sBAAsB;IAEtB,gBAAmB;IAEnB,4BAA0D;IAG1D;;MAEC;IAKL;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFW,OAAO,QAIjB;IAED,cAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QA2BhB;IAED;;;OAGG;IACH,cAFa,OAAO,CA2CnB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAmChB;IAED,eAOC;IAED;;;OAGG;IACH,0BAFW,MAAM,EAAE,QA2ClB;CACJ;mBApPkB,uCAAuC"}

package/src/engine/animation/keyed2/AnimationTrackPlayback.js

@@ -159,7 +159,11 @@ class AnimationTrackPlayback {
         if (timeDelta < 0) {
             //negative delta, going back in time
             this.setPosition(newPosition);
-        } else if (newPosition > this.__nextKeyTime) {
+            // the `>= timeEnd` term catches a frame that lands EXACTLY on the end: __nextKeyTime equals
+            // timeEnd on the final segment, so the strict `> __nextKeyTime` test would skip it, and the
+            // one-shot `ended` (guarded by position < timeEnd) would then never fire. Mid-track exact
+            // landings do not reach timeEnd, so they stay on the plain else branch as before.
+        } else if (newPosition > this.__nextKeyTime || newPosition >= this.track.timeEnd) {
 
             if (newPosition >= this.track.timeEnd) {
                 if (this.__loop) {

package/src/engine/ecs/EntityComponentDataset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityComponentDataset.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityComponentDataset.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"EntityComponentDataset.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityComponentDataset.js"],"names":[],"mappings":"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"}

package/src/engine/ecs/EntityComponentDataset.js

@@ -1,7 +1,6 @@
 import { assert } from "../../core/assert.js";
 import { BitSet } from "../../core/binary/BitSet.js";
 import { array_set_diff } from "../../core/collection/array/array_set_diff.js";
-import { array_shrink_to_size } from "../../core/collection/array/array_shrink_to_size.js";
 import { findSignalHandlerIndexByHandle } from "../../core/events/signal/findSignalHandlerIndexByHandle.js";
 import {
     findSignalHandlerIndexByHandleAndContext
@@ -107,18 +106,6 @@ function buildObserverCallbackArgs(entityIndex, mask, componentIndexMap, compone
     }
 }
 
-/**
- *
- * @type {number[]}
- */
-const scratch_indices = [];
-
-/**
- * Used for constructing arguments prior to traversal visitor call
- * @type {*[]}
- */
-const scratch_args = [];
-
 /**
  * Represents a storage for entities and their associated components.
  * Entities are just integer IDs and components are stored in a virtual table, where each component type has a separate column and each entity is a row in that table.
@@ -1327,8 +1314,10 @@ export class EntityComponentDataset {
 
         let entityIndex, i;
 
-        //map classes to indices
-        const indices = scratch_indices;
+        // Local arrays rather than the module-shared scratch pools: the visitor may itself call
+        // traverseEntities (an ordinary "for each A, scan the B entities" pattern), and a shared pool
+        // would let the inner call clobber this call's indices/args mid-scan. Matches traverseEntitiesExact.
+        const indices = [];
 
         // prepare sorted array of component indices
         const numClasses = classes.length;
@@ -1348,12 +1337,7 @@ export class EntityComponentDataset {
             indices[i] = componentIndex;
         }
 
-        const args = scratch_args;
-
-        // crop args array to the right length (since we're re-using a scratch array)
-        const args_length_intended = numClasses + 1;
-
-        array_shrink_to_size(scratch_args, args_length_intended);
+        const args = [];
 
         const entityOccupancy = this.entityOccupancy;
 

package/src/engine/ecs/fow/FogOfWar.d.ts

@@ -28,6 +28,18 @@ export class FogOfWar {
      */
     size: Vector2;
     color: Vector4;
+    /**
+     * What the fog does outside the fogged area — see {@link FogOfWarEdgeMode}.
+     *
+     * NOT serialized: it is configuration the owner sets when it builds the
+     * component, not accumulated reveal state, and adding it to the binary format
+     * would cost a version bump plus an updater for every existing save. A
+     * deserialized FogOfWar therefore comes back as Conceal; a consumer that
+     * wants Extend sets it after loading, in the same place it sets {@link color}.
+     *
+     * @type {FogOfWarEdgeMode}
+     */
+    edge_mode: FogOfWarEdgeMode;
     /**
      * Contains indices of pixes that are currently being updated
      * @type {RowFirstTable}
@@ -74,6 +86,14 @@ export class FogOfWar {
      * @param {number} radius
      */
     conceal(x: number, y: number, radius: number): void;
+    /**
+     * Rebuild the cell -> fade row index from the current {@link fadeMask}
+     * contents. Must be invoked whenever the fade mask is populated without
+     * going through {@link reveal}/{@link conceal}/{@link revealPoint} (e.g.
+     * after deserialization), otherwise those methods could stack duplicate
+     * fade rows for a cell.
+     */
+    rebuildFadeIndex(): void;
     dispose(): void;
     updateTexture(): void;
     /**
@@ -117,6 +137,7 @@ export class FogOfWar {
      * @param scale
      */
     resize(w: number, h: number, scale: any): void;
+    #private;
 }
 export namespace FogOfWar {
     let typeName: string;
@@ -125,6 +146,7 @@ import { DataTexture } from "three";
 import Vector1 from "../../../core/geom/Vector1.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector4 from "../../../core/geom/Vector4.js";
+import { FogOfWarEdgeMode } from "./FogOfWarEdgeMode.js";
 import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { Sampler2D } from "../../graphics/texture/sampler/Sampler2D.js";

package/src/engine/ecs/fow/FogOfWar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWar.js"],"names":[],"mappings":"AA+CA;;GAEG;AACH;IAEI;;;OAGG;IACH,oBAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,0BAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,SAFU,WAAW,GAAC,IAAI,CAEX;IAEf;;;OAGG;IACH,OAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB,eAAsC;IAEtC;;;OAGG;IACH,UAFU,aAAa,CAE2B;IAElD;;MAEE;IAEF;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,iBAFU,SAAS,CAEwB;IAE3C;;;OAGG;IACH,sBAFW,MAAM,QAqDhB;IAED;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAyBhB;IAED,cAOC;IAED,kBAOC;IAED,mBAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,UACN,MAAM,QA+ChB;IAED;;;;;OAKG;IACH,WAJW,MAAM,KACN,MAAM,UACN,MAAM,QAgDhB;IAED,gBAIC;IAED,sBAqCC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,0DA+BC;IAED;;;;;OAKG;IACH,yBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAelB;IAED;;;;;OAKG;IACH,yEAFW,MAAM,WA+EhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED,6BAKC;IAED,+BASC;IAED,uBAyBC;IAGD;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,oBAUhB;CACJ;;;;4BAxlB2F,OAAO;oBAM/E,+BAA+B;oBAC/B,+BAA+B;oBAC/B,+BAA+B;8BALrB,iDAAiD;mBAE5D,uCAAuC;0BAQhC,6CAA6C"}
+{"version":3,"file":"FogOfWar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWar.js"],"names":[],"mappings":"AAgDA;;GAEG;AACH;IAEI;;;OAGG;IACH,oBAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,0BAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,SAFU,WAAW,GAAC,IAAI,CAEX;IAEf;;;OAGG;IACH,OAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB,eAAsC;IAEtC;;;;;;;;;;OAUG;IACH,WAFU,gBAAgB,CAEW;IAErC;;;OAGG;IACH,UAFU,aAAa,CAE2B;IAWlD;;MAEE;IAEF;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,iBAFU,SAAS,CAEwB;IAE3C;;;OAGG;IACH,sBAFW,MAAM,QA6EhB;IA4DD;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAUhB;IAED,cAQC;IAED,kBAQC;IAED,mBAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;OAKG;IACH,WAJW,MAAM,KACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;;OAMG;IACH,yBAcC;IAED,gBAIC;IAmDD,sBA2CC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,0DA+BC;IAED;;;;;OAKG;IACH,yBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAelB;IAED;;;;;OAKG;IACH,yEAFW,MAAM,WA+EhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED,6BAKC;IAED,+BASC;IAED,uBAyBC;IAGD;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,oBAahB;;CACJ;;;;4BA5uB2F,OAAO;oBAM/E,+BAA+B;oBAC/B,+BAA+B;oBAC/B,+BAA+B;iCAOlB,uBAAuB;8BAZ1B,iDAAiD;mBAE5D,uCAAuC;0BAQhC,6CAA6C"}

package/src/engine/ecs/fow/FogOfWar.js

@@ -13,6 +13,7 @@ import { min2 } from "../../../core/math/min2.js";
 import { computeUnsignedDistanceField } from "../../graphics/texture/sampler/distance/computeUnsignedDistanceField.js";
 import { Sampler2D } from "../../graphics/texture/sampler/Sampler2D.js";
 import { writeSample2DDataToDataTexture } from "../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
+import { FogOfWarEdgeMode } from "./FogOfWarEdgeMode.js";
 
 const samplePosition = [];
 
@@ -81,12 +82,34 @@ export class FogOfWar {
 
     color = new Vector4(0.1, 0.1, 0.1, 1);
 
+    /**
+     * What the fog does outside the fogged area — see {@link FogOfWarEdgeMode}.
+     *
+     * NOT serialized: it is configuration the owner sets when it builds the
+     * component, not accumulated reveal state, and adding it to the binary format
+     * would cost a version bump plus an updater for every existing save. A
+     * deserialized FogOfWar therefore comes back as Conceal; a consumer that
+     * wants Extend sets it after loading, in the same place it sets {@link color}.
+     *
+     * @type {FogOfWarEdgeMode}
+     */
+    edge_mode = FogOfWarEdgeMode.Conceal;
+
     /**
      * Contains indices of pixes that are currently being updated
      * @type {RowFirstTable}
      */
     fadeMask = new RowFirstTable(revealMaskTableSpec);
 
+    /**
+     * Maps a sampler cell index to the row index of its in-progress fade in
+     * {@link fadeMask}. Enforces at most one fade row per cell, so that the
+     * latest reveal/conceal command for a cell re-aims its existing fade
+     * instead of stacking a second, opposing row.
+     * @type {Map<number, number>}
+     */
+    #fadeRowByCell = new Map();
+
     on = {
         textureChanged: new Signal()
     };
@@ -112,6 +135,8 @@ export class FogOfWar {
 
         const fadeMask = this.fadeMask;
 
+        const rowByCell = this.#fadeRowByCell;
+
         let numRows = fadeMask.length;
 
         let i = 0;
@@ -130,25 +155,24 @@ export class FogOfWar {
 
             let writeValue = value | 0;
 
-            //write new value
+            //store the advanced precise value
             fadeMask.writeCellValue(i, 1, value);
 
+            let completed = false;
+
             if (value <= 0) {
+                writeValue = 0;
+
                 if (speed < 0) {
-                    //we were going down and reached the end, clear row
-                    fadeMask.removeRows(i, 1);
-                    i--;
-                    numRows--;
+                    //revealing fade reached the bottom
+                    completed = true;
                 }
-                writeValue = 0;
             } else if (value >= 255) {
                 writeValue = 255;
 
                 if (speed > 0) {
-                    //we were going down and reached the end, clear row
-                    fadeMask.removeRows(i, 1);
-                    i--;
-                    numRows--;
+                    //concealing fade reached the top
+                    completed = true;
                 }
             }
 
@@ -157,41 +181,108 @@ export class FogOfWar {
                 samplerData[index] = writeValue;
                 this.textureNeedsUpdate = true;
             }
+
+            if (completed) {
+                //Drop the finished row while keeping the cell->row index
+                //consistent. Swap the last row into this slot (O(1)) instead of
+                //shifting the whole tail forward, so only one other row's index
+                //needs to be patched in the map.
+                rowByCell.delete(index);
+
+                const lastRow = numRows - 1;
+
+                if (i !== lastRow) {
+                    const movedCell = fadeMask.readCellValue(lastRow, 0);
+
+                    fadeMask.copyRow(lastRow, i);
+
+                    rowByCell.set(movedCell, i);
+                }
+
+                fadeMask.removeRows(lastRow, 1);
+
+                i--;
+                numRows--;
+            }
         }
     }
 
     /**
-     *
-     * @param {number} x
-     * @param {number} y
+     * Schedule (or re-aim) a fade for a single sampler cell so that it converges
+     * to `target`. Guarantees at most one fade row per cell: if the cell already
+     * has an in-progress fade its direction is updated in place, so the latest
+     * command wins instead of stacking a second, opposing row.
+     * @param {number} index sampler cell index
+     * @param {number} target target sampler value, either 0 (revealed) or 255 (concealed)
+     * @returns {boolean} whether the visible sampler value was changed (i.e. the distance field may need a rebuild)
      */
-    revealPoint(x, y) {
+    #scheduleCellFade(index, target) {
         const fadeMask = this.fadeMask;
+        const rowByCell = this.#fadeRowByCell;
 
-        const sampler = this.sampler;
+        const speed = target === 0 ? -FADE_SPEED : FADE_SPEED;
 
-        const samplerData = sampler.data;
+        const existingRow = rowByCell.get(index);
 
-        const samplerWidth = sampler.width;
+        if (existingRow !== undefined) {
+            //A fade is already in progress for this cell, re-aim it in place.
+            //The precise value column is left untouched so the fade resumes from
+            //its current progress and never snaps back through the far end.
+            fadeMask.writeCellValue(existingRow, 2, speed);
 
-        const index = (y + 1) * samplerWidth + (x + 1);
+            return false;
+        }
+
+        const samplerData = this.sampler.data;
+
+        const current = samplerData[index];
+
+        if (current === target) {
+            //already fully at the target, nothing to fade
+            return false;
+        }
+
+        let seedValue = current;
+        let visibleChanged = false;
 
-        if (samplerData[index] === 255) {
+        if (target === 0 && current === 255) {
+            //pre-fade off the fully-concealed value so the distance field
+            //immediately treats this cell as being revealed
+            seedValue = INITIAL_FADE_VALUE;
             samplerData[index] = INITIAL_FADE_VALUE;
+            visibleChanged = true;
+        }
 
-            //add record to fade mask
-            fadeRow[0] = index;
-            fadeRow[1] = INITIAL_FADE_VALUE;
-            fadeRow[2] = -FADE_SPEED;
+        //add record to fade mask
+        fadeRow[0] = index;
+        fadeRow[1] = seedValue;
+        fadeRow[2] = speed;
 
-            fadeMask.addRow(fadeRow);
+        const rowIndex = fadeMask.addRow(fadeRow);
+
+        rowByCell.set(index, rowIndex);
+
+        return visibleChanged;
+    }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    revealPoint(x, y) {
+        const samplerWidth = this.sampler.width;
+
+        const index = (y + 1) * samplerWidth + (x + 1);
+
+        if (this.#scheduleCellFade(index, 0)) {
             this.distanceFieldNeedsUpdate = true;
         }
     }
 
     clear() {
         this.fadeMask.clear();
+        this.#fadeRowByCell.clear();
 
         this.sampler.data.fill(255);
 
@@ -201,6 +292,7 @@ export class FogOfWar {
 
     revealAll() {
         this.fadeMask.clear();
+        this.#fadeRowByCell.clear();
 
         this.sampler.data.fill(0);
 
@@ -230,11 +322,8 @@ export class FogOfWar {
         const lastPixelX = samplerWidth - 1;
 
         let changeFlag = false;
-        const samplerData = sampler.data;
 
-        const fadeMask = this.fadeMask;
-
-        sampler.traverseCircle(x + 1, y + 1, radius, function (x, y, sampler) {
+        sampler.traverseCircle(x + 1, y + 1, radius, (x, y) => {
 
             if (x <= 0 || x >= lastPixelX || y <= 0 || y >= lastPixelY) {
                 //edges are reserved to preserve cover outside of the working area
@@ -243,16 +332,7 @@ export class FogOfWar {
 
             const index = y * samplerWidth + x;
 
-            if (samplerData[index] === 255) {
-                samplerData[index] = INITIAL_FADE_VALUE;
-
-                //add record to fade mask
-                fadeRow[0] = index;
-                fadeRow[1] = INITIAL_FADE_VALUE;
-                fadeRow[2] = -FADE_SPEED;
-
-                fadeMask.addRow(fadeRow);
-
+            if (this.#scheduleCellFade(index, 0)) {
                 changeFlag = true;
             }
 
@@ -283,11 +363,8 @@ export class FogOfWar {
         const lastPixelX = samplerWidth - 1;
 
         let changeFlag = false;
-        const samplerData = sampler.data;
-
-        const fadeMask = this.fadeMask;
 
-        sampler.traverseCircle(x + 1, y + 1, radius, function (x, y, sampler) {
+        sampler.traverseCircle(x + 1, y + 1, radius, (x, y) => {
 
             if (x <= 0 || x >= lastPixelX || y <= 0 || y >= lastPixelY) {
                 //edges are reserved to preserve cover outside of the working area
@@ -296,17 +373,7 @@ export class FogOfWar {
 
             const index = y * samplerWidth + x;
 
-            const value = samplerData[index];
-
-            if (value !== 255) {
-
-                //add record to fade mask
-                fadeRow[0] = index;
-                fadeRow[1] = value;
-                fadeRow[2] = FADE_SPEED;
-
-                fadeMask.addRow(fadeRow);
-
+            if (this.#scheduleCellFade(index, 255)) {
                 changeFlag = true;
             }
 
@@ -319,13 +386,91 @@ export class FogOfWar {
         }
     }
 
+    /**
+     * Rebuild the cell -> fade row index from the current {@link fadeMask}
+     * contents. Must be invoked whenever the fade mask is populated without
+     * going through {@link reveal}/{@link conceal}/{@link revealPoint} (e.g.
+     * after deserialization), otherwise those methods could stack duplicate
+     * fade rows for a cell.
+     */
+    rebuildFadeIndex() {
+        const rowByCell = this.#fadeRowByCell;
+
+        rowByCell.clear();
+
+        const fadeMask = this.fadeMask;
+
+        const numRows = fadeMask.length;
+
+        for (let i = 0; i < numRows; i++) {
+            const index = fadeMask.readCellValue(i, 0);
+
+            rowByCell.set(index, i);
+        }
+    }
+
     dispose() {
         if (this.texture !== null) {
             this.texture.dispose();
         }
     }
 
+    /**
+     * Copy the sampler's outermost REAL cells out into the 1-cell ring that
+     * {@link rebuildSampler} pads it with.
+     *
+     * That ring is padding — it exists so the shader's 5x5 blur and the distance
+     * field have something to read past the edge — and it is filled with full
+     * concealment. The blur then drags that concealment ~2 cells back INTO the
+     * fogged area, so the outermost cells of the world can never read as fully
+     * revealed however thoroughly they are explored; and every lookup from outside
+     * the area clamps onto it, which is what paints the void. Mirroring makes the
+     * padding agree with the edge it pads, on both counts.
+     *
+     * O(perimeter), and only on frames that upload a new texture.
+     *
+     * @private
+     */
+    #mirrorBorderRing() {
+        const s = this.sampler;
+
+        const w = s.width;
+        const h = s.height;
+
+        if (w < 3 || h < 3) {
+            // no interior to mirror from
+            return;
+        }
+
+        const data = s.data;
+
+        const last_row = (h - 1) * w;
+        const second_last_row = (h - 2) * w;
+
+        // top and bottom edges, corners excluded — those come from the sides below
+        for (let x = 1; x < w - 1; x++) {
+            data[x] = data[w + x];
+            data[last_row + x] = data[second_last_row + x];
+        }
+
+        // left and right edges, corners INCLUDED: the row above and below have
+        // already been mirrored, so a corner ends up with its diagonal neighbour's
+        // value rather than an arbitrary one
+        for (let y = 0; y < h; y++) {
+            const row = y * w;
+
+            data[row] = data[row + 1];
+            data[row + w - 1] = data[row + w - 2];
+        }
+    }
+
     updateTexture() {
+        if (this.edge_mode === FogOfWarEdgeMode.Extend) {
+            // do this HERE, at the single point every reveal path funnels through
+            // on its way to the GPU, rather than in each of them
+            this.#mirrorBorderRing();
+        }
+
         const s = this.sampler;
 
         /**
@@ -594,7 +739,10 @@ export class FogOfWar {
         this.size.set(w, h);
         this.scale.set(scale);
 
-        //TODO update fade mask as necessary
+        //TODO update fade mask as necessary - the sampler indices change with the
+        //new width, so any in-progress fade rows (and the #fadeRowByCell index that
+        //mirrors them) would need remapping or clearing. Only reachable at link time
+        //today, when both are empty.
 
         this.rebuildSampler();
     }

package/src/engine/ecs/fow/FogOfWarEdgeMode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What the fog of war does AT, and beyond, the edge of the fogged area.
+ *
+ * The fog is a screen-space effect (see screenSpaceFogOfWarShader): per pixel it
+ * reconstructs a world position from the depth buffer and reads that position out
+ * of the fog sampler. Neither end of that pipeline is defined outside the fogged
+ * rectangle — a pixel with no geometry has no world position to reconstruct, and
+ * a world position outside the sampler has no cell to read — so what happens
+ * there is a POLICY rather than a fact, and this is the knob for it.
+ */
+export type FogOfWarEdgeMode = number;
+export namespace FogOfWarEdgeMode {
+    let Conceal: number;
+    let Extend: number;
+}
+//# sourceMappingURL=FogOfWarEdgeMode.d.ts.map

package/src/engine/ecs/fow/FogOfWarEdgeMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FogOfWarEdgeMode.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarEdgeMode.js"],"names":[],"mappings":";;;;;;;;;;+BAUU,MAAM"}

package/src/engine/ecs/fow/FogOfWarEdgeMode.js

@@ -0,0 +1,39 @@
+/**
+ * What the fog of war does AT, and beyond, the edge of the fogged area.
+ *
+ * The fog is a screen-space effect (see screenSpaceFogOfWarShader): per pixel it
+ * reconstructs a world position from the depth buffer and reads that position out
+ * of the fog sampler. Neither end of that pipeline is defined outside the fogged
+ * rectangle — a pixel with no geometry has no world position to reconstruct, and
+ * a world position outside the sampler has no cell to read — so what happens
+ * there is a POLICY rather than a fact, and this is the knob for it.
+ *
+ * @enum {number}
+ */
+export const FogOfWarEdgeMode = {
+    /**
+     * Everything outside the fogged area is CONCEALED: the sampler's border ring
+     * is left at full concealment, and a pixel with no geometry takes whatever
+     * the clamped lookup returns — which is that same border.
+     *
+     * The default, and the behaviour of every release before this option existed.
+     * Right for a world that fills the screen, where "outside" is somewhere the
+     * player is never shown.
+     */
+    Conceal: 0,
+
+    /**
+     * The fog EXTENDS outward instead: the border ring mirrors the cells just
+     * inside it, and pixels with no geometry are left alone entirely.
+     *
+     * For a world with a VISIBLE boundary — a finite arena the camera can see
+     * past. Under {@link FogOfWarEdgeMode.Conceal} such a scene gets a hard black
+     * rectangle drawn exactly on its boundary (the concealed border ring, clamped
+     * across the whole void), which both advertises where the map stops and paints
+     * over anything drawn earlier to hide it — this layer composites last, over
+     * every other effect. Under Extend the fog agrees with the ground it borders:
+     * explored terrain stays clear right out past the boundary, unexplored terrain
+     * stays dark, and nothing marks where the geometry ends.
+     */
+    Extend: 1,
+};

package/src/engine/ecs/fow/FogOfWarSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarSystem.js"],"names":[],"mappings":"AAwBA;IACI;;;OAGG;IACH,sCA0BC;IAvBG;;;OAGG;IACH,yBAAwB;IAExB,mDAAuC;IAEvC,gEAEC;IAED,mCAAoD;IAIpD;;;OAGG;IACH,eAFU,aAAa,CAEE;IAEzB,uBAAuB;IAG3B;;;OAGG;IACH,yBAFa,gBAAgB,CAuE5B;IAsBG,kBAAgC;IA+DpC,4CAEC;IAED;;;;;OAKG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAmBhB;IAED,kDAQC;IAED,6BAUC;CACJ;uBAzPsB,cAAc;oBACjB,2BAA2B;yBACtB,eAAe;4CAdI,oDAAoD;iCAS/D,sDAAsD;8BAPzD,0CAA0C"}
+{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarSystem.js"],"names":[],"mappings":"AAwBA;IACI;;;OAGG;IACH,sCA0BC;IAvBG;;;OAGG;IACH,yBAAwB;IAExB,mDAAuC;IAEvC,gEAEC;IAED,mCAAoD;IAIpD;;;OAGG;IACH,eAFU,aAAa,CAEE;IAEzB,uBAAuB;IAG3B;;;OAGG;IACH,yBAFa,gBAAgB,CAuE5B;IAsBG,kBAAgC;IAgEpC,4CAEC;IAED;;;;;OAKG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAmBhB;IAED,kDAQC;IAED,6BAUC;CACJ;uBA1PsB,cAAc;oBACjB,2BAA2B;yBACtB,eAAe;4CAdI,oDAAoD;iCAS/D,sDAAsD;8BAPzD,0CAA0C"}

package/src/engine/ecs/fow/FogOfWarSystem.js

@@ -178,6 +178,7 @@ export class FogOfWarSystem extends System {
                 fogOfWarRenderer.setResolution(fow.size.x, fow.size.y);
                 fogOfWarRenderer.setUvTransformFromFog(fow);
                 fogOfWarRenderer.setFogColor(fow.color);
+                fogOfWarRenderer.setEdgeMode(fow.edge_mode);
 
 
                 //stop traversal

package/src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js"],"names":[],"mappings":"AAQA;;IAEI,uBAAiB;IAGjB,oDAA2D;IAE3D;;;;OAIG;IACH,uCAFW,QAAQ,QAyBlB;IAED;;;;OAIG;IACH,yCAFW,QAAQ,QAgClB;CACJ;gDAjF+C,yDAAyD;yBAChF,gBAAgB;8CAKlC,kFAAkF"}
+{"version":3,"file":"FogOfWarSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js"],"names":[],"mappings":"AAQA;;IAEI,uBAAiB;IAGjB,oDAA2D;IAE3D;;;;OAIG;IACH,uCAFW,QAAQ,QAyBlB;IAED;;;;OAIG;IACH,yCAFW,QAAQ,QAmClB;CACJ;gDApF+C,yDAAyD;yBAChF,gBAAgB;8CAKlC,kFAAkF"}

package/src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js

@@ -75,6 +75,9 @@ export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapte
         //deserialize reveal state
         deserializeRowFirstTable(buffer, value.fadeMask);
 
+        //rebuild the cell -> fade row index to match the restored fade mask
+        value.rebuildFadeIndex();
+
         //
         value.textureNeedsUpdate = true;
         value.rebuildDistanceSampler();

package/src/engine/ecs/fow/shader/FogOfWarRenderer.d.ts

@@ -47,6 +47,12 @@ export class FogOfWarRenderer {
      * @param {Vector4} color
      */
     setFogColor(color: Vector4): void;
+    /**
+     * What the fog does outside the fogged area. See {@link FogOfWarEdgeMode}.
+     *
+     * @param {FogOfWarEdgeMode} mode
+     */
+    setEdgeMode(mode: FogOfWarEdgeMode): void;
     /**
      *
      * @param {WebGLRenderer} renderer
@@ -59,4 +65,5 @@ export class FogOfWarRenderer {
 import { Mesh } from "three";
 import { OrthographicCamera } from "three";
 import { Scene } from "three";
+import { FogOfWarEdgeMode } from "../FogOfWarEdgeMode.js";
 //# sourceMappingURL=FogOfWarRenderer.d.ts.map

package/src/engine/ecs/fow/shader/FogOfWarRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/FogOfWarRenderer.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,+EAFoB,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,gBAiBjD;AAED;IAEQ;;;OAGG;IACH,yBAAgD;IAEhD,2DAAkE;IAElE,2BAAwD;IACxD,aAAwB;IAI5B;;;OAGG;IACH,2CAKC;IAED;;;;;;OAMG;IACH,wBALW,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,QAqBhB;IAED;;;OAGG;IACH,uCAIC;IAED;;;OAGG;IACH,oCAGC;IAED;;;;OAIG;IACH,iBAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;;OAMG;IACH,wCAJW,oBAAkB,kBAAkB,SACpC,KAAK,mCAqBf;CACJ;qBAhJ+C,OAAO;mCAAP,OAAO;sBAAP,OAAO"}
+{"version":3,"file":"FogOfWarRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/FogOfWarRenderer.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,+EAFoB,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,gBAiBjD;AAED;IAEQ;;;OAGG;IACH,yBAAgD;IAEhD,2DAAkE;IAElE,2BAAwD;IACxD,aAAwB;IAI5B;;;OAGG;IACH,2CAKC;IAED;;;;;;OAMG;IACH,wBALW,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,QAqBhB;IAED;;;OAGG;IACH,uCAIC;IAED;;;OAGG;IACH,oCAGC;IAED;;;;OAIG;IACH,iBAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;OAGG;IACH,kCAEC;IAED;;;;OAIG;IACH,kBAFW,gBAAgB,QAI1B;IAED;;;;;;OAMG;IACH,wCAJW,oBAAkB,kBAAkB,SACpC,KAAK,mCAqBf;CACJ;qBA1J+C,OAAO;mCAAP,OAAO;sBAAP,OAAO;iCAItB,wBAAwB"}