@woosh/meep-engine 2.146.0 → 2.147.0

package/src/engine/interpolation/InterpolationSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAEI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAmDvE;IA9CG,sCAAkC;IAElC,oEAEC;IAED;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;;OAKG;IACH,mBAA2B;IAE3B;;;;OAIG;IACH,kBAAmC;IAGnC;;;;;;;OAOG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,yBAAiC;IAGrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAI7D;IAED;;OAEG;IACH,qDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAShB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAIhB;IAED,sBA0FC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;uBA/NsB,kBAAkB;6BAEyC,mBAAmB;4CAHzD,iDAAiD;iCAE5D,uBAAuB"}

package/src/engine/interpolation/InterpolationSystem.js

@@ -0,0 +1,233 @@
+import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
+import { ResourceAccessKind } from "../../core/model/ResourceAccessKind.js";
+import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
+import { System } from "../ecs/System.js";
+import { InterpolationLog } from "./InterpolationLog.js";
+import { Interpolated, INTERPOLATION_KEY_UNSET, INTERPOLATION_SOURCE_LOCAL } from "./Interpolated.js";
+
+/**
+ * Render-time consumer of the interpolation log. Runs in {@link update} (the
+ * variable-rate, render-loop-driven cycle): for every {@link Interpolated}
+ * entity it blends each interpoland between the last two completed fixed ticks
+ * by the current fixed-step alpha and writes the result into the live target
+ * component (e.g. {@link Transform}). Because it writes the live component, all
+ * Transform-linked machinery (culling, particles, trails, attachments) renders
+ * the smoothed pose.
+ *
+ * Producers (physics, network) record authoritative per-tick snapshots into
+ * {@link log}; this system only consumes. Cost is O(entities × interpolands),
+ * and producers record only for things that moved, so the log stays sparse.
+ *
+ * For a LOCAL entity (the default), tick + alpha come from the simulation hub:
+ * `entityManager.fixedStepTick` is the latest completed fixed step and
+ * `entityManager.getFixedStepAlpha()` is the sub-step fraction, blending
+ * `(fixedStepTick - 1, fixedStepTick)` from this system's own log.
+ *
+ * An entity may instead carry a non-default {@link Interpolated#sourceId} naming
+ * a timeline registered via {@link registerSource} (the log + window provider
+ * live on the system, not the component) — e.g. a networked entity blended on
+ * the network's render-delayed playout. The same render pass then drives both
+ * local and remote entities, so a mixed scene is coherent; each source is
+ * sampled once per frame.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class InterpolationSystem extends System {
+
+    /**
+     * @param {{ buffer_capacity_bytes?: number, records_capacity?: number }} [options]
+     */
+    constructor({ buffer_capacity_bytes = 65536, records_capacity = 4096 } = {}) {
+        super();
+
+        this.dependencies = [Interpolated];
+
+        this.components_used = [
+            ResourceAccessSpecification.from(Interpolated, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ];
+
+        /**
+         * Shared per-tick snapshot store. Producers record into it; this system
+         * blends from it.
+         * @type {InterpolationLog}
+         */
+        this.log = new InterpolationLog({ buffer_capacity_bytes, records_capacity });
+
+        /**
+         * Linked entities → their {@link Interpolated} component. Iterated each
+         * update.
+         * @private
+         * @type {Map<number, Interpolated>}
+         */
+        this.__entities = new Map();
+
+        /**
+         * Reusable decode buffer for blended snapshots.
+         * @private
+         * @type {BinaryBuffer}
+         */
+        this.__scratch = new BinaryBuffer();
+        this.__scratch.fromArrayBuffer(new ArrayBuffer(256));
+
+        /**
+         * Non-local timeline registry, keyed by `sourceId`. Each entry is the
+         * timeline's `{ log, sample() }` — its log to read and a per-frame window
+         * provider. Owners (e.g. the network layer) register here; the
+         * {@link Interpolated} component only carries the integer id.
+         * @private
+         * @type {Map<number, { log: InterpolationLog, sample: () => { tick_a: number, tick_b: number, t: number } }>}
+         */
+        this.__sources = new Map();
+
+        /**
+         * Per-update cache of `sourceId → window`, so a source's playout is
+         * sampled once per frame, not once per entity. Cleared each update.
+         * @private
+         * @type {Map<number, { tick_a: number, tick_b: number, t: number }>}
+         */
+        this.__source_windows = new Map();
+    }
+
+    /**
+     * Register a non-local interpolation timeline under `sourceId`. Entities
+     * carrying that id on their {@link Interpolated} component are blended from
+     * `log` on the window `sample()` returns (sampled once per render frame).
+     * Used by timeline owners — e.g. the network layer registers its
+     * render-delayed playout. `sourceId` must not be
+     * {@link INTERPOLATION_SOURCE_LOCAL} (reserved for the local clock).
+     *
+     * @param {number} sourceId
+     * @param {InterpolationLog} log
+     * @param {() => { tick_a: number, tick_b: number, t: number }} sample
+     */
+    registerSource(sourceId, log, sample) {
+        this.__sources.set(sourceId, { log, sample });
+    }
+
+    /**
+     * @param {EntityManager} entityManager
+     */
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+    }
+
+    /**
+     * @param {Interpolated} interpolated
+     * @param {number} entity
+     */
+    link(interpolated, entity) {
+        if (interpolated.key === INTERPOLATION_KEY_UNSET) {
+            // Default identity: the entity id. A producer (e.g. the network
+            // layer) may have set a network_id already, in which case we keep it.
+            interpolated.key = entity;
+        }
+        this.__entities.set(entity, interpolated);
+    }
+
+    /**
+     * @param {Interpolated} interpolated
+     * @param {number} entity
+     */
+    unlink(interpolated, entity) {
+        this.__entities.delete(entity);
+    }
+
+    update(dt) {
+        const entities = this.__entities;
+        if (entities.size === 0) {
+            return;
+        }
+
+        const em = this.entityManager;
+        const dataset = (em !== null && em !== undefined) ? em.dataset : null;
+        if (dataset === null || dataset === undefined) {
+            return;
+        }
+
+        const scratch = this.__scratch;
+
+        // Default (local) timeline: blend the last two completed fixed steps at
+        // the sub-step alpha, reading this system's own log.
+        const local_log = this.log;
+        const local_tick_b = em.fixedStepTick;
+        const local_tick_a = local_tick_b - 1;
+        const local_t = em.getFixedStepAlpha();
+
+        // A non-local source's playout window is sampled once per frame.
+        const source_windows = this.__source_windows;
+        source_windows.clear();
+
+        for (const [entity, interpolated] of entities) {
+            const key = interpolated.key;
+            if (key === INTERPOLATION_KEY_UNSET) {
+                continue;
+            }
+
+            if (interpolated.snap) {
+                // Teleport / wake: the live components already hold the
+                // authoritative pose (set by setPose, or the body's own pose on
+                // wake), which isn't in the log as the latest two ticks yet.
+                // Leave them untouched this frame so we don't slide across the
+                // jump; resume interpolating next frame.
+                interpolated.snap = false;
+                continue;
+            }
+
+            // Pick the timeline by id: the default local fixed-step clock, or a
+            // registered non-local source (e.g. the network playout).
+            let log, tick_a, tick_b, t;
+            const source_id = interpolated.sourceId;
+            if (source_id === INTERPOLATION_SOURCE_LOCAL) {
+                log = local_log;
+                tick_a = local_tick_a;
+                tick_b = local_tick_b;
+                t = local_t;
+            } else {
+                const src = this.__sources.get(source_id);
+                if (src === undefined) {
+                    continue; // unregistered source — nothing to read
+                }
+                log = src.log;
+                let win = source_windows.get(source_id);
+                if (win === undefined) {
+                    win = src.sample();
+                    source_windows.set(source_id, win);
+                }
+                tick_a = win.tick_a;
+                tick_b = win.tick_b;
+                t = win.t;
+            }
+
+            const interpolands = interpolated.interpolands;
+            const n = interpolands.length;
+            for (let i = 0; i < n; i++) {
+                const interpoland = interpolands[i];
+
+                scratch.position = 0;
+                const ok = log.interpolate(
+                    scratch, key, interpoland.type_id, tick_a, tick_b, t, interpoland.interpolation_adapter
+                );
+                if (!ok) {
+                    // Neither tick carries this interpoland — leave the live
+                    // component untouched.
+                    continue;
+                }
+
+                const target = dataset.getComponent(entity, interpoland.component_class);
+                if (target === undefined || target === null) {
+                    continue;
+                }
+
+                scratch.position = 0;
+                interpoland.serialization_adapter.deserialize(scratch, target);
+            }
+        }
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+InterpolationSystem.prototype.isInterpolationSystem = true;

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

@@ -0,0 +1,17 @@
+/**
+ * Linear-blend interpolator matching {@link TransformPoseSerializationAdapter}'s
+ * layout (7 × Float64: position xyz + rotation xyzw). Position lerps
+ * componentwise; rotation nlerps with shortest-arc correction and renormalize.
+ *
+ * `first_offset === second_offset` reduces to the input at any `t` (the
+ * snap-to-single-snapshot case the log relies on), with no special handling.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
+    /** @inheritdoc */
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+}
+import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
+//# sourceMappingURL=PoseInterpolationAdapter.d.ts.map

package/src/engine/interpolation/PoseInterpolationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoseInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/PoseInterpolationAdapter.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IAEI,kBAAkB;IAClB,+FA2CC;CACJ;2CA5D0C,iCAAiC"}

package/src/engine/interpolation/PoseInterpolationAdapter.js

@@ -0,0 +1,61 @@
+import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
+
+/**
+ * Linear-blend interpolator matching {@link TransformPoseSerializationAdapter}'s
+ * layout (7 × Float64: position xyz + rotation xyzw). Position lerps
+ * componentwise; rotation nlerps with shortest-arc correction and renormalize.
+ *
+ * `first_offset === second_offset` reduces to the input at any `t` (the
+ * snap-to-single-snapshot case the log relies on), with no special handling.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
+
+    /** @inheritdoc */
+    interpolate(out_buffer, source, first_offset, second_offset, t) {
+        source.position = first_offset;
+        const ax = source.readFloat64();
+        const ay = source.readFloat64();
+        const az = source.readFloat64();
+        const aqx = source.readFloat64();
+        const aqy = source.readFloat64();
+        const aqz = source.readFloat64();
+        const aqw = source.readFloat64();
+
+        source.position = second_offset;
+        const bx = source.readFloat64();
+        const by = source.readFloat64();
+        const bz = source.readFloat64();
+        let bqx = source.readFloat64();
+        let bqy = source.readFloat64();
+        let bqz = source.readFloat64();
+        let bqw = source.readFloat64();
+
+        // Position: componentwise lerp.
+        const ox = ax + (bx - ax) * t;
+        const oy = ay + (by - ay) * t;
+        const oz = az + (bz - az) * t;
+
+        // Rotation: shortest-arc nlerp.
+        if (aqx * bqx + aqy * bqy + aqz * bqz + aqw * bqw < 0) {
+            bqx = -bqx; bqy = -bqy; bqz = -bqz; bqw = -bqw;
+        }
+        let qx = aqx + (bqx - aqx) * t;
+        let qy = aqy + (bqy - aqy) * t;
+        let qz = aqz + (bqz - aqz) * t;
+        let qw = aqw + (bqw - aqw) * t;
+        const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
+        const inv = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
+        qx *= inv; qy *= inv; qz *= inv; qw *= inv;
+
+        out_buffer.writeFloat64(ox);
+        out_buffer.writeFloat64(oy);
+        out_buffer.writeFloat64(oz);
+        out_buffer.writeFloat64(qx);
+        out_buffer.writeFloat64(qy);
+        out_buffer.writeFloat64(qz);
+        out_buffer.writeFloat64(qw);
+    }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Full-precision (Float64) pose serializer for {@link Transform}: position +
+ * rotation only (the physics integrator never changes scale, so it's left to
+ * the live component). 7 × Float64 = 56 bytes.
+ *
+ * This is the LOCAL interpolation format, deliberately distinct from the
+ * network's bandwidth-tuned Float32 + packed-quaternion wire adapter: render
+ * fidelity in a massive world needs the full mantissa far from the origin, and
+ * the interpolation log is local memory, not wire bytes.
+ *
+ * `deserialize` writes through `position.set` / `rotation.set` so the
+ * Transform's onChanged subscribers (render, culling, particles, trails,
+ * attachments) all observe the interpolated pose.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class TransformPoseSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof Transform;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} transform
+     */
+    serialize(buffer: BinaryBuffer, transform: Transform): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} transform
+     */
+    deserialize(buffer: BinaryBuffer, transform: Transform): void;
+}
+import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { Transform } from "../ecs/transform/Transform.js";
+//# sourceMappingURL=TransformPoseSerializationAdapter.d.ts.map

package/src/engine/interpolation/TransformPoseSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformPoseSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/TransformPoseSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH;;IAEI,wBAAkB;IAClB,gBAAY;IAEZ;;;OAGG;IACH,2CAFW,SAAS,QAYnB;IAED;;;OAGG;IACH,6CAFW,SAAS,QAYnB;CACJ;gDAxD+C,0DAA0D;0BAChF,+BAA+B"}

package/src/engine/interpolation/TransformPoseSerializationAdapter.js

@@ -0,0 +1,57 @@
+import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { Transform } from "../ecs/transform/Transform.js";
+
+/**
+ * Full-precision (Float64) pose serializer for {@link Transform}: position +
+ * rotation only (the physics integrator never changes scale, so it's left to
+ * the live component). 7 × Float64 = 56 bytes.
+ *
+ * This is the LOCAL interpolation format, deliberately distinct from the
+ * network's bandwidth-tuned Float32 + packed-quaternion wire adapter: render
+ * fidelity in a massive world needs the full mantissa far from the origin, and
+ * the interpolation log is local memory, not wire bytes.
+ *
+ * `deserialize` writes through `position.set` / `rotation.set` so the
+ * Transform's onChanged subscribers (render, culling, particles, trails,
+ * attachments) all observe the interpolated pose.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class TransformPoseSerializationAdapter extends BinaryClassSerializationAdapter {
+
+    klass = Transform;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} 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);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} transform
+     */
+    deserialize(buffer, transform) {
+        const px = buffer.readFloat64();
+        const py = buffer.readFloat64();
+        const pz = buffer.readFloat64();
+        const rx = buffer.readFloat64();
+        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);
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Interpolation-log type id for the {@link Transform} 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
+ * network's replicated-component type id — tracked in INTEPOLATION_SYSTEM_PLAN.)
+ * @type {number}
+ */
+export const POSE_TYPE_ID: number;
+/**
+ * Shared, stateless pose interpoland: blend a body's {@link Transform} 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: Interpoland;
+import { Interpoland } from "./Interpoland.js";
+//# sourceMappingURL=pose_interpoland.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pose_interpoland.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/pose_interpoland.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;;;GAKG;AACH,+BAFU,WAAW,CAOnB;4BAzB0B,kBAAkB"}

package/src/engine/interpolation/pose_interpoland.js

@@ -0,0 +1,27 @@
+import { Transform } from "../ecs/transform/Transform.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
+ * 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
+ * network's replicated-component type id — tracked in INTEPOLATION_SYSTEM_PLAN.)
+ * @type {number}
+ */
+export const POSE_TYPE_ID = 0;
+
+/**
+ * Shared, stateless pose interpoland: blend a body's {@link Transform} 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,
+    new TransformPoseSerializationAdapter(),
+    new PoseInterpolationAdapter(),
+);

package/src/engine/network/NetworkSession.d.ts

@@ -375,12 +375,12 @@ export class NetworkSession {
 import { UUID } from "../ecs/guid/UUID.js";
 import Signal from "../../core/events/signal/Signal.js";
 import { BinarySerializationRegistry } from "../ecs/storage/binary/BinarySerializationRegistry.js";
-import { BinaryInterpolationAdapter } from "./sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../interpolation/BinaryInterpolationAdapter.js";
 import { SimAction } from "./sim/SimAction.js";
 import { ServerAuthoritativeServer } from "./orchestrator/ServerAuthoritativeServer.js";
 import { ServerAuthoritativeClient } from "./orchestrator/ServerAuthoritativeClient.js";
 import { NetworkPeer } from "./orchestrator/NetworkPeer.js";
-import { InterpolationLog } from "./sim/InterpolationLog.js";
+import { InterpolationLog } from "../interpolation/InterpolationLog.js";
 import { AdaptiveRenderDelay } from "./time/AdaptiveRenderDelay.js";
 import { TimeDilation } from "./time/TimeDilation.js";
 //# sourceMappingURL=NetworkSession.d.ts.map

package/src/engine/network/NetworkSession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;iCAqCoB,MAAM;AAhB1B;;;;;;;;;;;;;;;;;GAiBG;AACH;;;GAGG;AAuCH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA+NI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,mOA3CW;QACV,cAAkB,gBAAgB;QAClC,SAAa,CAAC,EAAE,MAAM,CAAC;QACvB,iBAAqB,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,CAAC;QACvC,IAAQ,CAAC,EAAE,QAAQ,GAAC,MAAM,CAAC;QAC3B,aAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,sBAA0B,CAAC,EAAE,MAAM,CAAC;QACpC,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,eAAmB,CAAC,EAAE,2BAA2B,CAAC;QAClD,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,aAAiB,CAAC,EAAE,YAAY,CAAC;QACjC,qBAAyB,CAAC,EAAE,mBAAmB,CAAC;QAChD,sBAA0B,CAAC,EAAE,MAAM,CAAC;QACpC,SAAa,CAAC,EAAE;YAChB,OAAa,CAAC,EAAE,OAAO,CAAC;YACxB,YAAkB,CAAC,EAAE,MAAM,CAAC;YAC5B,aAAmB,CAAC,EAAE,MAAM,CAAC;YAC7B,YAAkB,CAAC,EAAE,MAAM,CAAC;YAC5B,kBAAwB,CAAC,EAAE,MAAM,CAAC;YAClC,gBAAsB,CAAC,EAAE,MAAM,CAAC;YAChC,mBAAyB,CAAC,EAAE,OAAO,CAAC;SAC/B,CAAC;KACH,EA2HH;IA3SD;;;;;;OAMG;IACH,qBAAqB;IA0DrB;;;;;;OAMG;IACH,eAFU,IAAI,GAAC,IAAI,CAEE;IAqBrB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAE1B;;;;;OAKG;IACH,0BAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,kBAFU,MAAM,CAEgB;IAEhC;;;;OAIG;IACH,oBAFU,MAAM,CAEkB;IAElC;;;;;;OAMG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;;OAKG;IACH,6BAFU,MAAM,CAE2B;IAoFvC;;;OAGG;IACH,uCAAoC;IAEpC;;;OAGG;IACH,uCAAmC;IAEnC;;;OAGG;IACH,eAFU,kBAAkB,GAAC,MAAM,CAEnB;IAEhB;;;OAGG;IACH,yBAFU,MAAM,CAEyB;IAEzC;;;OAGG;IACH,iCAFU,MAAM,CAIT;IAEP;;;OAGG;IACH,wBAFU,MAAM,CAIgC;IAEhD;;;OAGG;IACH,0BAFU,2BAA2B,CAEsC;IAwC/E;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mDAFW,0BAA0B,QA4BpC;IAED;;;;;;;;OAQG;IACH,6CAIC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,uCAFmB,MAAM,KAAK,MAAM,SAAS,CAAC,GAAC,IAAI,QAWlD;IAMD;;;;;;;;;OASG;IACH,uBA+KC;IAED;;;;;;;;;OASG;IACH,wBAHW,MAAM,aACN,MAAM,QAuChB;IAED;;;;;;;;;;;;OAYG;IACH,mBAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;OAMG;IACH,oBAFW,MAAM,QA8BhB;IAED;;OAEG;IACH,aAaC;IAMD;;;;;;OAMG;IACH,iBAFW,MAAM,QAiChB;IAED;;;;;;;;;;OAUG;IACH,2BA8BC;IAED;;;;;;;OAOG;IACH,sBAFW,SAAS,QAQnB;IAMD;;OAEG;IACH,wCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,0CAEC;IAED;;OAEG;IACH,iDAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,4BAGC;;CAkxBJ;qBA5yDoB,qBAAqB;mBAFvB,oCAAoC;4CAGV,sDAAsD;2CASpC,qCAAqC;0BAE1E,oBAAoB;0CAJJ,6CAA6C;0CAD7C,6CAA6C;4BADtC,+BAA+B;iCAK/C,2BAA2B;oCAGxB,+BAA+B;6BACtC,wBAAwB"}
+{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":"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"}

package/src/engine/network/NetworkSession.js

@@ -12,8 +12,8 @@ import { NetworkPeer, ResumeRejectReason, } from "./orchestrator/NetworkPeer.js"
 import { ServerAuthoritativeClient } from "./orchestrator/ServerAuthoritativeClient.js";
 import { ServerAuthoritativeServer } from "./orchestrator/ServerAuthoritativeServer.js";
 import { OwnerAwareScope } from "./replication/ScopeFilter.js";
-import { BinaryInterpolationAdapter, InterpolationKind, } from "./sim/BinaryInterpolationAdapter.js";
-import { InterpolationLog } from "./sim/InterpolationLog.js";
+import { BinaryInterpolationAdapter, InterpolationKind, } from "../interpolation/BinaryInterpolationAdapter.js";
+import { InterpolationLog } from "../interpolation/InterpolationLog.js";
 import { SimAction } from "./sim/SimAction.js";
 import { snapshotter_emit } from "./sim/Snapshotter.js";
 import { AdaptiveRenderDelay } from "./time/AdaptiveRenderDelay.js";

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

@@ -10,5 +10,5 @@ export class QuaternionInterpolationAdapter extends BinaryInterpolationAdapter {
     /** @inheritdoc */
     interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
 }
-import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 //# sourceMappingURL=QuaternionInterpolationAdapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"QuaternionInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/QuaternionInterpolationAdapter.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH;IAEI,kBAAkB;IAClB,+FA6BC;CACJ;2CA3C0C,sCAAsC"}
+{"version":3,"file":"QuaternionInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/QuaternionInterpolationAdapter.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH;IAEI,kBAAkB;IAClB,+FA6BC;CACJ;2CA3C0C,mDAAmD"}

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

@@ -1,4 +1,4 @@
-import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 
 /**
  * Shortest-path nlerp for a 4 × Float32 quaternion payload (16 bytes).

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

@@ -14,5 +14,5 @@ export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
     /** @inheritdoc */
     interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
 }
-import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 //# sourceMappingURL=TransformInterpolationAdapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TransformInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformInterpolationAdapter.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH;IAEI,kBAAkB;IAClB,+FAiDC;CACJ;2CA1E0C,sCAAsC"}
+{"version":3,"file":"TransformInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformInterpolationAdapter.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH;IAEI,kBAAkB;IAClB,+FAiDC;CACJ;2CA1E0C,mDAAmD"}

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

@@ -2,7 +2,7 @@ import { quat_decode_from_uint32 } from "../../../core/geom/3d/quaternion/quat_d
 import { quat_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat_encode_to_uint32.js";
 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 { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 
 /**
  * Module-level scratch. Layout: `[aq.xyzw, bq.xyzw, as.xyz, bs.xyz]`.

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

@@ -14,5 +14,5 @@
  */
 export class Vector3InterpolationAdapter extends BinaryInterpolationAdapter {
 }
-import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 //# sourceMappingURL=Vector3InterpolationAdapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Vector3InterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/Vector3InterpolationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;CA4BC;2CA5C0C,sCAAsC"}
+{"version":3,"file":"Vector3InterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/Vector3InterpolationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;CA4BC;2CA5C0C,mDAAmD"}

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

@@ -1,5 +1,5 @@
 import { lerp } from "../../../core/math/lerp.js";
-import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 
 /**
  * Componentwise lerp of a 3-Float32 position payload.