@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/interpolation/TransformPoseSerializationAdapter.js

@@ -1,8 +1,8 @@
 import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 
 /**
- * Full-precision (Float64) pose serializer for {@link Transform}: position +
+ * Full-precision (Float64) pose serializer for {@link Transform64}: position +
  * rotation only (the physics integrator never changes scale, so it's left to
  * the live component). 7 × Float64 = 56 bytes.
  *
@@ -20,28 +20,27 @@ import { Transform } from "../ecs/transform/Transform.js";
  */
 export class TransformPoseSerializationAdapter extends BinaryClassSerializationAdapter {
 
-    klass = Transform;
+    klass = Transform64;
     version = 0;
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     serialize(buffer, transform) {
-        const p = transform.position;
         const r = transform.rotation;
-        buffer.writeFloat64(p.x);
-        buffer.writeFloat64(p.y);
-        buffer.writeFloat64(p.z);
-        buffer.writeFloat64(r.x);
-        buffer.writeFloat64(r.y);
-        buffer.writeFloat64(r.z);
-        buffer.writeFloat64(r.w);
+        buffer.writeFloat64(transform.translation_x);
+        buffer.writeFloat64(transform.translation_y);
+        buffer.writeFloat64(transform.translation_z);
+        buffer.writeFloat64(r[0]);
+        buffer.writeFloat64(r[1]);
+        buffer.writeFloat64(r[2]);
+        buffer.writeFloat64(r[3]);
     }
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     deserialize(buffer, transform) {
         const px = buffer.readFloat64();
@@ -51,7 +50,7 @@ export class TransformPoseSerializationAdapter extends BinaryClassSerializationA
         const ry = buffer.readFloat64();
         const rz = buffer.readFloat64();
         const rw = buffer.readFloat64();
-        transform.position.set(px, py, pz);
-        transform.rotation.set(rx, ry, rz, rw);
+        transform.setTranslation(px, py, pz);
+        transform.setRotation(rx, ry, rz, rw);
     }
 }

package/src/engine/interpolation/pose_interpoland.d.ts

@@ -1,5 +1,5 @@
 /**
- * Interpolation-log type id for the {@link Transform} pose interpoland. Type ids
+ * Interpolation-log type id for the {@link Transform64} pose interpoland. Type ids
  * distinguish interpoland kinds under one entity key; pose is the first (0).
  * When more kinds land, an interpolation registry should assign these so they
  * can't collide. (For replicated entities this must eventually align with the
@@ -8,7 +8,7 @@
  */
 export const POSE_TYPE_ID: number;
 /**
- * Shared, stateless pose interpoland: blend a body's {@link Transform} position
+ * Shared, stateless pose interpoland: blend a body's {@link Transform64} position
  * + rotation. Reused across every entity that interpolates its pose — a body
  * opting in carries an `Interpolated` whose `interpolands` is `[POSE_INTERPOLAND]`.
  * @type {Interpoland}

package/src/engine/interpolation/pose_interpoland.js

@@ -1,10 +1,10 @@
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { Interpoland } from "./Interpoland.js";
 import { PoseInterpolationAdapter } from "./PoseInterpolationAdapter.js";
 import { TransformPoseSerializationAdapter } from "./TransformPoseSerializationAdapter.js";
 
 /**
- * Interpolation-log type id for the {@link Transform} pose interpoland. Type ids
+ * Interpolation-log type id for the {@link Transform64} pose interpoland. Type ids
  * distinguish interpoland kinds under one entity key; pose is the first (0).
  * When more kinds land, an interpolation registry should assign these so they
  * can't collide. (For replicated entities this must eventually align with the
@@ -14,14 +14,14 @@ import { TransformPoseSerializationAdapter } from "./TransformPoseSerializationA
 export const POSE_TYPE_ID = 0;
 
 /**
- * Shared, stateless pose interpoland: blend a body's {@link Transform} position
+ * Shared, stateless pose interpoland: blend a body's {@link Transform64} position
  * + rotation. Reused across every entity that interpolates its pose — a body
  * opting in carries an `Interpolated` whose `interpolands` is `[POSE_INTERPOLAND]`.
  * @type {Interpoland}
  */
 export const POSE_INTERPOLAND = new Interpoland(
     POSE_TYPE_ID,
-    Transform,
+    Transform64,
     new TransformPoseSerializationAdapter(),
     new PoseInterpolationAdapter(),
 );

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts

@@ -2,7 +2,7 @@ export default PathFollowingSystem;
 declare class PathFollowingSystem extends System<any> {
     constructor();
     dependencies: (typeof PathFollower)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof PathFollower> | ResourceAccessSpecification<typeof Path>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof PathFollower> | ResourceAccessSpecification<typeof Path>)[];
     /**
      *
      * @type {number}
@@ -12,15 +12,15 @@ declare class PathFollowingSystem extends System<any> {
     /**
      *
      * @param {PathFollower} pathFollower
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {Path} path
      * @param {number} entity Entity ID
      */
-    __visit_entity(pathFollower: PathFollower, transform: Transform, path: Path, entity: number): void;
+    __visit_entity(pathFollower: PathFollower, transform: Transform64, path: Path, entity: number): void;
 }
 import { System } from '../../../ecs/System.js';
 import PathFollower from './PathFollower.js';
-import { Transform } from '../../../ecs/transform/Transform.js';
+import { Transform64 } from '../../../ecs/transform/Transform64.js';
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import Path from '../components/Path.js';
 //# sourceMappingURL=PathFollowingSystem.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;;IACI,sCAA8B;IAC9B,iKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBA9KsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}
+{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAiJA;;IACI,sCAA8B;IAC9B,mKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,WAAW,QACX,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBAvMsB,wBAAwB;yBAGtB,mBAAmB;4BAFhB,uCAAuC;4CAFvB,uDAAuD;iBAGlF,uBAAuB"}

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.js

@@ -4,11 +4,16 @@ import { min2 } from "../../../../core/math/min2.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../../ecs/System.js';
-import { Transform } from '../../../ecs/transform/Transform.js';
+import { Transform64 } from '../../../ecs/transform/Transform64.js';
 import Path from '../components/Path.js';
 import PathFollower from './PathFollower.js';
 import { PathFollowerEventType } from "./PathFollowerEventType.js";
 import { PathFollowerFlags } from "./PathFollowerFlags.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+
+const scratch_towards = new Quaternion();
+
+const scratch_forward = new Float64Array(3);
 
 const v3_forward = new Vector3();
 const v3_temp1 = new Vector3();
@@ -18,7 +23,7 @@ const scratch_quaternion = new Quaternion();
  *
  * @param {PathFollower} pathFollower
  * @param {Path} path
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} timeDelta
  */
 function performStep(pathFollower, path, transform, timeDelta) {
@@ -60,16 +65,16 @@ function performStep(pathFollower, path, transform, timeDelta) {
             pathFollower.position = next_offset_truncated;
         }
 
-        const position = transform.position;
+        const position = transform.translation;
 
         if (!pathFollower.getFlag(PathFollowerFlags.WritePositionX)) {
-            nextPosition.setX(position.x);
+            nextPosition.setX(position[0]);
         }
         if (!pathFollower.getFlag(PathFollowerFlags.WritePositionY)) {
-            nextPosition.setY(position.y);
+            nextPosition.setY(position[1]);
         }
         if (!pathFollower.getFlag(PathFollowerFlags.WritePositionZ)) {
-            nextPosition.setZ(position.z);
+            nextPosition.setZ(position[2]);
         }
 
         if (!nextPosition.equals(position)) {
@@ -84,13 +89,21 @@ function performStep(pathFollower, path, transform, timeDelta) {
                 // TODO we can extract tangent and normal from the path itself, no need to do euler approximation
 
                 //compute old facing direction vector
-                v3_forward.copy(Vector3.forward);
+                v3_quaternion_apply(
+                    scratch_forward, 0,
+                    Vector3.forward.x, Vector3.forward.y, Vector3.forward.z,
+                    transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
+                );
 
-                v3_forward.applyQuaternion(transform.rotation);
+                v3_forward.set(scratch_forward[0], scratch_forward[1], scratch_forward[2]);
 
                 const positionDelta = v3_temp2;
 
-                positionDelta.subVectors(nextPosition, oldPosition);
+                positionDelta.set(
+                    nextPosition[0] - oldPosition[0],
+                    nextPosition[1] - oldPosition[1],
+                    nextPosition[2] - oldPosition[2]
+                );
 
                 if (!alignment_x) {
                     positionDelta.x = v3_forward.x;
@@ -109,10 +122,22 @@ function performStep(pathFollower, path, transform, timeDelta) {
                 // console.log("Angular limit:", angularLimit, positionDelta.toJSON());
 
                 scratch_quaternion.lookRotation(positionDelta);
-                transform.rotation.rotateTowards(scratch_quaternion,angularLimit);
+                scratch_towards.set(
+                    transform.rotation_x, transform.rotation_y,
+                    transform.rotation_z, transform.rotation_w
+                );
+                scratch_towards.rotateTowards(scratch_quaternion, angularLimit);
+
+                transform.setRotation(
+                    scratch_towards.x, scratch_towards.y, scratch_towards.z, scratch_towards.w
+                );
+
+                transform.updateMatrix();
             }
 
-            position.copy(nextPosition);
+            position[0] = nextPosition[0];
+            position[1] = nextPosition[1];
+            position[2] = nextPosition[2];
         }
 
     }
@@ -122,7 +147,7 @@ class PathFollowingSystem extends System {
     dependencies = [PathFollower];
     components_used = [
         ResourceAccessSpecification.from(PathFollower, ResourceAccessKind.Read | ResourceAccessKind.Write),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read | ResourceAccessKind.Write),
         ResourceAccessSpecification.from(Path, ResourceAccessKind.Read),
     ];
 
@@ -136,7 +161,7 @@ class PathFollowingSystem extends System {
     /**
      *
      * @param {PathFollower} pathFollower
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {Path} path
      * @param {number} entity Entity ID
      */
@@ -174,7 +199,7 @@ class PathFollowingSystem extends System {
         const dataset = entityManager.dataset;
 
         if (dataset !== null) {
-            dataset.traverseEntities([PathFollower, Transform, Path], this.__visit_entity, this);
+            dataset.traverseEntities([PathFollower, Transform64, Path], this.__visit_entity, this);
         }
     }
 }

package/src/engine/network/adapters/TransformReplicationAdapter.d.ts

@@ -1,5 +1,5 @@
 /**
- * Network-replication adapter for {@link Transform}. Mirrors
+ * Network-replication adapter for {@link Transform64}. Mirrors
  * {@link TransformSerializationAdapter} but uses Float32 for position instead
  * of Float64, halving the per-component cost (12 B vs 24 B) for a precision
  * loss that is below visible threshold for typical action-game scales.
@@ -19,18 +19,18 @@
  */
 export class TransformReplicationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
-    klass: typeof Transform;
+    klass: typeof Transform64;
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
-    serialize(buffer: BinaryBuffer, value: Transform): void;
+    serialize(buffer: BinaryBuffer, value: Transform64): void;
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
-    deserialize(buffer: BinaryBuffer, value: Transform): void;
+    deserialize(buffer: BinaryBuffer, value: Transform64): void;
 }
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 //# sourceMappingURL=TransformReplicationAdapter.d.ts.map

package/src/engine/network/adapters/TransformReplicationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,wBAAkB;IAGlB;;;OAGG;IACH,uCAFW,SAAS,QAoBnB;IAED;;;OAGG;IACH,yCAFW,SAAS,QAmBnB;CACJ;gDAlF+C,6DAA6D;0BACnF,kCAAkC"}
+{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,0BAAoB;IAGpB;;;OAGG;IACH,uCAFW,WAAW,QAgBrB;IAED;;;OAGG;IACH,yCAFW,WAAW,QAsBrB;CACJ;gDAjF+C,6DAA6D;4BACjF,oCAAoC"}

package/src/engine/network/adapters/TransformReplicationAdapter.js

@@ -3,7 +3,7 @@ import { quat3_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat3_e
 import { v3_binary_equality_decode } from "../../../core/geom/vec3/serialization/v3_binary_equality_decode.js";
 import { v3_binary_equality_encode } from "../../../core/geom/vec3/serialization/v3_binary_equality_encode.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 
 /**
  * Decode scratch for {@link TransformReplicationAdapter#deserialize}. Decoders
@@ -15,7 +15,7 @@ import { Transform } from "../../ecs/transform/Transform.js";
 const decode_scratch = new Float32Array(4);
 
 /**
- * Network-replication adapter for {@link Transform}. Mirrors
+ * Network-replication adapter for {@link Transform64}. Mirrors
  * {@link TransformSerializationAdapter} but uses Float32 for position instead
  * of Float64, halving the per-component cost (12 B vs 24 B) for a precision
  * loss that is below visible threshold for typical action-game scales.
@@ -35,36 +35,32 @@ const decode_scratch = new Float32Array(4);
  */
 export class TransformReplicationAdapter extends BinaryClassSerializationAdapter {
 
-    klass = Transform;
+    klass = Transform64;
     version = 1;
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
     serialize(buffer, value) {
 
-        const position = value.position;
-        const rotation = value.rotation;
-        const scale = value.scale;
-
-        buffer.writeFloat32(position.x);
-        buffer.writeFloat32(position.y);
-        buffer.writeFloat32(position.z);
+        buffer.writeFloat32(value.translation_x);
+        buffer.writeFloat32(value.translation_y);
+        buffer.writeFloat32(value.translation_z);
 
         buffer.writeUint32(quat3_encode_to_uint32(
-            rotation.x,
-            rotation.y,
-            rotation.z,
-            rotation.w
+            value.rotation_x,
+            value.rotation_y,
+            value.rotation_z,
+            value.rotation_w
         ));
 
-        v3_binary_equality_encode(buffer, scale.x, scale.y, scale.z);
+        v3_binary_equality_encode(buffer, value.scale_x, value.scale_y, value.scale_z);
     }
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
     deserialize(buffer, value) {
 
@@ -77,11 +73,14 @@ export class TransformReplicationAdapter extends BinaryClassSerializationAdapter
         const s = decode_scratch;
 
         v3_binary_equality_decode(buffer, s, 0);
-        value.scale.set(s[0], s[1], s[2]);
+        value.setScale(s[0], s[1], s[2]);
 
         quat3_decode_from_uint32(s, 0, encoded_rotation);
-        value.rotation.set(s[0], s[1], s[2], s[3]);
+        value.setRotation(s[0], s[1], s[2], s[3]);
+
+        value.setTranslation(positionX, positionY, positionZ);
 
-        value.position.set(positionX, positionY, positionZ);
+        // rotation and scale both moved, so the matrix owes an update before anyone reads it
+        value.updateMatrix();
     }
 }

package/src/engine/network/orchestrator/ServerAuthoritativeClient.d.ts

@@ -18,6 +18,19 @@
  *    {@link onReplay} handler re-executes the same SimActions the original
  *    predict path produced.
  *
+ *  - A replay also reapplies the records in the rewound window that ARRIVED
+ *    from a peer, which {@link onReplay} cannot: it re-executes this client's
+ *    own input, and the AUTH_STATE that precedes it carries one `network_id`.
+ *    Without this step a rewind about one entity discards the owner's published
+ *    state for every OTHER entity in the window — permanently, for anything
+ *    published on change rather than every frame, because nothing re-sends it
+ *    and nothing else restores it. This is the client half of the rule
+ *    `SimAction` states and `ServerAuthoritativeServer.#read_historical`
+ *    implements: a record's `sender_id` says whether it arrived, was authored,
+ *    or was derived, and a replay reapplies the first two and recomputes the
+ *    third. Here the authored half is `onReplay`'s job and the arrived half is
+ *    this one's.
+ *
  *  - A no-op short-circuit is built in: before doing the rewind+replay, the
  *    orchestrator gives the user a chance to compute what the replay WOULD
  *    produce via {@link onComputeExpected}; if that matches the current
@@ -75,6 +88,20 @@ export class ServerAuthoritativeClient {
     reconcile_count: number;
     /** @type {number} */
     replay_frame_count: number;
+    /**
+     * Records that arrived from a peer and were reapplied by a replay, over the
+     * life of this client. Zero on a client whose peers publish nothing the
+     * rewind window covers; non-zero is the fix for the discard above doing
+     * work, and is what a test can assert on rather than inferring from a value.
+     * @type {number}
+     */
+    replayed_arrived_count: number;
+    /**
+     * Reconciliations abandoned because the action log no longer held the frames
+     * the rewind needed. See {@link onReconcileAbandoned}.
+     * @type {number}
+     */
+    reconcile_abandoned_count: number;
     /** @type {NetworkPeer} */
     peer: NetworkPeer;
     /** @type {EntityComponentDataset} */
@@ -199,6 +226,26 @@ export class ServerAuthoritativeClient {
      * @type {Signal}
      */
     onReconcileComplete: Signal;
+    /**
+     * Fires when a reconciliation is abandoned because the action log no
+     * longer holds the frames its rewind needed. Args:
+     * `(server_frame, network_id)`.
+     *
+     * This is a real loss of replicated state and not a hiccup: state a peer
+     * does not own reaches it on the action stream, and an owner that
+     * publishes on change never sends it again — so whatever that window
+     * carried for every entity other than `network_id` is gone. The server
+     * would normally back-fill via `RECOVERY_REQUEST`/`STATE_BURST`, which
+     * is request-driven, so something has to know to ask. That is what this
+     * signal is for; {@link reconcile_abandoned_count} is the same event as
+     * a counter.
+     *
+     * A client seeing this repeatedly is running further ahead of the server
+     * frame than its `frame_capacity` covers.
+     *
+     * @type {Signal}
+     */
+    onReconcileAbandoned: Signal;
     /**
      * Connect to a server peer over a transport.
      * @param {number} peer_id
@@ -262,4 +309,5 @@ import { InputRing } from "../state/InputRing.js";
 import { RewindEngine } from "../sim/RewindEngine.js";
 import { TimeDilation } from "../time/TimeDilation.js";
 import Signal from "../../../core/events/signal/Signal.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 //# sourceMappingURL=ServerAuthoritativeClient.d.ts.map

package/src/engine/network/orchestrator/ServerAuthoritativeClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAsBI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iOAxBW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,aAAiB,CAAC,EAAE,YAAY,CAAC;QACjC,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EA6LH;IAjND,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAyCnB,0BAA0B;IAC1B,MADW,WAAW,CAUpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAClC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAEhD;;;;OAIG;IACH,YAFU,SAAS,CAKjB;IAEF,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;OAKG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;;OAKG;IACH,eAFU,YAAY,CAEY;IAElC;;;;OAIG;IACH,mBAFU,MAAM,CAEW;IAE3B;;;;;;;;OAQG;IACH,iBAFU,MAAM,CAEU;IAO1B;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;;;OASG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAQ3C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;OAUG;IACH,oBAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,gBAKhB;IAiFD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BA7a2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBAJnC,uCAAuC"}
+{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA8DI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iOAxBW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,aAAiB,CAAC,EAAE,YAAY,CAAC;QACjC,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EAqNH;IAzPD,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAEvB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,2BAFU,MAAM,CAEc;IAyC1B,0BAA0B;IAC1B,MADW,WAAW,CAUpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAClC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAEhD;;;;OAIG;IACH,YAFU,SAAS,CAKjB;IAEF,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;OAKG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;;OAKG;IACH,eAFU,YAAY,CAEY;IAElC;;;;OAIG;IACH,mBAFU,MAAM,CAEW;IAE3B;;;;;;;;OAQG;IACH,iBAFU,MAAM,CAEU;IAO1B;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;;;OASG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAEvC;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAFU,MAAM,CAEwB;IAW5C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;OAUG;IACH,oBAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,GACJ,YAAY,CAIxB;IA6OD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BA9pB2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBALnC,uCAAuC;6BAF7B,sCAAsC"}