@woosh/meep-engine 2.168.1 → 2.169.0

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.js

@@ -69,62 +69,70 @@ export function computeSignedDistanceField_Chamfer(source, distanceField, emptyV
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++) {
 
-            const v = getD(x, y);
+            // each candidate must be compared against the running minimum, not
+            // against the value the cell started with -- otherwise the *last*
+            // candidate that beat the original wins instead of the smallest.
+            // Accumulating and writing once is also fewer stores than before.
+            let best = getD(x, y);
 
             const v0 = getD(x - 1, y - 1) + d2;
 
-            if (v0 < v) {
-                setD(x, y, v0);
+            if (v0 < best) {
+                best = v0;
             }
 
             const v1 = getD(x, y - 1) + d1;
 
-            if (v1 < v) {
-                setD(x, y, v1);
+            if (v1 < best) {
+                best = v1;
             }
 
             const v2 = getD(x + 1, y - 1) + d2;
 
-            if (v2 < v) {
-                setD(x, y, v2);
+            if (v2 < best) {
+                best = v2;
             }
 
             const v3 = getD(x - 1, y) + d1;
 
-            if (v3 < v) {
-                setD(x, y, v3);
+            if (v3 < best) {
+                best = v3;
             }
+
+            setD(x, y, best);
         }
     }
 
     //second pass (backward)
     for (y = maxY; y >= 0; y--) {
         for (x = maxX; x >= 0; x--) {
-            const v = getD(x, y);
+            let best = getD(x, y);
 
             const v0 = getD(x + 1, y) + d1;
 
-            if (v0 < v) {
-                setD(x, y, v0);
+            if (v0 < best) {
+                best = v0;
             }
 
             const v1 = getD(x - 1, y + 1) + d2;
 
-            if (v1 < v) {
-                setD(x, y, v1);
+            if (v1 < best) {
+                best = v1;
             }
 
             const v2 = getD(x, y + 1) + d1;
 
-            if (v2 < v) {
-                setD(x, y, v2);
+            if (v2 < best) {
+                best = v2;
             }
 
             const v3 = getD(x + 1, y + 1) + d2;
 
-            if (v3 < v) {
-                setD(x, y, v3);
+            if (v3 < best) {
+                best = v3;
             }
+
+            setD(x, y, best);
         }
     }
 

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.d.ts

@@ -1,9 +1,22 @@
 /**
+ * Separable gaussian blur.
+ *
+ * `size` is the full footprint width in pixels: every output pixel is gathered
+ * from `[-size/2, +size/2]` around itself along each axis, at `sample_count`
+ * evenly spaced taps. `quality` scales the tap count, trading cost against
+ * sampling density; it leaves both the footprint and the standard deviation in
+ * pixels unchanged.
+ *
+ * Below `quality = 1` the taps are spaced more than a pixel apart, so detail
+ * finer than that spacing aliases — an isolated bright pixel gets smeared into
+ * a ring of tap-spaced echoes rather than a smooth falloff. On smooth input the
+ * result is indistinguishable from the fully sampled filter, which is what the
+ * setting is for; do not turn it down on input with isolated highlights.
  *
  * @param {Sampler2D} output
  * @param {Sampler2D} input
- * @param {number} size
- * @param {number} [quality]
+ * @param {number} size footprint width, in pixels
+ * @param {number} [quality] taps per pixel of footprint; 1 gives roughly one tap per pixel
  */
 export function sampler2d_blur_gaussian(output: Sampler2D, input: Sampler2D, size: number, quality?: number): void;
 import { Sampler2D } from "../Sampler2D.js";

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_blur_gaussian.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,gDALW,SAAS,SACT,SAAS,QACT,MAAM,YACN,MAAM,QAoFhB;0BA9FyB,iBAAiB"}
+{"version":3,"file":"sampler2d_blur_gaussian.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDALW,SAAS,SACT,SAAS,QACT,MAAM,YACN,MAAM,QAiGhB;0BAxHyB,iBAAiB"}

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js

@@ -7,17 +7,43 @@ import { Sampler2D } from "../Sampler2D.js";
 let temp_data = new Float64Array(1);
 
 /**
+ * Separable gaussian blur.
+ *
+ * `size` is the full footprint width in pixels: every output pixel is gathered
+ * from `[-size/2, +size/2]` around itself along each axis, at `sample_count`
+ * evenly spaced taps. `quality` scales the tap count, trading cost against
+ * sampling density; it leaves both the footprint and the standard deviation in
+ * pixels unchanged.
+ *
+ * Below `quality = 1` the taps are spaced more than a pixel apart, so detail
+ * finer than that spacing aliases — an isolated bright pixel gets smeared into
+ * a ring of tap-spaced echoes rather than a smooth falloff. On smooth input the
+ * result is indistinguishable from the fully sampled filter, which is what the
+ * setting is for; do not turn it down on input with isolated highlights.
  *
  * @param {Sampler2D} output
  * @param {Sampler2D} input
- * @param {number} size
- * @param {number} [quality]
+ * @param {number} size footprint width, in pixels
+ * @param {number} [quality] taps per pixel of footprint; 1 gives roughly one tap per pixel
  */
 export function sampler2d_blur_gaussian(output, input, size, quality = 1) {
 
-    const sigma = size * 3;
     const sample_count = max2(3, nextOdd(Math.round(size * quality)));
 
+    // `build_gaussian_kernel_1d` places taps one unit apart, so its sigma is in
+    // TAP units, whereas the footprint is in pixels -- the two are related by
+    // `local_u_scale` below. Working in tap units, the outermost tap sits at
+    // (sample_count - 1) / 2, and we want the kernel truncated there at three
+    // standard deviations: beyond 3 sigma a gaussian carries ~0.3% of its mass,
+    // so cutting it there is visually lossless while keeping the taps busy.
+    //
+    // This previously read `size * 3`, which is the same expression with the
+    // ratio inverted and the wrong unit. That put every tap inside ±(1/6) of a
+    // standard deviation, where a gaussian is flat: the outermost tap carried
+    // ~99% of the weight of the centre one, so the filter was a box blur and
+    // `size` had no influence on the shape of the falloff at all.
+    const sigma = (sample_count - 1) / 6;
+
     const kernel = new Float32Array(sample_count);
 
     build_gaussian_kernel_1d(kernel, sample_count, sigma);

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.d.ts

@@ -1,5 +1,15 @@
 /**
- * Good for down-sampling
+ * Good for down-sampling.
+ *
+ * The kernel is separable and evaluated in destination-pixel units: a source
+ * texel's distance from the destination pixel's centre is divided by the
+ * scaling ratio, which is what stretches the filter's support to cover the
+ * whole footprint being averaged.
+ *
+ * Negative lobes are kept. They are the entire point of Lanczos -- discarding
+ * them removes the sharpening and, when every sample in the footprint happens
+ * to land in a negative lobe, leaves a zero weight sum and a NaN result.
+ *
  * @param {Sampler2D} source
  * @param {Sampler2D} destination
  * @param {number} [lobes]

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_scale_down_lanczos.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.js"],"names":[],"mappings":"AAkEA;;;;;GAKG;AACH,gGAFW,MAAM,QAoGhB"}
+{"version":3,"file":"sampler2d_scale_down_lanczos.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH,gGAFW,MAAM,QA8GhB"}

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.js

@@ -1,171 +1,158 @@
-import { max2 } from "../../../../../core/math/max2.js";
-import { min2 } from "../../../../../core/math/min2.js";
-
-
-/**
- * @see https://en.wikipedia.org/wiki/Lanczos_resampling
- * Calculate lanczos weight
- * @param {number} x
- * @param {number} lobes
- * @returns {number}
- */
-function lanczos(x, lobes) {
-
-    /*
-    // not needed in our case, as X is always positive
-    if (x < 0) {
-        x = -x;
-    }
-
-     */
-
-    if (x > lobes) {
-        return 0;
-    }
-
-    if (x < 1.1920929e-7) {
-        return 1;
-    }
-
-    x *= Math.PI;
-
-    const xx = x / lobes;
-
-    return (Math.sin(x) / x) * Math.sin(xx) / (xx);
-}
-
-/**
- * Original formulation version from wiki
- * @see https://en.wikipedia.org/wiki/Lanczos_resampling
- * Calculate lanczos weight
- * @param {number} x
- * @param {number} lobes
- * @returns {number}
- */
-function lanczos_orig(x, lobes) {
-
-    /*
-    // not needed in our case, as X is always positive
-    if (x < 0) {
-        x = -x;
-    }
-
-     */
-
-    if (x > lobes) {
-        return 0;
-    }
-
-    if (x < 1.1920929e-7) {
-        return 1;
-    }
-
-    return (lobes * Math.sin(Math.PI * x) * Math.sin(Math.PI * x / lobes)) / (Math.PI * Math.PI * x * x);
-}
-
-
-/**
- * Good for down-sampling
- * @param {Sampler2D} source
- * @param {Sampler2D} destination
- * @param {number} [lobes]
- */
-export function sampler2d_scale_down_lanczos(source, destination, lobes = 2) {
-
-    const d_w = destination.width;
-    const d_h = destination.height;
-
-    const item_size = destination.itemSize;
-
-    const source_width = source.width;
-    const source_height = source.height;
-
-    if (source_width < d_w || source_height < d_h) {
-        throw new Error('Invalid scale, source is larger than destination in at least 1 dimension');
-    }
-
-    const source_data = source.data;
-    const destination_data = destination.data;
-
-    const ratio_x = source_width / d_w;
-    const ratio_y = source_height / d_h;
-
-    const rcp_ratio_y = 2 / ratio_y;
-    const rcp_ratio_x = 2 / ratio_x;
-
-
-    const range2_x = Math.ceil(ratio_x * lobes * 0.5);
-    const range2_y = Math.ceil(ratio_y * lobes * 0.5);
-
-    const sample = new Array(item_size);
-
-    let v, u, i, j, k;
-
-    for (v = 0; v < d_h; v++) {
-
-        const center_y = (v + 0.5) * ratio_y;
-        const i_center_y = Math.floor(center_y);
-        //
-        const source_y0 = max2(0, i_center_y - range2_y);
-        const source_y1 = min2(i_center_y + range2_y, source_height - 1);
-
-        for (u = 0; u < d_w; u++) {
-            const center_x = (u + 0.5) * ratio_x;
-            const i_center_x = Math.floor(center_x);
-
-            const source_x0 = max2(i_center_x - range2_x, 0);
-            const source_x1 = min2(i_center_x + range2_x, source_width - 1);
-
-            let weight_sum = 0;
-            // reset sample
-            for (i = 0; i < item_size; i++) {
-                sample[i] = 0;
-            }
-
-            for (j = source_y0; j <= source_y1; j++) {
-
-                const f_y = (j - center_y);
-
-                const f_y_rcp = f_y * rcp_ratio_y;
-                const f_y_rcp2 = f_y_rcp * f_y_rcp;
-
-                for (i = source_x0; i <= source_x1; i++) {
-
-                    const f_x = (i - center_x);
-
-                    const f_x_rcp = f_x * rcp_ratio_x;
-                    const f_x_rcp2 = f_x_rcp * f_x_rcp;
-
-                    const distance_from_center_sqr = f_x_rcp2 + f_y_rcp2;
-                    const distance_from_center = Math.sqrt(distance_from_center_sqr);
-
-                    const weight = lanczos(distance_from_center, lobes);
-
-                    if (weight <= 0) {
-                        continue;
-                    }
-
-                    weight_sum += weight;
-
-                    const source_texel_address = (j * source_width + i) * item_size;
-
-                    for (k = 0; k < item_size; k++) {
-                        sample[k] += weight * source_data[source_texel_address + k];
-                    }
-
-                }
-            }
-
-
-            // dilute sample and write to destination
-            const inv_z = 1 / weight_sum;
-
-            const texel_address = (v * d_w + u) * item_size;
-
-            for (i = 0; i < item_size; i++) {
-                destination_data[texel_address + i] = sample[i] * inv_z;
-            }
-        }
-    }
-
-}
+import { max2 } from "../../../../../core/math/max2.js";
+import { min2 } from "../../../../../core/math/min2.js";
+
+
+/**
+ * @see https://en.wikipedia.org/wiki/Lanczos_resampling
+ * Calculate lanczos weight. `x` may be negative; the kernel is even.
+ * @param {number} x
+ * @param {number} lobes
+ * @returns {number}
+ */
+function lanczos(x, lobes) {
+
+    if (x < 0) {
+        x = -x;
+    }
+
+    if (x >= lobes) {
+        return 0;
+    }
+
+    if (x < 1.1920929e-7) {
+        return 1;
+    }
+
+    const pix = x * Math.PI;
+
+    const pix_over_a = pix / lobes;
+
+    return (Math.sin(pix) / pix) * (Math.sin(pix_over_a) / pix_over_a);
+}
+
+
+/**
+ * Good for down-sampling.
+ *
+ * The kernel is separable and evaluated in destination-pixel units: a source
+ * texel's distance from the destination pixel's centre is divided by the
+ * scaling ratio, which is what stretches the filter's support to cover the
+ * whole footprint being averaged.
+ *
+ * Negative lobes are kept. They are the entire point of Lanczos -- discarding
+ * them removes the sharpening and, when every sample in the footprint happens
+ * to land in a negative lobe, leaves a zero weight sum and a NaN result.
+ *
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ * @param {number} [lobes]
+ */
+export function sampler2d_scale_down_lanczos(source, destination, lobes = 2) {
+
+    const d_w = destination.width;
+    const d_h = destination.height;
+
+    const item_size = destination.itemSize;
+
+    const source_width = source.width;
+    const source_height = source.height;
+
+    if (source_width < d_w || source_height < d_h) {
+        throw new Error('Invalid scale, source is larger than destination in at least 1 dimension');
+    }
+
+    const source_data = source.data;
+    const destination_data = destination.data;
+
+    const ratio_x = source_width / d_w;
+    const ratio_y = source_height / d_h;
+
+    const inv_ratio_x = 1 / ratio_x;
+    const inv_ratio_y = 1 / ratio_y;
+
+    // support of the kernel measured in source texels
+    const range_x = Math.ceil(lobes * ratio_x);
+    const range_y = Math.ceil(lobes * ratio_y);
+
+    const sample = new Array(item_size);
+
+    const weights_x = new Float64Array(range_x * 2 + 2);
+
+    for (let v = 0; v < d_h; v++) {
+
+        // centre of this destination pixel, expressed in source texels
+        const center_y = (v + 0.5) * ratio_y;
+
+        const source_y0 = max2(0, Math.floor(center_y - range_y));
+        const source_y1 = min2(Math.ceil(center_y + range_y), source_height - 1);
+
+        for (let u = 0; u < d_w; u++) {
+
+            const center_x = (u + 0.5) * ratio_x;
+
+            const source_x0 = max2(0, Math.floor(center_x - range_x));
+            const source_x1 = min2(Math.ceil(center_x + range_x), source_width - 1);
+
+            // horizontal weights are the same for every row of this column
+            for (let i = source_x0; i <= source_x1; i++) {
+                weights_x[i - source_x0] = lanczos((i + 0.5 - center_x) * inv_ratio_x, lobes);
+            }
+
+            let weight_sum = 0;
+
+            for (let i = 0; i < item_size; i++) {
+                sample[i] = 0;
+            }
+
+            for (let j = source_y0; j <= source_y1; j++) {
+
+                const weight_y = lanczos((j + 0.5 - center_y) * inv_ratio_y, lobes);
+
+                if (weight_y === 0) {
+                    continue;
+                }
+
+                const row_address = j * source_width;
+
+                for (let i = source_x0; i <= source_x1; i++) {
+
+                    const weight = weights_x[i - source_x0] * weight_y;
+
+                    if (weight === 0) {
+                        continue;
+                    }
+
+                    weight_sum += weight;
+
+                    const source_texel_address = (row_address + i) * item_size;
+
+                    for (let k = 0; k < item_size; k++) {
+                        sample[k] += weight * source_data[source_texel_address + k];
+                    }
+                }
+            }
+
+            const texel_address = (v * d_w + u) * item_size;
+
+            if (weight_sum === 0) {
+                // the footprint contributed nothing; copy the nearest texel
+                // rather than emitting NaN
+                const nearest = (min2(Math.floor(center_y), source_height - 1) * source_width
+                    + min2(Math.floor(center_x), source_width - 1)) * item_size;
+
+                for (let i = 0; i < item_size; i++) {
+                    destination_data[texel_address + i] = source_data[nearest + i];
+                }
+
+                continue;
+            }
+
+            const inv_z = 1 / weight_sum;
+
+            for (let i = 0; i < item_size; i++) {
+                destination_data[texel_address + i] = sample[i] * inv_z;
+            }
+        }
+    }
+
+}

package/src/engine/graphics/texture/sampler/sampler2d_paint.js

@@ -65,7 +65,7 @@ export function sampler2d_paint(
 
             destination.read(d_x, d_y, c0);
 
-            const s_x = Math.round(x + sourceY);
+            const s_x = Math.round(x + sourceX);
             const s_y = Math.round(y + sourceY);
 
             source.read(s_x, s_y, c1);

package/src/engine/graphics/texture/sampler/util/bitSet2Sampler2D.js

@@ -32,9 +32,9 @@ export function bitSet2Sampler2D(source, target, vTrue, vFalse) {
             const flag = source.get(cellIndex);
 
             if (flag) {
-                target.set(x, y, vTrue);
+                target.write(x, y, vTrue);
             } else {
-                target.set(x, y, vFalse);
+                target.write(x, y, vFalse);
             }
         }
     }

package/src/engine/input/ecs/util/TopDownCameraControllerHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopDownCameraControllerHelper.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/util/TopDownCameraControllerHelper.js"],"names":[],"mappings":";AA2CA,+GAmCC;mBA5EkB,wBAAwB"}
+{"version":3,"file":"TopDownCameraControllerHelper.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/util/TopDownCameraControllerHelper.js"],"names":[],"mappings":";AAkDA,+GAmCC;mBA5EkB,wBAAwB"}

package/src/engine/input/ecs/util/TopDownCameraControllerHelper.js

@@ -1,4 +1,11 @@
-import { Group as ThreeGroup, Matrix4 as ThreeMatrix4, Mesh as ThreeMesh, MeshLambertMaterial } from 'three';
+import {
+    CylinderGeometry as ThreeCylinderGeometry,
+    Group as ThreeGroup,
+    Matrix4 as ThreeMatrix4,
+    Mesh as ThreeMesh,
+    MeshLambertMaterial,
+    SphereGeometry as ThreeSphereGeometry
+} from 'three';
 import Vector3 from '../../../../core/geom/Vector3.js';
 import Entity from '../../../ecs/Entity.js';
 import Renderable from '../../../ecs/renderable/Renderable.js';
@@ -42,8 +49,8 @@ const lookAt = (function () {
     return lookAt;
 })();
 const TopDownCameraControllerHelper = function (targetController, targetTransform, size) {
-    const tMarkerFromGeometry = new CylinderGeometry(0, size * 0.5, size, 10, 1);
-    const tMarkerToGeometry = new SphereGeometry(size / 2, 32, 32);
+    const tMarkerFromGeometry = new ThreeCylinderGeometry(0, size * 0.5, size, 10, 1);
+    const tMarkerToGeometry = new ThreeSphereGeometry(size / 2, 32, 32);
 
     const matrix4 = new ThreeMatrix4();
     matrix4.makeRotationX(-Math.PI / 2);

package/src/engine/navigation/ecs/components/PathSerializationUpgrader_2_3.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Version 3 did not change the wire layout -- it is byte-for-byte what
+ * {@link PathSerializationUpgrader_1_2} already emits, and what the current
+ * adapter reads. The bump was made without adding this step, which left every
+ * save written at version 2 or earlier with no path to the current version:
+ * the registry finds no chain and the component cannot be loaded at all.
+ *
+ * Carry the payload across unchanged.
+ */
+export class PathSerializationUpgrader_2_3 extends BinaryClassUpgrader {
+    upgrade(source: any, target: any): void;
+}
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=PathSerializationUpgrader_2_3.d.ts.map

package/src/engine/navigation/ecs/components/PathSerializationUpgrader_2_3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathSerializationUpgrader_2_3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/PathSerializationUpgrader_2_3.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAQI,wCAiBC;CACJ;oCArCmC,oDAAoD"}

package/src/engine/navigation/ecs/components/PathSerializationUpgrader_2_3.js

@@ -0,0 +1,38 @@
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+
+/**
+ * Version 3 did not change the wire layout -- it is byte-for-byte what
+ * {@link PathSerializationUpgrader_1_2} already emits, and what the current
+ * adapter reads. The bump was made without adding this step, which left every
+ * save written at version 2 or earlier with no path to the current version:
+ * the registry finds no chain and the component cannot be loaded at all.
+ *
+ * Carry the payload across unchanged.
+ */
+export class PathSerializationUpgrader_2_3 extends BinaryClassUpgrader {
+    constructor() {
+        super();
+
+        this.__startVersion = 2;
+        this.__targetVersion = 3;
+    }
+
+    upgrade(source, target) {
+        const interpolation = source.readUint8();
+
+        const numPoints = source.readUintVar();
+        const elementsPerPoint = source.readUintVar();
+
+        const point_data_size = numPoints * elementsPerPoint;
+        const point_data = new Float32Array(point_data_size);
+
+        source.readFloat32Array(point_data, 0, point_data_size);
+
+        target.writeUint8(interpolation);
+
+        target.writeUintVar(numPoints);
+        target.writeUintVar(elementsPerPoint);
+
+        target.writeFloat32Array(point_data, 0, point_data_size);
+    }
+}

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":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAOI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2MApBW;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;KAC9B,EAkMH;IA7KG,0BAA0B;IAC1B,MADW,WAAW,CASpB;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;IAO1C,qBAAqB;IACrB,iBADW,MAAM,CACO;IACxB,qBAAqB;IACrB,oBADW,MAAM,CACU;IAE3B;;;;;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;4BAla2B,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":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAeI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2MApBW;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;KAC9B,EAiMH;IA5KG,0BAA0B;IAC1B,MADW,WAAW,CASpB;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;IAM1C,qBAAqB;IACrB,iBADW,MAAM,CACO;IACxB,qBAAqB;IACrB,oBADW,MAAM,CACU;IAE3B;;;;;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;4BAza2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBAJnC,uCAAuC"}