@woosh/meep-engine 3.26.0 → 3.28.0

package/src/core/binary/lz4/lz4_decompress_block.d.ts

@@ -6,7 +6,8 @@
  * its low nibble the match length less four; either saturates at fifteen and continues in whole
  * bytes, a 255 meaning "and more". The match's distance is a 16-bit little-endian offset back from
  * the write head, and it is allowed to reach into bytes this same sequence is producing — that
- * overlap is how the format codes runs, so the copy has to go a byte at a time.
+ * overlap is how the format codes runs, so a match that reaches back less far than it is long is
+ * copied a byte at a time.
  *
  * Blocks here are independent: a match reaches back no further than `destination_offset`, never
  * into whatever a previous block left in the buffer. That is what `LZ4_compress_default` produces

package/src/core/binary/lz4/lz4_decompress_block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lz4_decompress_block.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/lz4/lz4_decompress_block.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,kDATW,UAAU,sBACV,MAAM,mBACN,MAAM,UACN,UAAU,iBACV,MAAM,cACN,MAAM,GACJ,MAAM,CA8GlB"}
+{"version":3,"file":"lz4_decompress_block.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/lz4/lz4_decompress_block.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,kDATW,UAAU,sBACV,MAAM,mBACN,MAAM,UACN,UAAU,iBACV,MAAM,cACN,MAAM,GACJ,MAAM,CAyHlB"}

package/src/core/binary/lz4/lz4_decompress_block.js

@@ -1,5 +1,18 @@
 import { assert } from "../../assert.js";
 
+/**
+ * Runs shorter than this are cheaper to copy a byte at a time than to hand to `set` or
+ * `copyWithin`, whose call overhead dominates until there is a memmove's worth of work behind it.
+ * Both halves earn their keep, and on real geometry it is the literals that carry the win: four
+ * fifths of a decoded `.vgeo` page arrives as literal runs of about thirty-five bytes, while its
+ * matches average nine and stay in the loop whatever this is set to.
+ *
+ * Swept on 2,267 real pages at both block shapes. The top of the curve is broad — anything from
+ * sixteen up is most of the win — and this is where it sits, which is also where
+ * {@link lz4_compress_block} put its own, arrived at separately and on literals alone.
+ */
+const BULK_COPY_LENGTH = 32;
+
 /**
  * Decode one LZ4 block.
  *
@@ -8,7 +21,8 @@ import { assert } from "../../assert.js";
  * its low nibble the match length less four; either saturates at fifteen and continues in whole
  * bytes, a 255 meaning "and more". The match's distance is a 16-bit little-endian offset back from
  * the write head, and it is allowed to reach into bytes this same sequence is producing — that
- * overlap is how the format codes runs, so the copy has to go a byte at a time.
+ * overlap is how the format codes runs, so a match that reaches back less far than it is long is
+ * copied a byte at a time.
  *
  * Blocks here are independent: a match reaches back no further than `destination_offset`, never
  * into whatever a previous block left in the buffer. That is what `LZ4_compress_default` produces
@@ -72,8 +86,12 @@ export function lz4_decompress_block(destination, destination_offset, destinatio
             );
         }
 
-        for (let i = 0; i < literal_length; i++) {
-            destination[d + i] = source[s + i];
+        if (literal_length >= BULK_COPY_LENGTH) {
+            destination.set(source.subarray(s, s + literal_length), d);
+        } else {
+            for (let i = 0; i < literal_length; i++) {
+                destination[d + i] = source[s + i];
+            }
         }
 
         d += literal_length;
@@ -127,9 +145,16 @@ export function lz4_decompress_block(destination, destination_offset, destinatio
             );
         }
 
-        // a byte at a time: the match is allowed to overlap what it is writing, which is how runs are coded
-        for (let i = 0; i < match_length; i++) {
-            destination[d + i] = destination[match_position + i];
+        // A match that does not reach back as far as it is long overlaps the bytes it is writing, and
+        // that is how the format codes runs: `copyWithin` moves as if through a temporary, so it
+        // would lay down one copy of the pattern where the format means it to repeat. Only a match
+        // clear of its own output can take it, and the byte loop below is the run.
+        if (match_length >= BULK_COPY_LENGTH && match_offset >= match_length) {
+            destination.copyWithin(d, match_position, match_position + match_length);
+        } else {
+            for (let i = 0; i < match_length; i++) {
+                destination[d + i] = destination[match_position + i];
+            }
         }
 
         d += match_length;

package/src/core/geom/3d/mat4/m4_linear_determinant.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Determinant of the linear (upper-left 3x3) part of a 4x4 transform.
+ *
+ * The sign is the interesting part: it is negative exactly when the transform reflects — an odd
+ * number of negative scale axes anywhere in the chain that produced it. A reflection reverses the
+ * winding order of every triangle drawn under it and flips the handedness of its tangent frame,
+ * so renderers have to know. The magnitude is the volume scale factor.
+ *
+ * The translation column cannot affect it, which is why only the 3x3 is read.
+ *
+ * @param {number[]|Float32Array} m 16-element, column-major 4x4 matrix
+ * @returns {number}
+ */
+export function m4_linear_determinant(m: number[] | Float32Array): number;
+//# sourceMappingURL=m4_linear_determinant.d.ts.map

package/src/core/geom/3d/mat4/m4_linear_determinant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_linear_determinant.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_linear_determinant.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAYlB"}

package/src/core/geom/3d/mat4/m4_linear_determinant.js

@@ -0,0 +1,24 @@
+/**
+ * Determinant of the linear (upper-left 3x3) part of a 4x4 transform.
+ *
+ * The sign is the interesting part: it is negative exactly when the transform reflects — an odd
+ * number of negative scale axes anywhere in the chain that produced it. A reflection reverses the
+ * winding order of every triangle drawn under it and flips the handedness of its tangent frame,
+ * so renderers have to know. The magnitude is the volume scale factor.
+ *
+ * The translation column cannot affect it, which is why only the 3x3 is read.
+ *
+ * @param {number[]|Float32Array} m 16-element, column-major 4x4 matrix
+ * @returns {number}
+ */
+export function m4_linear_determinant(m) {
+    // columns of the upper-left 3x3 (column-major)
+    const c0_x = m[0], c0_y = m[1], c0_z = m[2];
+    const c1_x = m[4], c1_y = m[5], c1_z = m[6];
+    const c2_x = m[8], c2_y = m[9], c2_z = m[10];
+
+    // dot(c0, cross(c1, c2))
+    return c0_x * (c1_y * c2_z - c1_z * c2_y)
+        + c0_y * (c1_z * c2_x - c1_x * c2_z)
+        + c0_z * (c1_x * c2_y - c1_y * c2_x);
+}

package/src/core/geom/3d/mat4/m4_normal_matrix3.d.ts

@@ -4,8 +4,10 @@
  *
  * The normal matrix is the transpose of the inverse of the linear part of the transform. The
  * cofactor matrix equals `det(M) * (M^-1)^T`, so it points the same direction as the true normal
- * matrix and avoids an explicit matrix inversion. The `det(M)` scale factor is irrelevant because
- * the transformed normals must be re-normalized afterwards anyway.
+ * matrix and avoids an explicit matrix inversion. The `det(M)` magnitude is irrelevant because the
+ * transformed normals must be re-normalized afterwards anyway — its *sign* is not. Under a
+ * reflection the cofactor matrix points every normal into the surface instead of out of it, so the
+ * result is re-oriented by the determinant's sign.
  *
  * NOTE: the resulting matrix produces scaled (non-unit) vectors — normalize the output of any
  * transform performed with it.

package/src/core/geom/3d/mat4/m4_normal_matrix3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_normal_matrix3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_normal_matrix3.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAHW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,QAsB/B"}
+{"version":3,"file":"m4_normal_matrix3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_normal_matrix3.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAHW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,QA8B/B"}

package/src/core/geom/3d/mat4/m4_normal_matrix3.js

@@ -4,8 +4,10 @@
  *
  * The normal matrix is the transpose of the inverse of the linear part of the transform. The
  * cofactor matrix equals `det(M) * (M^-1)^T`, so it points the same direction as the true normal
- * matrix and avoids an explicit matrix inversion. The `det(M)` scale factor is irrelevant because
- * the transformed normals must be re-normalized afterwards anyway.
+ * matrix and avoids an explicit matrix inversion. The `det(M)` magnitude is irrelevant because the
+ * transformed normals must be re-normalized afterwards anyway — its *sign* is not. Under a
+ * reflection the cofactor matrix points every normal into the surface instead of out of it, so the
+ * result is re-oriented by the determinant's sign.
  *
  * NOTE: the resulting matrix produces scaled (non-unit) vectors — normalize the output of any
  * transform performed with it.
@@ -23,17 +25,25 @@ export function m4_normal_matrix3(out, m) {
     const c2_x = m[8], c2_y = m[9], c2_z = m[10];
 
     // column 0 = cross(c1, c2)
-    out[0] = c1_y * c2_z - c1_z * c2_y;
-    out[1] = c1_z * c2_x - c1_x * c2_z;
-    out[2] = c1_x * c2_y - c1_y * c2_x;
+    const cofactor_0_x = c1_y * c2_z - c1_z * c2_y;
+    const cofactor_0_y = c1_z * c2_x - c1_x * c2_z;
+    const cofactor_0_z = c1_x * c2_y - c1_y * c2_x;
+
+    // dot(c0, cross(c1, c2)) is the determinant, and the cross is already in hand
+    const determinant = c0_x * cofactor_0_x + c0_y * cofactor_0_y + c0_z * cofactor_0_z;
+    const orientation = determinant < 0 ? -1 : 1;
+
+    out[0] = cofactor_0_x * orientation;
+    out[1] = cofactor_0_y * orientation;
+    out[2] = cofactor_0_z * orientation;
 
     // column 1 = cross(c2, c0)
-    out[3] = c2_y * c0_z - c2_z * c0_y;
-    out[4] = c2_z * c0_x - c2_x * c0_z;
-    out[5] = c2_x * c0_y - c2_y * c0_x;
+    out[3] = (c2_y * c0_z - c2_z * c0_y) * orientation;
+    out[4] = (c2_z * c0_x - c2_x * c0_z) * orientation;
+    out[5] = (c2_x * c0_y - c2_y * c0_x) * orientation;
 
     // column 2 = cross(c0, c1)
-    out[6] = c0_y * c1_z - c0_z * c1_y;
-    out[7] = c0_z * c1_x - c0_x * c1_z;
-    out[8] = c0_x * c1_y - c0_y * c1_x;
+    out[6] = (c0_y * c1_z - c0_z * c1_y) * orientation;
+    out[7] = (c0_z * c1_x - c0_x * c1_z) * orientation;
+    out[8] = (c0_x * c1_y - c0_y * c1_x) * orientation;
 }

package/src/core/geom/3d/shape/HeightMapShape3D.d.ts

@@ -184,13 +184,20 @@ export class HeightMapShape3D extends AbstractShape3D {
      * (the shared {@link tri3_raycast} convention). A cast from below the terrain
      * therefore reports a downward normal, not the surface's true upward one.
      *
-     * A hit landing exactly ON a sub-cell boundary gets the normal of one of the
-     * facets meeting there, and which one follows from traversal order: this walks
-     * the grid along the ray, the narrowphase enumerates it row-major, so on a grid
-     * line — and especially a grid corner, where four facets meet — the two can
-     * name different facets. The hit POINT still agrees; a faceted surface simply
-     * has no single normal at a seam. Measure-zero, and called out because it is
-     * the only place the two answers part company.
+     * A hit landing exactly ON a seam between facets gets the normal of one of the
+     * facets meeting there. INSIDE a sub-cell the two paths agree — they split on
+     * the same D–B diagonal and break the resulting tie in favour of the same
+     * facet — which matters because that diagonal runs through the sub-cell's
+     * centre, so a cast down the middle of a cell lands on it routinely rather
+     * than exceptionally.
+     *
+     * BETWEEN sub-cells they can differ, and which facet each names follows from
+     * traversal order: this walks the grid along the ray, the narrowphase
+     * enumerates it row-major, so on a grid line — and especially a grid corner,
+     * where four facets meet — the two can name different facets. The hit POINT
+     * still agrees; a faceted surface simply has no single normal at a seam.
+     * Measure-zero, and called out because it is the only place the two answers
+     * part company.
      *
      * `size.y` does NOT bound the query. Sampler values are not clamped to it (see
      * the class docstring), so clipping the ray to the height range that

package/src/core/geom/3d/shape/HeightMapShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeightMapShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/HeightMapShape3D.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IA4DI;;;;;;;;;;;OAWG;IACH,wCATW,MAAM,UACN,MAAM,UACN,MAAM,gBACN,OAAO,iBACP,MAAM,GAGJ,gBAAgB,CAqB5B;IA1FD;;;;;OAKG;IACH,sBAFU,OAAO,CAEkB;IAEnC;;;;;;;OAOG;IACH,eAFU,OAAO,CAEW;IAE5B;;;;;OAKG;IACH,SAFU,YAAY,IAAI,CAEX;IAEf;;;;;;;;;;;;;;;;OAgBG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,eAA6B;IAG7B,6BAA2B;IAE3B,6BAA2B;IAC3B,6BAA2B;IAmC3B;;;;;;;;;OASG;IACH,sBA+CC;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,8BALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAelB;IAED,wCA8BC;IAED,oCA2BC;IAED;;;;;;;;OAQG;IACH,6CAmBC;IAED;;;;OAIG;IACH,4DA2BC;IAED;;;;;;;;;OASG;IACH,qGAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyDG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,cAEnB,OAAO,CAyNnB;IAED,kFAiBC;IA6CD;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CAUnB;IAWL;;;;;;OAMG;IACH,6BAFU,OAAO,CAE4B;CAT5C;gCA5tB+B,sBAAsB;wBAD9B,kBAAkB"}
+{"version":3,"file":"HeightMapShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/HeightMapShape3D.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IA4DI;;;;;;;;;;;OAWG;IACH,wCATW,MAAM,UACN,MAAM,UACN,MAAM,gBACN,OAAO,iBACP,MAAM,GAGJ,gBAAgB,CAqB5B;IA1FD;;;;;OAKG;IACH,sBAFU,OAAO,CAEkB;IAEnC;;;;;;;OAOG;IACH,eAFU,OAAO,CAEW;IAE5B;;;;;OAKG;IACH,SAFU,YAAY,IAAI,CAEX;IAEf;;;;;;;;;;;;;;;;OAgBG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,eAA6B;IAG7B,6BAA2B;IAE3B,6BAA2B;IAC3B,6BAA2B;IAmC3B;;;;;;;;;OASG;IACH,sBA8CC;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,8BALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAelB;IAED,wCA6BC;IAED,oCA2BC;IAED;;;;;;;;OAQG;IACH,6CAmBC;IAED;;;;OAIG;IACH,4DA2BC;IAED;;;;;;;;;OASG;IACH,qGAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgEG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,cAEnB,OAAO,CA0NnB;IAED,kFAiBC;IA6CD;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CAUnB;IAWL;;;;;;OAMG;IACH,6BAFU,OAAO,CAE4B;CAT5C;gCAluB+B,sBAAsB;wBAD9B,kBAAkB"}

package/src/core/geom/3d/shape/HeightMapShape3D.js

@@ -2,9 +2,12 @@ import { hash_mix3 } from "../../../math/hash/hash_mix3.js";
 import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
+import { clamp_index } from "../../../math/clamp_index.js";
 import { optional_equality } from "../../../model/object/optional_equality.js";
 import { optional_hash } from "../../../model/object/optional_hash.js";
 import { tri3_raycast } from "../triangle/tri3_raycast.js";
+import { v3_cross } from "../../vec3/v3_cross.js";
+import { v3_dot } from "../../vec3/v3_dot.js";
 import { v3_length } from "../../vec3/v3_length.js";
 import { Vector3 } from "../../Vector3.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
@@ -192,14 +195,13 @@ export class HeightMapShape3D extends AbstractShape3D {
         u_y *= u_inv;
         u_z *= u_inv;
 
-        // v = u × n  (for n=+Y, u=+X this gives v=+Z, the intuitive choice)
-        const v_x = u_y * nz - u_z * ny;
-        const v_y = u_z * nx - u_x * nz;
-        const v_z = u_x * ny - u_y * nx;
-
         const b = this._basis;
+
         b[0] = u_x; b[1] = u_y; b[2] = u_z;
-        b[3] = v_x; b[4] = v_y; b[5] = v_z;
+
+        // v = u × n  (for n=+Y, u=+X this gives v=+Z, the intuitive choice)
+        v3_cross(b, 3, u_x, u_y, u_z, nx, ny, nz);
+
         b[6] = nx;  b[7] = ny;  b[8] = nz;
 
         this._basis_orientation_x = nx;
@@ -233,8 +235,8 @@ export class HeightMapShape3D extends AbstractShape3D {
         const b = this._basis;
 
         // project onto basis u and basis v
-        const u_coord = b[0] * px + b[1] * py + b[2] * pz;
-        const v_coord = b[3] * px + b[4] * py + b[5] * pz;
+        const u_coord = v3_dot(b[0], b[1], b[2], px, py, pz);
+        const v_coord = v3_dot(b[3], b[4], b[5], px, py, pz);
 
         const u01 = u_coord / this.size[0] + 0.5;
         const v01 = v_coord / this.size[2] + 0.5;
@@ -266,11 +268,10 @@ export class HeightMapShape3D extends AbstractShape3D {
 
             const uv_extent = Math.abs(cu) * half_u + Math.abs(cv) * half_v;
 
-            const h_lo = ch < 0 ? ch * sy : 0;
-            const h_hi = ch > 0 ? ch * sy : 0;
+            const h_extent = ch * sy;
 
-            result[k] = -uv_extent + h_lo;
-            result[k + 3] = uv_extent + h_hi;
+            result[k] = -uv_extent + Math.min(h_extent, 0);
+            result[k + 3] = uv_extent + Math.max(h_extent, 0);
         }
     }
 
@@ -284,9 +285,9 @@ export class HeightMapShape3D extends AbstractShape3D {
         const b = this._basis;
 
         // project into heightmap-local frame (u, v, h)
-        const u_coord = b[0] * px + b[1] * py + b[2] * pz;
-        const v_coord = b[3] * px + b[4] * py + b[5] * pz;
-        const h_coord = b[6] * px + b[7] * py + b[8] * pz;
+        const u_coord = v3_dot(b[0], b[1], b[2], px, py, pz);
+        const v_coord = v3_dot(b[3], b[4], b[5], px, py, pz);
+        const h_coord = v3_dot(b[6], b[7], b[8], px, py, pz);
 
         const half_u = this.size[0] * 0.5;
         const half_v = this.size[2] * 0.5;
@@ -321,9 +322,9 @@ export class HeightMapShape3D extends AbstractShape3D {
 
         const b = this._basis;
 
-        const u_coord = b[0] * px + b[1] * py + b[2] * pz;
-        const v_coord = b[3] * px + b[4] * py + b[5] * pz;
-        const h_coord = b[6] * px + b[7] * py + b[8] * pz;
+        const u_coord = v3_dot(b[0], b[1], b[2], px, py, pz);
+        const v_coord = v3_dot(b[3], b[4], b[5], px, py, pz);
+        const h_coord = v3_dot(b[6], b[7], b[8], px, py, pz);
 
         const u01 = u_coord / this.size[0] + 0.5;
         const v01 = v_coord / this.size[2] + 0.5;
@@ -347,8 +348,8 @@ export class HeightMapShape3D extends AbstractShape3D {
 
         const b = this._basis;
 
-        const u_coord = b[0] * rx + b[1] * ry + b[2] * rz;
-        const v_coord = b[3] * rx + b[4] * ry + b[5] * rz;
+        const u_coord = v3_dot(b[0], b[1], b[2], rx, ry, rz);
+        const v_coord = v3_dot(b[3], b[4], b[5], rx, ry, rz);
 
         const half_u = this.size[0] * 0.5;
         const half_v = this.size[2] * 0.5;
@@ -407,13 +408,20 @@ export class HeightMapShape3D extends AbstractShape3D {
      * (the shared {@link tri3_raycast} convention). A cast from below the terrain
      * therefore reports a downward normal, not the surface's true upward one.
      *
-     * A hit landing exactly ON a sub-cell boundary gets the normal of one of the
-     * facets meeting there, and which one follows from traversal order: this walks
-     * the grid along the ray, the narrowphase enumerates it row-major, so on a grid
-     * line — and especially a grid corner, where four facets meet — the two can
-     * name different facets. The hit POINT still agrees; a faceted surface simply
-     * has no single normal at a seam. Measure-zero, and called out because it is
-     * the only place the two answers part company.
+     * A hit landing exactly ON a seam between facets gets the normal of one of the
+     * facets meeting there. INSIDE a sub-cell the two paths agree — they split on
+     * the same D–B diagonal and break the resulting tie in favour of the same
+     * facet — which matters because that diagonal runs through the sub-cell's
+     * centre, so a cast down the middle of a cell lands on it routinely rather
+     * than exceptionally.
+     *
+     * BETWEEN sub-cells they can differ, and which facet each names follows from
+     * traversal order: this walks the grid along the ray, the narrowphase
+     * enumerates it row-major, so on a grid line — and especially a grid corner,
+     * where four facets meet — the two can name different facets. The hit POINT
+     * still agrees; a faceted surface simply has no single normal at a seam.
+     * Measure-zero, and called out because it is the only place the two answers
+     * part company.
      *
      * `size.y` does NOT bound the query. Sampler values are not clamped to it (see
      * the class docstring), so clipping the ray to the height range that
@@ -473,10 +481,10 @@ export class HeightMapShape3D extends AbstractShape3D {
         // Body → heightmap-local footprint coordinates. The basis is orthonormal,
         // so the direction stays unit and `t` is the same distance in both frames;
         // the height component is never needed, the triangles carry it.
-        const o_u = b[0] * o_x + b[1] * o_y + b[2] * o_z;
-        const o_v = b[3] * o_x + b[4] * o_y + b[5] * o_z;
-        const d_u = b[0] * d_x + b[1] * d_y + b[2] * d_z;
-        const d_v = b[3] * d_x + b[4] * d_y + b[5] * d_z;
+        const o_u = v3_dot(b[0], b[1], b[2], o_x, o_y, o_z);
+        const o_v = v3_dot(b[3], b[4], b[5], o_x, o_y, o_z);
+        const d_u = v3_dot(b[0], b[1], b[2], d_x, d_y, d_z);
+        const d_v = v3_dot(b[3], b[4], b[5], d_x, d_y, d_z);
 
         const half_u = size_x * 0.5;
         const half_v = size_z * 0.5;
@@ -489,22 +497,22 @@ export class HeightMapShape3D extends AbstractShape3D {
 
         if (d_u > RAY_SLAB_EPSILON || d_u < -RAY_SLAB_EPSILON) {
             const inv = 1 / d_u;
-            let t0 = (-half_u - o_u) * inv;
-            let t1 = (half_u - o_u) * inv;
-            if (t0 > t1) { const s = t0; t0 = t1; t1 = s; }
-            if (t0 > t_enter) t_enter = t0;
-            if (t1 < t_exit) t_exit = t1;
+            const t0 = (-half_u - o_u) * inv;
+            const t1 = (half_u - o_u) * inv;
+
+            t_enter = Math.max(t_enter, Math.min(t0, t1));
+            t_exit = Math.min(t_exit, Math.max(t0, t1));
         } else if (o_u < -half_u || o_u > half_u) {
             return false;
         }
 
         if (d_v > RAY_SLAB_EPSILON || d_v < -RAY_SLAB_EPSILON) {
             const inv = 1 / d_v;
-            let t0 = (-half_v - o_v) * inv;
-            let t1 = (half_v - o_v) * inv;
-            if (t0 > t1) { const s = t0; t0 = t1; t1 = s; }
-            if (t0 > t_enter) t_enter = t0;
-            if (t1 < t_exit) t_exit = t1;
+            const t0 = (-half_v - o_v) * inv;
+            const t1 = (half_v - o_v) * inv;
+
+            t_enter = Math.max(t_enter, Math.min(t0, t1));
+            t_exit = Math.min(t_exit, Math.max(t0, t1));
         } else if (o_v < -half_v || o_v > half_v) {
             return false;
         }
@@ -528,34 +536,33 @@ export class HeightMapShape3D extends AbstractShape3D {
         const g_u = (o_u + d_u * t_enter + half_u) * per_cell_u;
         const g_v = (o_v + d_v * t_enter + half_v) * per_cell_v;
 
-        // Clamped because the slab clip lands the entry point ON the boundary,
-        // where rounding can put it a ULP outside the grid.
-        let i = Math.floor(g_u);
-        let j = Math.floor(g_v);
-
-        if (i < 0) i = 0; else if (i > seg_u - 1) i = seg_u - 1;
-        if (j < 0) j = 0; else if (j > seg_v - 1) j = seg_v - 1;
+        // Clamped to the grid because the slab clip lands the entry point ON the
+        // boundary, where rounding can put it a ULP outside.
+        let i = clamp_index(Math.floor(g_u), seg_u);
+        let j = clamp_index(Math.floor(g_v), seg_v);
 
+        // `t_next` is the distance at which the ray leaves the starting cell
+        // through that axis' far grid line, `t_delta` the distance a whole cell
+        // costs thereafter. A zero rate leaves both at Infinity: that axis is
+        // never the one the walk steps along.
         let step_i = 0, t_delta_u = Infinity, t_next_u = Infinity;
-        if (rate_u > 0) {
-            step_i = 1;
-            t_delta_u = 1 / rate_u;
-            t_next_u = t_enter + (i + 1 - g_u) * t_delta_u;
-        } else if (rate_u < 0) {
-            step_i = -1;
-            t_delta_u = -1 / rate_u;
-            t_next_u = t_enter + (i - g_u) / rate_u;
+        if (rate_u !== 0) {
+            // the grid line the starting cell is left through: its far side
+            // in the direction of travel
+            const exit_line = rate_u > 0 ? i + 1 : i;
+
+            step_i = rate_u > 0 ? 1 : -1;
+            t_delta_u = Math.abs(1 / rate_u);
+            t_next_u = t_enter + (exit_line - g_u) / rate_u;
         }
 
         let step_j = 0, t_delta_v = Infinity, t_next_v = Infinity;
-        if (rate_v > 0) {
-            step_j = 1;
-            t_delta_v = 1 / rate_v;
-            t_next_v = t_enter + (j + 1 - g_v) * t_delta_v;
-        } else if (rate_v < 0) {
-            step_j = -1;
-            t_delta_v = -1 / rate_v;
-            t_next_v = t_enter + (j - g_v) / rate_v;
+        if (rate_v !== 0) {
+            const exit_line = rate_v > 0 ? j + 1 : j;
+
+            step_j = rate_v > 0 ? 1 : -1;
+            t_delta_v = Math.abs(1 / rate_v);
+            t_next_v = t_enter + (exit_line - g_v) / rate_v;
         }
 
         const inv_seg_u = 1 / seg_u;
@@ -607,25 +614,27 @@ export class HeightMapShape3D extends AbstractShape3D {
             const Dy = uy * u_lo + vy * v_hi + ny * hD;
             const Dz = uz * u_lo + vz * v_hi + nz * hD;
 
-            // tri3_raycast writes hit[3..5] only for a hit inside the budget it
-            // was given, so handing the second triangle the first's distance
-            // leaves the nearer one's normal standing. Both can claim a point on
-            // the shared D–B diagonal, and this keeps the second where the
-            // narrowphase's copy of the same test keeps the first — the seam case
-            // the docstring calls out.
-            let best = tri3_raycast(
+            // Tested in reverse enumeration order, and that is what decides the
+            // tie. The two facets share the D–B diagonal — which runs through the
+            // sub-cell's centre, so a ray landing on it is the ordinary case, not a
+            // corner one — and a ray that lands on it hits both at one distance.
+            // `refine_ray_concave` enumerates (A,D,B) first and lets a later
+            // triangle win only by a strictly smaller distance, so the facet it
+            // names is (A,D,B). tri3_raycast admits `t <= tMax` and writes hit[3..5]
+            // only on a hit, so testing (D,C,B) first and handing (A,D,B) its
+            // distance as the budget lets the equal hit overwrite the normal — and
+            // the two paths name the same facet.
+            const t_dcb = tri3_raycast(
                 hit, 3, o_x, o_y, o_z, d_x, d_y, d_z, t_max,
-                Ax, Ay, Az, Dx, Dy, Dz, Bx, By, Bz
+                Dx, Dy, Dz, Cx, Cy, Cz, Bx, By, Bz
             );
 
-            const t_second = tri3_raycast(
-                hit, 3, o_x, o_y, o_z, d_x, d_y, d_z, best < t_max ? best : t_max,
-                Dx, Dy, Dz, Cx, Cy, Cz, Bx, By, Bz
+            const t_adb = tri3_raycast(
+                hit, 3, o_x, o_y, o_z, d_x, d_y, d_z, Math.min(t_dcb, t_max),
+                Ax, Ay, Az, Dx, Dy, Dz, Bx, By, Bz
             );
 
-            if (t_second < best) {
-                best = t_second;
-            }
+            const best = Math.min(t_adb, t_dcb);
 
             if (best !== Infinity) {
                 hit[0] = o_x + d_x * best;

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAoCa,OAAO,8BAA8B,EAAE,cAAc;AA6BlE;IAoEI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OA2OjB;IAhSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IA6BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eA6BC;IAED;;;OAGG;IACH,sBAkEC;IAqBD;;OAEG;IACH,sBAyCC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BApwB8B,+BAA+B;wBAUtC,wBAAwB;0BApBtB,0CAA0C;wCAcN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAejG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAtC4B,sCAAsC;sBA2B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAoCa,OAAO,8BAA8B,EAAE,cAAc;AA6BlE;IA4EI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OA2OjB;IAhSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IA6BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBA0EC;IAqBD;;OAEG;IACH,sBAyCC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAzyB8B,+BAA+B;wBAUtC,wBAAwB;0BApBtB,0CAA0C;wCAcN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAejG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAtC4B,sCAAsC;sBA2B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -66,6 +66,14 @@ const FOCUSABLE_SELECTOR = 'input, textarea, select, button, a[href], [contented
 class Engine {
     #last_frame_timestamp = 0;
 
+    /**
+     * Simulation time, in seconds, as of the last drawn frame — the anchor {@link Engine#render}
+     * measures its delta against. Simulation time, not wall clock, so it does not move while the
+     * simulation is paused.
+     * @type {number}
+     */
+    #last_render_simulation_time = 0;
+
     /**
      * Handle of the pending render-loop frame, `-1` when the loop is not running
      * @type {number}
@@ -629,7 +637,28 @@ class Engine {
 
             const t0 = performance.now();
 
-            graphics.render();
+            /*
+             Simulation seconds since the last DRAWN frame — what everything the renderer advances
+             steps by: GPU particles, the animation tick, exposure adaptation.
+
+             Taken from the simulation clock rather than measured here, because that is the clock
+             those things belong to: it freezes while the simulation is paused, and it carries the
+             scene's speed modifiers (see SceneManager), so a paused game holds its particles still
+             and a slowed one slows them. A wall-clock measurement would do neither.
+
+             `updateElapsedTime` advances the clock and reads it without touching the anchor
+             `getDelta` keeps, so this does not consume the delta the entity manager's tick is
+             about to be handed.
+
+             Moved only when a frame is actually drawn, so simulation time that passes while
+             rendering is off is caught up by the next frame rather than lost.
+            */
+            const simulation_time = this.ticker.clock.updateElapsedTime();
+            const time_delta_seconds = simulation_time - this.#last_render_simulation_time;
+
+            this.#last_render_simulation_time = simulation_time;
+
+            graphics.render(time_delta_seconds);
 
             const t1 = performance.now();
             const frame_time = (t1 - t0) / 1000;
@@ -694,6 +723,14 @@ class Engine {
 
             //start simulation
             this.ticker.start({ maxTimeout: 200 });
+
+            /*
+             The render delta's anchor, purged for the same reason `Ticker#start` purges the tick's:
+             `Ticker#stop` leaves the clock running, so a stopped engine keeps accruing simulation
+             time and a restart would otherwise hand the first drawn frame the whole gap. After
+             start(), not before — start() itself advances the clock past that gap.
+            */
+            this.#last_render_simulation_time = this.ticker.clock.updateElapsedTime();
             //self.uiController.init(self);
 
             //load options

package/src/engine/graphics3/GraphicsEngine.d.ts

@@ -351,7 +351,11 @@ export class GraphicsEngine {
     /**
      * Draw a frame, if there is anything to draw it with.
      *
-     * @param {number} [time_delta_seconds]
+     * @param {number} [time_delta_seconds] simulation seconds to advance the frame by — GPU
+     * particles, the animation tick and exposure adaptation all step by this. Defaults to zero, so
+     * a caller that just wants the current state on screen (a scene transition, a preview) draws it
+     * without moving anything. It deliberately does NOT default to a frame's worth of time: doing
+     * that silently ran the simulation at a fixed 60 Hz regardless of the real clock.
      * @returns {boolean} whether a frame was submitted
      */
     render(time_delta_seconds?: number): boolean;

package/src/engine/graphics3/GraphicsEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IA0DG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAkDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAoDnB;;CACJ;sBA7yBY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;8BAC3E,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAdrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IA0DG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAkDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CAoDnB;;CACJ;sBAjzBY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;8BAC3E,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAdrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}