@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/graph/metis/native/bisection/compute_2way_params.js

@@ -79,6 +79,8 @@ export function compute_2way_params(graph) {
         }
     }
 
-    graph.current_cut = cut_doubled >> 1;
+    // /2 not >>1: cut_doubled is exactly twice the cut (each crossing edge counted
+    // at both endpoints), and may be fractional now that edge weights are float.
+    graph.current_cut = cut_doubled / 2;
     graph.boundary_count = boundary_count;
 }

package/src/core/graph/metis/native/metis_partition_kway.d.ts

@@ -14,7 +14,7 @@
  * @param {number} partition_count
  * @param {Uint32Array} edge_addresses CSR row pointers, length vertex_count + 1
  * @param {Uint32Array} adjacency CSR column indices, length edge_addresses[vertex_count]
- * @param {Uint32Array} edge_weights parallel to adjacency
+ * @param {Float32Array} edge_weights parallel to adjacency; fractional weights are supported
  * @param {{
  *   seed?: number,
  *   niter?: number,
@@ -32,7 +32,7 @@
  *     Default 'recursive_bisection'.
  * @returns {Uint32Array} partition assignment per vertex, values in [0, partition_count)
  */
-export function metis_partition_kway(vertex_count: number, partition_count: number, edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Uint32Array, options?: {
+export function metis_partition_kway(vertex_count: number, partition_count: number, edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array, options?: {
     seed?: number;
     niter?: number;
     ufactor?: number;

package/src/core/graph/metis/native/metis_partition_kway.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metis_partition_kway.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/metis_partition_kway.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,mDAtBW,MAAM,mBACN,MAAM,kBACN,WAAW,aACX,WAAW,gBACX,WAAW;WAEV,MAAM;YACL,MAAM;cACJ,MAAM;iCACa,qBAAqB,GAAG,KAAK;IAWlD,WAAW,CAoFvB"}
+{"version":3,"file":"metis_partition_kway.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/metis_partition_kway.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,mDAtBW,MAAM,mBACN,MAAM,kBACN,WAAW,aACX,WAAW,gBACX,YAAY;WAEX,MAAM;YACL,MAAM;cACJ,MAAM;iCACa,qBAAqB,GAAG,KAAK;IAWlD,WAAW,CAoFvB"}

package/src/core/graph/metis/native/metis_partition_kway.js

@@ -23,7 +23,7 @@ import { RefinementScratch } from "./refine/RefinementScratch.js";
  * @param {number} partition_count
  * @param {Uint32Array} edge_addresses CSR row pointers, length vertex_count + 1
  * @param {Uint32Array} adjacency CSR column indices, length edge_addresses[vertex_count]
- * @param {Uint32Array} edge_weights parallel to adjacency
+ * @param {Float32Array} edge_weights parallel to adjacency; fractional weights are supported
  * @param {{
  *   seed?: number,
  *   niter?: number,

package/src/core/graph/metis/native/refine/compute_kway_params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_kway_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/compute_kway_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAHW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM,QA0HhB"}
+{"version":3,"file":"compute_kway_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/compute_kway_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAHW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM,QAsIhB"}

package/src/core/graph/metis/native/refine/compute_kway_params.js

@@ -25,6 +25,7 @@ export function compute_kway_params(graph, partition_count) {
     const vertex_partition = graph.vertex_partition;
     const partition_weights = graph.partition_weights;
     const internal_degree = graph.internal_degree;
+    const internal_edge_count = graph.internal_edge_count;
     const external_degree = graph.external_degree;
     const neighbor_partition_count = graph.neighbor_partition_count;
     const neighbor_partition_offset = graph.neighbor_partition_offset;
@@ -37,6 +38,7 @@ export function compute_kway_params(graph, partition_count) {
 
     partition_weights.fill(0);
     internal_degree.fill(0);
+    internal_edge_count.fill(0);
     external_degree.fill(0);
     neighbor_partition_count.fill(0);
     neighbor_partition_offset.fill(-1);
@@ -61,7 +63,10 @@ export function compute_kway_params(graph, partition_count) {
     // nor `partition_count`; `partition_count` is the safe upper bound on
     // scratch size.
     const scratch_partition_id = new Uint32Array(partition_count);
-    const scratch_partition_edge_weight = new Uint32Array(partition_count);
+    const scratch_partition_edge_weight = new Float32Array(partition_count);
+    // Exact count of edges summed into each scratch weight; copied into the pool
+    // so downstream add/remove decisions key off counts, not float-weight equality.
+    const scratch_partition_edge_count = new Uint32Array(partition_count);
 
     let boundary_count = 0;
     let cut_doubled = 0;
@@ -70,6 +75,7 @@ export function compute_kway_params(graph, partition_count) {
         const my_partition = vertex_partition[vertex];
 
         let v_internal_degree = 0;
+        let v_internal_edge_count = 0;
         let v_external_degree = 0;
         let distinct_neighbor_partitions = 0;
 
@@ -80,6 +86,7 @@ export function compute_kway_params(graph, partition_count) {
             const edge_weight = edge_weights[edge_offset];
             if (neighbor_partition === my_partition) {
                 v_internal_degree += edge_weight;
+                v_internal_edge_count++;
             } else {
                 v_external_degree += edge_weight;
                 const existing_position = scratch_partition_position[neighbor_partition];
@@ -87,14 +94,17 @@ export function compute_kway_params(graph, partition_count) {
                     scratch_partition_position[neighbor_partition] = distinct_neighbor_partitions;
                     scratch_partition_id[distinct_neighbor_partitions] = neighbor_partition;
                     scratch_partition_edge_weight[distinct_neighbor_partitions] = edge_weight;
+                    scratch_partition_edge_count[distinct_neighbor_partitions] = 1;
                     distinct_neighbor_partitions++;
                 } else {
                     scratch_partition_edge_weight[existing_position] += edge_weight;
+                    scratch_partition_edge_count[existing_position]++;
                 }
             }
         }
 
         internal_degree[vertex] = v_internal_degree;
+        internal_edge_count[vertex] = v_internal_edge_count;
         external_degree[vertex] = v_external_degree;
 
         if (v_external_degree > 0) {
@@ -106,17 +116,19 @@ export function compute_kway_params(graph, partition_count) {
             // and introduce a new partition; we need room.
             const degree = edge_end - edge_start;
             const pool_record_offset = neighbor_partition_pool.allocate_continuous(degree);
-            // Re-read the backing view AFTER allocating: allocate_continuous may have grown the pool and
-            // replaced data_uint32, leaving any previously-captured view pointing at a detached (stale) buffer.
+            // Re-read BOTH backing views AFTER allocating: allocate_continuous may have grown the pool and
+            // replaced the buffer, leaving any previously-captured view pointing at a detached (stale) buffer.
             const pool_data = neighbor_partition_pool.data_uint32;
+            const pool_data_f32 = neighbor_partition_pool.data_float32;
             neighbor_partition_offset[vertex] = pool_record_offset;
             neighbor_partition_count[vertex] = distinct_neighbor_partitions;
 
-            // Each pool record is 8 bytes = 2 uint32 words: (partition_id, edge_weight).
+            // Each pool record is 3 words: (partition_id:u32, edge_weight:f32, edge_count:u32).
             const word_base = neighbor_partition_pool.element_word(pool_record_offset);
             for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
-                pool_data[word_base + nbr * 2] = scratch_partition_id[nbr];
-                pool_data[word_base + nbr * 2 + 1] = scratch_partition_edge_weight[nbr];
+                pool_data[word_base + nbr * 3] = scratch_partition_id[nbr];
+                pool_data_f32[word_base + nbr * 3 + 1] = scratch_partition_edge_weight[nbr];
+                pool_data[word_base + nbr * 3 + 2] = scratch_partition_edge_count[nbr];
             }
 
             if (v_external_degree >= v_internal_degree) {
@@ -133,7 +145,7 @@ export function compute_kway_params(graph, partition_count) {
     }
 
     // Each crossing edge contributes to both endpoints' external_degree, so we
-    // counted it twice across the loop above.
-    graph.current_cut = cut_doubled >> 1;
+    // counted it twice across the loop above. /2 not >>1: the cut may be fractional.
+    graph.current_cut = cut_doubled / 2;
     graph.boundary_count = boundary_count;
 }

package/src/core/graph/metis/native/refine/fm_kway.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fm_kway.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/fm_kway.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,+BAjBW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM;kBAEO,MAAM;iBACZ,MAAM;gBACP,MAAM;mBACH,MAAM;YAMf,OAAO,wBAAwB,EAAE,iBAAiB,GAGhD,MAAM,CAgZlB"}
+{"version":3,"file":"fm_kway.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/fm_kway.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,+BAjBW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM;kBAEO,MAAM;iBACZ,MAAM;gBACP,MAAM;mBACH,MAAM;YAMf,OAAO,wBAAwB,EAAE,iBAAiB,GAGhD,MAAM,CAyalB"}

package/src/core/graph/metis/native/refine/fm_kway.js

@@ -77,6 +77,7 @@ export function fm_kway(graph, partition_count, opts, scratch) {
     const boundary_vertices = graph.boundary_vertices;
     const boundary_position_of_vertex = graph.boundary_position_of_vertex;
     const internal_degree = graph.internal_degree;
+    const internal_edge_count = graph.internal_edge_count;
     const external_degree = graph.external_degree;
     const neighbor_partition_count = graph.neighbor_partition_count;
     const neighbor_partition_offset = graph.neighbor_partition_offset;
@@ -169,6 +170,7 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             const from_partition = vertex_partition[vertex];
             const vertex_weight = vertex_weights[vertex];
             const v_internal_degree = internal_degree[vertex];
+            const v_internal_edge_count = internal_edge_count[vertex];
             const v_external_degree = external_degree[vertex];
             const v_nbr_partition_count = neighbor_partition_count[vertex];
             const v_pool_offset = neighbor_partition_offset[vertex];
@@ -189,15 +191,19 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             // The balance-improvement test `pwgts[from] - vwgt > pwgts[to]`
             // is master's `tpwgts[from]*pwgts[to] < tpwgts[to]*(pwgts[from]-vwgt)`
             // simplified for uniform tpwgts (which is all we support).
+            // Pool records are 3 words: id (u32), weight (f32), count (u32). Read ids/counts
+            // through pool_data, weights through pool_data_f32. No allocation happens between
+            // here and the commit below, so these views stay valid for v's region.
             const pool_data = neighbor_partition_pool.data_uint32;
+            const pool_data_f32 = neighbor_partition_pool.data_float32;
             const v_pool_word_base = neighbor_partition_pool.element_word(v_pool_offset);
 
             const partition_weight_from_after = partition_weights[from_partition] - vertex_weight;
 
             let best_nbr_index = -1;
             for (let nbr_index = v_nbr_partition_count - 1; nbr_index >= 0; nbr_index--) {
-                const candidate_partition = pool_data[v_pool_word_base + nbr_index * 2];
-                const candidate_edge_weight = pool_data[v_pool_word_base + nbr_index * 2 + 1];
+                const candidate_partition = pool_data[v_pool_word_base + nbr_index * 3];
+                const candidate_edge_weight = pool_data_f32[v_pool_word_base + nbr_index * 3 + 1];
                 const candidate_weight_after = partition_weights[candidate_partition] + vertex_weight;
 
                 // "Move improves proportional balance" (uniform-tpwgts form).
@@ -220,11 +226,11 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             }
 
             {
-                let best_edge_weight = pool_data[v_pool_word_base + best_nbr_index * 2 + 1];
-                let best_target_partition = pool_data[v_pool_word_base + best_nbr_index * 2];
+                let best_edge_weight = pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1];
+                let best_target_partition = pool_data[v_pool_word_base + best_nbr_index * 3];
                 for (let nbr_index = best_nbr_index - 1; nbr_index >= 0; nbr_index--) {
-                    const candidate_partition = pool_data[v_pool_word_base + nbr_index * 2];
-                    const candidate_edge_weight = pool_data[v_pool_word_base + nbr_index * 2 + 1];
+                    const candidate_partition = pool_data[v_pool_word_base + nbr_index * 3];
+                    const candidate_edge_weight = pool_data_f32[v_pool_word_base + nbr_index * 3 + 1];
                     const candidate_weight_after = partition_weights[candidate_partition] + vertex_weight;
                     const balance_improves = candidate_weight_after - vertex_weight < partition_weight_from_after;
 
@@ -245,8 +251,9 @@ export function fm_kway(graph, partition_count, opts, scratch) {
                 }
             }
 
-            const to_partition = pool_data[v_pool_word_base + best_nbr_index * 2];
-            const to_edge_weight = pool_data[v_pool_word_base + best_nbr_index * 2 + 1];
+            const to_partition = pool_data[v_pool_word_base + best_nbr_index * 3];
+            const to_edge_weight = pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1];
+            const to_edge_count = pool_data[v_pool_word_base + best_nbr_index * 3 + 2];
             const gain = to_edge_weight - v_internal_degree;
 
             // ===== Commit the move =========================================
@@ -266,21 +273,26 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             const new_internal_degree = to_edge_weight;
             const new_external_degree = v_external_degree - to_edge_weight + v_internal_degree;
             internal_degree[vertex] = new_internal_degree;
+            // v's internal edges are now exactly the ones that used to go to `to_partition`.
+            internal_edge_count[vertex] = to_edge_count;
             external_degree[vertex] = new_external_degree;
 
-            if (v_internal_degree === 0) {
-                // No back-edges to `from_partition`. Drop the entry by swap-with-last.
+            if (v_internal_edge_count === 0) {
+                // No back-edges to `from_partition` (exact edge-count test, not a float
+                // weight test). Drop the entry by swap-with-last; copy all three words.
                 const last_index = v_nbr_partition_count - 1;
                 if (best_nbr_index !== last_index) {
-                    pool_data[v_pool_word_base + best_nbr_index * 2]     = pool_data[v_pool_word_base + last_index * 2];
-                    pool_data[v_pool_word_base + best_nbr_index * 2 + 1] = pool_data[v_pool_word_base + last_index * 2 + 1];
+                    pool_data    [v_pool_word_base + best_nbr_index * 3]     = pool_data    [v_pool_word_base + last_index * 3];
+                    pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1] = pool_data_f32[v_pool_word_base + last_index * 3 + 1];
+                    pool_data    [v_pool_word_base + best_nbr_index * 3 + 2] = pool_data    [v_pool_word_base + last_index * 3 + 2];
                 }
                 neighbor_partition_count[vertex] = last_index;
             } else {
                 // The slot that used to represent `to_partition` now represents
-                // `from_partition` with the old internal_degree as its edge weight.
-                pool_data[v_pool_word_base + best_nbr_index * 2] = from_partition;
-                pool_data[v_pool_word_base + best_nbr_index * 2 + 1] = v_internal_degree;
+                // `from_partition` with the old internal degree/count as its edge data.
+                pool_data    [v_pool_word_base + best_nbr_index * 3]     = from_partition;
+                pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1] = v_internal_degree;
+                pool_data    [v_pool_word_base + best_nbr_index * 3 + 2] = v_internal_edge_count;
             }
 
             // Update v's boundary membership.
@@ -318,11 +330,13 @@ export function fm_kway(graph, partition_count, opts, scratch) {
                     neighbor_pool_offset = neighbor_partition_pool.allocate_continuous(neighbor_degree);
                     neighbor_partition_offset[neighbor] = neighbor_pool_offset;
                 }
-                // Re-fetch the data view in case the pool grew during allocate.
+                // Re-fetch BOTH data views in case the pool grew during allocate.
                 const pool_data_for_neighbor = neighbor_partition_pool.data_uint32;
+                const pool_data_for_neighbor_f32 = neighbor_partition_pool.data_float32;
                 const neighbor_pool_word_base = neighbor_partition_pool.element_word(neighbor_pool_offset);
 
                 let n_internal_degree = internal_degree[neighbor];
+                let n_internal_edge_count = internal_edge_count[neighbor];
                 let n_external_degree = external_degree[neighbor];
                 let n_nbr_partition_count = neighbor_partition_count[neighbor];
 
@@ -330,56 +344,67 @@ export function fm_kway(graph, partition_count, opts, scratch) {
                     // The edge v–neighbor used to be internal for the neighbour
                     // (both in `from`); after v's move it becomes external.
                     n_internal_degree -= edge_weight_to_neighbor;
+                    n_internal_edge_count--;
                     n_external_degree += edge_weight_to_neighbor;
                 } else if (neighbor_owning_partition === to_partition) {
                     // The reverse — was external, now internal.
                     n_internal_degree += edge_weight_to_neighbor;
+                    n_internal_edge_count++;
                     n_external_degree -= edge_weight_to_neighbor;
                 }
 
-                // Remove the neighbour's record of `from_partition` (or
-                // decrement it). Only do this if the neighbour is not itself
-                // in `from_partition`; if it is, `from` isn't in its neighbour
-                // list at all.
+                // Remove the neighbour's record of `from_partition` (or decrement it).
+                // Only do this if the neighbour is not itself in `from_partition`; if it
+                // is, `from` isn't in its neighbour list at all. The v–neighbor edge is
+                // exactly one edge into `from`, so drop the entry's edge count by 1 and
+                // remove the entry only when that count hits 0 — an exact decision, not
+                // the float weight comparison that fractional weights would make unsafe.
                 if (neighbor_owning_partition !== from_partition) {
                     for (let nbr_index = 0; nbr_index < n_nbr_partition_count; nbr_index++) {
-                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2] === from_partition) {
-                            const current_edge_weight = pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1];
-                            if (current_edge_weight === edge_weight_to_neighbor) {
-                                // Last edge to from-partition; remove the entry.
+                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 3] === from_partition) {
+                            const remaining_count = pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 3 + 2] - 1;
+                            if (remaining_count === 0) {
+                                // Last edge to from-partition; remove the entry by swap-with-last.
                                 const last_index = n_nbr_partition_count - 1;
                                 if (nbr_index !== last_index) {
-                                    pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2]     = pool_data_for_neighbor[neighbor_pool_word_base + last_index * 2];
-                                    pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1] = pool_data_for_neighbor[neighbor_pool_word_base + last_index * 2 + 1];
+                                    pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3]     = pool_data_for_neighbor    [neighbor_pool_word_base + last_index * 3];
+                                    pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1] = pool_data_for_neighbor_f32[neighbor_pool_word_base + last_index * 3 + 1];
+                                    pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3 + 2] = pool_data_for_neighbor    [neighbor_pool_word_base + last_index * 3 + 2];
                                 }
                                 n_nbr_partition_count = last_index;
                             } else {
-                                pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1] = current_edge_weight - edge_weight_to_neighbor;
+                                const current_edge_weight = pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1];
+                                pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1] = current_edge_weight - edge_weight_to_neighbor;
+                                pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3 + 2] = remaining_count;
                             }
                             break;
                         }
                     }
                 }
 
-                // Add or increment the neighbour's record of `to_partition`,
-                // unless the neighbour is itself in `to_partition`.
+                // Add or increment the neighbour's record of `to_partition`, unless the
+                // neighbour is itself in `to_partition`. The v–neighbor edge adds exactly
+                // one edge into `to`, so bump the entry's edge count by 1.
                 if (neighbor_owning_partition !== to_partition) {
                     let found_existing_entry = false;
                     for (let nbr_index = 0; nbr_index < n_nbr_partition_count; nbr_index++) {
-                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2] === to_partition) {
-                            pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1] += edge_weight_to_neighbor;
+                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 3] === to_partition) {
+                            pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1] += edge_weight_to_neighbor;
+                            pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3 + 2] += 1;
                             found_existing_entry = true;
                             break;
                         }
                     }
                     if (!found_existing_entry) {
-                        pool_data_for_neighbor[neighbor_pool_word_base + n_nbr_partition_count * 2]     = to_partition;
-                        pool_data_for_neighbor[neighbor_pool_word_base + n_nbr_partition_count * 2 + 1] = edge_weight_to_neighbor;
+                        pool_data_for_neighbor    [neighbor_pool_word_base + n_nbr_partition_count * 3]     = to_partition;
+                        pool_data_for_neighbor_f32[neighbor_pool_word_base + n_nbr_partition_count * 3 + 1] = edge_weight_to_neighbor;
+                        pool_data_for_neighbor    [neighbor_pool_word_base + n_nbr_partition_count * 3 + 2] = 1;
                         n_nbr_partition_count++;
                     }
                 }
 
                 internal_degree[neighbor] = n_internal_degree;
+                internal_edge_count[neighbor] = n_internal_edge_count;
                 external_degree[neighbor] = n_external_degree;
                 neighbor_partition_count[neighbor] = n_nbr_partition_count;
 

package/src/engine/EngineHarness.js

@@ -359,14 +359,14 @@ export class EngineHarness {
     static async buildLights({
                                  engine,
                                  ecd = engine.entityManager.dataset,
-                                 shadowmapResolution = 1024,
+                                 shadowmapResolution = 2048,
                                  castShadow = true,
                                  sun = DEFAULT_SUNLIGHT_COLOR,
                                  sunIntensity = 0.9,
                                  sunDirection = new Vector3(0.17, -1, 0.17),
                                  sunShadowDistance = 1000,
                                  ambient = Color.white,
-                                 ambientIntensity = 0.1
+                                 ambientIntensity = 0.07
                              }) {
         const em = engine.entityManager;
 

package/src/engine/animation/curve/view/AnimationCurveView.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
 import { m3_cm_compose_transform } from "../../../../core/geom/mat3/m3_cm_compose_transform.js";
-import { m3_cm_invert } from "../../../../core/geom/mat3/m3_cm_invert.js";
+import { m3_invert } from "../../../../core/geom/mat3/m3_invert.js";
 import { v2_length } from "../../../../core/geom/vec2/v2_length.js";
 import { v2_matrix3_cm_multiply } from "../../../../core/geom/vec2/v2_matrix3_cm_multiply.js";
 import { CanvasView } from "../../../../view/elements/CanvasView.js";
@@ -108,7 +108,7 @@ export class AnimationCurveView extends EmptyView {
             frame.x0, frame.y1, 0
         );
 
-        m3_cm_invert(this.#transform_inverse, this.#transform);
+        m3_invert(this.#transform_inverse, this.#transform);
     }
 
     /**

package/src/engine/asset/loaders/material/planeHash.js

@@ -1,4 +1,4 @@
-import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
+import { v3_morton_encode_magicbits } from "../../../../core/geom/3d/morton/v3_morton_encode_magicbits.js";
 
 /**
  *
@@ -6,5 +6,5 @@ import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEn
  * @returns {number}
  */
 export function planeHash(plane) {
-    return mortonEncode_magicbits(plane.normal.x, plane.normal.y, plane.normal.z) ^ plane.constant;
+    return v3_morton_encode_magicbits(plane.normal.x, plane.normal.y, plane.normal.z) ^ plane.constant;
 }

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts.map

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

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.js

@@ -1,4 +1,7 @@
 import { assert } from "../../../core/assert.js";
+import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
+import { CapsuleShape3D } from "../../../core/geom/3d/shape/CapsuleShape3D.js";
+import { TransformedShape3D } from "../../../core/geom/3d/shape/TransformedShape3D.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { clamp } from "../../../core/math/clamp.js";
@@ -11,27 +14,24 @@ import Entity from "../../ecs/Entity.js";
 import { System } from "../../ecs/System.js";
 import { Transform } from "../../ecs/transform/Transform.js";
 import { Camera } from "../../graphics/ecs/camera/Camera.js";
-import { EyeOffsetStack } from "./composer/EyeOffsetStack.js";
-import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
-import { CapsuleShape3D } from "../../../core/geom/3d/shape/CapsuleShape3D.js";
-import { TransformedShape3D } from "../../../core/geom/3d/shape/TransformedShape3D.js";
 import { BodyKind } from "../../physics/ecs/BodyKind.js";
 import { Collider } from "../../physics/ecs/Collider.js";
 import { PhysicsSystem } from "../../physics/ecs/PhysicsSystem.js";
 import { RigidBody } from "../../physics/ecs/RigidBody.js";
 import { PhysicsSurfacePoint } from "../../physics/queries/PhysicsSurfacePoint.js";
+import { KinematicMover } from "./collision/KinematicMover.js";
+import { EyeOffsetStack } from "./composer/EyeOffsetStack.js";
 import { FirstPersonPlayerController } from "./FirstPersonPlayerController.js";
 import { DecisionPoint } from "./mastery/DecisionPoint.js";
 import { computeJumpFromApex } from "./math/computeJumpFromApex.js";
-import { jumpForceForHeight, launchVelocityForForce } from "./math/jumpDynamics.js";
 import { computeLRCBreathRate } from "./math/computeLRCBreathRate.js";
 import { computeMassRatios } from "./math/computeMassRatios.js";
+import { jumpForceForHeight, launchVelocityForForce } from "./math/jumpDynamics.js";
 import { Spring } from "./math/Spring.js";
 import { stepTowards } from "./math/stepTowards.js";
 import { FirstPersonActionState, FirstPersonLocomotionMode } from "./pose/FirstPersonPose.js";
 import { FirstPersonPosture } from "./pose/FirstPersonPosture.js";
 import { FirstPersonSensors } from "./sensors/FirstPersonSensors.js";
-import { KinematicMover } from "./collision/KinematicMover.js";
 
 // ---------------------------------------------------------------------------
 // Scratch allocations — reused per frame to avoid GC pressure
@@ -582,7 +582,7 @@ export class FirstPersonPlayerControllerSystem extends System {
             camera.fov.set(controller.config.fov.base);
             camera.clip_near = 0.05;
             camera.clip_far = 1000;
-            camera.autoClip = false;
+            camera.autoClip = true;
 
             eye.add(eyeTransform);
             eye.add(camera);

package/src/engine/control/first-person/prototype_first_person_controller.js

@@ -3,7 +3,7 @@ import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
 import { BoxShape3D } from "../../../core/geom/3d/shape/BoxShape3D.js";
 import { CapsuleShape3D } from "../../../core/geom/3d/shape/CapsuleShape3D.js";
 import { TransformedShape3D } from "../../../core/geom/3d/shape/TransformedShape3D.js";
-import { shape_mesh_from_geometry } from "../../../core/geom/3d/shape/shape_mesh_from_geometry.js";
+import { shape3_mesh_from_geometry } from "../../../core/geom/3d/shape/shape3_mesh_from_geometry.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector3 from "../../../core/geom/Vector3.js";
@@ -243,7 +243,7 @@ function buildGym(ecd) {
 /**
  * Drop a torus-knot prop off to the side as a smoke test for
  * {@link MeshShape3D}: arbitrary indexed triangle mesh → tetrahedralised
- * collider via {@link shape_mesh_from_geometry}.
+ * collider via {@link shape3_mesh_from_geometry}.
  *
  * Dynamic body, so the player capsule (kinematic) can bump it around.
  * KinematicPosition bodies don't receive impulses themselves (the
@@ -273,7 +273,7 @@ function buildMeshShapeShowcase(ecd) {
         ? src_indices
         : Uint32Array.from(src_indices);
 
-    const shape = shape_mesh_from_geometry(positions, indices);
+    const shape = shape3_mesh_from_geometry(positions, indices);
 
     const material = new MeshStandardMaterial({ color: 0xffaa66, roughness: 0.5 });
     const sg = ShadedGeometry.from(geom, material);

package/src/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -2,11 +2,11 @@ import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import {
-    bvh_query_user_data_overlaps_frustum
-} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
+    bvh_query_user_data_intersects_frustum
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_frustum.js";
 
 import { noop } from "../../../../core/function/noop.js";
-import { read_three_planes_to_array } from "../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
+import { frustum3_planes_to_flat_from_three } from "../../../../core/geom/3d/frustum/frustum3_planes_to_flat_from_three.js";
 import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { TextureAssetLoader } from "../../../asset/loaders/texture/TextureAssetLoader.js";
@@ -112,7 +112,7 @@ class TerrainSystem extends System {
             ecd.traverseComponents(Terrain, (component, entity) => {
                 const tile_manager = component.tiles;
 
-                const hit_count = bvh_query_user_data_overlaps_frustum(
+                const hit_count = bvh_query_user_data_intersects_frustum(
                     tiles, 0,
                     tile_manager.bvh, view.frustum
                 );
@@ -272,9 +272,9 @@ class TerrainSystem extends System {
 
                 for (let i = 0; i < frustums.length; i++) {
 
-                    read_three_planes_to_array(frustums[i].planes, frustum);
+                    frustum3_planes_to_flat_from_three(frustums[i].planes, frustum);
 
-                    found_tiles += bvh_query_user_data_overlaps_frustum(tiles, tile_count, tileManager.bvh, frustum);
+                    found_tiles += bvh_query_user_data_intersects_frustum(tiles, tile_count, tileManager.bvh, frustum);
                 }
 
                 for (let i = 0; i < found_tiles; i++) {

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -13,7 +13,7 @@ import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
-import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { ray3_compose_array } from "../../../../core/geom/3d/ray/ray3_compose_array.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import Vector2 from '../../../../core/geom/Vector2.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
@@ -172,7 +172,7 @@ class TerrainTile {
 
         mat4.invert(m4_tmp, m4);
 
-        ray3_array_compose(
+        ray3_compose_array(
             ray_tmp,
             originX, originY, originZ,
             directionX, directionY, directionZ

package/src/engine/ecs/terrain/tiles/TerrainTileManager.js

@@ -8,7 +8,7 @@ import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query
 import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 import { Color } from "../../../../core/color/Color.js";
 import Signal from '../../../../core/events/signal/Signal.js';
-import { aabb2_overlap_exists } from "../../../../core/geom/2d/aabb/aabb2_overlap_exists.js";
+import { aabb2_intersects_aabb2 } from "../../../../core/geom/2d/aabb/aabb2_intersects_aabb2.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import Vector2 from '../../../../core/geom/Vector2.js';
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
@@ -329,7 +329,7 @@ class TerrainTileManager {
             const tx1 = tx0 + tile.size.x;
             const ty1 = ty0 + tile.size.y;
             if (
-                aabb2_overlap_exists(
+                aabb2_intersects_aabb2(
                     x0, y0, x1, y1,
                     tx0, ty0, tx1, ty1
                 )
@@ -618,9 +618,9 @@ class TerrainTileManager {
     ) {
 
         const hit_count = bvh_query_leaves_ray(
+            scratch_array, 0,
             this.bvh,
             this.bvh.root,
-            scratch_array, 0,
             originX, originY, originZ,
             directionX, directionY, directionZ
         );