@woosh/meep-engine 2.156.0 → 2.157.0

package/src/engine/graphics/texture/3d/scs3d_sample_linear3.js

@@ -0,0 +1,81 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import { lerp } from "../../../../core/math/lerp.js";
+
+/**
+ * Trilinearly sample THREE single-channel 3D grids at the same fractional
+ * position, sharing one set of corner indices and interpolation weights.
+ *
+ * Identical result to calling {@link scs3d_sample_linear} once per channel —
+ * but the index/weight computation (the majority of the scalar sampler's work)
+ * is done once instead of three times. The fluid advection kernels sample
+ * velocity_x/y/z at a common back-traced point per cell, which makes this the
+ * hot sampling path.
+ *
+ * Positions outside the grid are clamped to the edge, channel-independently
+ * identical to the scalar sampler.
+ *
+ * @param {Float32Array|number[]} out  length-3 destination, one value per channel
+ * @param {Float32Array} data_0
+ * @param {Float32Array} data_1
+ * @param {Float32Array} data_2
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {Float32Array|number[]} `out`, for chaining.
+ */
+export function scs3d_sample_linear3(out, data_0, data_1, data_2, res_x, res_y, res_z, x, y, z) {
+    const x_max = res_x - 1;
+    const y_max = res_y - 1;
+    const z_max = res_z - 1;
+
+    const x_clamped = clamp(x, 0, x_max);
+    const y_clamped = clamp(y, 0, y_max);
+    const z_clamped = clamp(z, 0, z_max);
+
+    const x0 = x_clamped | 0;
+    const y0 = y_clamped | 0;
+    const z0 = z_clamped | 0;
+
+    const f_x = x_clamped - x0;
+    const f_y = y_clamped - y0;
+    const f_z = z_clamped - z0;
+
+    const x1 = x_clamped === x0 ? x0 : x0 + 1;
+    const y1 = y_clamped === y0 ? y0 : y0 + 1;
+    const z1 = z_clamped === z0 ? z0 : z0 + 1;
+
+    const slice = res_x * res_y;
+    const z0_offset = z0 * slice;
+    const z1_offset = z1 * slice;
+    const y0_offset = y0 * res_x;
+    const y1_offset = y1 * res_x;
+
+    const c000 = z0_offset + y0_offset + x0;
+    const c100 = z0_offset + y0_offset + x1;
+    const c010 = z0_offset + y1_offset + x0;
+    const c110 = z0_offset + y1_offset + x1;
+    const c001 = z1_offset + y0_offset + x0;
+    const c101 = z1_offset + y0_offset + x1;
+    const c011 = z1_offset + y1_offset + x0;
+    const c111 = z1_offset + y1_offset + x1;
+
+    out[0] = lerp(
+        lerp(lerp(data_0[c000], data_0[c100], f_x), lerp(data_0[c010], data_0[c110], f_x), f_y),
+        lerp(lerp(data_0[c001], data_0[c101], f_x), lerp(data_0[c011], data_0[c111], f_x), f_y),
+        f_z
+    );
+    out[1] = lerp(
+        lerp(lerp(data_1[c000], data_1[c100], f_x), lerp(data_1[c010], data_1[c110], f_x), f_y),
+        lerp(lerp(data_1[c001], data_1[c101], f_x), lerp(data_1[c011], data_1[c111], f_x), f_y),
+        f_z
+    );
+    out[2] = lerp(
+        lerp(lerp(data_2[c000], data_2[c100], f_x), lerp(data_2[c010], data_2[c110], f_x), f_y),
+        lerp(lerp(data_2[c001], data_2[c101], f_x), lerp(data_2[c011], data_2[c111], f_x), f_y),
+        f_z
+    );
+    return out;
+}

package/src/engine/graphics/texture/isImageBitmap.d.ts

@@ -1,7 +1,2 @@
-/**
- * Guards against cases where ImageBitmap doesn't exist
- * @param {*} image
- * @return {boolean}
- */
-export function isImageBitmap(image: any): boolean;
+export { isImageBitmap } from "../../../core/dom/isImageBitmap.js";
 //# sourceMappingURL=isImageBitmap.d.ts.map

package/src/engine/graphics/texture/isImageBitmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isImageBitmap.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/isImageBitmap.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,2CAFY,OAAO,CAQlB"}
+{"version":3,"file":"isImageBitmap.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/texture/isImageBitmap.js"],"names":[],"mappings":""}

package/src/engine/graphics/texture/isImageBitmap.js

@@ -1,12 +1,2 @@
-/**
- * Guards against cases where ImageBitmap doesn't exist
- * @param {*} image
- * @return {boolean}
- */
-export function isImageBitmap(image) {
-    /**
-     * check that browser/environment has the class at all to avoid potential exceptions
-     * Required for Safari below version 15.6
-     */
-    return typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;
-}
+// Re-export for path compatibility; implementation lives in core/dom/isImageBitmap.js
+export { isImageBitmap } from "../../../core/dom/isImageBitmap.js";

package/src/{core/process/action → engine/intelligence/behavior/util}/AsynchronousDelayAction.d.ts

@@ -10,6 +10,6 @@ export class AsynchronousDelayAction extends AsynchronousAction {
     __entity: Entity;
     cancel(): Promise<void>;
 }
-import { AsynchronousAction } from "./AsynchronousAction.js";
-import Entity from "../../../engine/ecs/Entity.js";
+import { AsynchronousAction } from "../../../../core/process/action/AsynchronousAction.js";
+import Entity from "../../../ecs/Entity.js";
 //# sourceMappingURL=AsynchronousDelayAction.d.ts.map

package/src/engine/intelligence/behavior/util/AsynchronousDelayAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsynchronousDelayAction.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/util/AsynchronousDelayAction.js"],"names":[],"mappings":"AAUA;IAEI;;;;OAIG;IACH,+CAFW,MAAM,EAqBhB;IAdG,8BAAgB;IAChB,eAAkB;IAElB,iBAA4B;IAahC,wBASC;CAOJ;mCArDkC,uDAAuD;mBAEvE,wBAAwB"}

package/src/{core/process/action → engine/intelligence/behavior/util}/AsynchronousDelayAction.js

@@ -1,55 +1,55 @@
-import Entity from "../../../engine/ecs/Entity.js";
-import { SequenceBehavior } from "../../../engine/intelligence/behavior/composite/SequenceBehavior.js";
-import { BehaviorComponent } from "../../../engine/intelligence/behavior/ecs/BehaviorComponent.js";
-import { DieBehavior } from "../../../engine/intelligence/behavior/ecs/DieBehavior.js";
-import { ActionBehavior } from "../../../engine/intelligence/behavior/primitive/ActionBehavior.js";
-import { DelayBehavior } from "../../../engine/intelligence/behavior/util/DelayBehavior.js";
-import { assert } from "../../assert.js";
-import TaskState from "../task/TaskState.js";
-import { AsynchronousAction } from "./AsynchronousAction.js";
-
-export class AsynchronousDelayAction extends AsynchronousAction {
-
-    /**
-     *
-     * @param {EntityComponentDataset} ecd
-     * @param {number} time in seconds
-     */
-    constructor(ecd, time) {
-        super();
-
-        assert.isNumber(time, 'time');
-
-        this.__ecd = ecd;
-        this.__time = time;
-
-        this.__entity = new Entity();
-
-        this.__entity.add(BehaviorComponent.from(
-            SequenceBehavior.from([
-                DelayBehavior.from(time),
-                new ActionBehavior(() => {
-                    this.__succeed();
-                }),
-                DieBehavior.create()
-            ])
-        ));
-    }
-
-    cancel() {
-        if (this.status === TaskState.RUNNING) {
-            this.__entity.destroy();
-            // transition state and notify listeners, mirroring AsynchronousActionSequence.cancel
-            this.status = TaskState.CANCELLED;
-            this.on.cancelled.send0();
-        }
-
-        return Promise.resolve();
-    }
-
-    start() {
-        super.start();
-
-        this.__entity.build(this.__ecd);
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { AsynchronousAction } from "../../../../core/process/action/AsynchronousAction.js";
+import TaskState from "../../../../core/process/task/TaskState.js";
+import Entity from "../../../ecs/Entity.js";
+import { SequenceBehavior } from "../composite/SequenceBehavior.js";
+import { BehaviorComponent } from "../ecs/BehaviorComponent.js";
+import { DieBehavior } from "../ecs/DieBehavior.js";
+import { ActionBehavior } from "../primitive/ActionBehavior.js";
+import { DelayBehavior } from "./DelayBehavior.js";
+
+export class AsynchronousDelayAction extends AsynchronousAction {
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {number} time in seconds
+     */
+    constructor(ecd, time) {
+        super();
+
+        assert.isNumber(time, 'time');
+
+        this.__ecd = ecd;
+        this.__time = time;
+
+        this.__entity = new Entity();
+
+        this.__entity.add(BehaviorComponent.from(
+            SequenceBehavior.from([
+                DelayBehavior.from(time),
+                new ActionBehavior(() => {
+                    this.__succeed();
+                }),
+                DieBehavior.create()
+            ])
+        ));
+    }
+
+    cancel() {
+        if (this.status === TaskState.RUNNING) {
+            this.__entity.destroy();
+            // transition state and notify listeners, mirroring AsynchronousActionSequence.cancel
+            this.status = TaskState.CANCELLED;
+            this.on.cancelled.send0();
+        }
+
+        return Promise.resolve();
+    }
+
+    start() {
+        super.start();
+
+        this.__entity.build(this.__ecd);
+    }
+}

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

@@ -94,6 +94,9 @@ export class NetworkSession {
      * - `simulation_delay_ticks` is honored only under `role: 'host'`.
      *   Default 4. See {@link ServerAuthoritativeServer}.
      * - `tick_rate_hz` defaults to 60.
+     * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
+     *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).
+     *   Default 32. Raise it for high-RTT / lossy links.
      * - `scope_filter` defaults to {@link OwnerAwareScope} on the host.
      * - `server_resume_grace_ms` (host role): how long peer state is
      *   retained after a transport drop before being freed. Default 30s.
@@ -101,7 +104,7 @@ export class NetworkSession {
      *   {@link DEFAULT_RECONNECT_POLICY}. Set `enabled: false` to opt
      *   out entirely.
      */
-    constructor({ entity_manager, transport, transport_factory, role, local_peer_id, simulation_delay_ticks, tick_rate_hz, binary_registry, scope_filter, time_dilation, adaptive_render_delay, server_resume_grace_ms, reconnect, }?: {
+    constructor({ entity_manager, transport, transport_factory, role, local_peer_id, simulation_delay_ticks, tick_rate_hz, frame_capacity, binary_registry, scope_filter, time_dilation, adaptive_render_delay, server_resume_grace_ms, reconnect, }?: {
         entity_manager: EntityManager;
         transport?: object;
         transport_factory?: (() => object);
@@ -205,6 +208,14 @@ export class NetworkSession {
      * @type {number}
      */
     readonly simulation_delay_ticks: number;
+    /**
+     * Depth of the action-log ring passed to the orchestrator. Bounds
+     * rollback depth, back-fill range, and retransmit window — see
+     * {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}.
+     * @readonly
+     * @type {number}
+     */
+    readonly frame_capacity: number;
     /**
      * @readonly
      * @type {number}

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":"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"}
+{"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

@@ -45,6 +45,25 @@ export const NetworkSessionRole = Object.freeze({
 const DEFAULT_TICK_RATE_HZ = 60;
 const DEFAULT_SIMULATION_DELAY_TICKS = 4;
 const DEFAULT_INITIAL_RENDER_DELAY_FRAMES = 6;
+
+/**
+ * Default depth of the action-log ring (in frames). This single value bounds
+ * THREE distinct horizons at once:
+ *   1. Rollback depth — how far back the server can rewind+replay to fold in
+ *      late client input.
+ *   2. Fresh-connect back-fill range — how many past frames a newly-connected
+ *      peer's action stream covers before it has acked anything.
+ *   3. Action-stream retransmit window — how long an unacked frame stays
+ *      resendable before it ages out of the ring.
+ *
+ * At 60 Hz, 32 frames ≈ 0.53 s. That is comfortable for rollback but tight for
+ * loss recovery on high-latency links: if a peer's ack RTT + jitter exceeds the
+ * window, unacked frames age out and the action stream develops gaps that fall
+ * back to the heavier RECOVERY_REQUEST → STATE_BURST path. Raise `frame_capacity`
+ * for high-RTT / lossy deployments (memory cost is ~one buffer per frame per
+ * orchestrator, so it is cheap to grow).
+ */
+const DEFAULT_ACTION_LOG_FRAME_CAPACITY = 32;
 const PULL_PER_MS = 0.0005;        // wall-clock low-pass on render frame state machine
 const MAX_CLIENT_DILATED_TICKS_PER_STEP = 3;
 const MAX_FIXED_STEPS_PER_TICK = 8;
@@ -79,6 +98,13 @@ const ReconnectState = Object.freeze({
  */
 const SCRATCH_BUFFER_BYTES = 1024;
 
+/**
+ * Shared zero-length payload for empty ack packets. Hoisted to module scope so
+ * the per-peer, per-tick ack send doesn't allocate a fresh array each time.
+ * @type {Uint8Array}
+ */
+const EMPTY_PAYLOAD = new Uint8Array(0);
+
 /**
  * High-level networking facade. Wraps the orchestrator + state machinery
  * into one config + lifecycle surface. The lower-level orchestrators
@@ -358,6 +384,9 @@ export class NetworkSession {
      * - `simulation_delay_ticks` is honored only under `role: 'host'`.
      *   Default 4. See {@link ServerAuthoritativeServer}.
      * - `tick_rate_hz` defaults to 60.
+     * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
+     *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).
+     *   Default 32. Raise it for high-RTT / lossy links.
      * - `scope_filter` defaults to {@link OwnerAwareScope} on the host.
      * - `server_resume_grace_ms` (host role): how long peer state is
      *   retained after a transport drop before being freed. Default 30s.
@@ -373,6 +402,7 @@ export class NetworkSession {
                     local_peer_id = -1,
                     simulation_delay_ticks = DEFAULT_SIMULATION_DELAY_TICKS,
                     tick_rate_hz = DEFAULT_TICK_RATE_HZ,
+                    frame_capacity = DEFAULT_ACTION_LOG_FRAME_CAPACITY,
                     binary_registry = null,
                     scope_filter = null,
                     time_dilation = null,
@@ -388,6 +418,7 @@ export class NetworkSession {
         assert.isNumber(tick_rate_hz, 'tick_rate_hz');
         assert.ok(tick_rate_hz > 0, 'tick_rate_hz must be positive');
         assert.isNonNegativeInteger(simulation_delay_ticks, 'simulation_delay_ticks');
+        assert.isPositiveInteger(frame_capacity, 'frame_capacity');
 
         /**
          * @readonly
@@ -421,6 +452,15 @@ export class NetworkSession {
             ? simulation_delay_ticks
             : 0;
 
+        /**
+         * Depth of the action-log ring passed to the orchestrator. Bounds
+         * rollback depth, back-fill range, and retransmit window — see
+         * {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}.
+         * @readonly
+         * @type {number}
+         */
+        this.frame_capacity = frame_capacity;
+
         /**
          * @readonly
          * @type {number}
@@ -631,6 +671,7 @@ export class NetworkSession {
             binary_registry: this.binary_registry,
             replicated_components,
             action_classes,
+            frame_capacity: this.frame_capacity,
         };
 
         if (this.role === NetworkSessionRole.Host) {
@@ -867,6 +908,9 @@ export class NetworkSession {
             this.#peer.disconnect_peer(peer_id);
         } catch (_) { /* swallow */
         }
+        // Drop the peer from the live send set so the (still-running) tick loop
+        // doesn't try to push empty-ack packets through the disposed channel.
+        this.#connected_peers.delete(peer_id);
         if (this.#current_transport_listener !== null && this.#current_transport !== null) {
             try {
                 this.#current_transport.onDisconnect.remove(this.#current_transport_listener);
@@ -1242,7 +1286,7 @@ export class NetworkSession {
      */
     #send_empty_ack_packet() {
         for (const peer_id of this.#connected_peers) {
-            this.#peer.channel_for(peer_id).send(new Uint8Array(0), 0);
+            this.#peer.channel_for(peer_id).send(EMPTY_PAYLOAD, 0);
         }
     }
 
@@ -1559,6 +1603,13 @@ export class NetworkSession {
                 this.#peer.disconnect_peer(this.#remote_peer_id);
             } catch (_) { /* swallow */
             }
+            // Stop treating this peer as a live send target. The channel is
+            // gone, but `#remote_peer_id` is deliberately kept so the reconnect
+            // ladder can re-`connect()` to the same id. Without this delete,
+            // `#send_empty_ack_packet` (driven every tick) dereferences the
+            // now-undefined channel and throws — which would crash the very
+            // tick loop that drives the reconnect ladder.
+            this.#connected_peers.delete(this.#remote_peer_id);
         }
         this.#current_transport = null;
         this.#current_transport_listener = null;

package/src/engine/network/README.md

@@ -0,0 +1,45 @@
+# `engine/network` — netcode package
+
+Action-log replication, client-side prediction + reconciliation, and a
+server-authoritative rollback orchestrator, layered over a pluggable transport.
+
+## Layers (bottom → top)
+
+| Layer | Pieces | Responsibility |
+| --- | --- | --- |
+| Transport | `transport/adapters/*` (`WebRTCDataChannel`, `WebTransport`, `WebSocket`, `NodeUDP`, `Simulated`, `Loopback`) | Move opaque byte buffers. UDP-style unless `reliable`/`ordered` say otherwise. |
+| Channel | `transport/Channel.js` | Seq + ack-bitfield header; surfaces `onPacketAcked` / `onPacketLost` / `onPayload`. No retransmit. |
+| Reliability / fragmentation | `transport/ReliableCommandPipeline.js`, `transport/fragments/*` | At-least-once commands; MTU fragmentation + NACK retransmit. |
+| Sim core | `sim/*` (`ActionLog`, `SimAction`, `SimActionExecutor`, `RewindEngine`, `Snapshotter`, registries) | Record/apply/rewind replicated state mutations. |
+| Replication | `replication/Replicator.js`, `replication/ScopeFilter.js` | Pack/unpack action records per peer, scope-filtered. |
+| Orchestrator | `orchestrator/NetworkPeer.js`, `orchestrator/ServerAuthoritative{Server,Client}.js` | Per-tick send/recv, rollback (server), predict-reconcile (client). |
+| Facade | `NetworkSession.js` | One config + lifecycle surface; wires everything below. |
+
+## Wired automatically by `NetworkSession`
+
+`NetworkPeer` (and through it `Channel`, `Replicator`, `ActionLog`,
+`SimActionExecutor`, the registries, `ReplicationSlotTable`, `Baseline`,
+the fragment layer, and `ReliableCommandPipeline`), the two orchestrators
+(and through them `RewindEngine` and `InputRing`), plus `TimeDilation`,
+`AdaptiveRenderDelay`, `InterpolationLog`, `NetworkSystem`, `NetworkIdentity`,
+and `Snapshotter`. `ChangedEntitySet` / `MutationLedger` are wired on the host
+when a mutation ledger is supplied.
+
+## Opt-in primitives — NOT wired by `NetworkSession`
+
+These are tested, public library surface intended for game code to wire up
+directly; the facade does not use them. They are deliberate exports, not dead
+code — fix bugs in them, don't delete them.
+
+| Primitive | What it's for | To use it |
+| --- | --- | --- |
+| `time/TimeSync.js` | NTP-style clock-offset estimation | Drive it from a ping/pong round-trip; read `offset()` / `best_rtt()`. |
+| `time/JitterBuffer.js` | Frame-tagged reorder/hold buffer | `push(frame, payload)`; `drain_until(current_frame, cb)`. |
+| `sim/SmoothingState.js` | Hide the post-reconcile correction snap | After reconcile, feed the pre/post pose; add the decaying error in your render path. |
+| `state/PriorityAccumulator.js` | Bandwidth-aware action scheduling | Consult `sorted_descending()` when an outgoing packet approaches MTU. |
+| `diagnostics/BandwidthMeter.js` | Throughput accounting | Sample around `transport.getStats()`. |
+| `diagnostics/ReplayLog.js` | Record/replay packet streams | Capture inbound/outbound for offline repro. |
+| `diagnostics/SyncTest.js` | Determinism / desync checking | Compare state hashes across peers. |
+| `adapters/Quaternion`/`Vector3InterpolationAdapter.js` | Interp building blocks | Reference when writing a component interpolation adapter (cf. `TransformInterpolationAdapter`). |
+
+If you wire one of these into the facade, move its row up to the section above.

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

@@ -1,9 +1,2 @@
-/**
- * Given a path, which may be a local path, produce a fully qualified URL
- * @example '/path' -> 'http://example.com/path'
- * @example 'some/local/path' -> 'http://example.com/current_path/some/local/path'
- * @param {string} path
- * @return {string}
- */
-export function convertPathToURL(path: string): string;
+export { convertPathToURL } from "../../core/path/convertPathToURL.js";
 //# sourceMappingURL=convertPathToURL.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"convertPathToURL.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/convertPathToURL.js"],"names":[],"mappings":"AAuFA;;;;;;GAMG;AACH,uCAHW,MAAM,GACL,MAAM,CAcjB"}
+{"version":3,"file":"convertPathToURL.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/convertPathToURL.js"],"names":[],"mappings":""}

package/src/engine/network/convertPathToURL.js

@@ -1,107 +1,2 @@
-import { assert } from "../../core/assert.js";
-
-const rx_url_schema = /[a-zA-Z0-9_\-]+\:\/\//;
-
-/**
- *
- * @param {string} path
- * @return {boolean}
- */
-function isGlobalPath(path) {
-    //search for URL schema at the start of the path
-    return path.search(rx_url_schema) === 0;
-}
-
-// *** Environment setup code ***
-const ENVIRONMENT_IS_WEB = typeof window === 'object';
-const ENVIRONMENT_IS_NODE = typeof process === 'object' && !ENVIRONMENT_IS_WEB;
-const ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
-const ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
-
-/**
- *
- * @param {string} path
- * @return {string}
- */
-function localPathToGlobal(path) {
-    /**
-     * @type {Window|DedicatedWorkerGlobalScope}
-     */
-    let scope;
-
-    if (ENVIRONMENT_IS_WEB) {
-        scope = window;
-    } else if (ENVIRONMENT_IS_WORKER) {
-        scope = self;
-    } else if (ENVIRONMENT_IS_NODE) {
-
-        let normalized_path = `${process.cwd()}/`.replace(/\\/g, '/');
-
-        // remove multiple sequential slashes
-        normalized_path = normalized_path.replace(/\/+/g, '/');
-
-        if (normalized_path[0] !== '/') {
-            // Windows drive letter must be prefixed with a slash.
-            normalized_path = `/${normalized_path}`;
-        }
-
-        scope = {
-            location: {
-                pathname: normalized_path,
-                host: '',
-                protocol: 'file:'
-            }
-        };
-    } else {
-        throw new Error('Unknown environment');
-    }
-
-    const location = scope.location;
-    const pathname = location.pathname;
-
-    let directoryPath;
-
-    /*
-    path name contains file name also, there are two options here, "a/b" or "a/b/" second is a directory
-    we need to extract directory to load relative path
-    */
-
-    if (pathname.endsWith('/')) {
-        //path is to a directory, strip last slash
-        directoryPath = pathname.substring(0, pathname.length - 1);
-    } else {
-        //path is to a file
-        const i = pathname.lastIndexOf('/');
-
-        if (i === -1) {
-            //root level file
-            directoryPath = ""
-        } else {
-            directoryPath = pathname.substring(0, i);
-        }
-    }
-
-    const urlBase = location.protocol + "//" + location.host + directoryPath + "/";
-    return urlBase + path;
-}
-
-/**
- * Given a path, which may be a local path, produce a fully qualified URL
- * @example '/path' -> 'http://example.com/path'
- * @example 'some/local/path' -> 'http://example.com/current_path/some/local/path'
- * @param {string} path
- * @return {string}
- */
-export function convertPathToURL(path) {
-    assert.isString(path, 'path');
-
-    const is_global = isGlobalPath(path);
-
-    let result = path;
-
-    if (!is_global) {
-        result = localPathToGlobal(path);
-    }
-
-    return result;
-}
+// Re-export for path compatibility; implementation lives in core/path/convertPathToURL.js
+export { convertPathToURL } from "../../core/path/convertPathToURL.js";

package/src/engine/network/core/quantize/quantize_float.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quantize_float.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/core/quantize/quantize_float.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;GAcG;AACH,sCANW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;;;;;GASG;AACH,4CANW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;GAUG;AACH,sDANW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"quantize_float.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/core/quantize/quantize_float.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;GAcG;AACH,sCANW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;;;;GASG;AACH,4CANW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;;;GAUG;AACH,sDANW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/engine/network/core/quantize/quantize_float.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../../core/assert.js";
+
 /**
  * Uniform float quantization to an N-bit unsigned integer.
  *
@@ -29,6 +31,10 @@
  * @returns {number} unsigned integer in [0, 2^bits - 1]
  */
 export function quantize_float(value, min, max, bits) {
+    // `1 << bits` overflows into the sign bit at bits >= 31, silently producing
+    // a negative max_int and garbage output. Guard the documented 1..30 range.
+    // Asserts are stripped in production, so this costs nothing on the hot path.
+    assert.ok(bits >= 1 && bits <= 30, `quantize_float: bits must be in [1, 30], got ${bits}`);
     const max_int = (1 << bits) - 1;
     const normalized = (value - min) / (max - min);
     const clamped = normalized < 0 ? 0 : (normalized > 1 ? 1 : normalized);
@@ -46,6 +52,7 @@ export function quantize_float(value, min, max, bits) {
  * @returns {number}
  */
 export function dequantize_float(quantized, min, max, bits) {
+    assert.ok(bits >= 1 && bits <= 30, `dequantize_float: bits must be in [1, 30], got ${bits}`);
     const max_int = (1 << bits) - 1;
     return min + (quantized / max_int) * (max - min);
 }

package/src/engine/network/core/quantize/quantize_position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quantize_position.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/core/quantize/quantize_position.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,yCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,0CAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"quantize_position.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/core/quantize/quantize_position.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,yCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,0CAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAelB"}

package/src/engine/network/core/quantize/quantize_position.js

@@ -50,5 +50,16 @@ export function dequantize_position(quantized, range, bits) {
  * @returns {number}
  */
 export function position_bit_count(range, quanta_per_unit) {
-    return Math.ceil(Math.log2(2 * range * quanta_per_unit));
+    const bits = Math.ceil(Math.log2(2 * range * quanta_per_unit));
+    // quantize_float uses `1 << bits`, which overflows the sign bit at >= 31.
+    // A real throw (not an assert) so an over-large range/precision combo fails
+    // loudly at setup in production too, rather than silently corrupting every
+    // quantized position. This is setup-time, not a hot path.
+    if (bits > 30) {
+        throw new Error(
+            `position_bit_count: range=${range} × quanta_per_unit=${quanta_per_unit} needs ${bits} bits, ` +
+            `exceeding the 30-bit limit of the quantizer; reduce range or precision, or split across components`
+        );
+    }
+    return bits;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":"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"}