@woosh/meep-engine 3.45.0 → 3.47.0

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

@@ -0,0 +1,30 @@
+/**
+ * Action-stream slices sent to one peer and not yet resolved, keyed by a small integer token: the
+ * token the connection hands back with the slice's acknowledgement or loss.
+ *
+ * Typed arrays and a free list, so a tick's sends allocate nothing once the pool has grown to the
+ * peer's high-watermark.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PendingSlices {
+    /** Slices awaiting their outcome. */
+    get size(): number;
+    /**
+     * @param {number} frame_start first frame the slice covers
+     * @param {number} frame_end last frame the slice covers
+     * @param {boolean} head the slice began at the pack start
+     * @returns {number} token
+     */
+    acquire(frame_start: number, frame_end: number, head: boolean): number;
+    /**
+     * @param {number} token
+     */
+    release(token: number): void;
+    frame_start(token: any): number;
+    frame_end(token: any): number;
+    head(token: any): boolean;
+    #private;
+}
+//# sourceMappingURL=PendingSlices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PendingSlices.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/PendingSlices.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH;IAWI,qCAAqC;IACrC,mBAEC;IAED;;;;;OAKG;IACH,qBALW,MAAM,aACN,MAAM,QACN,OAAO,GACL,MAAM,CAelB;IAED;;OAEG;IACH,eAFW,MAAM,QAKhB;IAED,gCAEC;IAED,8BAEC;IAED,0BAEC;;CAiBJ"}

package/src/engine/network/orchestrator/PendingSlices.js

@@ -0,0 +1,83 @@
+/**
+ * Action-stream slices sent to one peer and not yet resolved, keyed by a small integer token: the
+ * token the connection hands back with the slice's acknowledgement or loss.
+ *
+ * Typed arrays and a free list, so a tick's sends allocate nothing once the pool has grown to the
+ * peer's high-watermark.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PendingSlices {
+    #frame_start = new Float64Array(16);
+    #frame_end = new Float64Array(16);
+    #head = new Uint8Array(16);
+    /** free tokens, a stack */
+    #free = new Int32Array(16);
+    #free_count = 0;
+    /** tokens ever handed out; the next new one */
+    #high = 0;
+    #in_use = 0;
+
+    /** Slices awaiting their outcome. */
+    get size() {
+        return this.#in_use;
+    }
+
+    /**
+     * @param {number} frame_start first frame the slice covers
+     * @param {number} frame_end last frame the slice covers
+     * @param {boolean} head the slice began at the pack start
+     * @returns {number} token
+     */
+    acquire(frame_start, frame_end, head) {
+        let token;
+        if (this.#free_count > 0) {
+            token = this.#free[--this.#free_count];
+        } else {
+            token = this.#high++;
+            if (token === this.#frame_start.length) this.#grow();
+        }
+        this.#frame_start[token] = frame_start;
+        this.#frame_end[token] = frame_end;
+        this.#head[token] = head ? 1 : 0;
+        this.#in_use++;
+        return token;
+    }
+
+    /**
+     * @param {number} token
+     */
+    release(token) {
+        this.#free[this.#free_count++] = token;
+        this.#in_use--;
+    }
+
+    frame_start(token) {
+        return this.#frame_start[token];
+    }
+
+    frame_end(token) {
+        return this.#frame_end[token];
+    }
+
+    head(token) {
+        return this.#head[token] === 1;
+    }
+
+    #grow() {
+        const capacity = this.#frame_start.length * 2;
+        const start = new Float64Array(capacity);
+        const end = new Float64Array(capacity);
+        const head = new Uint8Array(capacity);
+        const free = new Int32Array(capacity);
+        start.set(this.#frame_start);
+        end.set(this.#frame_end);
+        head.set(this.#head);
+        free.set(this.#free);
+        this.#frame_start = start;
+        this.#frame_end = end;
+        this.#head = head;
+        this.#free = free;
+    }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Action-stream frames too large for a datagram, sent to one peer on the connection's FRAMES lane
+ * and not yet delivered: oldest first, as the lane delivers them.
+ *
+ * Each is sent once. The pack skips the frames one covers while it is in flight, and it is credited
+ * like any slice when the lane says it has arrived. Typed arrays grown to a high-watermark; a few
+ * entries at most in practice.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ReliableFrames {
+    get count(): number;
+    /**
+     * @param {number} frame_start
+     * @param {number} frame_end
+     * @param {boolean} head the slice began at the pack start
+     * @param {number} mark the lane's delivery mark
+     */
+    push(frame_start: number, frame_end: number, head: boolean, mark: number): void;
+    front_start(): number;
+    front_end(): number;
+    front_head(): boolean;
+    front_mark(): number;
+    shift(): void;
+    /**
+     * Last frame of the entry covering `frame`, or -1 when none does.
+     * @param {number} frame
+     * @returns {number}
+     */
+    covering_end(frame: number): number;
+    #private;
+}
+//# sourceMappingURL=ReliableFrames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReliableFrames.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ReliableFrames.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IASI,oBAEC;IAED;;;;;OAKG;IACH,kBALW,MAAM,aACN,MAAM,QACN,OAAO,QACP,MAAM,QAUhB;IAED,sBAEC;IAED,oBAEC;IAED,sBAEC;IAED,qBAEC;IAED,cAGC;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CASlB;;CAsBJ"}

package/src/engine/network/orchestrator/ReliableFrames.js

@@ -0,0 +1,96 @@
+/**
+ * Action-stream frames too large for a datagram, sent to one peer on the connection's FRAMES lane
+ * and not yet delivered: oldest first, as the lane delivers them.
+ *
+ * Each is sent once. The pack skips the frames one covers while it is in flight, and it is credited
+ * like any slice when the lane says it has arrived. Typed arrays grown to a high-watermark; a few
+ * entries at most in practice.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ReliableFrames {
+    #start = new Float64Array(8);
+    #end = new Float64Array(8);
+    #mark = new Float64Array(8);
+    #head = new Uint8Array(8);
+    /** index of the oldest entry */
+    #first = 0;
+    #count = 0;
+
+    get count() {
+        return this.#count;
+    }
+
+    /**
+     * @param {number} frame_start
+     * @param {number} frame_end
+     * @param {boolean} head the slice began at the pack start
+     * @param {number} mark the lane's delivery mark
+     */
+    push(frame_start, frame_end, head, mark) {
+        if (this.#count === this.#start.length) this.#grow();
+        const i = (this.#first + this.#count) % this.#start.length;
+        this.#start[i] = frame_start;
+        this.#end[i] = frame_end;
+        this.#head[i] = head ? 1 : 0;
+        this.#mark[i] = mark;
+        this.#count++;
+    }
+
+    front_start() {
+        return this.#start[this.#first];
+    }
+
+    front_end() {
+        return this.#end[this.#first];
+    }
+
+    front_head() {
+        return this.#head[this.#first] === 1;
+    }
+
+    front_mark() {
+        return this.#mark[this.#first];
+    }
+
+    shift() {
+        this.#first = (this.#first + 1) % this.#start.length;
+        this.#count--;
+    }
+
+    /**
+     * Last frame of the entry covering `frame`, or -1 when none does.
+     * @param {number} frame
+     * @returns {number}
+     */
+    covering_end(frame) {
+        const capacity = this.#start.length;
+        for (let k = 0; k < this.#count; k++) {
+            const i = (this.#first + k) % capacity;
+            if (frame >= this.#start[i] && frame <= this.#end[i]) return this.#end[i];
+        }
+        return -1;
+    }
+
+    #grow() {
+        const capacity = this.#start.length;
+        const next = capacity * 2;
+        const start = new Float64Array(next);
+        const end = new Float64Array(next);
+        const mark = new Float64Array(next);
+        const head = new Uint8Array(next);
+        for (let k = 0; k < this.#count; k++) {
+            const i = (this.#first + k) % capacity;
+            start[k] = this.#start[i];
+            end[k] = this.#end[i];
+            mark[k] = this.#mark[i];
+            head[k] = this.#head[i];
+        }
+        this.#start = start;
+        this.#end = end;
+        this.#mark = mark;
+        this.#head = head;
+        this.#first = 0;
+    }
+}

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

@@ -10,14 +10,37 @@
  *    action_log via the executor (capturing prior-state for later rewind),
  *    and goes out over the action stream when `peer.end_tick` flushes it.
  *
- *  - On AUTH_STATE arrival: rewind the world to end-of-(server_frame - 1)
- *    via the {@link RewindEngine}, deserialize the server's authoritative
- *    state bytes via {@link onApplyAuthState}, then replay forward by
- *    firing {@link onReplay} for every frame in the InputRing between
- *    `server_frame + 1` and the client's current frame. The user's
+ *  - On AUTH_STATE arrival: rewind the world to the end of `server_frame`
+ *    via the {@link RewindEngine}, overwrite it there with the server's
+ *    authoritative state bytes via {@link onApplyAuthState}, then replay
+ *    forward by firing {@link onReplay} for every frame in the InputRing
+ *    between `server_frame + 1` and the client's current frame. The user's
  *    {@link onReplay} handler re-executes the same SimActions the original
  *    predict path produced.
  *
+ *    An AUTH_STATE is the server's state at the END of `server_frame`, and it
+ *    is put back at exactly that point. It covers one `network_id`; the rest of
+ *    the world at that point is this client's own prediction of it, which
+ *    already holds the frame's input — so frame `server_frame` itself is never
+ *    undone, and nothing in it is lost or applied twice. (Undoing it and then
+ *    skipping it, which this did, took the frame's input back off every
+ *    predicted entity the bytes do not describe.)
+ *
+ *  - An applied AUTH_STATE stays on the timeline as a correction: a
+ *    `SENDER_CORRECTED` record at the end of `server_frame` in the action log,
+ *    holding the entity's state from before it and the bytes
+ *    {@link onApplyAuthState} read. A rewind across the frame undoes it like any
+ *    record, and the replay applies it again, last in its frame. Both halves
+ *    matter when one entity's AUTH_STATE arrives after another's newer one,
+ *    which a lossy link does routinely. Without the replay half the older
+ *    rewind replayed the prediction underneath the newer correction and left
+ *    that entity on its misprediction until its next AUTH_STATE. Without the
+ *    undo half the newer correction stayed in the world while the older frames
+ *    replayed, so an action there that read the entity read the server's value
+ *    from a later frame. The record is never packed for a peer — this log is
+ *    also the outbound stream, and the host would take a client-owned entity's
+ *    old state from it.
+ *
  *  - A replay also reapplies the records in the rewound window that ARRIVED
  *    from a peer, which {@link onReplay} cannot: it re-executes this client's
  *    own input, and the AUTH_STATE that precedes it carries one `network_id`.
@@ -60,8 +83,16 @@ export class ServerAuthoritativeClient {
      *   time_dilation?: TimeDilation,
      *   max_packets_per_tick?: number,
      *   auto_reconcile?: boolean,
+     *   clock: function(): number,
+     *   tick_period_ms: number,
+     *   send_rate_bytes_per_second?: number,
+     *   max_message_bytes?: number,
+     *   receive_window_bytes?: number,
+     *   max_queued_bytes?: number,
      * }} options
      *
+     * `clock`, `tick_period_ms` and the connection options: forwarded to {@link NetworkPeer}.
+     *
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
      * On TIME_DILATION feedback the client recomputes
      * {@link dilation_factor} for the caller to scale its tick cadence.
@@ -77,7 +108,7 @@ export class ServerAuthoritativeClient {
      * turns it off and listens to `peer.onAuthState` itself; {@link reconcile}
      * remains available to it.
      */
-    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, input_ring_capacity, input_byte_size, reconcile_epsilon, time_dilation, max_packets_per_tick, auto_reconcile, }: {
+    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, input_ring_capacity, input_byte_size, reconcile_epsilon, time_dilation, max_packets_per_tick, auto_reconcile, clock, tick_period_ms, send_rate_bytes_per_second, max_message_bytes, receive_window_bytes, max_queued_bytes, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -91,6 +122,12 @@ export class ServerAuthoritativeClient {
         time_dilation?: TimeDilation;
         max_packets_per_tick?: number;
         auto_reconcile?: boolean;
+        clock: () => number;
+        tick_period_ms: number;
+        send_rate_bytes_per_second?: number;
+        max_message_bytes?: number;
+        receive_window_bytes?: number;
+        max_queued_bytes?: number;
     });
     /** @type {number} */
     reconcile_count: number;
@@ -225,6 +262,14 @@ export class ServerAuthoritativeClient {
      * payload bytes. The handler should deserialize the bytes into
      * the world (the rewind has already happened; the buffer's bytes
      * ARE the new authoritative state at server_frame).
+     *
+     * The handler must leave `buffer.position` past what it read: those
+     * bytes are what this client keeps as the correction, and a later
+     * replay that crosses `server_frame` fires this again, at the end of
+     * that frame, with a buffer positioned at them.
+     *
+     * Write only the entity's replicated components: the correction's
+     * prior state, which a rewind puts back, is captured for those.
      * @type {Signal}
      */
     onApplyAuthState: Signal;
@@ -265,9 +310,11 @@ export class ServerAuthoritativeClient {
      * @param {number} peer_id
      */
     disconnect_from_server(peer_id: number): void;
-    /** Channel accessor for manual packet plumbing.
-     * @param {number} peer_id */
-    channel_for(peer_id: number): import("../transport/Channel.js").Channel;
+    /**
+     * The server's connection, for diagnostics. See {@link NetworkPeer#connection_for}.
+     * @param {number} peer_id
+     */
+    connection_for(peer_id: number): import("../transport/connection/Connection.js").Connection;
     /**
      * Run one client-side prediction tick: {@link begin_tick} followed immediately by
      * {@link end_tick}.
@@ -290,7 +337,8 @@ export class ServerAuthoritativeClient {
      */
     begin_tick(current_frame: number): void;
     /**
-     * Second half of a tick: close the frame and flush the action stream to the server.
+     * Second half of a tick: close the frame and send the action stream, with everything else
+     * queued, to the server.
      */
     end_tick(): void;
     /**
@@ -325,6 +373,25 @@ export class ServerAuthoritativeClient {
      * @param {BinaryBuffer} buffer positioned at the authoritative payload
      */
     reconcile(server_frame: number, network_id: number, buffer: BinaryBuffer): void;
+    /**
+     * Forget everything this client holds about the frames it has run: the
+     * action log's records — the kept corrections among them — the sampled
+     * input, and the newest reconciled frame per network id.
+     *
+     * For when the frame numbering they were kept under is replaced — a resync
+     * that brings a new world and seeks the clock, possibly backwards. Kept, a
+     * correction from the old numbering would be written into the new one by
+     * the first replay that crosses its frame number, and the old watermark
+     * would refuse the new AUTH_STATEs that should overwrite it. The log and the
+     * input matter where the seek leaves frames the new world never runs: a
+     * sync at host frame F seeks past F by the input lead, and a rewind to F
+     * crosses the frames in between — it would put back the old world's prior
+     * state from the records there, and the replay would hand the old input
+     * to {@link onReplay}.
+     *
+     * Must be called with no frame open.
+     */
+    forget_timeline(): void;
     /**
      * Helper for the {@link onComputeExpected} handler: stash the
      * computed scalar so the orchestrator can read it. Called inside the

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":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA8DI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,iPA/BW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,aAAiB,CAAC,EAAE,YAAY,CAAC;QACjC,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,cAAkB,CAAC,EAAE,OAAO,CAAC;KAC1B,EA8NH;IAnQD,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAEvB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,2BAFU,MAAM,CAEc;IAiD1B,0BAA0B;IAC1B,MADW,WAAW,CAUpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAClC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAEhD;;;;OAIG;IACH,YAFU,SAAS,CAKjB;IAEF,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;OAKG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;;OAKG;IACH,eAFU,YAAY,CAEY;IAElC;;;;OAIG;IACH,mBAFU,MAAM,CAEW;IAE3B;;;;;;;;OAQG;IACH,iBAFU,MAAM,CAEU;IAO1B;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;;;OASG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAEvC;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAFU,MAAM,CAEwB;IAa5C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;;OAWG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;;;OAMG;IACH,0BAFW,MAAM,QAUhB;IAED;;OAEG;IACH,iBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;;;;;OAQG;IACH,wBAJW,MAAM,cACN,MAAM,UACN,YAAY,QAItB;IA6OD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BA9sB2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBALnC,uCAAuC;6BAF7B,sCAAsC"}
+{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"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"}