@woosh/meep-engine 2.138.0 → 2.138.1

package/src/engine/network/diagnostics/BandwidthMeter.js

@@ -0,0 +1,155 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Aggregates `getStats()` snapshots from one or more named sources (typically
+ * a `Transport`, `Channel`, or `NetworkPeer.channel_for(peer)`) and reports
+ * recent throughput rates.
+ *
+ * Per-source stats are queried via the source's `getStats()` method. A "sample"
+ * captures the current totals at a wall-clock moment; the meter retains a
+ * sliding window of samples and computes bytes-per-second / packets-per-second
+ * over the window.
+ *
+ * No timer of its own — caller invokes {@link sample} per tick (or whenever).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class BandwidthMeter {
+    #sources;
+    #samples;
+
+
+    /**
+     * @param {{ window_seconds?: number }} [options]
+     */
+    constructor({ window_seconds = 5 } = {}) {
+        assert.isNumber(window_seconds, 'window_seconds');
+        if (window_seconds <= 0) throw new Error('BandwidthMeter: window_seconds must be > 0');
+
+        /** @readonly */
+        this.window_seconds = window_seconds;
+
+        /**
+         * Registered sources. Each is { name: string, source: { getStats() } }.
+         * @type {{name: string, source: any}[]}
+         * @private
+         */
+        this.#sources = [];
+
+        /**
+         * Per-window samples (oldest first). Each entry: { time_ms, totals }.
+         * @type {{time_ms: number, totals: {bytes_in: number, bytes_out: number, packets_in: number, packets_out: number}}[]}
+         * @private
+         */
+        this.#samples = [];
+    }
+
+    /**
+     * @param {string} name human-readable label
+     * @param {{ getStats(): {bytes_in: number, bytes_out: number, packets_in: number, packets_out: number} }} source
+     */
+    add_source(name, source) {
+        assert.isString(name, 'name');
+        assert.ok(source && typeof source.getStats === 'function', 'source must implement getStats()');
+        this.#sources.push({ name, source });
+    }
+
+    /**
+     * Capture a fresh sample at the given wall-clock time (caller-supplied so
+     * tests can use a deterministic clock; in production typically `Date.now()`).
+     *
+     * @param {number} now_ms
+     */
+    sample(now_ms) {
+        assert.isNumber(now_ms, 'now_ms');
+        const totals = this.#sum_totals();
+        this.#samples.push({ time_ms: now_ms, totals });
+
+        // Drop samples older than the window, but keep one straddling expired
+        // sample if it's the only thing standing between us and "only the
+        // just-pushed sample is left" (which would silently make __rate return
+        // 0 after a long quiet stretch). Once we have 2+ in-window samples the
+        // straddle is no longer needed and would bias the rate, so drop it.
+        const cutoff = now_ms - this.window_seconds * 1000;
+        while (this.#samples.length >= 2 && this.#samples[1].time_ms < cutoff) {
+            this.#samples.shift();
+        }
+        if (this.#samples.length >= 3 && this.#samples[0].time_ms < cutoff) {
+            this.#samples.shift();
+        }
+    }
+
+    /**
+     * Cumulative totals across all sources, right now (re-queries getStats()).
+     * Independent of the sample window.
+     */
+    cumulative() {
+        return this.#sum_totals();
+    }
+
+    /**
+     * Bytes-per-second received, averaged over the sample window.
+     * Returns 0 if fewer than 2 samples have been taken.
+     */
+    rate_bytes_in() {
+        return this.#rate('bytes_in');
+    }
+    rate_bytes_out() {
+        return this.#rate('bytes_out');
+    }
+    rate_packets_in() {
+        return this.#rate('packets_in');
+    }
+    rate_packets_out() {
+        return this.#rate('packets_out');
+    }
+
+    /**
+     * Per-source breakdown of cumulative totals (re-queries getStats()).
+     * @returns {Array<{name: string, totals: object}>}
+     */
+    per_source() {
+        const result = [];
+        for (let i = 0; i < this.#sources.length; i++) {
+            const s = this.#sources[i];
+            result.push({ name: s.name, totals: s.source.getStats() });
+        }
+        return result;
+    }
+
+    /**
+     * Drop all retained samples. Source registrations are preserved.
+     */
+    reset_samples() {
+        this.#samples.length = 0;
+    }
+
+    /**
+     * @private
+     */
+    #sum_totals() {
+        let bytes_in = 0, bytes_out = 0, packets_in = 0, packets_out = 0;
+        for (let i = 0; i < this.#sources.length; i++) {
+            const s = this.#sources[i].source.getStats();
+            bytes_in += s.bytes_in;
+            bytes_out += s.bytes_out;
+            packets_in += s.packets_in;
+            packets_out += s.packets_out;
+        }
+        return { bytes_in, bytes_out, packets_in, packets_out };
+    }
+
+    /**
+     * @private
+     */
+    #rate(key) {
+        const n = this.#samples.length;
+        if (n < 2) return 0;
+        const oldest = this.#samples[0];
+        const newest = this.#samples[n - 1];
+        const dt_seconds = (newest.time_ms - oldest.time_ms) / 1000;
+        if (dt_seconds <= 0) return 0;
+        return (newest.totals[key] - oldest.totals[key]) / dt_seconds;
+    }
+}

package/src/engine/network/diagnostics/ReplayLog.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Append-only record of action bytes per frame. Useful for offline replay,
+ * bug reproduction, and demos.
+ *
+ * Each entry stores a copy of the action bytes for one frame. The bytes
+ * typically come from the per-frame `ActionLog` buffer (the action portion
+ * after `Replicator.pack_for_peer` strips prior-state). The format on the wire
+ * is the same one `Replicator.unpack_from_peer` consumes, so a recorded
+ * session can be replayed by feeding the bytes back through a peer.
+ *
+ * Persistence to disk / IndexedDB / network is left to the application —
+ * `serialize_to_buffer` produces a single contiguous `BinaryBuffer` snapshot.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class ReplayLog {
+    /**
+     * Build a ReplayLog from a previously-serialized buffer. Reads from the
+     * buffer's current position; advances the position past the consumed bytes.
+     *
+     * @param {BinaryBuffer} buffer
+     * @returns {ReplayLog}
+     */
+    static deserialize_from_buffer(buffer: BinaryBuffer): ReplayLog;
+    /**
+     * Append a frame's bytes. The source array is copied; caller may reuse it.
+     *
+     * @param {number} frame
+     * @param {Uint8Array} bytes
+     * @param {number} length
+     */
+    record(frame: number, bytes: Uint8Array, length: number): void;
+    /**
+     * @returns {number}
+     */
+    size(): number;
+    /**
+     * Iterate frames in `[start_frame, end_frame]` (inclusive).
+     * @param {number} start_frame
+     * @param {number} end_frame
+     * @param {function(number, Uint8Array): void} callback receives (frame, bytes)
+     */
+    for_each_in_range(start_frame: number, end_frame: number, callback: (arg0: number, arg1: Uint8Array) => void): void;
+    /**
+     * Drop all entries.
+     */
+    clear(): void;
+    /**
+     * Frame number of the first entry, or -1 if empty.
+     */
+    earliest_frame(): any;
+    /**
+     * Frame number of the last entry, or -1 if empty.
+     */
+    latest_frame(): any;
+    /**
+     * Serialize the entire log to a fresh buffer. Format:
+     * ```
+     *   varint:    entry_count
+     *   loop:
+     *     varint:  frame
+     *     varint:  bytes_length
+     *     bytes:   payload
+     * ```
+     *
+     * @param {BinaryBuffer} [buffer] if provided, written into; otherwise a fresh one is created
+     * @returns {BinaryBuffer}
+     */
+    serialize_to_buffer(buffer?: BinaryBuffer): BinaryBuffer;
+    #private;
+}
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+//# sourceMappingURL=ReplayLog.d.ts.map

package/src/engine/network/diagnostics/ReplayLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplayLog.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/diagnostics/ReplayLog.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH;IAkGI;;;;;;OAMG;IACH,uCAHW,YAAY,GACV,SAAS,CAarB;IAxGD;;;;;;OAMG;IACH,cAJW,MAAM,SACN,UAAU,UACV,MAAM,QAQhB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,+BAJW,MAAM,aACN,MAAM,mBACG,MAAM,QAAE,UAAU,KAAG,IAAI,QAY5C;IAED;;OAEG;IACH,cAEC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;;;;;;;;OAYG;IACH,6BAHW,YAAY,GACV,YAAY,CAYxB;;CAqBJ;6BAvI4B,sCAAsC"}

package/src/engine/network/diagnostics/ReplayLog.js

@@ -0,0 +1,137 @@
+import { assert } from "../../../core/assert.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+/**
+ * Append-only record of action bytes per frame. Useful for offline replay,
+ * bug reproduction, and demos.
+ *
+ * Each entry stores a copy of the action bytes for one frame. The bytes
+ * typically come from the per-frame `ActionLog` buffer (the action portion
+ * after `Replicator.pack_for_peer` strips prior-state). The format on the wire
+ * is the same one `Replicator.unpack_from_peer` consumes, so a recorded
+ * session can be replayed by feeding the bytes back through a peer.
+ *
+ * Persistence to disk / IndexedDB / network is left to the application —
+ * `serialize_to_buffer` produces a single contiguous `BinaryBuffer` snapshot.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class ReplayLog {
+    #entries;
+
+
+    constructor() {
+        /**
+         * @type {{frame: number, bytes: Uint8Array}[]}
+         * @private
+         */
+        this.#entries = [];
+    }
+
+    /**
+     * Append a frame's bytes. The source array is copied; caller may reuse it.
+     *
+     * @param {number} frame
+     * @param {Uint8Array} bytes
+     * @param {number} length
+     */
+    record(frame, bytes, length) {
+        assert.isNonNegativeInteger(frame, 'frame');
+        assert.isNonNegativeInteger(length, 'length');
+        const copy = new Uint8Array(length);
+        copy.set(bytes.subarray(0, length));
+        this.#entries.push({ frame, bytes: copy });
+    }
+
+    /**
+     * @returns {number}
+     */
+    size() {
+        return this.#entries.length;
+    }
+
+    /**
+     * Iterate frames in `[start_frame, end_frame]` (inclusive).
+     * @param {number} start_frame
+     * @param {number} end_frame
+     * @param {function(number, Uint8Array): void} callback receives (frame, bytes)
+     */
+    for_each_in_range(start_frame, end_frame, callback) {
+        assert.isNonNegativeInteger(start_frame, 'start_frame');
+        assert.isNonNegativeInteger(end_frame, 'end_frame');
+        assert.isFunction(callback, 'callback');
+        for (let i = 0; i < this.#entries.length; i++) {
+            const e = this.#entries[i];
+            if (e.frame >= start_frame && e.frame <= end_frame) {
+                callback(e.frame, e.bytes);
+            }
+        }
+    }
+
+    /**
+     * Drop all entries.
+     */
+    clear() {
+        this.#entries.length = 0;
+    }
+
+    /**
+     * Frame number of the first entry, or -1 if empty.
+     */
+    earliest_frame() {
+        return this.#entries.length === 0 ? -1 : this.#entries[0].frame;
+    }
+
+    /**
+     * Frame number of the last entry, or -1 if empty.
+     */
+    latest_frame() {
+        return this.#entries.length === 0 ? -1 : this.#entries[this.#entries.length - 1].frame;
+    }
+
+    /**
+     * Serialize the entire log to a fresh buffer. Format:
+     * ```
+     *   varint:    entry_count
+     *   loop:
+     *     varint:  frame
+     *     varint:  bytes_length
+     *     bytes:   payload
+     * ```
+     *
+     * @param {BinaryBuffer} [buffer] if provided, written into; otherwise a fresh one is created
+     * @returns {BinaryBuffer}
+     */
+    serialize_to_buffer(buffer) {
+        const buf = buffer === undefined ? new BinaryBuffer() : buffer;
+        buf.writeUintVar(this.#entries.length);
+        for (let i = 0; i < this.#entries.length; i++) {
+            const e = this.#entries[i];
+            buf.writeUintVar(e.frame);
+            buf.writeUintVar(e.bytes.length);
+            buf.writeBytes(e.bytes, 0, e.bytes.length);
+        }
+        return buf;
+    }
+
+    /**
+     * Build a ReplayLog from a previously-serialized buffer. Reads from the
+     * buffer's current position; advances the position past the consumed bytes.
+     *
+     * @param {BinaryBuffer} buffer
+     * @returns {ReplayLog}
+     */
+    static deserialize_from_buffer(buffer) {
+        const log = new ReplayLog();
+        const count = buffer.readUintVar();
+        for (let i = 0; i < count; i++) {
+            const frame = buffer.readUintVar();
+            const length = buffer.readUintVar();
+            const bytes = new Uint8Array(length);
+            buffer.readUint8Array(bytes, 0, length);
+            log.#entries.push({ frame, bytes });
+        }
+        return log;
+    }
+}

package/src/engine/network/diagnostics/SyncTest.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Compute a 32-bit fingerprint of every replicated component on every entity
+ * in the world. Used by `SyncTest` and as a general "did the world state change?"
+ * primitive.
+ *
+ * The hash is FNV-1a — fast, stable, no dependencies. Not cryptographic.
+ *
+ * Iteration order: entities in the order yielded by `world` (the
+ * EntityComponentDataset's iterator), then components in `type_id` order.
+ * As long as both sides iterate identically, the fingerprint is comparable.
+ *
+ * @param {EntityComponentDataset} world
+ * @param {ReplicatedComponentRegistry} component_registry
+ * @param {BinaryBuffer} [scratch] optional reusable scratch; resets to position 0 each call
+ * @returns {number} 32-bit unsigned hash
+ */
+export function fingerprint_world(world: EntityComponentDataset, component_registry: ReplicatedComponentRegistry, scratch?: BinaryBuffer): number;
+/**
+ * Diagnostic harness for catching rewind / replay bugs.
+ *
+ * Usage:
+ *   - `harness.checkpoint()` — records the current world fingerprint.
+ *   - … run tick logic …
+ *   - `harness.assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame)`
+ *     rewinds and asserts the world's fingerprint matches the checkpoint.
+ *
+ * For full nondeterminism detection (GGPO-style "save → advance → load →
+ * advance → diff"), the application's tick logic must be re-runnable; that
+ * coordination is left to the caller. This harness provides the fingerprint +
+ * compare primitives and the assertion shape.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class SyncTest {
+    /**
+     * @param {{
+     *   world: EntityComponentDataset,
+     *   component_registry: ReplicatedComponentRegistry,
+     * }} options
+     */
+    constructor({ world, component_registry }: {
+        world: EntityComponentDataset;
+        component_registry: ReplicatedComponentRegistry;
+    });
+    /** @type {EntityComponentDataset} */
+    world: EntityComponentDataset;
+    /** @type {ReplicatedComponentRegistry} */
+    component_registry: ReplicatedComponentRegistry;
+    /**
+     * Capture the current world state as the reference point for the next
+     * `assert_recoverable_to_checkpoint` call.
+     */
+    checkpoint(): void;
+    /**
+     * @returns {number}
+     */
+    current_fingerprint(): number;
+    /**
+     * Rewind from `current_frame` back to `target_frame` (typically the frame
+     * at which `checkpoint()` was called) and assert the resulting world state
+     * matches the checkpoint.
+     *
+     * Throws on mismatch with a diagnostic message including both fingerprints.
+     *
+     * @param {RewindEngine} rewind_engine
+     * @param {number} current_frame
+     * @param {number} target_frame
+     */
+    assert_recoverable_to_checkpoint(rewind_engine: RewindEngine, current_frame: number, target_frame: number): void;
+    #private;
+}
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+//# sourceMappingURL=SyncTest.d.ts.map

package/src/engine/network/diagnostics/SyncTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncTest.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/diagnostics/SyncTest.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,4HAHW,YAAY,GACV,MAAM,CAmClB;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH;IAMI;;;;;OAKG;IACH,2CALW;QACV,KAAS,yBAAyB;QAClC,kBAAsB,8BAA8B;KACjD,EAoBH;IAdG,qCAAqC;IACrC,8BAAkB;IAElB,0CAA0C;IAC1C,gDAA4C;IAYhD;;;OAGG;IACH,mBAGC;IAED;;OAEG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,6EAHW,MAAM,gBACN,MAAM,QAahB;;CACJ;6BArJ4B,sCAAsC"}

package/src/engine/network/diagnostics/SyncTest.js

@@ -0,0 +1,151 @@
+import { assert } from "../../../core/assert.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+/**
+ * Compute a 32-bit fingerprint of every replicated component on every entity
+ * in the world. Used by `SyncTest` and as a general "did the world state change?"
+ * primitive.
+ *
+ * The hash is FNV-1a — fast, stable, no dependencies. Not cryptographic.
+ *
+ * Iteration order: entities in the order yielded by `world` (the
+ * EntityComponentDataset's iterator), then components in `type_id` order.
+ * As long as both sides iterate identically, the fingerprint is comparable.
+ *
+ * @param {EntityComponentDataset} world
+ * @param {ReplicatedComponentRegistry} component_registry
+ * @param {BinaryBuffer} [scratch] optional reusable scratch; resets to position 0 each call
+ * @returns {number} 32-bit unsigned hash
+ */
+export function fingerprint_world(world, component_registry, scratch) {
+    assert.ok(world, 'world required');
+    assert.ok(component_registry, 'component_registry required');
+
+    const buffer = scratch === undefined ? new BinaryBuffer() : scratch;
+    let h = 0x811c9dc5; // FNV-1a 32-bit offset basis
+
+    const type_count = component_registry.type_count();
+    for (const entity of world) {
+        for (let type_id = 0; type_id < type_count; type_id++) {
+            const klass = component_registry.class_of(type_id);
+            if (!world.hasComponent(entity, klass)) continue;
+
+            const adapter = component_registry.adapter_for_id(type_id);
+            buffer.position = 0;
+            adapter.serialize(buffer, world.getComponent(entity, klass));
+
+            // Mix entity_id and type_id into the hash so structurally-identical
+            // components on different entities/types produce different prints.
+            h = __fnv_byte(h, entity & 0xFF);
+            h = __fnv_byte(h, (entity >> 8) & 0xFF);
+            h = __fnv_byte(h, (entity >> 16) & 0xFF);
+            h = __fnv_byte(h, (entity >> 24) & 0xFF);
+            h = __fnv_byte(h, type_id);
+
+            const bytes = buffer.raw_bytes;
+            const len = buffer.position;
+            for (let i = 0; i < len; i++) {
+                h = __fnv_byte(h, bytes[i]);
+            }
+        }
+    }
+    return h >>> 0;
+}
+
+/**
+ * @private
+ */
+function __fnv_byte(h, byte) {
+    h ^= byte;
+    return Math.imul(h, 0x01000193) >>> 0;
+}
+
+/**
+ * Diagnostic harness for catching rewind / replay bugs.
+ *
+ * Usage:
+ *   - `harness.checkpoint()` — records the current world fingerprint.
+ *   - … run tick logic …
+ *   - `harness.assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame)`
+ *     rewinds and asserts the world's fingerprint matches the checkpoint.
+ *
+ * For full nondeterminism detection (GGPO-style "save → advance → load →
+ * advance → diff"), the application's tick logic must be re-runnable; that
+ * coordination is left to the caller. This harness provides the fingerprint +
+ * compare primitives and the assertion shape.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class SyncTest {
+    #scratch;
+    #checkpoint_hash;
+    #has_checkpoint;
+
+
+    /**
+     * @param {{
+     *   world: EntityComponentDataset,
+     *   component_registry: ReplicatedComponentRegistry,
+     * }} options
+     */
+    constructor({ world, component_registry }) {
+        assert.ok(world, 'world required');
+        assert.ok(component_registry, 'component_registry required');
+
+        /** @type {EntityComponentDataset} */
+        this.world = world;
+
+        /** @type {ReplicatedComponentRegistry} */
+        this.component_registry = component_registry;
+
+        /** Reused scratch for fingerprint serialization. */
+        this.#scratch = new BinaryBuffer();
+
+        /** @type {number} @private */
+        this.#checkpoint_hash = 0;
+
+        /** @type {boolean} @private */
+        this.#has_checkpoint = false;
+    }
+
+    /**
+     * Capture the current world state as the reference point for the next
+     * `assert_recoverable_to_checkpoint` call.
+     */
+    checkpoint() {
+        this.#checkpoint_hash = fingerprint_world(this.world, this.component_registry, this.#scratch);
+        this.#has_checkpoint = true;
+    }
+
+    /**
+     * @returns {number}
+     */
+    current_fingerprint() {
+        return fingerprint_world(this.world, this.component_registry, this.#scratch);
+    }
+
+    /**
+     * Rewind from `current_frame` back to `target_frame` (typically the frame
+     * at which `checkpoint()` was called) and assert the resulting world state
+     * matches the checkpoint.
+     *
+     * Throws on mismatch with a diagnostic message including both fingerprints.
+     *
+     * @param {RewindEngine} rewind_engine
+     * @param {number} current_frame
+     * @param {number} target_frame
+     */
+    assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame) {
+        assert.ok(this.#has_checkpoint, 'SyncTest: no checkpoint() taken before assertion');
+        rewind_engine.rewind_to(current_frame, target_frame);
+        const after = fingerprint_world(this.world, this.component_registry, this.#scratch);
+        if (after !== this.#checkpoint_hash) {
+            throw new Error(
+                `SyncTest: world fingerprint after rewind (${after.toString(16)}) ` +
+                `does not match checkpoint (${this.#checkpoint_hash.toString(16)}) ` +
+                `— rewind is non-deterministic or did not fully restore state`
+            );
+        }
+    }
+}

package/src/engine/network/ecs/NetworkSystem.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ECS system that owns the per-entity replication lifecycle.
+ *
+ * Responsibilities:
+ *   - When an entity gains a {@link NetworkIdentity}, allocate a `network_id`
+ *     in the peer's slot table (or honour an explicit pre-set one — used by
+ *     `Snapshotter` and incoming-packet flows).
+ *   - When an entity loses its `NetworkIdentity` (or is destroyed), free the
+ *     slot.
+ *
+ * **Not** responsible for the per-tick `begin_tick` / `end_tick` cadence —
+ * the engine's `EntityManager` doesn't expose pre/post-simulate hooks, so the
+ * application code wraps its `engine.simulate(dt)` call:
+ *
+ * ```js
+ *   peer.begin_tick(frame_number);
+ *   engine.simulate(dt);
+ *   peer.end_tick();
+ * ```
+ *
+ * Add this system to the engine once per `NetworkPeer` instance:
+ *
+ * ```js
+ *   const peer = new NetworkPeer({ ... });
+ *   const network_system = new NetworkSystem(peer);
+ *   engine.entityManager.addSystem(network_system);
+ * ```
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class NetworkSystem extends System<any, any, any, any, any> {
+    /**
+     * @param {NetworkPeer} peer
+     */
+    constructor(peer: NetworkPeer);
+    dependencies: (typeof NetworkIdentity)[];
+    components_used: ResourceAccessSpecification<typeof NetworkIdentity>[];
+    /**
+     * @type {NetworkPeer}
+     */
+    peer: NetworkPeer;
+    /**
+     * @param {NetworkIdentity} identity
+     * @param {number} entity
+     */
+    link(identity: NetworkIdentity, entity: number): void;
+    /**
+     * @param {NetworkIdentity} identity
+     * @param {number} entity
+     */
+    unlink(identity: NetworkIdentity, entity: number): void;
+}
+import { System } from "../../ecs/System.js";
+import { NetworkIdentity } from "./components/NetworkIdentity.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+//# sourceMappingURL=NetworkSystem.d.ts.map

package/src/engine/network/ecs/NetworkSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/ecs/NetworkSystem.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAQI;;OAEG;IACH,+BAQC;IAjBD,yCAAiC;IAEjC,uEAEE;IASE;;OAEG;IACH,kBAAgB;IAGpB;;;OAGG;IACH,eAHW,eAAe,UACf,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHW,eAAe,UACf,MAAM,QAOhB;CACJ;uBAhFsB,qBAAqB;gCACZ,iCAAiC;4CAFrB,oDAAoD"}