@woosh/meep-engine 3.29.0 → 3.31.0

package/src/engine/ecs/EntityManager.js

@@ -31,10 +31,13 @@ export const EntityManagerState = {
 };
 
 /**
+ * How long a system is given to finish starting up or shutting down before a deadlock is suspected and
+ * warned about. Nothing is aborted; the warning is the whole of it.
+ *
  * In seconds
  * @type {number}
  */
-const DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK = 5;
+const DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK = 5;
 
 /**
  * Brings together {@link System}s and an {@link EntityComponentDataset}
@@ -152,6 +155,23 @@ export class EntityManager {
      */
     __fixedStepAccumulator = 0;
 
+    /**
+     * Multiplier on the wall time {@link update} feeds into the fixed-step accumulator — and on
+     * nothing else. Systems still receive {@link fixedUpdateStepSize} in `fixedUpdate`, and the
+     * variable-rate `update` pass still receives the raw delta.
+     *
+     * So this changes how often a fixed step runs, never how long one is: at `1.05` the simulation
+     * advances 5% more steps per wall second, each one the same size, and the interpolation alpha
+     * stays a true fraction of a step. That is what network time dilation needs — a client running a
+     * few percent fast or slow to keep the host's input buffer at depth — and what dropping or
+     * doubling whole steps could not give it: a skipped step reads as a hitch.
+     *
+     * Must be finite and non-negative. `0` freezes the fixed-step simulation (the `update` pass keeps
+     * running).
+     * @type {number}
+     */
+    fixedStepTimeScale = 1;
+
     /**
      * Currently attached dataset.
      * Do not modify directly, instead use {@link attachDataset} and {@link detachDataset} respectively.
@@ -180,6 +200,13 @@ export class EntityManager {
      */
     #fixed_step_gates = [];
 
+    /**
+     * Per system, in execution order: whether it opened the fixed step being run
+     * ({@link System#openFixedStep} returned normally), so it — and only it — is closed.
+     * @type {Uint8Array}
+     */
+    #fixed_step_opened = new Uint8Array(8);
+
     /**
      * Whenever a system is added or removed, optimal execution plan changes, this flag tells us to rebuild the current plan
      * see {@link #systemsExecutionOrder}
@@ -212,7 +239,8 @@ export class EntityManager {
                 continue;
             }
 
-            if (system.update === noop && system.fixedUpdate === noop) {
+            if (system.update === noop && system.fixedUpdate === noop
+                && system.openFixedStep === noop && system.closeFixedStep === noop) {
                 // not a simulation system
                 continue;
             }
@@ -557,7 +585,19 @@ export class EntityManager {
         // (All fixedUpdates for a step run before any update() — a clean
         // sim-then-render phase split that also keeps every system on the same
         // tick boundary for deterministic rewind/resim.)
-        this.__fixedStepAccumulator += time_delta_seconds;
+        const time_scale = this.fixedStepTimeScale;
+
+        assert.isFinite(time_scale, 'fixedStepTimeScale');
+        assert.greaterThanOrEqual(time_scale, 0, 'fixedStepTimeScale must be >= 0');
+
+        this.__fixedStepAccumulator += time_delta_seconds * time_scale;
+
+        // which systems opened the current step, so only those are closed
+        let opened = this.#fixed_step_opened;
+        if (opened.length < system_count) {
+            opened = new Uint8Array(system_count);
+            this.#fixed_step_opened = opened;
+        }
 
         const t0 = performance.now();
         while (this.__fixedStepAccumulator >= fixed_step) {
@@ -572,6 +612,19 @@ export class EntityManager {
 
             this.fixedStepTick++;
 
+            for (let i = 0; i < system_count; i++) {
+                const system = systems[i];
+                opened[i] = 0;
+                if (system.openFixedStep !== noop) {
+                    try {
+                        system.openFixedStep();
+                        opened[i] = 1;
+                    } catch (e) {
+                        console.error(`Failed during openFixedStep of system '${computeSystemName(system)}': `, e);
+                    }
+                }
+            }
+
             for (let i = 0; i < system_count; i++) {
                 const system = systems[i];
                 if (system.fixedUpdate !== noop) {
@@ -583,6 +636,19 @@ export class EntityManager {
                 }
             }
 
+            // reverse order: the first system to open a step is the last to close it
+            for (let i = system_count - 1; i >= 0; i--) {
+                if (opened[i] === 0) continue;
+                const system = systems[i];
+                if (system.closeFixedStep !== noop) {
+                    try {
+                        system.closeFixedStep();
+                    } catch (e) {
+                        console.error(`Failed during closeFixedStep of system '${computeSystemName(system)}': `, e);
+                    }
+                }
+            }
+
             this.__fixedStepAccumulator -= fixed_step;
 
             // Runaway guard: cap total fixed-step catch-up per simulate so a long
@@ -776,7 +842,26 @@ export class EntityManager {
             assert.notNull(promise, "promise");
             assert.isFunction(promise.then, "promise.then");
 
-            promise.then(systemReady, systemFailed);
+            const shutdown_check_timeout = setTimeout(
+                () => {
+                    console.warn(`System '${computeSystemName(system)}' failed to complete shutdown process in ${DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
+                },
+                DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK * 1000,
+            );
+
+            // cleared inside the handlers rather than through `promise.finally`, because `finally`
+            // returns a *derived* promise that rejects with the same reason and that nobody is holding —
+            // an unhandled rejection for every system whose shutdown fails, on top of the failure
+            promise.then(
+                () => {
+                    clearTimeout(shutdown_check_timeout);
+                    systemReady();
+                },
+                (reason) => {
+                    clearTimeout(shutdown_check_timeout);
+                    systemFailed(reason);
+                }
+            );
         } catch (e) {
             console.error(`Failed to execute system shutdown`, e);
             errorCallback(e);
@@ -859,16 +944,23 @@ export class EntityManager {
 
             const startup_check_timeout = setTimeout(
                 () => {
-                    console.warn(`System '${computeSystemName(system)}' failed to complete startup process in ${DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
+                    console.warn(`System '${computeSystemName(system)}' failed to complete startup process in ${DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
                 },
-                DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK * 1000,
+                DEFAULT_SYSTEM_LIFECYCLE_TIMEOUT_CHECK * 1000,
             );
 
-            promise.finally(() => {
-                clearTimeout(startup_check_timeout);
-            });
-
-            promise.then(systemReady, errorCallback);
+            // cleared inside the handlers rather than through `promise.finally`; see the note on the
+            // shutdown side of this
+            promise.then(
+                () => {
+                    clearTimeout(startup_check_timeout);
+                    systemReady();
+                },
+                (reason) => {
+                    clearTimeout(startup_check_timeout);
+                    errorCallback(reason);
+                }
+            );
 
         } catch (e) {
             console.error(`Failed to execute system startup`, e);
@@ -1055,13 +1147,9 @@ export class EntityManager {
             }
         }
 
-        function systemReady(system) {
-            //startup all systems
+        function systemReady() {
             readyCount++;
 
-            system.state.set(SystemState.STOPPED);
-
-            self.on.systemStopped.send1(system);
             if (readyCount === expectedReadyCount) {
                 finalizeShutdown();
             }
@@ -1069,45 +1157,32 @@ export class EntityManager {
 
         let firstFailure = true;
 
-        function systemError(system) {
-            console.error("Failed to shutdown system", system);
+        function systemError(system, error) {
+            console.error("Failed to shutdown system", system, 'Error:', error);
 
             if (firstFailure) {
                 firstFailure = false;
 
                 self.state = EntityManagerState.Failed;
 
-                errorCallback();
+                errorCallback(error);
             }
         }
 
         if (expectedReadyCount === 0) {
             //no systems registered, we're done
             finalizeShutdown();
+            return;
         }
 
         for (const system of systems) {
-
-            system.state.set(SystemState.STOPPING);
-
             const cbOK = systemReady.bind(null, system);
             const cbError = systemError.bind(null, system);
 
-            try {
-                const promise = system.shutdown(this);
-
-                assert.defined(promise, 'promise');
-                assert.notNull(promise, 'promise');
-                assert.isFunction(promise.then, 'promise.then');
-
-                // TODO add timeout
-
-                promise.then(cbOK, cbError);
-            } catch (e) {
-                //failure in shutdown function
-                cbError(e);
-            }
-
+            // `stopSystem` owns the STOPPING/STOPPED transitions, the `systemStopped` signal and the
+            // deadlock warning; this loop only counts. Inlining it here is what let the two drift — the
+            // copy dropped the rejection reason on the floor, which the removeSystem path reported
+            this.stopSystem(system, cbOK, cbError);
         }
     }
 }

package/src/engine/ecs/EntityObserver.d.ts

@@ -76,6 +76,13 @@ export class EntityObserver {
     get isConnected(): boolean;
     /**
      * A shortcut for {@link EntityComponentDataset.removeObserver}
+     *
+     * NOTE: `immediate: true`, mirroring {@link connect}. `connect` replays every existing match
+     * through the complete-callback, so disconnecting has to run the broken-callback for each of
+     * them or the pair is asymmetric and whatever those handlers own is never released - and a
+     * reconnect replays every match on top of the stale state. `EntityManager.detachDataset`
+     * already passes `true`; this shortcut omitted it. A caller that genuinely wants a
+     * non-breaking detach can still call `removeObserver` directly.
      */
     disconnect(): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,sDALW,CAAC,UAAU,OAAO,KAAK,IAAI,kBAC3B,CAAC,UAAU,OAAO,KAAK,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,iBAFW,sBAAsB,QAQhC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,mBAQC;CACJ;qCAhJY,OAAO,6BAA6B,EAAE,sBAAsB;uBAHlD,6BAA6B"}
+{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,sDALW,CAAC,UAAU,OAAO,KAAK,IAAI,kBAC3B,CAAC,UAAU,OAAO,KAAK,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,iBAFW,sBAAsB,QAQhC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;;;;;;OASG;IACH,mBAQC;CACJ;qCAvJY,OAAO,6BAA6B,EAAE,sBAAsB;uBAHlD,6BAA6B"}

package/src/engine/ecs/EntityObserver.js

@@ -136,6 +136,13 @@ export class EntityObserver {
 
     /**
      * A shortcut for {@link EntityComponentDataset.removeObserver}
+     *
+     * NOTE: `immediate: true`, mirroring {@link connect}. `connect` replays every existing match
+     * through the complete-callback, so disconnecting has to run the broken-callback for each of
+     * them or the pair is asymmetric and whatever those handlers own is never released - and a
+     * reconnect replays every match on top of the stale state. `EntityManager.detachDataset`
+     * already passes `true`; this shortcut omitted it. A caller that genuinely wants a
+     * non-breaking detach can still call `removeObserver` directly.
      */
     disconnect() {
         if (this.dataset === null) {
@@ -143,7 +150,7 @@ export class EntityObserver {
             return;
         }
         //de-register updates
-        this.dataset.removeObserver(this);
+        this.dataset.removeObserver(this, true);
         this.dataset = null;
     }
 }

package/src/engine/ecs/System.d.ts

@@ -147,6 +147,29 @@ export class System<C> {
      * @type {(time_delta_seconds: number) => void} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
      */
     fixedUpdate: (time_delta_seconds: number) => void;
+    /**
+     * Opens a fixed step: called for every system that defines it, in execution order, after
+     * {@link EntityManager.fixedStepTick} has advanced and before any system's {@link fixedUpdate} for
+     * the step. The counterpart of {@link closeFixedStep}, which the same system gets after every
+     * {@link fixedUpdate} of the step, in reverse execution order — so steps nest: the first to open is
+     * the last to close.
+     *
+     * This is for work that frames a step as a unit rather than takes part in it: opening and closing
+     * a network frame the whole step's simulation is recorded into, or putting render-only values back
+     * before anything simulates from them. It runs outside the derived execution order on purpose, so
+     * it must not simulate: simulation belongs in {@link fixedUpdate}, where the data a system touches
+     * is declared and ordered.
+     *
+     * {@link closeFixedStep} is called only for systems whose open returned normally.
+     *
+     * @type {() => void}
+     */
+    openFixedStep: () => void;
+    /**
+     * Closes a fixed step. See {@link openFixedStep}.
+     * @type {() => void}
+     */
+    closeFixedStep: () => void;
     /**
      * This update is generally synchronized with the render loop.
      * Note that this time step can vary depending on system conditions and hardware we are running on.

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

@@ -1 +1 @@
-{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,yBAFU,aAAa,CAEF;IAErB;;;;OAIG;IACH,gBAFU,cAAe,WAAW,CAAC,CAEU;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,4FAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,aAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAElB;IAG5B;;;;;;OAMG;IACH,QAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAEvB;CAvBtB;0BA2BS,MAAM;;;;;;;;;qCAzOH,OAAO,6BAA6B,EAAE,sBAAsB;4BAC5D,OAAO,oBAAoB,EAAE,aAAa;0BAN7B,mCAAmC"}
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,yBAFU,aAAa,CAEF;IAErB;;;;OAIG;IACH,gBAFU,cAAe,WAAW,CAAC,CAEU;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,4FAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,aAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAElB;IAG5B;;;;;;;;;;;;;;;;OAgBG;IACH,eAFU,MAAM,IAAI,CAEU;IAE9B;;;OAGG;IACH,gBAFU,MAAM,IAAI,CAEW;IAE/B;;;;;;OAMG;IACH,QAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAEvB;CAhDtB;0BAoDS,MAAM;;;;;;;;;qCAlQH,OAAO,6BAA6B,EAAE,sBAAsB;4BAC5D,OAAO,oBAAoB,EAAE,aAAa;0BAN7B,mCAAmC"}

package/src/engine/ecs/System.js

@@ -228,6 +228,31 @@ System.prototype.isSystem = true;
 System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
 
 
+/**
+ * Opens a fixed step: called for every system that defines it, in execution order, after
+ * {@link EntityManager.fixedStepTick} has advanced and before any system's {@link fixedUpdate} for
+ * the step. The counterpart of {@link closeFixedStep}, which the same system gets after every
+ * {@link fixedUpdate} of the step, in reverse execution order — so steps nest: the first to open is
+ * the last to close.
+ *
+ * This is for work that frames a step as a unit rather than takes part in it: opening and closing
+ * a network frame the whole step's simulation is recorded into, or putting render-only values back
+ * before anything simulates from them. It runs outside the derived execution order on purpose, so
+ * it must not simulate: simulation belongs in {@link fixedUpdate}, where the data a system touches
+ * is declared and ordered.
+ *
+ * {@link closeFixedStep} is called only for systems whose open returned normally.
+ *
+ * @type {() => void}
+ */
+System.prototype.openFixedStep = noop;
+
+/**
+ * Closes a fixed step. See {@link openFixedStep}.
+ * @type {() => void}
+ */
+System.prototype.closeFixedStep = noop;
+
 /**
  * This update is generally synchronized with the render loop.
  * Note that this time step can vary depending on system conditions and hardware we are running on.

package/src/engine/ecs/components/Tag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tag.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/Tag.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAsNI;;;;;OAKG;IACH,kBAJW,MAAM,EAAE,gCAEN,MAAM,EAAE,CAsBpB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,GAAG,CAQf;IAGD;;;;OAIG;IACH,4BAFa,GAAG,CAQf;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,GAAG,CAUd;IAzRD;;;OAGG;IACH,eAAY;IAEZ;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,OAHW,MAAM,GACJ,MAAM,CAMlB;IAED,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,QAWlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,WA4BlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAsBnB;IAED;;;OAGG;IACH,aAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,yBAHoB,MAAM,+BAKzB;IAED;;;OAGG;IACH,QAFY,MAAM,CAmBjB;IAED;;;;OAIG;IACH,cAHW,GAAG,GACF,OAAO,CAIlB;IAED,mBAEC;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,GAAC,MAAM,QAiBzB;CAuEJ;;kBAIS,MAAM"}
+{"version":3,"file":"Tag.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/Tag.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAyNI;;;;;OAKG;IACH,kBAJW,MAAM,EAAE,gCAEN,MAAM,EAAE,CAsBpB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,GAAG,CAQf;IAGD;;;;OAIG;IACH,4BAFa,GAAG,CAQf;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,GAAG,CAUd;IA5RD;;;OAGG;IACH,eAAY;IAEZ;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,OAHW,MAAM,GACJ,MAAM,CAMlB;IAED,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,QAWlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,WA4BlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAsBnB;IAED;;;OAGG;IACH,aAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,yBAHoB,MAAM,+BAKzB;IAED;;;OAGG;IACH,QAFY,MAAM,CAmBjB;IAED;;;;OAIG;IACH,cAHW,GAAG,GACF,OAAO,CAIlB;IAED,mBAKC;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,GAAC,MAAM,QAiBzB;CAuEJ;;kBAIS,MAAM"}

package/src/engine/ecs/components/Tag.js

@@ -195,7 +195,10 @@ export class Tag {
     }
 
     toJSON() {
-        return this.values;
+        // a copy: `values` is private, and `EntityBlueprint.add` keeps whatever comes back here as
+        // its template, so handing out the live array let a later `tag.add` change every entity the
+        // blueprint had yet to build
+        return this.values.slice();
     }
 
     /**

package/src/engine/ecs/computeComponentClassName.d.ts

@@ -1,2 +1,14 @@
-declare function computeComponentClassName(klass: any): any;
+/**
+ * Best available human-readable name for a component class, for diagnostics.
+ *
+ * NOTE: exported. It was declared without the keyword, so the module had an empty export list and
+ * nothing could import it - which is why the one consumer referenced it as a free variable and got
+ * a ReferenceError instead of the message it was building.
+ *
+ * @param {Function|{type: string}} klass
+ * @returns {string}
+ */
+export function computeComponentClassName(klass: Function | {
+    type: string;
+}): string;
 //# sourceMappingURL=computeComponentClassName.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"computeComponentClassName.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/computeComponentClassName.js"],"names":[],"mappings":"AAAA,4DAYC"}
+{"version":3,"file":"computeComponentClassName.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/computeComponentClassName.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,iDAHW,WAAS;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GACrB,MAAM,CAclB"}

package/src/engine/ecs/computeComponentClassName.js

@@ -1,4 +1,14 @@
-function computeComponentClassName(klass) {
+/**
+ * Best available human-readable name for a component class, for diagnostics.
+ *
+ * NOTE: exported. It was declared without the keyword, so the module had an empty export list and
+ * nothing could import it - which is why the one consumer referenced it as a free variable and got
+ * a ReferenceError instead of the message it was building.
+ *
+ * @param {Function|{type: string}} klass
+ * @returns {string}
+ */
+export function computeComponentClassName(klass) {
     if (klass === undefined) {
         return "undefined";
     } else if (klass === null) {

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yCALW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,wBAAwB,KAAK,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}
+{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AAwGA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yCALW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,wBAAwB,KAAK,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAjlBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -48,6 +48,17 @@ class Context extends SystemEntityContext {
      */
     next_idle_event_time = 0;
 
+    reset() {
+        super.reset();
+
+        // the context is pooled: anything set outside link() survives into the next entity that
+        // draws this object unless it is cleared here
+        this.execution.rule = null;
+        this.execution.executor = null;
+
+        this.next_idle_event_time = 0;
+    }
+
     /**
      *
      * @param {string} event

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":"AA8CA;;GAEG;AACH;IAEI;;;OAGG;IACH,oBAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,0BAFU,OAAO,CAEgB;IAEjC;;;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;IAmDD,sBAWC;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;;;;oBAzrBmB,+BAA+B;oBAC/B,+BAA+B;oBAC/B,+BAA+B;iCAMlB,uBAAuB;8BAX1B,iDAAiD;mBAE5D,uCAAuC;0BAQhC,6CAA6C"}
+{"version":3,"file":"FogOfWar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWar.js"],"names":[],"mappings":"AA8CA;;GAEG;AACH;IAEI;;;OAGG;IACH,oBAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,0BAFU,OAAO,CAEgB;IAEjC;;;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;IAmDD,sBAWC;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,WA4FhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED,6BAKC;IAED,+BASC;IAED,uBAyBC;IAGD;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,oBAahB;;CACJ;;;;oBAntBmB,+BAA+B;oBAC/B,+BAA+B;oBAC/B,+BAA+B;iCAMlB,uBAAuB;8BAX1B,iDAAiD;mBAE5D,uCAAuC;0BAQhC,6CAA6C"}

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

@@ -546,8 +546,23 @@ export class FogOfWar {
     computeAABBVisibility(aabb, cameraFocalPoint, clearance) {
         assert.isNumber(clearance, 'clearance');
 
-        let sx0 = this.size.x - 1;
-        let sy0 = this.size.y - 1;
+        const distanceSampler = this.distanceSampler;
+
+        /*
+         worldToSamplePosition returns coordinates in the PADDED sampler's space — it adds the +1
+         guard border offset, and the sampler is size + 2 on each axis. The clamp here was to
+         size - 1, two indices short of the padded maximum, so the last world cell and everything
+         beyond it was tested against a cell two rows and columns back inside the map. The guard
+         border exists precisely so a lookup just outside the fogged area has something correct to
+         read.
+        */
+        const sampler_max_x = distanceSampler.width - 1;
+        const sampler_max_y = distanceSampler.height - 1;
+
+        // the sample-space bounding box is seeded from the sampler's extent for the same reason: a
+        // box lying wholly out in the border must not pick up size - 1 as its lower bound
+        let sx0 = sampler_max_x;
+        let sy0 = sampler_max_y;
         let sx1 = 0;
         let sy1 = 0;
 
@@ -566,8 +581,6 @@ export class FogOfWar {
         corners2d[6] = aabb.x1;
         corners2d[7] = aabb.z1;
 
-        const distanceSampler = this.distanceSampler;
-
         //check corners, this is fast compared to checking each cell of fog overlapping bounding box
         for (i = 0; i < 8; i += 2) {
 
@@ -579,10 +592,10 @@ export class FogOfWar {
             const sampleX = samplePosition[0];
             const sampleY = samplePosition[1];
 
-            const sX = clamp(sampleX, 0, this.size.x - 1);
-            const sY = clamp(sampleY, 0, this.size.y - 1);
+            const sX = clamp(sampleX, 0, sampler_max_x);
+            const sY = clamp(sampleY, 0, sampler_max_y);
 
-            const distance = distanceSampler.readChannel(sX | 0, sY | 0, 0);
+            const distance = distanceSampler.readChannel(Math.floor(sX), Math.floor(sY), 0);
 
             //Check if cell is visible
             if (distance <= clearance) {
@@ -608,7 +621,7 @@ export class FogOfWar {
         const sMidX = sx0 + shExtX;
         const sMidY = sy0 + shExtY;
 
-        const centerOcclusionDistance = distanceSampler.readChannel(sMidX | 0, sMidY | 0, 0);
+        const centerOcclusionDistance = distanceSampler.readChannel(Math.floor(sMidX), Math.floor(sMidY), 0);
 
         const maxDistanceFromCenter = max2(shExtX, shExtY);
 
@@ -631,10 +644,23 @@ export class FogOfWar {
     getWorldClearance(x, y) {
         this.worldToSamplePosition(x, y, samplePosition);
 
-        const sampleX = samplePosition[0];
-        const sampleY = samplePosition[1];
+        const distanceSampler = this.distanceSampler;
 
-        return this.distanceSampler.readChannel(sampleX | 0, sampleY | 0, 0);
+        /*
+         Clamped into the PADDED sampler, which is size + 2 on each axis.
+
+         This used to read whatever the raw sample coordinate indexed. A world position past the
+         +X edge ran off the end of its row and wrapped into the next one — on a 4x4 fog, world
+         (8, 0) is padded sample (7, 1), and 1 * 6 + 7 is the cell at (1, 2), so a point twice the
+         map's width away reported that cell's clearance — and a negative one indexed off the front
+         of the buffer entirely, where the undefined that came back compared false against every
+         threshold. Math.floor rather than | 0 because | 0 truncates toward zero, which folds a
+         negative coordinate onto row 0 rather than off the map.
+        */
+        const sampleX = clamp(samplePosition[0], 0, distanceSampler.width - 1);
+        const sampleY = clamp(samplePosition[1], 0, distanceSampler.height - 1);
+
+        return distanceSampler.readChannel(Math.floor(sampleX), Math.floor(sampleY), 0);
     }
 
     rebuildDistanceField() {

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

@@ -21,7 +21,14 @@ export class FogOfWarRevealerSystem extends System<any> {
      */
     link(revealer: FogOfWarRevealer, transform: Transform64, team: Team, entity: any): void;
     forceUpdate(): void;
-    unlink(revealer: any, position: any, team: any, entity: any): void;
+    /**
+     *
+     * @param {FogOfWarRevealer} revealer
+     * @param {Transform64} transform
+     * @param {Team} team
+     * @param {number} entity
+     */
+    unlink(revealer: FogOfWarRevealer, transform: Transform64, team: Team, entity: number): void;
 }
 import { System } from "../System.js";
 import { Transform64 } from "../transform/Transform64.js";

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

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarRevealerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js"],"names":[],"mappings":"AAaA;IAOI;;;OAGG;IACH,kBAFW,MAAM,EAUhB;IAlBD,6EAAqD;IACrD,gEAEE;IACF,YAAU;IASN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;;;;;OAMG;IACH,eALW,gBAAgB,aAChB,WAAW,QACX,IAAI,qBA0Dd;IAED,oBAmCC;IAED,mEAMC;CACJ;uBA9IsB,cAAc;4BAKT,6BAA6B;iCAJxB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAKI,oDAAoD"}
+{"version":3,"file":"FogOfWarRevealerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js"],"names":[],"mappings":"AAcA;IAOI;;;OAGG;IACH,kBAFW,MAAM,EAUhB;IAlBD,6EAAqD;IACrD,gEAEE;IACF,YAAU;IASN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;;;;;OAMG;IACH,eALW,gBAAgB,aAChB,WAAW,QACX,IAAI,qBAqFd;IAED,oBAmCC;IAED;;;;;;OAMG;IACH,iBALW,gBAAgB,aAChB,WAAW,QACX,IAAI,UACJ,MAAM,QAQhB;CACJ;uBAjLsB,cAAc;4BAKT,6BAA6B;iCAJxB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAMI,oDAAoD"}

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

@@ -4,6 +4,7 @@ import { SignalBinding } from "../../../core/events/signal/SignalBinding.js";
 import { FogOfWar } from "./FogOfWar.js";
 import Team from "../team/Team.js";
 import { Transform64 } from "../transform/Transform64.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../transform/TRANSFORM64_EVENT_CHANGE.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
@@ -67,7 +68,34 @@ export class FogOfWarRevealerSystem extends System {
 
         const signalBindings = [];
 
-        const positionWatcher = new SignalBinding(position.onChanged, update);
+        /**
+         * Transform64 carries no signals — TRANSFORM64_EVENT_CHANGE exists precisely because
+         * `position.onChanged` is gone — so the watch is registered against the entity and the
+         * transform's own change event. Wrapped to keep the link/unlink shape the team watcher
+         * below and `unlink` both rely on; `addEntityEventListener` has no idempotence of its own,
+         * hence the flag.
+         */
+        let transform_watched = false;
+
+        const positionWatcher = {
+            link() {
+                if (transform_watched) {
+                    return;
+                }
+
+                em.dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, update);
+                transform_watched = true;
+            },
+            unlink() {
+                if (!transform_watched) {
+                    return;
+                }
+
+                em.dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, update);
+                transform_watched = false;
+            }
+        };
+
         signalBindings.push(positionWatcher);
 
 
@@ -133,7 +161,14 @@ export class FogOfWarRevealerSystem extends System {
         }
     }
 
-    unlink(revealer, position, team, entity) {
+    /**
+     *
+     * @param {FogOfWarRevealer} revealer
+     * @param {Transform64} transform
+     * @param {Team} team
+     * @param {number} entity
+     */
+    unlink(revealer, transform, team, entity) {
         const bindings = this.data[entity];
 
         bindings.forEach(b => b.unlink());

package/src/engine/ecs/guid/UUID.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UUID.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/guid/UUID.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA2HI;;;OAGG;IACH,aAFY,IAAI,CAQf;IA2BD;;;OAGG;IACH,aAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAFY,MAAM,CAIjB;IA6CD;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,CAQf;IAxOD;;;OAGG;IACH,4BAKC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,sBAKC;IAED;;;;OAIG;IACH,OAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,MAFa,IAAI,CAwEhB;IAcD;;;OAGG;IACH,MAFa,IAAI,CAqBhB;IAuBD;;;OAGG;IACH,cAFW,MAAM,QAuChB;IAeD;;;;;;OAMG;IACH,YAFa,MAAM,CA2BlB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAcnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAIL;;OAEG;IACH,uBAzFiB,MAAM,CAyFF;IAErB;;OAEG;IACH,4BAzJe,MAAM,UAyJE;IAQvB;;;OAGG;IACH,iBAFU,OAAO,CAEI;;CAtBpB;;kBAcS,MAAM"}
+{"version":3,"file":"UUID.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/guid/UUID.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA2HI;;;OAGG;IACH,aAFY,IAAI,CAQf;IAkBD;;;OAGG;IACH,aAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAFY,MAAM,CAIjB;IA6CD;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,CAQf;IA/ND;;;OAGG;IACH,4BAKC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,sBAKC;IAED;;;;OAIG;IACH,OAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,MAFa,IAAI,CAwEhB;IAcD;;;OAGG;IACH,MAFa,IAAI,CAYhB;IAuBD;;;OAGG;IACH,cAFW,MAAM,QAuChB;IAeD;;;;;;OAMG;IACH,YAFa,MAAM,CA2BlB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAcnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAIL;;OAEG;IACH,uBAzFiB,MAAM,CAyFF;IAErB;;OAEG;IACH,4BAzJe,MAAM,UAyJE;IAQvB;;;OAGG;IACH,iBAFU,OAAO,CAEI;;CAtBpB;;kBAcS,MAAM"}