@woosh/meep-engine 2.169.6 → 2.170.0

package/src/engine/network/sim/SmoothingState.js

@@ -1,222 +1,220 @@
-import { assert } from "../../../core/assert.js";
-import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { quat3_nlerp } from "../../../core/geom/3d/quaternion/quat3_nlerp.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
-import { v3_length } from "../../../core/geom/vec3/v3_length.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-
-/**
- * Visual smoothing for the divergence between predicted and authoritative state.
- *
- * After client reconciliation, the simulation position jumps to the
- * authoritative value. Without smoothing, this looks like a teleport. With
- * smoothing, we keep an `error` offset between the rendered position and the
- * simulation position; the error decays toward zero over a few frames, hiding
- * the snap.
- *
- * Algorithm (Glenn Fiedler, *State Synchronization*):
- *   - On reconciliation: `error += pre_correction_render_pos - post_correction_sim_pos`.
- *     The rendered position (simulation_pos + error) stays continuous across the jump.
- *   - Each frame: `error *= decay_factor(|error|)` where decay is adaptive —
- *     slow for small errors (smooth blend), fast for large errors (snappy).
- *
- * Per-entity state is stored sparsely in a `Map`. Entities not tracked have
- * implicit zero error.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-const POSITION_SMALL_THRESHOLD = 0.25;
-const POSITION_LARGE_THRESHOLD = 1.0;
-const FACTOR_SMALL = 0.95;
-const FACTOR_LARGE = 0.85;
-
-function position_decay_factor(magnitude) {
-    if (magnitude <= POSITION_SMALL_THRESHOLD) return FACTOR_SMALL;
-    if (magnitude >= POSITION_LARGE_THRESHOLD) return FACTOR_LARGE;
-    const t = (magnitude - POSITION_SMALL_THRESHOLD) / (POSITION_LARGE_THRESHOLD - POSITION_SMALL_THRESHOLD);
-    return FACTOR_SMALL + t * (FACTOR_LARGE - FACTOR_SMALL);
-}
-
-class EntitySmoothing {
-    constructor() {
-        this.position_error = new Vector3(0, 0, 0);
-        this.orientation_error = new Quaternion(0, 0, 0, 1);
-    }
-}
-
-export class SmoothingState {
-
-    /** @type {Map<number, EntitySmoothing>} @private */
-    #per_entity = new Map();
-
-    /**
-     * Begin tracking an entity. Initial error is zero.
-     * @param {number} entity_id
-     */
-    track(entity_id) {
-        assert.isNonNegativeInteger(entity_id, 'entity_id');
-        if (!this.#per_entity.has(entity_id)) {
-            this.#per_entity.set(entity_id, new EntitySmoothing());
-        }
-    }
-
-    /**
-     * Stop tracking an entity. Releases the stored error state.
-     * @param {number} entity_id
-     */
-    untrack(entity_id) {
-        assert.isNonNegativeInteger(entity_id, 'entity_id');
-        this.#per_entity.delete(entity_id);
-    }
-
-    /**
-     * Returns true if `entity_id` has tracked smoothing state.
-     * @param {number} entity_id
-     * @returns {boolean}
-     */
-    is_tracked(entity_id) {
-        return this.#per_entity.has(entity_id);
-    }
-
-    /**
-     * Apply a correction. Called when the simulation position has been snapped
-     * from `pre_render_pos` (the position the entity rendered at last frame,
-     * i.e. `sim_old + error_old`) to `post_correction_pos` (the new
-     * authoritative sim position). The error term absorbs the jump so the
-     * rendered position (`sim + error`) stays continuous.
-     *
-     * Note this is an assignment, not an accumulation: the prior error is
-     * already baked into `pre_render_pos`, so adding it again would
-     * double-count and drift visibly across successive corrections.
-     *
-     * @param {number} entity_id
-     * @param {Vector3|ArrayLike<number>} pre_render_pos position the entity was about to render at
-     * @param {Vector3|ArrayLike<number>} post_correction_pos the new authoritative simulation position
-     */
-    apply_position_correction(entity_id, pre_render_pos, post_correction_pos) {
-        assert.isNonNegativeInteger(entity_id, 'entity_id');
-        let s = this.#per_entity.get(entity_id);
-        if (s === undefined) {
-            s = new EntitySmoothing();
-            this.#per_entity.set(entity_id, s);
-        }
-        // error = pre - post (rendered = post + error = pre — continuous).
-        s.position_error[0] = pre_render_pos[0] - post_correction_pos[0];
-        s.position_error[1] = pre_render_pos[1] - post_correction_pos[1];
-        s.position_error[2] = pre_render_pos[2] - post_correction_pos[2];
-    }
-
-    /**
-     * Same as {@link apply_position_correction} but for orientation. Stores the
-     * relative rotation `pre_render_rot * inverse(post_correction_rot)` as the
-     * error quaternion so that the render path's `error * post == pre`
-     * invariant holds.
-     *
-     * Like position, this is an assignment: `pre_render_rot` already
-     * incorporates the prior error (it's the orientation the entity rendered
-     * at last frame), so composing with `error_old` again would double-count
-     * and drift across successive corrections.
-     *
-     * @param {number} entity_id
-     * @param {Quaternion|ArrayLike<number>} pre_render_rot
-     * @param {Quaternion|ArrayLike<number>} post_correction_rot
-     */
-    apply_orientation_correction(entity_id, pre_render_rot, post_correction_rot) {
-        assert.isNonNegativeInteger(entity_id, 'entity_id');
-        let s = this.#per_entity.get(entity_id);
-        if (s === undefined) {
-            s = new EntitySmoothing();
-            this.#per_entity.set(entity_id, s);
-        }
-        // error = pre * inverse(post). With render = error * post, this
-        // satisfies render = pre — continuous across the correction.
-        // `post` is a unit quaternion, so its inverse is its conjugate:
-        // negate the vector part and hand the pair to the shared product.
-        quat3_multiply(
-            s.orientation_error, 0,
-            pre_render_rot[0], pre_render_rot[1], pre_render_rot[2], pre_render_rot[3],
-            -post_correction_rot[0], -post_correction_rot[1], -post_correction_rot[2], post_correction_rot[3],
-        );
-    }
-
-    /**
-     * Decay both error terms toward zero. Position uses adaptive decay
-     * (slow for small errors, fast for large); orientation uses a flat
-     * decay matching the position decay at the current position-error magnitude.
-     *
-     * Should be called once per render frame for each tracked entity.
-     *
-     * @param {number} entity_id
-     */
-    decay(entity_id) {
-        assert.isNonNegativeInteger(entity_id, 'entity_id');
-        const s = this.#per_entity.get(entity_id);
-        if (s === undefined) return;
-
-        const ex = s.position_error[0], ey = s.position_error[1], ez = s.position_error[2];
-        const magnitude = v3_length(ex, ey, ez);
-        const factor = position_decay_factor(magnitude);
-
-        s.position_error[0] = ex * factor;
-        s.position_error[1] = ey * factor;
-        s.position_error[2] = ez * factor;
-
-        // Orientation: nlerp toward identity by `1 - factor`, so `factor` of the
-        // error survives — the same easing the position error just got.
-        //
-        // The sign flip is applied to the error term rather than left to
-        // `quat3_nlerp`'s own hemisphere check: the primitive would flip the
-        // *other* operand (identity), which names the same rotation but stores
-        // the whole result negated. Pre-flipping keeps `w` non-negative, so the
-        // stored error stays in the hemisphere the decay walks toward.
-        const qw = s.orientation_error[3];
-        const sign = qw < 0 ? -1 : 1;
-
-        quat3_nlerp(
-            s.orientation_error, 0,
-            s.orientation_error[0] * sign, s.orientation_error[1] * sign, s.orientation_error[2] * sign, qw * sign,
-            0, 0, 0, 1,
-            1 - factor,
-        );
-    }
-
-    /**
-     * Get the render position by adding the error term to the simulation position.
-     *
-     * @param {number} entity_id
-     * @param {Vector3|ArrayLike<number>} sim_pos input
-     * @param {Vector3|ArrayLike<number>} out_pos output (mutated)
-     */
-    render_position(entity_id, sim_pos, out_pos) {
-        const s = this.#per_entity.get(entity_id);
-        if (s === undefined) {
-            out_pos[0] = sim_pos[0];
-            out_pos[1] = sim_pos[1];
-            out_pos[2] = sim_pos[2];
-        } else {
-            out_pos[0] = sim_pos[0] + s.position_error[0];
-            out_pos[1] = sim_pos[1] + s.position_error[1];
-            out_pos[2] = sim_pos[2] + s.position_error[2];
-        }
-    }
-
-    /**
-     * Direct access to the per-entity error terms (or undefined if not tracked).
-     *
-     * @param {number} entity_id
-     * @returns {{position_error: Vector3, orientation_error: Quaternion}|undefined}
-     */
-    state_for(entity_id) {
-        return this.#per_entity.get(entity_id);
-    }
-
-    /**
-     * Number of tracked entities.
-     * @returns {number}
-     */
-    tracked_count() {
-        return this.#per_entity.size;
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_nlerp } from "../../../core/geom/3d/quaternion/quat3_nlerp.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+
+/**
+ * Visual smoothing for the divergence between predicted and authoritative state.
+ *
+ * After client reconciliation, the simulation position jumps to the
+ * authoritative value. Without smoothing, this looks like a teleport. With
+ * smoothing, we keep an `error` offset between the rendered position and the
+ * simulation position; the error decays toward zero over a few frames, hiding
+ * the snap.
+ *
+ * Algorithm (Glenn Fiedler, *State Synchronization*):
+ *   - On reconciliation: `error += pre_correction_render_pos - post_correction_sim_pos`.
+ *     The rendered position (simulation_pos + error) stays continuous across the jump.
+ *   - Each frame: `error *= decay_factor(|error|)` where decay is adaptive —
+ *     slow for small errors (smooth blend), fast for large errors (snappy).
+ *
+ * Per-entity state is stored sparsely in a `Map`. Entities not tracked have
+ * implicit zero error.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+const POSITION_SMALL_THRESHOLD = 0.25;
+const POSITION_LARGE_THRESHOLD = 1.0;
+const FACTOR_SMALL = 0.95;
+const FACTOR_LARGE = 0.85;
+
+function position_decay_factor(magnitude) {
+    if (magnitude <= POSITION_SMALL_THRESHOLD) return FACTOR_SMALL;
+    if (magnitude >= POSITION_LARGE_THRESHOLD) return FACTOR_LARGE;
+    const t = (magnitude - POSITION_SMALL_THRESHOLD) / (POSITION_LARGE_THRESHOLD - POSITION_SMALL_THRESHOLD);
+    return FACTOR_SMALL + t * (FACTOR_LARGE - FACTOR_SMALL);
+}
+
+class EntitySmoothing {
+    position_error = new Vector3(0, 0, 0);
+    orientation_error = new Quaternion(0, 0, 0, 1);
+}
+
+export class SmoothingState {
+
+    /** @type {Map<number, EntitySmoothing>} @private */
+    #per_entity = new Map();
+
+    /**
+     * Begin tracking an entity. Initial error is zero.
+     * @param {number} entity_id
+     */
+    track(entity_id) {
+        assert.isNonNegativeInteger(entity_id, 'entity_id');
+        if (!this.#per_entity.has(entity_id)) {
+            this.#per_entity.set(entity_id, new EntitySmoothing());
+        }
+    }
+
+    /**
+     * Stop tracking an entity. Releases the stored error state.
+     * @param {number} entity_id
+     */
+    untrack(entity_id) {
+        assert.isNonNegativeInteger(entity_id, 'entity_id');
+        this.#per_entity.delete(entity_id);
+    }
+
+    /**
+     * Returns true if `entity_id` has tracked smoothing state.
+     * @param {number} entity_id
+     * @returns {boolean}
+     */
+    is_tracked(entity_id) {
+        return this.#per_entity.has(entity_id);
+    }
+
+    /**
+     * Apply a correction. Called when the simulation position has been snapped
+     * from `pre_render_pos` (the position the entity rendered at last frame,
+     * i.e. `sim_old + error_old`) to `post_correction_pos` (the new
+     * authoritative sim position). The error term absorbs the jump so the
+     * rendered position (`sim + error`) stays continuous.
+     *
+     * Note this is an assignment, not an accumulation: the prior error is
+     * already baked into `pre_render_pos`, so adding it again would
+     * double-count and drift visibly across successive corrections.
+     *
+     * @param {number} entity_id
+     * @param {Vector3|ArrayLike<number>} pre_render_pos position the entity was about to render at
+     * @param {Vector3|ArrayLike<number>} post_correction_pos the new authoritative simulation position
+     */
+    apply_position_correction(entity_id, pre_render_pos, post_correction_pos) {
+        assert.isNonNegativeInteger(entity_id, 'entity_id');
+        let s = this.#per_entity.get(entity_id);
+        if (s === undefined) {
+            s = new EntitySmoothing();
+            this.#per_entity.set(entity_id, s);
+        }
+        // error = pre - post (rendered = post + error = pre — continuous).
+        s.position_error[0] = pre_render_pos[0] - post_correction_pos[0];
+        s.position_error[1] = pre_render_pos[1] - post_correction_pos[1];
+        s.position_error[2] = pre_render_pos[2] - post_correction_pos[2];
+    }
+
+    /**
+     * Same as {@link apply_position_correction} but for orientation. Stores the
+     * relative rotation `pre_render_rot * inverse(post_correction_rot)` as the
+     * error quaternion so that the render path's `error * post == pre`
+     * invariant holds.
+     *
+     * Like position, this is an assignment: `pre_render_rot` already
+     * incorporates the prior error (it's the orientation the entity rendered
+     * at last frame), so composing with `error_old` again would double-count
+     * and drift across successive corrections.
+     *
+     * @param {number} entity_id
+     * @param {Quaternion|ArrayLike<number>} pre_render_rot
+     * @param {Quaternion|ArrayLike<number>} post_correction_rot
+     */
+    apply_orientation_correction(entity_id, pre_render_rot, post_correction_rot) {
+        assert.isNonNegativeInteger(entity_id, 'entity_id');
+        let s = this.#per_entity.get(entity_id);
+        if (s === undefined) {
+            s = new EntitySmoothing();
+            this.#per_entity.set(entity_id, s);
+        }
+        // error = pre * inverse(post). With render = error * post, this
+        // satisfies render = pre — continuous across the correction.
+        // `post` is a unit quaternion, so its inverse is its conjugate:
+        // negate the vector part and hand the pair to the shared product.
+        quat3_multiply(
+            s.orientation_error, 0,
+            pre_render_rot[0], pre_render_rot[1], pre_render_rot[2], pre_render_rot[3],
+            -post_correction_rot[0], -post_correction_rot[1], -post_correction_rot[2], post_correction_rot[3],
+        );
+    }
+
+    /**
+     * Decay both error terms toward zero. Position uses adaptive decay
+     * (slow for small errors, fast for large); orientation uses a flat
+     * decay matching the position decay at the current position-error magnitude.
+     *
+     * Should be called once per render frame for each tracked entity.
+     *
+     * @param {number} entity_id
+     */
+    decay(entity_id) {
+        assert.isNonNegativeInteger(entity_id, 'entity_id');
+        const s = this.#per_entity.get(entity_id);
+        if (s === undefined) return;
+
+        const ex = s.position_error[0], ey = s.position_error[1], ez = s.position_error[2];
+        const magnitude = v3_length(ex, ey, ez);
+        const factor = position_decay_factor(magnitude);
+
+        s.position_error[0] = ex * factor;
+        s.position_error[1] = ey * factor;
+        s.position_error[2] = ez * factor;
+
+        // Orientation: nlerp toward identity by `1 - factor`, so `factor` of the
+        // error survives — the same easing the position error just got.
+        //
+        // The sign flip is applied to the error term rather than left to
+        // `quat3_nlerp`'s own hemisphere check: the primitive would flip the
+        // *other* operand (identity), which names the same rotation but stores
+        // the whole result negated. Pre-flipping keeps `w` non-negative, so the
+        // stored error stays in the hemisphere the decay walks toward.
+        const qw = s.orientation_error[3];
+        const sign = qw < 0 ? -1 : 1;
+
+        quat3_nlerp(
+            s.orientation_error, 0,
+            s.orientation_error[0] * sign, s.orientation_error[1] * sign, s.orientation_error[2] * sign, qw * sign,
+            0, 0, 0, 1,
+            1 - factor,
+        );
+    }
+
+    /**
+     * Get the render position by adding the error term to the simulation position.
+     *
+     * @param {number} entity_id
+     * @param {Vector3|ArrayLike<number>} sim_pos input
+     * @param {Vector3|ArrayLike<number>} out_pos output (mutated)
+     */
+    render_position(entity_id, sim_pos, out_pos) {
+        const s = this.#per_entity.get(entity_id);
+        if (s === undefined) {
+            out_pos[0] = sim_pos[0];
+            out_pos[1] = sim_pos[1];
+            out_pos[2] = sim_pos[2];
+        } else {
+            out_pos[0] = sim_pos[0] + s.position_error[0];
+            out_pos[1] = sim_pos[1] + s.position_error[1];
+            out_pos[2] = sim_pos[2] + s.position_error[2];
+        }
+    }
+
+    /**
+     * Direct access to the per-entity error terms (or undefined if not tracked).
+     *
+     * @param {number} entity_id
+     * @returns {{position_error: Vector3, orientation_error: Quaternion}|undefined}
+     */
+    state_for(entity_id) {
+        return this.#per_entity.get(entity_id);
+    }
+
+    /**
+     * Number of tracked entities.
+     * @returns {number}
+     */
+    tracked_count() {
+        return this.#per_entity.size;
+    }
+}

package/src/engine/network/sim/SpeculationLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpeculationLog.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SpeculationLog.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAaI;;;OAGG;IACH,sBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,OAAO,CAKnB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ,OAAO,CAKnB;IAED;;OAEG;IACH,qBAFa,MAAM,CAIlB;IAED;;OAEG;IACH,cAEC;;CACJ"}
+{"version":3,"file":"SpeculationLog.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SpeculationLog.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAQI;;;OAGG;IACH,sBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,OAAO,CAKnB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ,OAAO,CAKnB;IAED;;OAEG;IACH,qBAFa,MAAM,CAIlB;IAED;;OAEG;IACH,cAEC;;CACJ"}

package/src/engine/network/sim/SpeculationLog.js

@@ -1,84 +1,79 @@
-import { assert } from "../../../core/assert.js";
-
-/**
- * Tracks the boundary between confirmed and speculative frames.
- *
- * A frame is **confirmed** if its actions have been acknowledged by the
- * authoritative source (server, or remote peer in P2P) — meaning the frame
- * cannot be rewound away. A frame is **speculative** if it's been predicted
- * locally but not yet acked.
- *
- * Used for:
- *   - **Side-effect gating.** One-shot effects (sounds, particle bursts,
- *     scene transitions, brutalities) should only fire from confirmed frames;
- *     speculative frames may be rolled back, and re-firing the effect on
- *     replay produces the same audio/VFX glitch the MK X postmortem warned
- *     about.
- *   - **Garbage collection of action-log frames.** Frames at or below the
- *     confirmed boundary will not be rewound to, so their action records
- *     can be dropped from the ring once they fall out of the per-peer
- *     baseline window too.
- *
- * Implementation is intentionally trivial: a single monotonic counter.
- * Frames `<= confirmed_through` are confirmed; frames `> confirmed_through`
- * are speculative. There is no per-frame metadata.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class SpeculationLog {
-    #confirmed_through;
-
-
-    constructor() {
-        /**
-         * The most recent frame known to be confirmed. -1 if no frame has been confirmed yet.
-         * @type {number}
-         * @private
-         */
-        this.#confirmed_through = -1;
-    }
-
-    /**
-     * Advance the confirmed boundary. Monotonic: setting an older frame is a no-op.
-     * @param {number} frame
-     */
-    mark_confirmed(frame) {
-        assert.isNonNegativeInteger(frame, 'frame');
-        if (frame > this.#confirmed_through) {
-            this.#confirmed_through = frame;
-        }
-    }
-
-    /**
-     * @param {number} frame
-     * @returns {boolean}
-     */
-    is_confirmed(frame) {
-        assert.isInteger(frame, 'frame');
-        return frame <= this.#confirmed_through;
-    }
-
-    /**
-     * @param {number} frame
-     * @returns {boolean}
-     */
-    is_speculative(frame) {
-        assert.isInteger(frame, 'frame');
-        return frame > this.#confirmed_through;
-    }
-
-    /**
-     * @returns {number} the most recent confirmed frame, or -1 if none
-     */
-    confirmed_through() {
-        return this.#confirmed_through;
-    }
-
-    /**
-     * Reset the log (e.g. on disconnect).
-     */
-    reset() {
-        this.#confirmed_through = -1;
-    }
-}
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Tracks the boundary between confirmed and speculative frames.
+ *
+ * A frame is **confirmed** if its actions have been acknowledged by the
+ * authoritative source (server, or remote peer in P2P) — meaning the frame
+ * cannot be rewound away. A frame is **speculative** if it's been predicted
+ * locally but not yet acked.
+ *
+ * Used for:
+ *   - **Side-effect gating.** One-shot effects (sounds, particle bursts,
+ *     scene transitions, brutalities) should only fire from confirmed frames;
+ *     speculative frames may be rolled back, and re-firing the effect on
+ *     replay produces the same audio/VFX glitch the MK X postmortem warned
+ *     about.
+ *   - **Garbage collection of action-log frames.** Frames at or below the
+ *     confirmed boundary will not be rewound to, so their action records
+ *     can be dropped from the ring once they fall out of the per-peer
+ *     baseline window too.
+ *
+ * Implementation is intentionally trivial: a single monotonic counter.
+ * Frames `<= confirmed_through` are confirmed; frames `> confirmed_through`
+ * are speculative. There is no per-frame metadata.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SpeculationLog {
+    /**
+     * The most recent frame known to be confirmed. -1 if no frame has been confirmed yet.
+     * @type {number}
+     * @private
+     */
+    #confirmed_through = -1;
+
+    /**
+     * Advance the confirmed boundary. Monotonic: setting an older frame is a no-op.
+     * @param {number} frame
+     */
+    mark_confirmed(frame) {
+        assert.isNonNegativeInteger(frame, 'frame');
+        if (frame > this.#confirmed_through) {
+            this.#confirmed_through = frame;
+        }
+    }
+
+    /**
+     * @param {number} frame
+     * @returns {boolean}
+     */
+    is_confirmed(frame) {
+        assert.isInteger(frame, 'frame');
+        return frame <= this.#confirmed_through;
+    }
+
+    /**
+     * @param {number} frame
+     * @returns {boolean}
+     */
+    is_speculative(frame) {
+        assert.isInteger(frame, 'frame');
+        return frame > this.#confirmed_through;
+    }
+
+    /**
+     * @returns {number} the most recent confirmed frame, or -1 if none
+     */
+    confirmed_through() {
+        return this.#confirmed_through;
+    }
+
+    /**
+     * Reset the log (e.g. on disconnect).
+     */
+    reset() {
+        this.#confirmed_through = -1;
+    }
+}

package/src/engine/network/state/Baseline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Baseline.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/Baseline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IAaI;;;;;;OAMG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFoB,MAAM,QAAE,MAAM,KAAG,IAAI,QAKxC;;CACJ"}
+{"version":3,"file":"Baseline.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/Baseline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IAQI;;;;;;OAMG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFoB,MAAM,QAAE,MAAM,KAAG,IAAI,QAKxC;;CACJ"}