@woosh/meep-engine 3.30.0 → 3.32.0

package/src/engine/intelligence/behavior/ecs/BehaviorSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BehaviorSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/BehaviorSystem.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH;IAII;;;OAGG;IACH,4BAQC;IAfD,2CAAmC;IACnC,mBAA0B;IAStB;;;OAGG;IACH,eAAoB;IAGxB,2CAIC;IAED,4CAEC;IAED;;;;OAIG;IACH,gBAHW,iBAAiB,UACjB,MAAM,QAiBhB;IAED;;;;OAIG;IACH,kBAHW,iBAAiB,UACjB,MAAM,QAUhB;IAED,6BA2CC;CACJ;kCAzIiC,wBAAwB;uBAFnC,wBAAwB;kBAD7B,mBAAmB"}
+{"version":3,"file":"BehaviorSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/BehaviorSystem.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH;IAII;;;OAGG;IACH,4BAQC;IAfD,2CAAmC;IACnC,mBAA0B;IAStB;;;OAGG;IACH,eAAoB;IAGxB,2CAIC;IAED,4CAEC;IAED;;;;OAIG;IACH,gBAHW,iBAAiB,UACjB,MAAM,QAiBhB;IAED;;;;OAIG;IACH,kBAHW,iBAAiB,UACjB,MAAM,QAgBhB;IAED,6BAkDC;CACJ;kCAtJiC,wBAAwB;uBAFnC,wBAAwB;kBAD7B,mBAAmB"}

package/src/engine/intelligence/behavior/ecs/BehaviorSystem.js

@@ -85,6 +85,12 @@ export class BehaviorSystem extends System {
      * @param {number} entity
      */
     unlink(component, entity) {
+        if (component.getFlag(BehaviorComponentFlag.Resolved)) {
+            // already finalized at the point it resolved; finalizing again would double-release
+            // whatever the tree held
+            return;
+        }
+
         const behavior = component.behavior;
 
         if (behavior !== null) {
@@ -131,6 +137,13 @@ export class BehaviorSystem extends System {
 
                 if (state === BehaviorStatus.Failed || state === BehaviorStatus.Succeeded) {
                     b.setFlag(BehaviorComponentFlag.Resolved);
+
+                    // Every `initialize` is matched by a `finalize` throughout the tree, and the
+                    // root was the one place that was not: a completed tree kept everything its
+                    // initialize acquired - a WaitForEventBehavior's dataset listener, a blackboard
+                    // acquisition - for the entity's whole lifetime, and `onFinalized` never fired.
+                    // `unlink` was the only caller, i.e. only when the component was removed.
+                    behavior.finalize();
                 }
             }
 

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

@@ -58,10 +58,10 @@ export class InterpolationLog {
         buffer_capacity_bytes?: number;
         records_capacity?: number;
     });
-    /** @readonly @type {number} */
-    readonly buffer_capacity: number;
-    /** @readonly @type {number} */
-    readonly records_capacity: number;
+    /** Byte-ring capacity. Grows only through {@link ensure_ticks}. @type {number} */
+    buffer_capacity: number;
+    /** Record capacity. Grows only through {@link ensure_ticks}. @type {number} */
+    records_capacity: number;
     /**
      * Open a new tick for recording. May wrap either ring at this point — but
      * never mid-tick, so a single tick's data is always contiguous in both
@@ -144,6 +144,53 @@ export class InterpolationLog {
      * @returns {boolean} true if a payload was written; false if neither tick has the component
      */
     interpolate(out_buffer: BinaryBuffer, network_id: number, type_id: number, tick_a: number, tick_b: number, t: number, adapter: BinaryInterpolationAdapter): boolean;
+    /**
+     * Replace one closed record's payload in place, with a payload of the same length.
+     *
+     * The log is append-only by design — a tick cannot be re-opened to add a record without
+     * clobbering its neighbours — but a record's bytes can be overwritten where they lie, and that
+     * is all a history correction needs: "this entity was at P at tick T, not where it was
+     * recorded". A teleport rewrites its entity's latest records so the blend continues from the new
+     * pose instead of sliding across the jump; a network correction shifts a predicted entity's
+     * recent records by the error it corrects.
+     *
+     * `serialize` writes the new payload into a scratch buffer; the log copies it over the record
+     * only if it is exactly as long as the one it replaces, and otherwise leaves the log untouched.
+     * Layouts that vary in length per value cannot be rewritten this way.
+     *
+     * @param {number} tick a closed tick
+     * @param {number} network_id
+     * @param {number} type_id
+     * @param {(buffer: BinaryBuffer) => void} serialize writes the replacement payload at the buffer's position
+     * @returns {boolean} true if the record existed and was replaced
+     */
+    rewrite(tick: number, network_id: number, type_id: number, serialize: (buffer: BinaryBuffer) => void): boolean;
+    /**
+     * Newest live tick at or before `tick`, or -1 when the log holds none. Walks back from `tick`
+     * to the oldest held tick, so it is O(distance) — cheap for "the frame the playhead is in, or
+     * the last one before it that carried anything".
+     *
+     * @param {number} tick
+     * @returns {number}
+     */
+    latest_tick_at_or_before(tick: number): number;
+    /**
+     * Grow the log, if needed, so that `tick_count` ticks as large as the largest one recorded so
+     * far fit without squashing each other. Returns whether it grew.
+     *
+     * The log never grows on its own: a tick that outgrows it squashes older ticks, and a blend
+     * that needs one of them falls back to a single snapshot — which, for a render blend, is a
+     * visible snap. A producer whose tick size depends on something it does not control (how many
+     * entities are interpolated) calls this after each tick so that happens at most once, while
+     * the log is growing.
+     *
+     * Growing keeps everything held: the byte ring and the record table are copied into larger
+     * ones at the same offsets, which stay valid, and the cursors carry on from where they were.
+     *
+     * @param {number} tick_count
+     * @returns {boolean}
+     */
+    ensure_ticks(tick_count: number): boolean;
     /**
      * Number of ticks currently held. Squashed ticks are excluded.
      * @returns {number}

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

@@ -1 +1 @@
-{"version":3,"file":"InterpolationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationLog.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IA+CI;;;;;OAKG;IACH,0DALW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAkDvE;IA9BG,+BAA+B;IAC/B,0BADqB,MAAM,CACiB;IAY5C,+BAA+B;IAC/B,2BADqB,MAAM,CACa;IAkB5C;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAkEhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAJW,MAAM,WACN,MAAM,GACJ,YAAY,CAmCxB;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;;;OAOG;IACH,iBAeC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YAPW,MAAM,EAAE,GAAC,WAAW,cACpB,MAAM,QACN,MAAM,cACN,MAAM,WACN,MAAM,GACJ,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBATW,YAAY,cACZ,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,KACN,MAAM,wCAEJ,OAAO,CAuBnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cASC;;CACJ;6BAljB4B,mCAAmC"}
+{"version":3,"file":"InterpolationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationLog.js"],"names":[],"mappings":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IA+CI;;;;;OAKG;IACH,0DALW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAkDvE;IA9BG,kFAAkF;IAClF,iBADwE,MAAM,CAClC;IAY5C,+EAA+E;IAC/E,kBADqE,MAAM,CACnC;IAkB5C;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAkEhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAJW,MAAM,WACN,MAAM,GACJ,YAAY,CAmCxB;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;;;OAOG;IACH,iBAeC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YAPW,MAAM,EAAE,GAAC,WAAW,cACpB,MAAM,QACN,MAAM,cACN,MAAM,WACN,MAAM,GACJ,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBATW,YAAY,cACZ,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,KACN,MAAM,wCAEJ,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cANW,MAAM,cACN,MAAM,WACN,MAAM,aACN,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC5B,OAAO,CAyBnB;IAED;;;;;;;OAOG;IACH,+BAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBAHW,MAAM,GACJ,OAAO,CAqCnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cASC;;CACJ;6BAprB4B,mCAAmC"}

package/src/engine/interpolation/InterpolationLog.js

@@ -25,6 +25,14 @@ const MAX_PAGE_WORDS = BLOOM_WORDS + METADATA_PAGE_SIZE * RECORD_WORDS; // 164
  */
 const scratch_u32 = new Uint32Array(8);
 
+/**
+ * Staging buffer for {@link InterpolationLog#rewrite}: the replacement payload is written here first
+ * and only copied over the record once its length is known to match.
+ * @type {BinaryBuffer}
+ */
+const rewrite_scratch = new BinaryBuffer();
+rewrite_scratch.setCapacity(256);
+
 /**
  * Insert a u32 key into the 256-bit bloom filter at words `[base..base+7]` of `table`.
  * Reference: standard double-hashing trick, k=3 hashes derived from one murmur3 mix.
@@ -192,7 +200,7 @@ export class InterpolationLog {
         this.#buffer = new BinaryBuffer();
         this.#buffer.fromArrayBuffer(new ArrayBuffer(buffer_capacity_bytes));
 
-        /** @readonly @type {number} */
+        /** Byte-ring capacity. Grows only through {@link ensure_ticks}. @type {number} */
         this.buffer_capacity = buffer_capacity_bytes;
 
         /**
@@ -205,7 +213,7 @@ export class InterpolationLog {
         const total_words = num_pages * MAX_PAGE_WORDS;
         this.#records = new Uint32Array(total_words);
 
-        /** @readonly @type {number} */
+        /** Record capacity. Grows only through {@link ensure_ticks}. @type {number} */
         this.records_capacity = records_capacity;
 
         /** Total word capacity of the metadata table (used for wrap/overlap math). @readonly @type {number} */
@@ -531,6 +539,128 @@ export class InterpolationLog {
         return true;
     }
 
+    /**
+     * Replace one closed record's payload in place, with a payload of the same length.
+     *
+     * The log is append-only by design — a tick cannot be re-opened to add a record without
+     * clobbering its neighbours — but a record's bytes can be overwritten where they lie, and that
+     * is all a history correction needs: "this entity was at P at tick T, not where it was
+     * recorded". A teleport rewrites its entity's latest records so the blend continues from the new
+     * pose instead of sliding across the jump; a network correction shifts a predicted entity's
+     * recent records by the error it corrects.
+     *
+     * `serialize` writes the new payload into a scratch buffer; the log copies it over the record
+     * only if it is exactly as long as the one it replaces, and otherwise leaves the log untouched.
+     * Layouts that vary in length per value cannot be rewritten this way.
+     *
+     * @param {number} tick a closed tick
+     * @param {number} network_id
+     * @param {number} type_id
+     * @param {(buffer: BinaryBuffer) => void} serialize writes the replacement payload at the buffer's position
+     * @returns {boolean} true if the record existed and was replaced
+     */
+    rewrite(tick, network_id, type_id, serialize) {
+        if (this.#current_tick !== -1 && tick === this.#current_tick) {
+            throw new Error(`InterpolationLog.rewrite: tick ${tick} is still open; call end_tick first`);
+        }
+
+        if (!this.locate(scratch_u32, 4, tick, network_id, type_id)) {
+            return false;
+        }
+
+        const offset = scratch_u32[4];
+        const length = scratch_u32[5];
+
+        const scratch = rewrite_scratch;
+        scratch.position = 0;
+        serialize(scratch);
+
+        if (scratch.position !== length) {
+            return false;
+        }
+
+        this.#buffer.raw_bytes.set(scratch.raw_bytes.subarray(0, length), offset);
+
+        return true;
+    }
+
+    /**
+     * Newest live tick at or before `tick`, or -1 when the log holds none. Walks back from `tick`
+     * to the oldest held tick, so it is O(distance) — cheap for "the frame the playhead is in, or
+     * the last one before it that carried anything".
+     *
+     * @param {number} tick
+     * @returns {number}
+     */
+    latest_tick_at_or_before(tick) {
+        const oldest = this.#oldest_tick;
+
+        if (oldest === -1) {
+            return -1;
+        }
+
+        for (let t = Math.floor(tick); t >= oldest; t--) {
+            if (this.#ticks.has(t)) {
+                return t;
+            }
+        }
+
+        return -1;
+    }
+
+    /**
+     * Grow the log, if needed, so that `tick_count` ticks as large as the largest one recorded so
+     * far fit without squashing each other. Returns whether it grew.
+     *
+     * The log never grows on its own: a tick that outgrows it squashes older ticks, and a blend
+     * that needs one of them falls back to a single snapshot — which, for a render blend, is a
+     * visible snap. A producer whose tick size depends on something it does not control (how many
+     * entities are interpolated) calls this after each tick so that happens at most once, while
+     * the log is growing.
+     *
+     * Growing keeps everything held: the byte ring and the record table are copied into larger
+     * ones at the same offsets, which stay valid, and the cursors carry on from where they were.
+     *
+     * @param {number} tick_count
+     * @returns {boolean}
+     */
+    ensure_ticks(tick_count) {
+        assert.isPositiveInteger(tick_count, 'tick_count');
+
+        const need_bytes = this.#max_tick_bytes * tick_count;
+        const need_words = this.#max_tick_words * tick_count;
+
+        const grow_bytes = need_bytes > this.buffer_capacity;
+        const grow_words = need_words > this.#records_word_capacity;
+
+        if (!grow_bytes && !grow_words) {
+            return false;
+        }
+
+        if (grow_bytes) {
+            // A tick that outgrew the ring was written on past its end — the byte buffer grows on
+            // write — so what it holds can reach beyond `buffer_capacity`. Keep all of it.
+            const held = this.#buffer.raw_bytes;
+            const capacity = Math.max(need_bytes, this.buffer_capacity * 2, held.length);
+            const bytes = new Uint8Array(capacity);
+            bytes.set(held, 0);
+            this.#buffer.fromArrayBuffer(bytes.buffer);
+            this.buffer_capacity = capacity;
+        }
+
+        if (grow_words) {
+            const pages = Math.ceil(Math.max(need_words, this.#records_word_capacity * 2) / MAX_PAGE_WORDS);
+            const words = pages * MAX_PAGE_WORDS;
+            const records = new Uint32Array(words);
+            records.set(this.#records, 0);
+            this.#records = records;
+            this.#records_word_capacity = words;
+            this.records_capacity = pages * METADATA_PAGE_SIZE;
+        }
+
+        return true;
+    }
+
     /**
      * Number of ticks currently held. Squashed ticks are excluded.
      * @returns {number}

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

@@ -1,27 +1,48 @@
 /**
- * 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.
+ * Move `t` by `(dx, dy, dz)` and turn it by the unit quaternion `(ex, ey, ez, ew)` in its own
+ * frame — on the right, `q' = q * e`.
  *
- * 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.
+ * That is the correction that carries over a difference in orientation observed at an earlier
+ * moment: if `q_now = W * q_then` for whatever world-frame rotation `W` happened since (physics
+ * integrates angular velocity that way), then replacing `q_then` by `q_then * e` gives
+ * `q_now * e`. Position differences carry over by addition.
  *
- * 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.
+ * @param {Transform64} t
+ * @param {Float64Array} q_scratch 4 elements
+ */
+export function apply_pose_correction(t: Transform64, dx: any, dy: any, dz: any, ex: any, ey: any, ez: any, ew: any, q_scratch: Float64Array): void;
+/**
+ * Render-time interpolation, end to end. For every {@link Interpolated} entity it:
+ *
+ *  - **records** the entity's state for every completed fixed step, under that step's tick, when
+ *    the entity is on the local timeline (the default). Nothing else has to: physics, a character
+ *    controller, a network prediction and plain game code in a `fixedUpdate` all get interpolated
+ *    the same way. The record is taken after the step, when the next step opens or the next render
+ *    update comes, whichever is first — so it is after every system, and an entity created during a
+ *    step is recorded on the tick it was born in.
+ *  - **blends** it every render frame, in {@link update}: local entities between the last two
+ *    completed steps at the fixed-step alpha; entities on a registered timeline (a network
+ *    playout, a remote editor's presence stream) on that timeline's window. The blend is written
+ *    into the live target component (e.g. {@link Transform64}) and announced, so everything that
+ *    follows the transform — mesh placement, attachments, particles — renders the smoothed pose.
+ *    The system declares write access to {@link Transform64}, so derived execution order puts the
+ *    blend before systems that read transforms, such as the camera.
+ *  - **restores** the truth before anything simulates from it. A blend is a render-only value and
+ *    must not become simulation state, so when a fixed step opens — and whenever {@link restore}
+ *    is called — every value a blend displaced is put back. Whatever else was written to the live
+ *    component after the blend is discarded with it, unless the writer set
+ *    {@link Interpolated#snap}: a write made between steps, at render rate, is a write to a drawn
+ *    pose, not to the simulation. Code that has to change the simulation between steps calls
+ *    {@link restore} first; after it the live components hold the truth, and what is written there
+ *    stays (the network session does this before every action it applies).
  *
- * 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.
+ * An interpolated entity is therefore simulated at the fixed step: moved in a `fixedUpdate`, by
+ * physics, by an action, by the network. Something that genuinely repositions it between steps —
+ * a teleport — sets {@link Interpolated#snap} (`PhysicsSystem.setPose` does): the next consume
+ * shows the live value as it is, the entity's recent records are rewritten to it so the blend
+ * resumes from there instead of sliding across the jump, and no restore puts the old value back.
+ *
+ * Cost is O(entities × interpolands) per render frame and per fixed step.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -35,26 +56,13 @@ export class InterpolationSystem extends System<any> {
         records_capacity?: number;
     });
     dependencies: (typeof Interpolated)[];
-    components_used: ResourceAccessSpecification<typeof Interpolated>[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof Interpolated>)[];
     /**
-     * Shared per-tick snapshot store. Producers record into it; this system
-     * blends from it.
-     * @type {InterpolationLog}
-     */
-    log: InterpolationLog;
-    /**
-     * Linked entities → their {@link Interpolated} component. Iterated each
-     * update.
+     * Linked entities → their {@link Interpolated} component. Iterated each update.
      * @private
      * @type {Map<number, Interpolated>}
      */
     private __entities;
-    /**
-     * Reusable decode buffer for blended snapshots.
-     * @private
-     * @type {BinaryBuffer}
-     */
-    private __scratch;
     /**
      * Non-local timeline registry, keyed by `sourceId`. Each entry is the
      * timeline's `{ log, sample() }` — its log to read and a per-frame window
@@ -71,6 +79,24 @@ export class InterpolationSystem extends System<any> {
      * @type {Map<number, { tick_a: number, tick_b: number, t: number }>}
      */
     private __source_windows;
+    /**
+     * The local timeline's per-tick snapshot store: recorded by this system for every completed
+     * fixed step, blended from every render frame.
+     * @type {InterpolationLog}
+     */
+    log: InterpolationLog;
+    /**
+     * Reusable decode buffer for blended snapshots.
+     * @private
+     * @type {BinaryBuffer}
+     */
+    private __scratch;
+    /**
+     * Reusable buffer for serializing a component that cannot copy itself.
+     * @private
+     * @type {BinaryBuffer}
+     */
+    private __probe;
     /**
      * Register a non-local interpolation timeline under `sourceId`. Entities
      * carrying that id on their {@link Interpolated} component are blended from
@@ -88,6 +114,11 @@ export class InterpolationSystem extends System<any> {
         tick_b: number;
         t: number;
     }): void;
+    /**
+     * A source id no one else holds, for an owner that does not need a meaningful one of its own.
+     * @returns {number}
+     */
+    allocateSourceId(): number;
     /**
      * Forget a source (its peer left). Entities still marked with it are left where they are
      * until their marker goes; the system does not blend from a source it does not have.
@@ -99,6 +130,10 @@ export class InterpolationSystem extends System<any> {
      * @param {EntityManager} entityManager
      */
     startup(entityManager: EntityManager): Promise<void>;
+    /**
+     * @param {EntityManager} entityManager
+     */
+    shutdown(entityManager: EntityManager): Promise<void>;
     /**
      * @param {Interpolated} interpolated
      * @param {number} entity
@@ -109,13 +144,56 @@ export class InterpolationSystem extends System<any> {
      * @param {number} entity
      */
     unlink(interpolated: Interpolated, entity: number): void;
+    /**
+     * Put back the truth wherever a render blend is in the live components (keeping, instead, the
+     * live value of an entity that declared it with {@link Interpolated#snap}). Idempotent, and cheap
+     * when nothing is blended. Safe to call at any time.
+     */
+    restore(): void;
+    /**
+     * Ready the interpolated entities for the fixed step that is opening: blends restored, the step
+     * just completed recorded, teleports raised since then settled into its record. Idempotent per
+     * step — the first call does the work, later ones in the same step return.
+     *
+     * The engine runs it when the step opens ({@link openFixedStep}). A system that applies state as
+     * a step opens and must find the simulation's truth there — the network, before it applies what
+     * arrived — calls it first, so which of the two opens first does not matter. Only valid while a
+     * fixed step is opening: `entityManager.fixedStepTick` names the step about to run.
+     */
+    settle(): void;
+    /**
+     * Hide a correction of a local-timeline entity's pose: the simulation has just moved it by
+     * `(dx, dy, dz)` and turned it by the unit quaternion `(ex, ey, ez, ew)` in its own frame
+     * (`q' = q * e`), and the picture should not jump.
+     *
+     * The entity's most recent records are moved by the same correction, so the blend reads a
+     * history consistent with the corrected simulation; and the drawn pose carries the opposite
+     * offset, which then decays over a fraction of a second. The drawn pose is continuous at the
+     * moment of the correction and converges on the corrected one.
+     *
+     * Call with the correction already applied to the live pose. Only {@link Transform64}
+     * interpolands on the local timeline are corrected; anything else is left as is.
+     *
+     * @param {number} entity
+     * @param {number} dx
+     * @param {number} dy
+     * @param {number} dz
+     * @param {number} [ex]
+     * @param {number} [ey]
+     * @param {number} [ez]
+     * @param {number} [ew]
+     * @returns {boolean} whether there was anything to correct
+     */
+    correct(entity: number, dx: number, dy: number, dz: number, ex?: number, ey?: number, ez?: number, ew?: number): boolean;
     update(dt: any): void;
     /**
      * @readonly
      * @type {boolean}
      */
     readonly isInterpolationSystem: boolean;
+    #private;
 }
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { System } from "../ecs/System.js";
 import { Interpolated } from "./Interpolated.js";
 import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";

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

@@ -1 +1 @@
-{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAOI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA6CvE;IAnDD,sCAA8B;IAC9B,oEAEE;IAQE;;;;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;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAShB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAIhB;IAED,sBA6FC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;uBA3OsB,kBAAkB;6BAEyC,mBAAmB;4CAHzD,iDAAiD;iCAE5D,uBAAuB"}
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,yCAHW,WAAW,4EACX,YAAY,QAgBtB;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAoGI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA2BvE;IA9HD,sCAA8B;IAC9B,wHAIE;IAEF;;;;OAIG;IACH,mBAAuB;IAEvB;;;;;;;OAOG;IACH,kBAAsB;IAEtB;;;;;OAKG;IACH,yBAA6B;IA0EzB;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;OAIG;IACH,kBAAmC;IAGnC;;;;OAIG;IACH,gBAAiC;IAIrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAc7D;IAED;;;OAGG;IACH,oBAFa,MAAM,CAOlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;OAEG;IACH,sDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAchB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAYC;IAED;;;;;;;;;OASG;IACH,eA6BC;IA2OD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAkCnB;IAuED,sBA0HC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;4BA11B2B,iCAAiC;uBADtC,kBAAkB;6BAIyC,mBAAmB;4CALzD,iDAAiD;iCAI5D,uBAAuB"}