@woosh/meep-engine 2.138.0 → 2.138.1

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

@@ -1 +1 @@
-{"version":3,"file":"PriorityFetch.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/PriorityFetch.js"],"names":[],"mappings":"AAiFA;;;GAGG;AACH;IACI;;;OA+BC;IA3BG;;;;OAIG;IACH,sBAAgC;IAEhC;;;;OAIG;IACH,gBAAiD;IAEjD;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAAwB;IAG5B;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAMC;IAED;;;OAGG;IACH,0BAEC;IAED;;;;OAIG;IACH,mBAkBC;IAED,eAMC;IAED,iDAUC;CACJ;qBA7LoB,6BAA6B"}
+{"version":3,"file":"PriorityFetch.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/PriorityFetch.js"],"names":[],"mappings":"AAgFA;;;GAGG;AACH;IACI;;;OA+BC;IA3BG;;;;OAIG;IACH,sBAAgC;IAEhC;;;;OAIG;IACH,gBAAiD;IAEjD;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAAwB;IAG5B;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAMC;IAED;;;OAGG;IACH,0BAEC;IAED;;;;OAIG;IACH,mBAoBC;IAED,eAMC;IAED,iDAUC;CACJ;qBA9LoB,6BAA6B"}

package/src/engine/network/PriorityFetch.js

@@ -26,9 +26,8 @@ function extract_priority_from_resource(p) {
 
         if (v === undefined) {
             console.warn(`Unsupported request priority value '${p}', defaulting to 'auto'`);
+            v = priority_value_map['auto'];
         }
-
-        v = priority_value_map['auto'];
     }
 
     return v;
@@ -151,6 +150,8 @@ export class PriorityFetch {
      * @private
      */
     __dispatch(req) {
+        this.__pending_set.add(req);
+
         const promise = this.__adapter(req.__resource, req.__options);
 
         promise.finally(() => {

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

@@ -0,0 +1,14 @@
+/**
+ * Shortest-path nlerp for a 4 × Float32 quaternion payload (16 bytes).
+ * Switch to a slerp variant if you need it for wide per-tick angular
+ * steps (animation-blended joints, slow snapshot rate).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class QuaternionInterpolationAdapter extends BinaryInterpolationAdapter {
+    /** @inheritdoc */
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+}
+import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+//# sourceMappingURL=QuaternionInterpolationAdapter.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+
+/**
+ * Shortest-path nlerp for a 4 × Float32 quaternion payload (16 bytes).
+ * Switch to a slerp variant if you need it for wide per-tick angular
+ * steps (animation-blended joints, slow snapshot rate).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class QuaternionInterpolationAdapter extends BinaryInterpolationAdapter {
+
+    /** @inheritdoc */
+    interpolate(out_buffer, source, first_offset, second_offset, t) {
+        source.position = first_offset;
+        const ax = source.readFloat32();
+        const ay = source.readFloat32();
+        const az = source.readFloat32();
+        const aw = source.readFloat32();
+
+        source.position = second_offset;
+        let bx = source.readFloat32();
+        let by = source.readFloat32();
+        let bz = source.readFloat32();
+        let bw = source.readFloat32();
+
+        if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+            bx = -bx; by = -by; bz = -bz; bw = -bw;
+        }
+
+        let qx = ax + (bx - ax) * t;
+        let qy = ay + (by - ay) * t;
+        let qz = az + (bz - az) * t;
+        let qw = aw + (bw - aw) * t;
+
+        const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
+        const inv_len = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
+
+        out_buffer.writeFloat32(qx * inv_len);
+        out_buffer.writeFloat32(qy * inv_len);
+        out_buffer.writeFloat32(qz * inv_len);
+        out_buffer.writeFloat32(qw * inv_len);
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Linear-blend interpolation for {@link Transform}, matching the wire
+ * layout of {@link TransformReplicationAdapter}: 3×Float32 position +
+ * uint32 packed quaternion + equality-encoded scale.
+ *
+ * Position lerps componentwise; rotation nlerps with shortest-path
+ * correction; scale decodes/lerps/re-encodes (output is still valid
+ * equality-encoded).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
+    /** @inheritdoc */
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+}
+import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+//# sourceMappingURL=TransformInterpolationAdapter.d.ts.map

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

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

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

@@ -0,0 +1,79 @@
+import { quat_decode_from_uint32 } from "../../../core/geom/3d/quaternion/quat_decode_from_uint32.js";
+import { quat_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat_encode_to_uint32.js";
+import { v3_binary_equality_decode } from "../../../core/geom/vec3/serialization/v3_binary_equality_decode.js";
+import { v3_binary_equality_encode } from "../../../core/geom/vec3/serialization/v3_binary_equality_encode.js";
+import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+
+/**
+ * Module-level scratch. Layout: `[aq.xyzw, bq.xyzw, as.xyz, bs.xyz]`.
+ * Safe because `interpolate` is synchronous and non-reentrant.
+ * @type {Float32Array}
+ */
+const scratch = new Float32Array(16);
+
+/**
+ * Linear-blend interpolation for {@link Transform}, matching the wire
+ * layout of {@link TransformReplicationAdapter}: 3×Float32 position +
+ * uint32 packed quaternion + equality-encoded scale.
+ *
+ * Position lerps componentwise; rotation nlerps with shortest-path
+ * correction; scale decodes/lerps/re-encodes (output is still valid
+ * equality-encoded).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
+
+    /** @inheritdoc */
+    interpolate(out_buffer, source, first_offset, second_offset, t) {
+        // ---- Decode sample A ----
+        source.position = first_offset;
+        const ax = source.readFloat32();
+        const ay = source.readFloat32();
+        const az = source.readFloat32();
+        const a_quat_packed = source.readUint32();
+        quat_decode_from_uint32(scratch, 0, a_quat_packed);  // → scratch[0..3]
+        v3_binary_equality_decode(source, scratch, 8);       // → scratch[8..10]
+
+        // ---- Decode sample B ----
+        source.position = second_offset;
+        const bx = source.readFloat32();
+        const by = source.readFloat32();
+        const bz = source.readFloat32();
+        const b_quat_packed = source.readUint32();
+        quat_decode_from_uint32(scratch, 4, b_quat_packed);  // → scratch[4..7]
+        v3_binary_equality_decode(source, scratch, 11);      // → scratch[11..13]
+
+        // ---- Position lerp ----
+        const out_x = ax + (bx - ax) * t;
+        const out_y = ay + (by - ay) * t;
+        const out_z = az + (bz - az) * t;
+
+        // ---- Rotation nlerp with shortest-path correction ----
+        const aqx = scratch[0], aqy = scratch[1], aqz = scratch[2], aqw = scratch[3];
+        let bqx = scratch[4], bqy = scratch[5], bqz = scratch[6], bqw = scratch[7];
+        if (aqx * bqx + aqy * bqy + aqz * bqz + aqw * bqw < 0) {
+            bqx = -bqx; bqy = -bqy; bqz = -bqz; bqw = -bqw;
+        }
+        let qx = aqx + (bqx - aqx) * t;
+        let qy = aqy + (bqy - aqy) * t;
+        let qz = aqz + (bqz - aqz) * t;
+        let qw = aqw + (bqw - aqw) * t;
+        const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
+        const inv_len = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
+        qx *= inv_len; qy *= inv_len; qz *= inv_len; qw *= inv_len;
+
+        // ---- Scale lerp ----
+        const out_sx = scratch[8]  + (scratch[11] - scratch[8])  * t;
+        const out_sy = scratch[9]  + (scratch[12] - scratch[9])  * t;
+        const out_sz = scratch[10] + (scratch[13] - scratch[10]) * t;
+
+        // ---- Re-encode to TransformReplicationAdapter wire layout ----
+        out_buffer.writeFloat32(out_x);
+        out_buffer.writeFloat32(out_y);
+        out_buffer.writeFloat32(out_z);
+        out_buffer.writeUint32(quat_encode_to_uint32(qx, qy, qz, qw));
+        v3_binary_equality_encode(out_buffer, out_sx, out_sy, out_sz);
+    }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Network-replication adapter for {@link Transform}. Mirrors
+ * {@link TransformSerializationAdapter} but uses Float32 for position instead
+ * of Float64, halving the per-component cost (12 B vs 24 B) for a precision
+ * loss that is below visible threshold for typical action-game scales.
+ *
+ * Wire layout (typical 17 B, 13 B if scale is identity):
+ *   - position: 3 × Float32              = 12 bytes
+ *   - rotation: smallest-three uint32    = 4 bytes
+ *   - scale:    `v3_binary_equality_encode` = 1 byte (identity) or 13 bytes (full)
+ *
+ * Total: 17 bytes typical, 29 bytes max.
+ *
+ * Distinct from {@link TransformSerializationAdapter} so save-game files keep
+ * Float64 position precision while wire packets stay tight.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class TransformReplicationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof Transform;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} value
+     */
+    serialize(buffer: BinaryBuffer, value: Transform): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} value
+     */
+    deserialize(buffer: BinaryBuffer, value: Transform): void;
+}
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+//# sourceMappingURL=TransformReplicationAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,wBAAkB;IAClB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,SAAS,QAoBnB;IAED;;;OAGG;IACH,yCAFW,SAAS,QAmBnB;CACJ;gDAlF+C,6DAA6D;0BACnF,kCAAkC"}

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

@@ -0,0 +1,87 @@
+import { quat_decode_from_uint32 } from "../../../core/geom/3d/quaternion/quat_decode_from_uint32.js";
+import { quat_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat_encode_to_uint32.js";
+import { v3_binary_equality_decode } from "../../../core/geom/vec3/serialization/v3_binary_equality_decode.js";
+import { v3_binary_equality_encode } from "../../../core/geom/vec3/serialization/v3_binary_equality_encode.js";
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+
+/**
+ * Decode scratch for {@link TransformReplicationAdapter#deserialize}. Decoders
+ * write into indexed slots; we then publish the final value to each field
+ * via `.set(...)` so the `onChanged` signal fires once with the assembled
+ * value rather than not at all (direct-write) or partially per intermediate.
+ * @type {Float32Array}
+ */
+const decode_scratch = new Float32Array(4);
+
+/**
+ * Network-replication adapter for {@link Transform}. Mirrors
+ * {@link TransformSerializationAdapter} but uses Float32 for position instead
+ * of Float64, halving the per-component cost (12 B vs 24 B) for a precision
+ * loss that is below visible threshold for typical action-game scales.
+ *
+ * Wire layout (typical 17 B, 13 B if scale is identity):
+ *   - position: 3 × Float32              = 12 bytes
+ *   - rotation: smallest-three uint32    = 4 bytes
+ *   - scale:    `v3_binary_equality_encode` = 1 byte (identity) or 13 bytes (full)
+ *
+ * Total: 17 bytes typical, 29 bytes max.
+ *
+ * Distinct from {@link TransformSerializationAdapter} so save-game files keep
+ * Float64 position precision while wire packets stay tight.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class TransformReplicationAdapter extends BinaryClassSerializationAdapter {
+
+    klass = Transform;
+    version = 1;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} value
+     */
+    serialize(buffer, value) {
+
+        const position = value.position;
+        const rotation = value.rotation;
+        const scale = value.scale;
+
+        buffer.writeFloat32(position.x);
+        buffer.writeFloat32(position.y);
+        buffer.writeFloat32(position.z);
+
+        buffer.writeUint32(quat_encode_to_uint32(
+            rotation.x,
+            rotation.y,
+            rotation.z,
+            rotation.w
+        ));
+
+        v3_binary_equality_encode(buffer, scale.x, scale.y, scale.z);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {Transform} value
+     */
+    deserialize(buffer, value) {
+
+        const positionX = buffer.readFloat32();
+        const positionY = buffer.readFloat32();
+        const positionZ = buffer.readFloat32();
+
+        const encoded_rotation = buffer.readUint32();
+
+        const s = decode_scratch;
+
+        v3_binary_equality_decode(buffer, s, 0);
+        value.scale.set(s[0], s[1], s[2]);
+
+        quat_decode_from_uint32(s, 0, encoded_rotation);
+        value.rotation.set(s[0], s[1], s[2], s[3]);
+
+        value.position.set(positionX, positionY, positionZ);
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Componentwise lerp of a 3-Float32 position payload.
+ *
+ * Wire layout (matching whatever serialization adapter wrote it):
+ *   - Float32 x
+ *   - Float32 y
+ *   - Float32 z
+ *
+ * 12 bytes per snapshot. Pair with a serialization adapter that uses this
+ * same format (the simplest "naked Vector3" encoding).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class Vector3InterpolationAdapter extends BinaryInterpolationAdapter {
+}
+import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+//# sourceMappingURL=Vector3InterpolationAdapter.d.ts.map

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

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

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

@@ -0,0 +1,46 @@
+import { lerp } from "../../../core/math/lerp.js";
+import { BinaryInterpolationAdapter } from "../sim/BinaryInterpolationAdapter.js";
+
+/**
+ * Componentwise lerp of a 3-Float32 position payload.
+ *
+ * Wire layout (matching whatever serialization adapter wrote it):
+ *   - Float32 x
+ *   - Float32 y
+ *   - Float32 z
+ *
+ * 12 bytes per snapshot. Pair with a serialization adapter that uses this
+ * same format (the simplest "naked Vector3" encoding).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+export class Vector3InterpolationAdapter extends BinaryInterpolationAdapter {
+
+    /**
+     * @param {BinaryBuffer} out_buffer
+     * @param {BinaryBuffer} source
+     * @param {number} first_offset
+     * @param {number} second_offset
+     * @param {number} t
+     */
+    interpolate(out_buffer, source, first_offset, second_offset, t) {
+        source.position = first_offset;
+        const ax = source.readFloat32();
+        const ay = source.readFloat32();
+        const az = source.readFloat32();
+
+        source.position = second_offset;
+        const bx = source.readFloat32();
+        const by = source.readFloat32();
+        const bz = source.readFloat32();
+
+        const out_x = lerp(ax, bx, t);
+        const out_y = lerp(ay, by, t);
+        const out_z = lerp(az, bz, t);
+
+        out_buffer.writeFloat32(out_x);
+        out_buffer.writeFloat32(out_y);
+        out_buffer.writeFloat32(out_z);
+    }
+}

package/src/engine/network/convertPathToURL.js

@@ -1,107 +1,107 @@
-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;
-}
+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;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Uniform float quantization to an N-bit unsigned integer.
+ *
+ * Maps `[min, max]` linearly to `[0, 2^bits - 1]` using nearest-integer rounding.
+ * Values outside the range are clamped. Round-trip error is bounded by
+ * `(max - min) / (2 * (2^bits - 1))`.
+ *
+ * Pure functions; safe to call on the hot path. Caller is responsible for
+ * passing the same `min`, `max`, and `bits` on both sender and receiver — there
+ * is no on-wire metadata.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2025
+ */
+/**
+ * Quantize `value` from the inclusive range `[min, max]` to an unsigned integer
+ * in `[0, 2^bits - 1]`.
+ *
+ * Passing `NaN` for `value` returns `NaN` (both clamp comparisons are false on
+ * NaN, so `Math.round(NaN * max_int)` propagates). Callers must guard against
+ * NaN at the boundary — a downstream `DataView.setUintXX` will silently coerce
+ * NaN to 0, hiding the upstream bug.
+ *
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max  must be > min
+ * @param {number} bits 1..30 (keep below 31 to stay in safe signed-shift territory)
+ * @returns {number} unsigned integer in [0, 2^bits - 1]
+ */
+export function quantize_float(value: number, min: number, max: number, bits: number): number;
+/**
+ * Inverse of {@link quantize_float}. Decodes an unsigned integer back into a float
+ * in `[min, max]`.
+ *
+ * @param {number} quantized
+ * @param {number} min
+ * @param {number} max
+ * @param {number} bits
+ * @returns {number}
+ */
+export function dequantize_float(quantized: number, min: number, max: number, bits: number): number;
+/**
+ * Round-trip a value through quantize+dequantize. Useful when sender and receiver
+ * must simulate from the same quantized state to remain in sync (state-sync /
+ * deterministic rollback).
+ *
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @param {number} bits
+ * @returns {number}
+ */
+export function quantize_then_dequantize_float(value: number, min: number, max: number, bits: number): number;
+//# sourceMappingURL=quantize_float.d.ts.map

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

@@ -0,0 +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"}