@woosh/meep-engine 3.41.0 → 3.42.0

package/src/engine/control/first-person/FirstPersonPlayerControllerConfig.d.ts.map

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

package/src/engine/control/first-person/FirstPersonPlayerControllerConfig.js

@@ -617,6 +617,7 @@ export class FirstPersonPlayerControllerConfig {
             mantle: { ...this.mantle },
             wallRun: { ...this.wallRun },
             wallJump: { ...this.wallJump },
+            scrambleUp: { ...this.scrambleUp },
             slide: { ...this.slide },
             bob: { ...this.bob },
             breath: { ...this.breath },
@@ -651,6 +652,7 @@ export class FirstPersonPlayerControllerConfig {
         if (json.mantle) Object.assign(this.mantle, json.mantle);
         if (json.wallRun) Object.assign(this.wallRun, json.wallRun);
         if (json.wallJump) Object.assign(this.wallJump, json.wallJump);
+        if (json.scrambleUp) Object.assign(this.scrambleUp, json.scrambleUp);
         if (json.slide) Object.assign(this.slide, json.slide);
         if (json.bob) Object.assign(this.bob, json.bob);
         if (json.breath) Object.assign(this.breath, json.breath);

package/src/engine/control/first-person/abilities/AbilitySet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbilitySet.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/AbilitySet.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACI;;;;;OAKG;IACH,WAFU,SAAS,CAEJ;IAEf;;;OAGG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;;;OAKG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,+BAQC;IAED;;;;;;;;;;;;;OAaG;IACH,0EANW,MAAM,iBAIJ,OAAO,CA4DnB;IAED;;OAEG;IACH,wCAcC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,oBAKC;CACJ"}
+{"version":3,"file":"AbilitySet.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/AbilitySet.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACI;;;;;OAKG;IACH,WAFU,SAAS,CAEJ;IAEf;;;OAGG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;;;OAKG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,+BAQC;IAED;;;;;;;;;;;;;OAaG;IACH,0EANW,MAAM,iBAIJ,OAAO,CAqEnB;IAED;;OAEG;IACH,wCAcC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,oBAKC;CACJ"}

package/src/engine/control/first-person/abilities/AbilitySet.js

@@ -85,11 +85,13 @@ export class AbilitySet {
      * @returns {boolean} true = run base locomotion; false = ability owned
      */
     tick(controller, runtime, bodyTransform, sensors, dt, system) {
+        let yielded = false;
         // Step 1: tick the active ability if any. May release control.
         if (this.active !== null) {
             const stillActive = this.active.tick(controller, runtime, bodyTransform, dt, system);
             if (!stillActive) {
                 this._deactivate(controller, runtime);
+                yielded = true;
             }
         }
 
@@ -141,6 +143,13 @@ export class AbilitySet {
             }
         }
 
+        // A yielded step belongs to its successor, just as it would to base locomotion.
+        if (yielded && this.active !== null) {
+            if (!this.active.tick(controller, runtime, bodyTransform, dt, system)) {
+                this._deactivate(controller, runtime);
+            }
+        }
+
         return this.active === null;
     }
 

package/src/engine/control/first-person/abilities/LedgeGrab.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LedgeGrab.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/LedgeGrab.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAII;;;;iCAI6B;IAC7B,iBAAa;IAEb,iBAAa;IACb,YAAQ;IACR,YAAQ;IACR,eAAW;IAEX;mEAC+D;IAC/D,aAAkB;IAElB,0BAAiC;IAEjC,kEAiCC;IAED,gDAuDC;IAED,wBAIC;IAED,kDAOC;IAED,wFAiHC;IAED;;;;;;OAMG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,yBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBA8CC;CACJ;wBAjZuB,cAAc;oCAFF,iDAAiD"}
+{"version":3,"file":"LedgeGrab.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/LedgeGrab.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAII;;;;iCAI6B;IAC7B,iBAAa;IAEb,iBAAa;IACb,YAAQ;IACR,YAAQ;IACR,eAAW;IAEX;mEAC+D;IAC/D,aAAkB;IAElB,0BAAiC;IAEjC,kEAiCC;IAED,gDAuDC;IAED,wBAIC;IAED,kDAOC;IAED,wFAuHC;IAED;;;;;;OAMG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,yBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBA8CC;CACJ;wBAvZuB,cAAc;oCAFF,iDAAiD"}

package/src/engine/control/first-person/abilities/LedgeGrab.js

@@ -296,6 +296,12 @@ export class LedgeGrab extends Ability {
             0, 1,
         );
 
+        // Release at saturation before the controller's later recovery step lowers exertion.
+        if (controller.state.exertion >= 1.0) {
+            controller.signals.onLedgeRelease.send1({ reason: "slip" });
+            return false;
+        }
+
         return true;
     }
 

package/src/engine/control/first-person/abilities/Slide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Slide.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Slide.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAMI,gEAAgE;IAChE,0BAAsB;IAEtB,mEAuBC;IAED,gDAuBC;IAED,uDAGC;IAED,uFAmEC;IAED,oDAEC;CACJ;wBAhKuB,cAAc"}
+{"version":3,"file":"Slide.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Slide.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAMI,gEAAgE;IAChE,0BAAsB;IAEtB,mEAuBC;IAED,gDAuBC;IAED,uDAGC;IAED,uFAoEC;IAED,oDAEC;CACJ;wBAjKuB,cAAc"}

package/src/engine/control/first-person/abilities/Slide.js

@@ -127,6 +127,7 @@ export class Slide extends Ability {
             runtime.midJump = true;
             runtime.apexFired = false;
             runtime.peakAltitude = runtime.bodyPosition[1];
+            controller.state.grounded = false;
             controller.state.isVariableJumpCut = false;
             controller.state.isAscending = true;
             // Mastery: scale the impulse via JumpImpulse evaluators if any.

package/src/engine/control/first-person/abilities/WallRun.d.ts

@@ -15,7 +15,8 @@
  *     out share the spring's smoothing).
  *
  * Exits on:
- *   - Timer (`cfg.wallRun.maxDuration`)
+ *   - Timer (`cfg.wallRun.maxDuration`); expiry requires landing before
+ *     another run. Other exits allow reacquisition during the same flight.
  *   - Lost wall contact (sensor's hit flag becomes false)
  *   - Re-grounded (we walked onto a floor at the wall's end)
  *   - Wall-jump preempts (higher priority — WallJump declares priority 60)
@@ -30,6 +31,8 @@ export class WallRun extends Ability {
     private _elapsed;
     /** @private "L" or "R" — which wall we're running on. */
     private _side;
+    /** @private A duration-expired run must land before starting another. */
+    private _durationState;
     canActivate(controller: any, runtime: any, sensors: any): boolean;
     onActivate(controller: any, runtime: any): void;
     /**

package/src/engine/control/first-person/abilities/WallRun.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WallRun.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/WallRun.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAII,qDAAqD;IACrD,iBAAa;IAEb,yDAAyD;IACzD,cAAY;IAEZ,kEAqCC;IAED,gDAqBC;IAED;;;;OAIG;IACH,wBAEC;IAED,uFAgEC;CAKJ;wBAnLuB,cAAc"}
+{"version":3,"file":"WallRun.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/WallRun.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAII,qDAAqD;IACrD,iBAAa;IAEb,yDAAyD;IACzD,cAAY;IAEZ,yEAAyE;IACzE,uBAAsC;IAEtC,kEAsCC;IAED,gDAqBC;IAED;;;;OAIG;IACH,wBAEC;IAED,uFAmEC;CAKJ;wBA/LuB,cAAc"}

package/src/engine/control/first-person/abilities/WallRun.js

@@ -1,6 +1,10 @@
 import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
 import { Ability } from "./Ability.js";
 
+function resetDurationOnLand() {
+    this.exhausted = false;
+}
+
 /**
  * Wall-run ability. Activates when the player is airborne with momentum
  * and a wall is detected to their left or right. While active:
@@ -18,7 +22,8 @@ import { Ability } from "./Ability.js";
  *     out share the spring's smoothing).
  *
  * Exits on:
- *   - Timer (`cfg.wallRun.maxDuration`)
+ *   - Timer (`cfg.wallRun.maxDuration`); expiry requires landing before
+ *     another run. Other exits allow reacquisition during the same flight.
  *   - Lost wall contact (sensor's hit flag becomes false)
  *   - Re-grounded (we walked onto a floor at the wall's end)
  *   - Wall-jump preempts (higher priority — WallJump declares priority 60)
@@ -38,9 +43,13 @@ export class WallRun extends Ability {
     /** @private "L" or "R" — which wall we're running on. */
     _side = "L";
 
+    /** @private A duration-expired run must land before starting another. */
+    _durationState = { exhausted: false };
+
     canActivate(controller, runtime, sensors) {
         const cfg = controller.config.wallRun;
         if (!cfg) return false;
+        if (this._durationState.exhausted) return false;
         if (sensors === undefined || sensors === null) return false;
         if (controller.state.grounded) return false;
         if (controller.state.airborneTime < cfg.minAirborneTime) return false;
@@ -115,6 +124,9 @@ export class WallRun extends Ability {
 
         // -- Exit: timer.
         if (this._elapsed >= cfg.maxDuration) {
+            this._durationState.exhausted = true;
+            // The pending listener owns only the state cell, never the ability.
+            controller.signals.onLand.addOne(resetDurationOnLand, this._durationState);
             return false;
         }
         // -- Exit: re-grounded (we ran onto a floor).

package/src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.d.ts

@@ -1,6 +1,6 @@
 /**
  * Default symmetric stride-timing curve for slide entry. Peaks at the
- * midstance phases (≈0.25 R-mid, ≈0.75 L-mid) — committing to the slide
+ * midstance phases (≈0.25, ≈0.75) — committing to the slide
  * at midstance lets you convert your push-off momentum into the slide's
  * forward velocity cleanly. Troughs near footfall transitions (≈0, ≈0.5)
  * where the leg's loading-response decelerates the body and a slide

package/src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SlideInitiationTimingEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,yDAFa,cAAc,CAS1B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAGI;;;;;OAKG;IACH,OAFU,cAAc,CAEwB;IAEhD;;;;;;OAMG;IACH,WAFU,MAAM,CAEA;IAEhB,qEAQC;CACJ;+BA/E8B,4CAA4C;iCAG1C,uBAAuB"}
+{"version":3,"file":"SlideInitiationTimingEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,yDAFa,cAAc,CAU1B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAGI;;;;;OAKG;IACH,OAFU,cAAc,CAEwB;IAEhD;;;;;;OAMG;IACH,WAFU,MAAM,CAEA;IAEhB,qEAQC;CACJ;+BAhF8B,4CAA4C;iCAG1C,uBAAuB"}

package/src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.js

@@ -5,7 +5,7 @@ import { MasteryEvaluator } from "./MasteryEvaluator.js";
 
 /**
  * Default symmetric stride-timing curve for slide entry. Peaks at the
- * midstance phases (≈0.25 R-mid, ≈0.75 L-mid) — committing to the slide
+ * midstance phases (≈0.25, ≈0.75) — committing to the slide
  * at midstance lets you convert your push-off momentum into the slide's
  * forward velocity cleanly. Troughs near footfall transitions (≈0, ≈0.5)
  * where the leg's loading-response decelerates the body and a slide
@@ -20,10 +20,11 @@ import { MasteryEvaluator } from "./MasteryEvaluator.js";
  */
 export function makeDefaultSlideInitiationTimingCurve() {
     return AnimationCurve.from([
-        Keyframe.from(0.00, 0.97), // R-foot footfall — slight penalty
-        Keyframe.from(0.25, 1.06), // R-foot midstance — peak commitment
-        Keyframe.from(0.50, 0.97), // L-foot footfall — slight penalty
-        Keyframe.from(0.75, 1.06), // L-foot midstance — peak commitment
+        Keyframe.from(0.00, 0.97), // footfall — slight penalty
+        Keyframe.from(0.25, 1.06), // midstance — peak commitment
+        Keyframe.from(0.50, 0.97), // footfall — slight penalty
+        Keyframe.from(0.75, 1.06), // midstance — peak commitment
+        Keyframe.from(1.00, 0.97), // next footfall closes the stride cycle
     ]);
 }
 

package/src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.d.ts

@@ -1,12 +1,12 @@
 /**
  * Default symmetric stride-timing curve for the jump-impulse decision
- * point. Peaks at the midstance phases (≈0.25 R-mid, ≈0.75 L-mid) and
+ * point. Peaks at the midstance phases (≈0.25, ≈0.75) and
  * troughs near the footfall transitions (≈0, ≈0.5).
  *
  * Curve is asymmetric in magnitude per the project rule: bonus side is
  * larger than penalty side. Default peak = +12%, default trough = −4%.
- * The curve is keyed at the four phase critical points; the engine's
- * tangent-interpolation gives smooth motion between them.
+ * The curve closes at the next footfall; tangent interpolation gives
+ * smooth motion between the critical phases.
  *
  * @returns {AnimationCurve}
  */

package/src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StrideTimingJumpEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,oDAFa,cAAc,CAS1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAGI;;;;;;OAMG;IACH,OAFU,cAAc,CAEmB;IAE3C;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,GAAG,GAAC,GAAG,GAAC,IAAI,CAEF;IAEpB;;;;OAIG;IACH,mBAFU,MAAM,CAES;IAEzB,oEAqBC;CACJ;+BAzG8B,4CAA4C;iCAG1C,uBAAuB"}
+{"version":3,"file":"StrideTimingJumpEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,oDAFa,cAAc,CAU1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAGI;;;;;;OAMG;IACH,OAFU,cAAc,CAEmB;IAE3C;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,GAAG,GAAC,GAAG,GAAC,IAAI,CAEF;IAEpB;;;;OAIG;IACH,mBAFU,MAAM,CAES;IAEzB,oEAqBC;CACJ;+BA1G8B,4CAA4C;iCAG1C,uBAAuB"}

package/src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.js

@@ -5,22 +5,23 @@ import { MasteryEvaluator } from "./MasteryEvaluator.js";
 
 /**
  * Default symmetric stride-timing curve for the jump-impulse decision
- * point. Peaks at the midstance phases (≈0.25 R-mid, ≈0.75 L-mid) and
+ * point. Peaks at the midstance phases (≈0.25, ≈0.75) and
  * troughs near the footfall transitions (≈0, ≈0.5).
  *
  * Curve is asymmetric in magnitude per the project rule: bonus side is
  * larger than penalty side. Default peak = +12%, default trough = −4%.
- * The curve is keyed at the four phase critical points; the engine's
- * tangent-interpolation gives smooth motion between them.
+ * The curve closes at the next footfall; tangent interpolation gives
+ * smooth motion between the critical phases.
  *
  * @returns {AnimationCurve}
  */
 export function makeDefaultStrideTimingJumpCurve() {
     return AnimationCurve.from([
-        Keyframe.from(0.00, 0.96),  // R-foot footfall — slight penalty (just touched down)
-        Keyframe.from(0.25, 1.12),  // R-foot midstance — peak push-off power
-        Keyframe.from(0.50, 0.96),  // L-foot footfall — slight penalty
-        Keyframe.from(0.75, 1.12),  // L-foot midstance — peak push-off power
+        Keyframe.from(0.00, 0.96),  // footfall — slight penalty (just touched down)
+        Keyframe.from(0.25, 1.12),  // midstance — peak push-off power
+        Keyframe.from(0.50, 0.96),  // footfall — slight penalty
+        Keyframe.from(0.75, 1.12),  // midstance — peak push-off power
+        Keyframe.from(1.00, 0.96),  // next footfall closes the stride cycle
     ]);
 }
 
@@ -98,7 +99,7 @@ export class StrideTimingJumpEvaluator extends MasteryEvaluator {
         if (this.dominantFoot !== null
             && runtime.standingFoot === this.dominantFoot
             && raw > 1.0) {
-            multiplier *= 1.0 + this.dominantFootBonus;
+            multiplier += this.dominantFootBonus;
         }
 
         return multiplier;

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BA0FC;IAED;;;;;;;;;;OAUG;IACH,wBAQC;IAED;;;;;;;;;;;;OAYG;IACH,kBAgBC;CACJ;uBAtOsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}
+{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAmGC;IAED;;;;;;;;;;OAUG;IACH,wBAQC;IAED;;;;;;;;;;;;OAYG;IACH,kBAgBC;CACJ;uBA/OsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js

@@ -150,9 +150,18 @@ export class FirstPersonSensorsSystem extends System {
         // the body height to decide vault vs. mantle vs. neither.
         this._probeRay(sensors.obstacleAhead, ox, oy, oz, fx, 0, fz, obstacleProbeDist, notSelf);
 
-        // Ledge ahead — only meaningful if obstacleAhead hit something
-        // around chest height: probe down from just past the top of the
-        // obstacle, look for ground.
+        let ledgeProbeDist = cfg.body.height * 0.5;
+        if (!sensors.obstacleAhead.hit && controller.state.grounded && cfg.mantle) {
+            // Grounded mantles can reach lower tops that the chest ray passes over.
+            const minimumHeight = cfg.mantle.minHeight;
+            this._probeRay(sensors.obstacleAhead, ox, transform.translation_y + minimumHeight, oz,
+                fx, 0, fz, obstacleProbeDist, notSelf);
+            if (sensors.obstacleAhead.hit) {
+                ledgeProbeDist = cfg.body.height + 0.1 - minimumHeight;
+            }
+        }
+
+        // Ledge ahead: probe downward from above the body to a reachable top.
         if (sensors.obstacleAhead.hit) {
             const topY = transform.translation_y + cfg.body.height + 0.1;
             const px = sensors.obstacleAhead.point[0] + fx * 0.3;
@@ -161,7 +170,7 @@ export class FirstPersonSensorsSystem extends System {
                 sensors.ledgeAhead,
                 px, topY, pz,
                 0, -1, 0,
-                cfg.body.height * 0.5,
+                ledgeProbeDist,
                 notSelf,
             );
         }

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

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAsBU,MAAM;;;;;;;;;AAoBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEY;IAE5B;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;;;;;;;;;;;OAcG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IA8Bf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;;;;;;;;;OAWG;IACH,6BAkGC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,cAkBhB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QA6HhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;OAKG;IACH,oBA4FC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,2BAHW,KAAK,GACH,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,kCAJW,KAAK,SACL,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAmEC;IAGL;;OAEG;IACH,yBA7wBe,sBAAsB,UA6wBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA5oBe,MAAM,UA4oBW;;CAd/B;6BAjpCY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;uBAP1B,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAsBU,MAAM;;;;;;;;;AAoBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEY;IAE5B;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;;;;;;;;;;;OAcG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IA8Bf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;;;;;;;;;OAWG;IACH,6BAkGC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,cAkBhB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QA6HhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;OAKG;IACH,oBA4FC;IAED;;;;;OAKG;IACH,kEA4EC;IAED;;;;OAIG;IACH,2BAHW,KAAK,GACH,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,kCAJW,KAAK,SACL,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAmEC;IAGL;;OAEG;IACH,yBAhxBe,sBAAsB,UAgxBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA/oBe,MAAM,UA+oBW;;CAd/B;6BAppCY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;uBAP1B,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}

package/src/engine/ecs/EntityManager.js

@@ -992,12 +992,19 @@ export class EntityManager {
 
         const self = this;
         const systems = this.systems;
-        let readyCount = 0;
+        let settledCount = 0;
         const expectedReadyCount = systems.length;
+        let failed = false;
+        let startupError;
 
         // console.log(`EntityManager startup initialized, starting ${expectedReadyCount} systems.`);
 
         function finalizeStartup() {
+            if (failed) {
+                self.state = EntityManagerState.Failed;
+                errorCallback(startupError);
+                return;
+            }
             self.state = EntityManagerState.Running;
 
             // console.log(`EntityManager startup finished, all systems started`);
@@ -1009,26 +1016,22 @@ export class EntityManager {
         }
 
         function systemReady() {
-            //startup all systems
-            readyCount++;
+            settledCount++;
 
-            if (readyCount === expectedReadyCount) {
+            if (settledCount === expectedReadyCount) {
                 finalizeStartup();
             }
         }
 
-        let firstFailure = true;
-
         function systemError(system, error) {
             console.error("Failed to start system", system, 'Error:', error);
 
-            if (firstFailure) {
-                firstFailure = false;
-
-                self.state = EntityManagerState.Failed;
-
-                errorCallback(error);
+            if (!failed) {
+                failed = true;
+                startupError = error;
             }
+            // A successful sibling must finish acquiring resources before rollback releases them.
+            systemReady();
         }
 
         if (expectedReadyCount === 0) {
@@ -1117,8 +1120,8 @@ export class EntityManager {
      * @param {function} [errorCallback] Called when an error occurs during the shutdown process. defaults to console error output
      */
     shutdown(readyCallback = noop, errorCallback = console.error) {
-        if (this.state !== EntityManagerState.Running) {
-            throw new IllegalStateException(`System is wrong state, expected '${EntityManagerState.Running}'`);
+        if (this.state !== EntityManagerState.Running && this.state !== EntityManagerState.Failed) {
+            throw new IllegalStateException(`System is wrong state, expected Running or Failed`);
         }
 
         assert.isFunction(readyCallback, 'readyCallback');
@@ -1198,4 +1201,4 @@ EntityManager.prototype.detachDataSet = EntityManager.prototype.detachDataset;
 /**
  * @deprecated renamed to `update`
  */
-EntityManager.prototype.simulate = EntityManager.prototype.update
+EntityManager.prototype.simulate = EntityManager.prototype.update

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicRuleDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js"],"names":[],"mappings":"AAUA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,8BAAiB;IACjB;;;OAGG;IACH,kCAAc;IACd;;;OAGG;IACH,YAFU,mBAAmB,CAEb;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;IACb;;;OAGG;IACH,6BAAyB;IACzB;;;OAGG;IACH,kBAFU,8BAA8B,EAAE,CAEpB;IAEtB;;;;OAIG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,yCAEC;IAED,cA+BC;IAED;;;;;;aA2BC;CACJ;+CA1H8C,qCAAqC"}
+{"version":3,"file":"DynamicRuleDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js"],"names":[],"mappings":"AAUA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,8BAAiB;IACjB;;;OAGG;IACH,kCAAc;IACd;;;OAGG;IACH,YAFU,mBAAmB,CAEb;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;IACb;;;OAGG;IACH,6BAAyB;IACzB;;;OAGG;IACH,kBAFU,8BAA8B,EAAE,CAEpB;IAEtB;;;;OAIG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,yCAEC;IAED,cAgCC;IAED;;;;;;aA2BC;CACJ;+CA3H8C,qCAAqC"}

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js

@@ -52,7 +52,7 @@ export class DynamicRuleDescription {
      * @returns {boolean}
      */
     equals(other) {
-        return this.id.equals(other.id);
+        return this.id === other.id;
     }
 
     /**
@@ -68,6 +68,7 @@ export class DynamicRuleDescription {
     }
 
     build() {
+        this.predicate_complexity = 0;
 
         //infer types
         inferReactiveExpressionTypes(this.condition);

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicRuleDescriptionTable.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js"],"names":[],"mappings":"AAMA;;IAEI;;;;OAIG;IACH,yCAAsC;IAEtC;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,oDAFY,sBAAsB,EAAE,GAAC,SAAS,CAI7C;IAED;;;OAGG;IACH,kBAFY,uBAAuB,CAclC;IAED,mBA8BC;IAED;;;;OAIG;IACH,yBAFa,sBAAsB,GAAC,SAAS,CAmC5C;IAED;;;;OAIG;IACH,qBAFa,sBAAsB,EAAE,CAgCpC;IAED,oEAIC;IAED,yCAMC;CAEJ;yCA1KwC,yDAAyD;uCAC3D,6BAA6B;wCAF5B,uEAAuE"}
+{"version":3,"file":"DynamicRuleDescriptionTable.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js"],"names":[],"mappings":"AAMA;;IAEI;;;;OAIG;IACH,yCAAsC;IAEtC;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,oDAFY,sBAAsB,EAAE,GAAC,SAAS,CAI7C;IAED;;;OAGG;IACH,kBAFY,uBAAuB,CAclC;IAED,mBA+BC;IAED;;;;OAIG;IACH,yBAFa,sBAAsB,GAAC,SAAS,CAmC5C;IAED;;;;OAIG;IACH,qBAFa,sBAAsB,EAAE,CAgCpC;IAED,oEAIC;IAED,yCAMC;CAEJ;yCA3KwC,yDAAyD;uCAC3D,6BAA6B;wCAF5B,uEAAuE"}

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js

@@ -48,6 +48,7 @@ export class DynamicRuleDescriptionTable extends StaticKnowledgeDataTable {
     }
 
     buildIndex() {
+        this.__predicate_rule_mapping.clear();
 
         /**
          *

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":"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"}
+{"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,qBAwFd;IAED,oBAmCC;IAED;;;;;;OAMG;IACH,iBALW,gBAAgB,aAChB,WAAW,QACX,IAAI,UACJ,MAAM,QAQhB;CACJ;uBApLsB,cAAc;4BAKT,6BAA6B;iCAJxB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAMI,oDAAoD"}

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

@@ -46,6 +46,9 @@ export class FogOfWarRevealerSystem extends System {
         const visibilityTeam = this.team;
 
         function update() {
+            if (team.getValue() !== visibilityTeam) {
+                return;
+            }
             const dataset = em.dataset;
 
 

package/src/engine/ecs/parent/EntityNode.js

@@ -311,12 +311,12 @@ export class EntityNode {
             // wrote `parent` onto a detached instance. The node kept lifetime parentage with no
             // transform attachment, so it rendered at its raw Transform64 in world space.
             if (attachment === null) {
-                attachment = this.__safe_get_attachment();
-            } else {
-                this_entity.add(attachment);
+                attachment = new TransformAttachment();
+                attachment.setFlag(TransformAttachmentFlags.Immediate);
             }
 
             attachment.parent = parent_entity_id;
+            this_entity.add(attachment);
         }
     }
 

package/src/engine/ecs/speaker/VoiceSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AA0KA;IA2CI;;;;OAIG;IACH;;;OA8CC;IA7FD,+BAAuB;IACvB,gZAQE;IAEF;;;OAGG;IACH,0BAAmB;IAEnB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,4BAAa;IAEb;;;OAGG;IACH,8BAAY;IAEZ;;;;OAIG;IACH,iCAAqC;IAajC;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAkC;IAGlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAiIf;CACJ;sCA5cqC,oCAAoC;sBAKpD,YAAY;4BAFN,6BAA6B;4CAxBb,oDAAoD;uBAkBzE,sBAAsB;6BAEhB,qCAAqC;oCAG9B,gDAAgD;2BAJzD,8BAA8B;sCAJnB,wCAAwC;kCAP5C,sDAAsD"}
+{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AA0KA;IA2CI;;;;OAIG;IACH;;;OA8CC;IA7FD,+BAAuB;IACvB,gZAQE;IAEF;;;OAGG;IACH,0BAAmB;IAEnB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,4BAAa;IAEb;;;OAGG;IACH,8BAAY;IAEZ;;;;OAIG;IACH,iCAAqC;IAajC;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAkC;IAGlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QA0Bf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAiIf;CACJ;sCAhdqC,oCAAoC;sBAKpD,YAAY;4BAFN,6BAA6B;4CAxBb,oDAAoD;uBAkBzE,sBAAsB;6BAEhB,qCAAqC;oCAG9B,gDAAgD;2BAJzD,8BAA8B;sCAJnB,wCAAwC;kCAP5C,sDAAsD"}

package/src/engine/ecs/speaker/VoiceSystem.js

@@ -320,6 +320,10 @@ export class VoiceSystem extends AbstractContextSystem {
 
         const selected_line = weightedRandomFromArray(temp_lines, Math.random, this.__weigher.compute, this.__weigher, collected_count);
 
+        if (selected_line === undefined) {
+            return;
+        }
+
         this.sayLine(entity, selected_line.id, voice);
     }
 

package/src/engine/ecs/storage/BinaryBufferDeSerializer.js

@@ -113,11 +113,6 @@ function deserializeTask(
     function cycleFunction() {
         while (collectionDeSerializer.getElementIndex() >= collectionDeSerializer.getElementCount()) {
 
-            //finished current type
-            if (typesLeft === 0) {
-                return TaskSignal.EndSuccess;
-            }
-
             const previousClass = collectionDeSerializer.getElementClass();
 
             if (typesDecoded > 0) {
@@ -126,6 +121,11 @@ function deserializeTask(
                 collectionDeSerializer.finalize();
             }
 
+            //finished current type
+            if (typesLeft === 0) {
+                return TaskSignal.EndSuccess;
+            }
+
             typesDecoded++;
 
             //start next type

package/src/engine/ecs/storage/binary/BinarySerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinarySerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinarySerializationRegistry.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;GAKG;AACH;IAEI;;;;OAIG;IACH,2BAAsB;IACtB;;;;OAIG;IACH,6BAAwB;IAWxB;;;OAGG;IACH,2BAFW,qFAAiC,QAM3C;IAED;;;;;;OAMG;IACH,0HAJW,MAAM,GACJ,OAAO,CAyCnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,sFAAgC,SAAS,CA2BrD;IAED;;;;;;;OAOG;IACH,+BAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,sFAAgC,SAAS,CAMrD;IAED;;;;;OAKG;IACH,4BAJW,MAAM,YACN,mBAAmB,GACjB,OAAO,CA6CnB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,gBACN,MAAM,eACN,MAAM,GACJ,mBAAmB,EAAE,GAAC,IAAI,CA0DtC;IAIL;;;OAGG;IACH,wCAFU,OAAO,CAEkD;;CANlE;;kCArQY,OAAO,0BAA0B,EAAE,mBAAmB"}
+{"version":3,"file":"BinarySerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinarySerializationRegistry.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;GAKG;AACH;IAEI;;;;OAIG;IACH,2BAAsB;IACtB;;;;OAIG;IACH,6BAAwB;IAWxB;;;OAGG;IACH,2BAFW,qFAAiC,QAM3C;IAED;;;;;;OAMG;IACH,0HAJW,MAAM,GACJ,OAAO,CAyCnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,sFAAgC,SAAS,CA2BrD;IAED;;;;;;;OAOG;IACH,+BAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,sFAAgC,SAAS,CAMrD;IAED;;;;;OAKG;IACH,4BAJW,MAAM,YACN,mBAAmB,GACjB,OAAO,CA6CnB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,gBACN,MAAM,eACN,MAAM,GACJ,mBAAmB,EAAE,GAAC,IAAI,CA0DtC;IAIL;;;OAGG;IACH,wCAFU,OAAO,CAEkD;;CANlE;;kCArQY,OAAO,0BAA0B,EAAE,mBAAmB"}

package/src/engine/ecs/storage/binary/BinarySerializationRegistry.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../../core/assert.js";
+import { EdgeDirectionType } from "../../../../core/graph/Edge.js";
 import { Graph } from "../../../../core/graph/v2/Graph.js";
 
 /**
@@ -190,9 +191,9 @@ export class BinarySerializationRegistry {
             }
 
             if (u.getStartVersion() === upgrader.getTargetVersion()) {
-                classUpgraders.createEdge(u, upgrader);
+                classUpgraders.createEdge(upgrader, u, EdgeDirectionType.Forward);
             } else if (u.getTargetVersion() === upgrader.getStartVersion()) {
-                classUpgraders.createEdge(upgrader, u);
+                classUpgraders.createEdge(u, upgrader, EdgeDirectionType.Forward);
             }
         });
 

package/src/engine/ecs/storage/binary/object/BinaryObjectSerializationAdapter2.js

@@ -413,7 +413,7 @@ export class BinaryObjectSerializationAdapter2 {
             // reference to the schema else-where
             const schema_address = buffer.readUintVar();
 
-            record = this.#schema_table.getRecord(schema_address);
+            record = this.#schema_table.getSchemaAt(schema_address);
         }
 
         const typeName = record.typeName;

package/src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryObjectDeSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;GAYG;AACH;IA4BI;;;OAGG;IACH,6EAGC;IAED;;OAEG;IACH,yDAKC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;OAMG;IACH,uBAHW,YAAY,KAwCtB;IA0BD;;;;;;OAMG;IACH,uBAHW,YAAY,OAgDtB;IAoFL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;;CAN5D;;;;;;;cAvRa,MAAM;;;;aACN,MAAM;;;;aACN,kCAAgC,SAAS;;;;WACzC,WAAS,SAAS;;;;eAClB,qBAAqB,GAAC,IAAI;;;;uBAC1B,OAAO;;6BAjCQ,4CAA4C"}
+{"version":3,"file":"BinaryObjectDeSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;GAYG;AACH;IA4BI;;;OAGG;IACH,6EAGC;IAED;;OAEG;IACH,yDAKC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;OAMG;IACH,uBAHW,YAAY,KAwCtB;IA0BD;;;;;;OAMG;IACH,uBAHW,YAAY,OAgDtB;IA2FL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;;CAN5D;;;;;;;cA9Ra,MAAM;;;;aACN,MAAM;;;;aACN,kCAAgC,SAAS;;;;WACzC,WAAS,SAAS;;;;eAClB,qBAAqB,GAAC,IAAI;;;;uBAC1B,OAAO;;6BAjCQ,4CAA4C"}

package/src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.js

@@ -258,7 +258,14 @@ export class BinaryObjectDeSerializer {
         const names = this.#shapes[shapeIdx];
 
         for (let i = 0; i < names.length; i++) {
-            target[names[i]] = this.readValue(buffer);
+            const name = names[i];
+            const value = this.readValue(buffer);
+            if (name === "__proto__") {
+                // This wire-format field is own data, not a prototype setter.
+                Object.defineProperty(target, name, { value, writable: true, enumerable: true, configurable: true });
+            } else {
+                target[name] = value;
+            }
         }
 
         return target;

package/src/engine/ecs/storage/populateEngineSerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAmLA;;;;;;;;GAQG;AACH,iGA8GC"}
+{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAwLA;;;;;;;;GAQG;AACH,iGAiHC"}