@woosh/meep-engine 3.2.0 → 3.3.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/avif/encoder_worker.js

@@ -8,21 +8,11 @@ import avifEncoderFactory from './codec/enc/avif_enc.js';
 import { initEmscriptenModule } from './utils.js';
 import { defaultOptions } from './meta.js';
 import { to_half_float_uint16 } from '../core/binary/to_half_float_uint16.js';
+import { linear_to_PQ } from '../core/color/PQ/linear_to_PQ.js';
+import { PQ_SDR_WHITE_LINEAR } from '../core/color/PQ/PQ_constants.js';
 
 const AVIF_DEFAULT_SPEED = 5;
 
-// PQ OETF (SMPTE ST 2084). Input: linear light normalized so 1.0 = 10000 nits. Output: PQ signal in [0,1].
-const PQ_M1 = 0.1593017578125;
-const PQ_M2 = 78.84375;
-const PQ_C1 = 0.8359375;
-const PQ_C2 = 18.8515625;
-const PQ_C3 = 18.6875;
-
-function linear_to_pq(x) {
-    const xp = Math.pow(Math.max(x, 0), PQ_M1);
-    return Math.pow((PQ_C1 + PQ_C2 * xp) / (1.0 + PQ_C3 * xp), PQ_M2);
-}
-
 const AvifSubsample = {
     YUV400: 0,
     YUV420: 1,
@@ -30,10 +20,6 @@ const AvifSubsample = {
     YUV444: 3,
 };
 
-// PQ tone mapping: 1.0 linear = SDR reference white = ~203 nits per BT.2408
-const SDR_WHITE_NITS = 203;
-const PQ_MAX_NITS = 10000;
-
 let encoder_promise = null;
 
 function get_encoder() {
@@ -103,8 +89,9 @@ function rgba_float16_to_pq_uint16(f16_view, width, height) {
     for (let i = 0; i < f16_view.length; i += 4) {
         for (let c = 0; c < 3; c++) {
             const linear = Math.max(f16_view[i + c], 0);
-            const normalized = linear * SDR_WHITE_NITS / PQ_MAX_NITS;
-            const pq = linear_to_pq(normalized);
+            // Engine linear is normalized to SDR reference white; PQ's is normalized to its own
+            // 10000-nit peak, so cross over before encoding.
+            const pq = linear_to_PQ(linear * PQ_SDR_WHITE_LINEAR);
             out[i + c] = Math.round(pq * 4095);
         }
         // alpha: linear 0..1 mapped directly to 0..4095

package/src/core/color/PQ/PQ_constants.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Coefficients of the SMPTE ST 2084 (a.k.a. "PQ", Perceptual Quantizer) transfer function.
+ *
+ * Every value is exact in binary floating point -- each is a small integer over a power of two, as the
+ * standard specifies them -- so the OETF and the EOTF built from these are exact inverses to within the
+ * rounding of `Math.pow` alone.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/** @type {number} 2610 / 16384 */
+export const PQ_M1: number;
+/** @type {number} 2523 / 32 */
+export const PQ_M2: number;
+/** @type {number} 3424 / 4096 */
+export const PQ_C1: number;
+/** @type {number} 2413 / 128 */
+export const PQ_C2: number;
+/** @type {number} 2392 / 128 */
+export const PQ_C3: number;
+/**
+ * Peak luminance of the PQ signal range, in nits. A linear value of `1.0` in PQ's own normalization is
+ * this bright -- which is why {@link linear_to_PQ} and {@link PQ_to_linear} work in that normalization
+ * and not in any renderer's.
+ * @type {number}
+ */
+export const PQ_MAX_NITS: number;
+/**
+ * Luminance of SDR reference white, in nits, per ITU-R BT.2408. This is the engine's `1.0`, and it is
+ * NOT PQ's `1.0`: converting between the two scales is the caller's job and needs
+ * {@link PQ_SDR_WHITE_LINEAR} in one direction or its reciprocal in the other.
+ * @type {number}
+ */
+export const SDR_WHITE_NITS: number;
+/**
+ * SDR reference white expressed in PQ's linear normalization, i.e. `SDR_WHITE_NITS / PQ_MAX_NITS`.
+ *
+ * Multiply an engine-normalized linear value by this before {@link linear_to_PQ}; divide by it after
+ * {@link PQ_to_linear} to come back.
+ * @type {number}
+ */
+export const PQ_SDR_WHITE_LINEAR: number;
+//# sourceMappingURL=PQ_constants.d.ts.map

package/src/core/color/PQ/PQ_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PQ_constants.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/PQ/PQ_constants.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,kCAAkC;AAClC,oBADW,MAAM,CACoB;AAErC,+BAA+B;AAC/B,oBADW,MAAM,CACa;AAE9B,iCAAiC;AACjC,oBADW,MAAM,CACc;AAE/B,gCAAgC;AAChC,oBADW,MAAM,CACe;AAEhC,gCAAgC;AAChC,oBADW,MAAM,CACY;AAE7B;;;;;GAKG;AACH,0BAFU,MAAM,CAEiB;AAEjC;;;;;GAKG;AACH,6BAFU,MAAM,CAEkB;AAElC;;;;;;GAMG;AACH,kCAFU,MAAM,CAEgD"}

package/src/core/color/PQ/PQ_constants.js

@@ -0,0 +1,50 @@
+/**
+ * Coefficients of the SMPTE ST 2084 (a.k.a. "PQ", Perceptual Quantizer) transfer function.
+ *
+ * Every value is exact in binary floating point -- each is a small integer over a power of two, as the
+ * standard specifies them -- so the OETF and the EOTF built from these are exact inverses to within the
+ * rounding of `Math.pow` alone.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/** @type {number} 2610 / 16384 */
+export const PQ_M1 = 0.1593017578125;
+
+/** @type {number} 2523 / 32 */
+export const PQ_M2 = 78.84375;
+
+/** @type {number} 3424 / 4096 */
+export const PQ_C1 = 0.8359375;
+
+/** @type {number} 2413 / 128 */
+export const PQ_C2 = 18.8515625;
+
+/** @type {number} 2392 / 128 */
+export const PQ_C3 = 18.6875;
+
+/**
+ * Peak luminance of the PQ signal range, in nits. A linear value of `1.0` in PQ's own normalization is
+ * this bright -- which is why {@link linear_to_PQ} and {@link PQ_to_linear} work in that normalization
+ * and not in any renderer's.
+ * @type {number}
+ */
+export const PQ_MAX_NITS = 10000;
+
+/**
+ * Luminance of SDR reference white, in nits, per ITU-R BT.2408. This is the engine's `1.0`, and it is
+ * NOT PQ's `1.0`: converting between the two scales is the caller's job and needs
+ * {@link PQ_SDR_WHITE_LINEAR} in one direction or its reciprocal in the other.
+ * @type {number}
+ */
+export const SDR_WHITE_NITS = 203;
+
+/**
+ * SDR reference white expressed in PQ's linear normalization, i.e. `SDR_WHITE_NITS / PQ_MAX_NITS`.
+ *
+ * Multiply an engine-normalized linear value by this before {@link linear_to_PQ}; divide by it after
+ * {@link PQ_to_linear} to come back.
+ * @type {number}
+ */
+export const PQ_SDR_WHITE_LINEAR = SDR_WHITE_NITS / PQ_MAX_NITS;

package/src/core/color/PQ/PQ_to_linear.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SMPTE ST 2084 EOTF: decode a PQ signal back to linear light. Exact inverse of {@link linear_to_PQ}.
+ *
+ * NORMALIZATION: the result is in PQ's own scale, where `1.0` is {@link PQ_MAX_NITS} (10000 nits) --
+ * not the engine's, where `1.0` is {@link SDR_WHITE_NITS} (203 nits). Divide by
+ * {@link PQ_SDR_WHITE_LINEAR} to land back in engine units:
+ *
+ * ```js
+ * const engine_linear = PQ_to_linear(pq) / PQ_SDR_WHITE_LINEAR;
+ * ```
+ *
+ * The numerator is clamped at `0` so that signals below `linear_to_PQ(0)` -- which the standard's
+ * curve never produces, but quantization and interpolation both do -- decode to black instead of
+ * `NaN` from a negative base under a fractional exponent.
+ *
+ * @param {number} pq PQ signal, in `[0, 1]`
+ * @returns {number} linear light, `1.0` = 10000 nits
+ * @see linear_to_PQ
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function PQ_to_linear(pq: number): number;
+//# sourceMappingURL=PQ_to_linear.d.ts.map

package/src/core/color/PQ/PQ_to_linear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PQ_to_linear.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/PQ/PQ_to_linear.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iCAPW,MAAM,GACJ,MAAM,CAalB"}

package/src/core/color/PQ/PQ_to_linear.js

@@ -0,0 +1,35 @@
+import { PQ_C1, PQ_C2, PQ_C3, PQ_M1, PQ_M2 } from "./PQ_constants.js";
+
+const PQ_M1_INV = 1 / PQ_M1;
+const PQ_M2_INV = 1 / PQ_M2;
+
+/**
+ * SMPTE ST 2084 EOTF: decode a PQ signal back to linear light. Exact inverse of {@link linear_to_PQ}.
+ *
+ * NORMALIZATION: the result is in PQ's own scale, where `1.0` is {@link PQ_MAX_NITS} (10000 nits) --
+ * not the engine's, where `1.0` is {@link SDR_WHITE_NITS} (203 nits). Divide by
+ * {@link PQ_SDR_WHITE_LINEAR} to land back in engine units:
+ *
+ * ```js
+ * const engine_linear = PQ_to_linear(pq) / PQ_SDR_WHITE_LINEAR;
+ * ```
+ *
+ * The numerator is clamped at `0` so that signals below `linear_to_PQ(0)` -- which the standard's
+ * curve never produces, but quantization and interpolation both do -- decode to black instead of
+ * `NaN` from a negative base under a fractional exponent.
+ *
+ * @param {number} pq PQ signal, in `[0, 1]`
+ * @returns {number} linear light, `1.0` = 10000 nits
+ * @see linear_to_PQ
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function PQ_to_linear(pq) {
+    const y = Math.pow(pq, PQ_M2_INV);
+
+    const numerator = Math.max(y - PQ_C1, 0);
+    const denominator = PQ_C2 - PQ_C3 * y;
+
+    return Math.pow(numerator / denominator, PQ_M1_INV);
+}

package/src/core/color/PQ/linear_to_PQ.d.ts

@@ -0,0 +1,27 @@
+/**
+ * SMPTE ST 2084 OETF: encode a linear light value as a PQ signal.
+ *
+ * NORMALIZATION: the input is in PQ's own scale, where `1.0` is {@link PQ_MAX_NITS} (10000 nits) --
+ * not the engine's, where `1.0` is {@link SDR_WHITE_NITS} (203 nits). Scale an engine-normalized
+ * value by {@link PQ_SDR_WHITE_LINEAR} first:
+ *
+ * ```js
+ * const pq = linear_to_PQ(engine_linear * PQ_SDR_WHITE_LINEAR);
+ * ```
+ *
+ * Keeping the transfer function free of any white-point convention is what makes it and
+ * {@link PQ_to_linear} an exact inverse pair; a scale folded into one side but not the other is the
+ * classic way this round-trip ends up off by a factor of ~49.
+ *
+ * Negative input is clamped to `0`, since `Math.pow` of a negative base to a fractional exponent is
+ * `NaN` and a linear light value below zero has no PQ encoding to give.
+ *
+ * @param {number} linear linear light, `1.0` = 10000 nits
+ * @returns {number} PQ signal, in `[0, 1]`
+ * @see PQ_to_linear
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function linear_to_PQ(linear: number): number;
+//# sourceMappingURL=linear_to_PQ.d.ts.map

package/src/core/color/PQ/linear_to_PQ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear_to_PQ.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/PQ/linear_to_PQ.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qCAPW,MAAM,GACJ,MAAM,CAUlB"}

package/src/core/color/PQ/linear_to_PQ.js

@@ -0,0 +1,32 @@
+import { PQ_C1, PQ_C2, PQ_C3, PQ_M1, PQ_M2 } from "./PQ_constants.js";
+
+/**
+ * SMPTE ST 2084 OETF: encode a linear light value as a PQ signal.
+ *
+ * NORMALIZATION: the input is in PQ's own scale, where `1.0` is {@link PQ_MAX_NITS} (10000 nits) --
+ * not the engine's, where `1.0` is {@link SDR_WHITE_NITS} (203 nits). Scale an engine-normalized
+ * value by {@link PQ_SDR_WHITE_LINEAR} first:
+ *
+ * ```js
+ * const pq = linear_to_PQ(engine_linear * PQ_SDR_WHITE_LINEAR);
+ * ```
+ *
+ * Keeping the transfer function free of any white-point convention is what makes it and
+ * {@link PQ_to_linear} an exact inverse pair; a scale folded into one side but not the other is the
+ * classic way this round-trip ends up off by a factor of ~49.
+ *
+ * Negative input is clamped to `0`, since `Math.pow` of a negative base to a fractional exponent is
+ * `NaN` and a linear light value below zero has no PQ encoding to give.
+ *
+ * @param {number} linear linear light, `1.0` = 10000 nits
+ * @returns {number} PQ signal, in `[0, 1]`
+ * @see PQ_to_linear
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function linear_to_PQ(linear) {
+    const y = Math.pow(Math.max(linear, 0), PQ_M1);
+
+    return Math.pow((PQ_C1 + PQ_C2 * y) / (1 + PQ_C3 * y), PQ_M2);
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_other_face.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The first face on `edge_id`'s radial cycle that is not `face_id`, or {@link NULL_POINTER} when the
+ * edge has no such face.
+ *
+ * On a manifold interior edge -- two faces -- that is unambiguously "the face on the other side", which
+ * is what callers walking across a mesh want. The other configurations are worth being explicit about,
+ * because the answer is only interesting in the first case:
+ *
+ *   - a wire edge (no faces) or a boundary edge whose one face IS `face_id`: {@link NULL_POINTER};
+ *   - a non-manifold edge (three faces or more): whichever of the others the radial base pointer
+ *     happens to reach first, which a caller cannot predict. Use {@link bt_edge_count_faces} first if
+ *     that distinction matters;
+ *   - an edge that `face_id` uses twice: the walk skips both of its loops and reports a genuine
+ *     neighbour, rather than reporting `face_id` back.
+ *
+ * Passing a `face_id` that is not on the edge at all is not detected -- it simply reports the edge's
+ * first face. That matches {@link bt_edge_other_vertex}, whose contract is the same shape.
+ *
+ * The walk is bounded by the loop pool's size, so a corrupted radial cycle cannot hang the caller; a
+ * cycle that long is broken, and {@link bt_mesh_validate} will say where.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @param {number} face_id the face already known to sit on this edge
+ * @returns {number} face id, or {@link NULL_POINTER}
+ * @see bt_edge_other_vertex
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_edge_other_face(mesh: BinaryTopology, edge_id: number, face_id: number): number;
+//# sourceMappingURL=bt_edge_other_face.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_other_face.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_edge_other_face.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_other_face.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,kEARW,MAAM,WACN,MAAM,GACJ,MAAM,CAgClB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_other_face.js

@@ -0,0 +1,59 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * The first face on `edge_id`'s radial cycle that is not `face_id`, or {@link NULL_POINTER} when the
+ * edge has no such face.
+ *
+ * On a manifold interior edge -- two faces -- that is unambiguously "the face on the other side", which
+ * is what callers walking across a mesh want. The other configurations are worth being explicit about,
+ * because the answer is only interesting in the first case:
+ *
+ *   - a wire edge (no faces) or a boundary edge whose one face IS `face_id`: {@link NULL_POINTER};
+ *   - a non-manifold edge (three faces or more): whichever of the others the radial base pointer
+ *     happens to reach first, which a caller cannot predict. Use {@link bt_edge_count_faces} first if
+ *     that distinction matters;
+ *   - an edge that `face_id` uses twice: the walk skips both of its loops and reports a genuine
+ *     neighbour, rather than reporting `face_id` back.
+ *
+ * Passing a `face_id` that is not on the edge at all is not detected -- it simply reports the edge's
+ * first face. That matches {@link bt_edge_other_vertex}, whose contract is the same shape.
+ *
+ * The walk is bounded by the loop pool's size, so a corrupted radial cycle cannot hang the caller; a
+ * cycle that long is broken, and {@link bt_mesh_validate} will say where.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @param {number} face_id the face already known to sit on this edge
+ * @returns {number} face id, or {@link NULL_POINTER}
+ * @see bt_edge_other_vertex
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_edge_other_face(mesh, edge_id, face_id) {
+    const start = mesh.edge_read_loop(edge_id);
+
+    if (start === NULL_POINTER) {
+        // wire edge, no faces at all
+        return NULL_POINTER;
+    }
+
+    const limit = mesh.loops.size;
+
+    let loop = start;
+    let visited = 0;
+
+    do {
+        const face = mesh.loop_read_face(loop);
+
+        if (face !== face_id) {
+            return face;
+        }
+
+        visited++;
+
+        loop = mesh.loop_read_radial_next(loop);
+    } while (loop !== start && loop !== NULL_POINTER && visited <= limit);
+
+    return NULL_POINTER;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_third_vertex.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The corner of `face_id` that lies on neither end of `edge_id` -- the apex of a triangle over that
+ * edge -- or {@link NULL_POINTER} when the face has no such corner.
+ *
+ * The edge is read for its two endpoints only; it is never required to be one of the face's own edges.
+ * A caller that hands over an unrelated edge therefore gets the face's first corner rather than an
+ * error, the same contract {@link bt_edge_other_vertex} carries.
+ *
+ * "Third" names the intended use, not a precondition: the face loop is walked to its end, so a polygon
+ * with more corners reports the first one clear of the edge. {@link NULL_POINTER} comes back for an
+ * face with no loop, and for a face all of whose corners sit on the edge -- a degenerate triangle with a
+ * repeated vertex, which {@link bt_mesh_validate} counts as a defect.
+ *
+ * The walk is bounded by the loop pool's size, so a corrupted face cycle cannot hang the caller.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @param {number} edge_id
+ * @returns {number} vertex id, or {@link NULL_POINTER}
+ * @see bt_edge_read_diamond for both apexes of an interior edge, with winding respected
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_face_third_vertex(mesh: BinaryTopology, face_id: number, edge_id: number): number;
+//# sourceMappingURL=bt_face_third_vertex.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_face_third_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_third_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_third_vertex.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oEARW,MAAM,WACN,MAAM,GACJ,MAAM,CAkClB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_third_vertex.js

@@ -0,0 +1,55 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * The corner of `face_id` that lies on neither end of `edge_id` -- the apex of a triangle over that
+ * edge -- or {@link NULL_POINTER} when the face has no such corner.
+ *
+ * The edge is read for its two endpoints only; it is never required to be one of the face's own edges.
+ * A caller that hands over an unrelated edge therefore gets the face's first corner rather than an
+ * error, the same contract {@link bt_edge_other_vertex} carries.
+ *
+ * "Third" names the intended use, not a precondition: the face loop is walked to its end, so a polygon
+ * with more corners reports the first one clear of the edge. {@link NULL_POINTER} comes back for an
+ * face with no loop, and for a face all of whose corners sit on the edge -- a degenerate triangle with a
+ * repeated vertex, which {@link bt_mesh_validate} counts as a defect.
+ *
+ * The walk is bounded by the loop pool's size, so a corrupted face cycle cannot hang the caller.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @param {number} edge_id
+ * @returns {number} vertex id, or {@link NULL_POINTER}
+ * @see bt_edge_read_diamond for both apexes of an interior edge, with winding respected
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_face_third_vertex(mesh, face_id, edge_id) {
+    const start = mesh.face_read_loop(face_id);
+
+    if (start === NULL_POINTER) {
+        return NULL_POINTER;
+    }
+
+    const edge_v1 = mesh.edge_read_vertex1(edge_id);
+    const edge_v2 = mesh.edge_read_vertex2(edge_id);
+
+    const limit = mesh.loops.size;
+
+    let loop = start;
+    let visited = 0;
+
+    do {
+        const vertex = mesh.loop_read_vertex(loop);
+
+        if (vertex !== edge_v1 && vertex !== edge_v2) {
+            return vertex;
+        }
+
+        visited++;
+
+        loop = mesh.loop_read_next(loop);
+    } while (loop !== start && loop !== NULL_POINTER && visited <= limit);
+
+    return NULL_POINTER;
+}

package/src/engine/ecs/storage/populateEngineSerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAkKA;;;;;;;;GAQG;AACH,iGA6FC"}
+{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAqKA;;;;;;;;GAQG;AACH,iGA8FC"}