@woosh/meep-engine 3.27.0 → 3.28.0

package/src/shade/renderer/geometry/virtual/build/page/vgeo_page_node_count.d.ts

@@ -0,0 +1,22 @@
+/**
+ * How many nodes {@link vgeo_build_page_nodes} will put over a page holding `group_count` groups.
+ *
+ * The tree's shape is a function of the group *count* alone — every node covers a contiguous run of
+ * the page's Morton order and splits it into as-near-equal parts as integers allow — so the node
+ * table's size is known before the tree exists. Which is what the page assembler needs: the node
+ * table is part of the decoded page, and a page whose size is a hard bound has to be measured with
+ * it included, while the tree itself cannot be built until the page's last group has arrived.
+ *
+ * This duplicates the recurrence in {@link vgeo_build_page_nodes} rather than sharing it, because
+ * the two want different things from it — one wants the ranges and one wants only how many there
+ * are — and the cost of the duplication is a spec that runs both and compares.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @param {number} group_count
+ * @returns {number} nodes, at least one
+ */
+export function vgeo_page_node_count(group_count: number): number;
+//# sourceMappingURL=vgeo_page_node_count.d.ts.map

package/src/shade/renderer/geometry/virtual/build/page/vgeo_page_node_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_page_node_count.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/page/vgeo_page_node_count.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,kDAHW,MAAM,GACJ,MAAM,CA8BlB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_page_node_count.js → page/vgeo_page_node_count.js}

@@ -1,5 +1,5 @@
-import { assert } from "../../../../../core/assert.js";
-import { VGEO_NODE_FANOUT } from "../format/page/VGEO_NODE_FANOUT.js";
+import { assert } from "../../../../../../core/assert.js";
+import { VGEO_NODE_FANOUT } from "../../format/page/VGEO_NODE_FANOUT.js";
 
 /**
  * How many nodes {@link vgeo_build_page_nodes} will put over a page holding `group_count` groups.

package/src/shade/renderer/geometry/virtual/build/partition/VGeoFaceGraph.d.ts

@@ -0,0 +1,52 @@
+export class VGeoFaceGraph {
+    /**
+     * @param {BinaryTopology} mesh
+     * @param {BinaryTopologyFaceGraph} face_graph
+     */
+    constructor(mesh: BinaryTopology, face_graph: BinaryTopologyFaceGraph);
+    /**
+     * @type {BinaryTopology}
+     */
+    mesh: BinaryTopology;
+    /**
+     * CSR over dense face-graph vertices; edge weights are shared-edge counts.
+     * @type {MetisGraph}
+     */
+    graph: MetisGraph;
+    /**
+     * `vertex_face_ids[dense] = face id`.
+     * @type {Uint32Array}
+     */
+    vertex_face_ids: Uint32Array;
+    /**
+     * Scratch stamp for unique-vertex counting, one entry per mesh vertex slot.
+     * @type {Int32Array}
+     */
+    vertex_stamp: Int32Array;
+    /**
+     * Monotonic stamp value, so the scratch never needs clearing.
+     * @type {number}
+     */
+    stamp: number;
+    /**
+     * Scratch `graph vertex -> its position in the member list being split right now`, one entry per
+     * graph vertex. Only the entries of that member list mean anything, which is all
+     * {@link vgeo_split_face_set}'s partition step ever reads: it consults this exclusively for
+     * neighbours the membership stamp has already confirmed are members.
+     *
+     * Dense rather than a `Map` because the keys are dense face-graph vertices to begin with, and
+     * because a `Map` cannot answer this question at all past 2^24 entries — the leaf cut runs over
+     * every face of the mesh at once, so a mesh of more than 16.7M triangles in one connected
+     * component would otherwise stop the builder dead.
+     * @type {Uint32Array}
+     */
+    member_index: Uint32Array;
+    /**
+     * How many distinct mesh vertices a set of dense face-graph vertices touches.
+     *
+     * @param {number[]|Int32Array} members dense face-graph vertices
+     * @returns {number}
+     */
+    count_unique_vertices(members: number[] | Int32Array): number;
+}
+//# sourceMappingURL=VGeoFaceGraph.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/VGeoFaceGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoFaceGraph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/VGeoFaceGraph.js"],"names":[],"mappings":"AAcA;IA4CI;;;OAGG;IACH,uEAMC;IArDD;;OAEG;IACH,qBAAY;IAEZ;;;OAGG;IACH,kBAAa;IAEb;;;OAGG;IACH,iBAFU,WAAW,CAEE;IAEvB;;;OAGG;IACH,cAFU,UAAU,CAEA;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;;;OAWG;IACH,cAFU,WAAW,CAED;IAcpB;;;;;OAKG;IACH,+BAHW,MAAM,EAAE,GAAC,UAAU,GACjB,MAAM,CA2BlB;CACJ"}

package/src/shade/renderer/geometry/virtual/build/{VGeoFaceGraph.js → partition/VGeoFaceGraph.js}

@@ -1,6 +1,6 @@
 import {
     bt_face_read_triangle_vertices
-} from "../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
+} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
 
 /**
  * A face-adjacency graph together with the mesh it came from, kept so that repeated splits over the

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Not re-entrant: one call's stamps are live until it returns, and it neither yields nor calls back
+ * into itself.
+ *
+ * @param {Uint32Array} edge_addresses CSR row pointers
+ * @param {Uint32Array} adjacency CSR column indices
+ * @param {number[]} members vertices of the subgraph
+ * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a
+ *     member. The caller stamps it, so nested calls over shrinking sets stay correct.
+ * @param {number} token
+ * @returns {number[][]} components, each ascending, ordered by their lowest member
+ */
+export function vgeo_graph_components(edge_addresses: Uint32Array, adjacency: Uint32Array, members: number[], membership: Int32Array, token: number): number[][];
+//# sourceMappingURL=vgeo_graph_components.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_graph_components.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;GAWG;AACH,sDARW,WAAW,aACX,WAAW,WACX,MAAM,EAAE,cACR,UAAU,SAEV,MAAM,GACJ,MAAM,EAAE,EAAE,CAmEtB"}

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_graph.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Partition a graph, and keep the build alive if the partitioner cannot.
+ *
+ * METIS is what should do this and what does do it: better cuts, and every partition the builder has
+ * ever produced has come from it. What it does not promise is to succeed. A build is an offline tool
+ * run over whatever a scanner or a CAD exporter produced, and a partitioner that throws takes the
+ * whole asset with it — for input nobody can inspect and a failure nobody can act on. The spectral
+ * bisection underneath is worse at its job and always finishes, which for a fallback is the right
+ * way round.
+ *
+ * This is not error suppression. A partitioner declining a graph is an expected outcome for input
+ * this open-ended, and the response is to use the other one — the same shape as a group that will
+ * not simplify going back to the frontier rather than failing its round. What is *not* caught is
+ * both of them failing: that is a bug, and it is thrown with both causes named.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @param {number} vertex_count
+ * @param {number} partition_count
+ * @param {Uint32Array} edge_addresses CSR row pointers, length `vertex_count + 1`
+ * @param {Uint32Array} adjacency CSR column indices
+ * @param {Float32Array} edge_weights parallel to `adjacency`
+ * @param {number} seed for METIS, so the same graph partitions the same way
+ * @returns {Uint32Array} partition assignment per vertex, values in `[0, partition_count)`
+ */
+export function vgeo_partition_graph(vertex_count: number, partition_count: number, edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array, seed: number): Uint32Array;
+//# sourceMappingURL=vgeo_partition_graph.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_partition_graph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_graph.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;GAQG;AACH,mDARW,MAAM,mBACN,MAAM,kBACN,WAAW,aACX,WAAW,gBACX,YAAY,QACZ,MAAM,GACJ,WAAW,CA0BvB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_partition_graph.js → partition/vgeo_partition_graph.js}

@@ -1,5 +1,5 @@
-import { graph_partition_spectral } from "../../../../../core/graph/graph_partition_spectral.js";
-import { metis_partition_kway } from "../../../../../core/graph/metis/native/metis_partition_kway.js";
+import { graph_partition_spectral } from "../../../../../../core/graph/graph_partition_spectral.js";
+import { metis_partition_kway } from "../../../../../../core/graph/metis/native/metis_partition_kway.js";
 
 /**
  * Partition a graph, and keep the build alive if the partitioner cannot.

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Partition the subgraph a CSR induces on a member set.
+ *
+ * Both places the builder partitions something want this, and for the same reason the components
+ * pass beside it exists: METIS takes a graph, not a graph and a mask, so the members have to be
+ * renumbered into a dense local graph first and the assignment scattered back afterwards. That is
+ * forty lines of the same bookkeeping either side of one call, and it was written twice — once for
+ * splitting faces into clusters, once for grouping clusters into groups.
+ *
+ * The two copies had already drifted on the point one of them documents at length: the face side
+ * keeps a dense `Uint32Array` scratch because a `Map` cannot answer this at all past 2^24 entries
+ * and the leaf cut runs over every face of the mesh at once, while the cluster side had reached for
+ * a `Map`. Taking the scratch as a parameter is what makes that a property of this function rather
+ * than of whoever last copied it.
+ *
+ * Edge weights are carried through unchanged; a caller that wants them shaped — the group pass
+ * scales by compactness — does that when it builds the CSR.
+ *
+ * @param {{edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array}} graph
+ *     CSR over the whole vertex set
+ * @param {number[]} members vertices of the subgraph to partition
+ * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a
+ *     member, which is what keeps a nested split from following an edge that leaves its subset
+ * @param {number} token
+ * @param {number} part_count at least 2
+ * @param {number} seed fixed by the caller, so the same subgraph always splits the same way
+ * @param {Uint32Array} local_index scratch, one entry per graph vertex. Only the members' entries
+ *     are written or read, so it never needs clearing between calls
+ * @returns {number[][]} the non-empty parts, in part order. **May be a single part** — METIS
+ *     balances what it is asked for but is not obliged to fill every bin, and a caller that needs
+ *     to make progress has to say what it does about that
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_partition_subgraph(graph: {
+    edge_addresses: Uint32Array;
+    adjacency: Uint32Array;
+    edge_weights: Float32Array;
+}, members: number[], membership: Int32Array, token: number, part_count: number, seed: number, local_index: Uint32Array): number[][];
+//# sourceMappingURL=vgeo_partition_subgraph.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_partition_subgraph.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,+CAjBW;IAAC,cAAc,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,WAAW,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAC,WAEjF,MAAM,EAAE,cACR,UAAU,SAEV,MAAM,cACN,MAAM,QACN,MAAM,eACN,WAAW,GAET,MAAM,EAAE,EAAE,CA4DtB"}

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_partition_subgraph.js

@@ -0,0 +1,92 @@
+import { assert } from "../../../../../../core/assert.js";
+import { vgeo_partition_graph } from "./vgeo_partition_graph.js";
+
+/**
+ * Partition the subgraph a CSR induces on a member set.
+ *
+ * Both places the builder partitions something want this, and for the same reason the components
+ * pass beside it exists: METIS takes a graph, not a graph and a mask, so the members have to be
+ * renumbered into a dense local graph first and the assignment scattered back afterwards. That is
+ * forty lines of the same bookkeeping either side of one call, and it was written twice — once for
+ * splitting faces into clusters, once for grouping clusters into groups.
+ *
+ * The two copies had already drifted on the point one of them documents at length: the face side
+ * keeps a dense `Uint32Array` scratch because a `Map` cannot answer this at all past 2^24 entries
+ * and the leaf cut runs over every face of the mesh at once, while the cluster side had reached for
+ * a `Map`. Taking the scratch as a parameter is what makes that a property of this function rather
+ * than of whoever last copied it.
+ *
+ * Edge weights are carried through unchanged; a caller that wants them shaped — the group pass
+ * scales by compactness — does that when it builds the CSR.
+ *
+ * @param {{edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array}} graph
+ *     CSR over the whole vertex set
+ * @param {number[]} members vertices of the subgraph to partition
+ * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a
+ *     member, which is what keeps a nested split from following an edge that leaves its subset
+ * @param {number} token
+ * @param {number} part_count at least 2
+ * @param {number} seed fixed by the caller, so the same subgraph always splits the same way
+ * @param {Uint32Array} local_index scratch, one entry per graph vertex. Only the members' entries
+ *     are written or read, so it never needs clearing between calls
+ * @returns {number[][]} the non-empty parts, in part order. **May be a single part** — METIS
+ *     balances what it is asked for but is not obliged to fill every bin, and a caller that needs
+ *     to make progress has to say what it does about that
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_partition_subgraph(
+    graph, members, membership, token, part_count, seed, local_index
+) {
+    assert.greaterThanOrEqual(part_count, 2, 'part_count');
+    assert.greaterThanOrEqual(local_index.length, membership.length, 'local_index.length');
+
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const edge_weights = graph.edge_weights;
+
+    members.forEach((member, index) => { local_index[member] = index; });
+
+    const local_addresses = new Uint32Array(members.length + 1);
+    const local_adjacency = [];
+    const local_weights = [];
+
+    members.forEach((member, index) => {
+        local_addresses[index] = local_adjacency.length;
+
+        for (let i = edge_addresses[member]; i < edge_addresses[member + 1]; i++) {
+            const other = adjacency[i];
+
+            if (membership[other] !== token) {
+                continue;
+            }
+
+            local_adjacency.push(local_index[other]);
+            local_weights.push(edge_weights[i]);
+        }
+    });
+
+    local_addresses[members.length] = local_adjacency.length;
+
+    const assignment = vgeo_partition_graph(
+        members.length,
+        part_count,
+        local_addresses,
+        Uint32Array.from(local_adjacency),
+        Float32Array.from(local_weights),
+        seed
+    );
+
+    const parts = [];
+
+    for (let i = 0; i < part_count; i++) {
+        parts.push([]);
+    }
+
+    members.forEach((member, index) => {
+        parts[assignment[index]].push(member);
+    });
+
+    return parts.filter((part) => part.length > 0);
+}

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[]} members dense face-graph vertices to split
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {number[][]} clusters, each within both caps, ordered by their lowest member so the
+ *     result does not depend on the order the recursion happened to take
+ */
+export function vgeo_split_face_set(face_graph: VGeoFaceGraph, members: number[], max_faces: number, max_vertices: number): number[][];
+//# sourceMappingURL=vgeo_split_face_set.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_split_face_set.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set.js"],"names":[],"mappings":"AA6EA;;;;;;;GAOG;AACH,wEANW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CA6DtB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_split_face_set.js → partition/vgeo_split_face_set.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
+import { assert } from "../../../../../../core/assert.js";
 import { vgeo_graph_components } from "./vgeo_graph_components.js";
-import { vgeo_partition_graph } from "./vgeo_partition_graph.js";
+import { vgeo_partition_subgraph } from "./vgeo_partition_subgraph.js";
 
 /**
  * Cut a set of faces into clusters that each satisfy Shade's meshlet limits.
@@ -42,6 +42,9 @@ const SPLIT_SEED = 0xC10D;
  * what keeps clusters well filled: METIS balances what it is asked for, so `ceil(n / 128)` parts land
  * near the ceiling, while a chain of bisections lands wherever the powers of two happen to fall.
  *
+ * What this adds to {@link vgeo_partition_subgraph} is the fallback, and only this caller needs it:
+ * the recursion here has to shrink its input every time or it does not terminate.
+ *
  * @param {VGeoFaceGraph} face_graph
  * @param {number[]} members
  * @param {Int32Array} membership one entry per graph vertex; an entry equal to `token` marks a member
@@ -50,62 +53,16 @@ const SPLIT_SEED = 0xC10D;
  * @returns {number[][]} non-empty parts; at least two of them
  */
 function partition(face_graph, members, membership, token, part_count) {
-    const graph = face_graph.graph;
-
-    const edge_addresses = graph.edge_addresses;
-    const adjacency = graph.adjacency;
-    const edge_weights = graph.edge_weights;
-
-    /**
-     * `local_index[global] = position in members`, valid only for members.
-     * @type {Uint32Array}
-     */
-    const local_index = face_graph.member_index;
-
-    members.forEach((member, index) => { local_index[member] = index; });
-
-    const local_addresses = new Uint32Array(members.length + 1);
-    const local_adjacency = [];
-    const local_weights = [];
-
-    members.forEach((member, index) => {
-        local_addresses[index] = local_adjacency.length;
-
-        for (let i = edge_addresses[member]; i < edge_addresses[member + 1]; i++) {
-            const other = adjacency[i];
-
-            if (membership[other] !== token) {
-                continue;
-            }
-
-            local_adjacency.push(local_index[other]);
-            local_weights.push(edge_weights[i]);
-        }
-    });
-
-    local_addresses[members.length] = local_adjacency.length;
-
-    const assignment = vgeo_partition_graph(
-        members.length,
+    const populated = vgeo_partition_subgraph(
+        face_graph.graph,
+        members,
+        membership,
+        token,
         part_count,
-        local_addresses,
-        Uint32Array.from(local_adjacency),
-        Float32Array.from(local_weights),
-        SPLIT_SEED
+        SPLIT_SEED,
+        face_graph.member_index
     );
 
-    const parts = [];
-
-    for (let i = 0; i < part_count; i++) {
-        parts.push([]);
-    }
-
-    members.forEach((member, index) => {
-        parts[assignment[index]].push(member);
-    });
-
-    const populated = parts.filter((part) => part.length > 0);
-
     if (populated.length >= 2) {
         return populated;
     }

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Split a face set into clusters within both meshlet caps, then merge the under-filled pieces.
+ *
+ * Only for sets whose spatial extent something else has already bounded — a group being re-split
+ * after simplification. Over an unbounded set this packs together whatever the Morton curve happens
+ * to place side by side, which is not the same question as "what is near what".
+ *
+ * @param {VGeoFaceGraph} face_graph
+ * @param {number[]} members dense face-graph vertices to split
+ * @param {number} max_faces
+ * @param {number} max_vertices
+ * @returns {number[][]} clusters within both caps, ordered by their lowest member
+ */
+export function vgeo_split_face_set_packed(face_graph: VGeoFaceGraph, members: number[], max_faces: number, max_vertices: number): number[][];
+//# sourceMappingURL=vgeo_split_face_set_packed.d.ts.map

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_split_face_set_packed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.js"],"names":[],"mappings":"AAwLA;;;;;;;;;;;;GAYG;AACH,+EALW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CAWtB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_split_face_set_packed.js → partition/vgeo_split_face_set_packed.js}

@@ -1,8 +1,8 @@
-import { aabb3_from_v3_array } from "../../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
-import { v3_morton_encode_bounded } from "../../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
+import { aabb3_from_v3_array } from "../../../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
+import { v3_morton_encode_bounded } from "../../../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
 import {
     bt_face_read_triangle_vertices
-} from "../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
+} from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
 import { vgeo_split_face_set } from "./vgeo_split_face_set.js";
 
 /**

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_bounding_sphere.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The minimal bounding sphere of a point set, rounded to float32 and inflated until it still
+ * contains every point.
+ *
+ * @param {Float32Array} points `3 * n` coordinates; at least one point
+ * @returns {Float32Array} `[x, y, z, radius]`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_bounding_sphere(points: Float32Array): Float32Array;
+//# sourceMappingURL=vgeo_bounding_sphere.d.ts.map

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_bounding_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_bounding_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/sphere/vgeo_bounding_sphere.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,6CANW,YAAY,GACV,YAAY,CAiBxB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_bounding_sphere.js → sphere/vgeo_bounding_sphere.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
-import { Miniball } from "../../../../../core/geom/packing/miniball/Miniball.js";
-import { PointSet } from "../../../../../core/geom/packing/miniball/PointSet.js";
+import { assert } from "../../../../../../core/assert.js";
+import { Miniball } from "../../../../../../core/geom/packing/miniball/Miniball.js";
+import { PointSet } from "../../../../../../core/geom/packing/miniball/PointSet.js";
 import { vgeo_sphere_inflate_to_contain } from "./vgeo_sphere_inflate_to_contain.js";
 
 /**

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_containing_sphere.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A sphere containing every given sphere and every given point, rounded to float32 and inflated
+ * until it still does.
+ *
+ * The fit is not minimal — a minimal sphere over spheres is a different problem than the miniball
+ * solves — and the format says so: the LOD-metric spheres are "monotonically inflated, never a tight
+ * fit". Fitting the miniball to the inner centres and then growing to swallow their radii is a
+ * conservative, deterministic construction that keeps the monotonicity the cut rule depends on.
+ *
+ * @param {ArrayLike<number>[]} spheres each `[x, y, z, radius]`; may be empty when `points` is not
+ * @param {Float32Array} points `3 * n` coordinates
+ * @returns {Float32Array} `[x, y, z, radius]`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_containing_sphere(spheres: ArrayLike<number>[], points: Float32Array): Float32Array;
+//# sourceMappingURL=vgeo_containing_sphere.d.ts.map

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_containing_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_containing_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/sphere/vgeo_containing_sphere.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,gDAPW,UAAU,MAAM,CAAC,EAAE,UACnB,YAAY,GACV,YAAY,CA2BxB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_containing_sphere.js → sphere/vgeo_containing_sphere.js}

@@ -1,6 +1,6 @@
-import { assert } from "../../../../../core/assert.js";
-import { Miniball } from "../../../../../core/geom/packing/miniball/Miniball.js";
-import { PointSet } from "../../../../../core/geom/packing/miniball/PointSet.js";
+import { assert } from "../../../../../../core/assert.js";
+import { Miniball } from "../../../../../../core/geom/packing/miniball/Miniball.js";
+import { PointSet } from "../../../../../../core/geom/packing/miniball/PointSet.js";
 import { vgeo_sphere_inflate_to_contain } from "./vgeo_sphere_inflate_to_contain.js";
 
 /**

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_sphere_inflate_to_contain.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Grow a stored sphere until it contains every point and every sphere it is meant to.
+ *
+ * @param {Float32Array} sphere `[x, y, z, radius]`, mutated in place
+ * @param {Float32Array} points `3 * n` coordinates
+ * @param {ArrayLike<number>[]} spheres
+ */
+export function vgeo_sphere_inflate_to_contain(sphere: Float32Array, points: Float32Array, spheres: ArrayLike<number>[]): void;
+//# sourceMappingURL=vgeo_sphere_inflate_to_contain.d.ts.map

package/src/shade/renderer/geometry/virtual/build/sphere/vgeo_sphere_inflate_to_contain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_sphere_inflate_to_contain.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/sphere/vgeo_sphere_inflate_to_contain.js"],"names":[],"mappings":"AA0CA;;;;;;GAMG;AACH,uDAJW,YAAY,UACZ,YAAY,WACZ,UAAU,MAAM,CAAC,EAAE,QAsB7B"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_sphere_inflate_to_contain.js → sphere/vgeo_sphere_inflate_to_contain.js}

@@ -1,4 +1,4 @@
-import { f32_next_up } from "../../../../../core/math/f32_next_up.js";
+import { f32_next_up } from "../../../../../../core/math/f32_next_up.js";
 
 /**
  * Bounds that still bound after they have been rounded to float32.

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A face set gathered into standalone, locally-indexed form.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoGatheredFaces {
+    /**
+     * `3 * vertex_count` local coordinates.
+     * @type {Float32Array}
+     */
+    positions: Float32Array;
+    /**
+     * `3 * triangle_count` local vertex indices.
+     * @type {Uint32Array}
+     */
+    indices: Uint32Array;
+    /**
+     * Vertex ids in the mesh this was pulled out of, one per local vertex, in first-use order.
+     * @type {Uint32Array}
+     */
+    vertex_ids: Uint32Array;
+}
+//# sourceMappingURL=VGeoGatheredFaces.d.ts.map

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoGatheredFaces.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/VGeoGatheredFaces.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;OAGG;IACH,WAFU,YAAY,CAEU;IAEhC;;;OAGG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,YAFU,WAAW,CAEW;CACnC"}

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A face set pulled out of a larger mesh, with the map back to where it came from.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoSubmesh {
+    /**
+     * @type {VirtualGeometryMesh}
+     */
+    mesh: VirtualGeometryMesh;
+    /**
+     * `source_vertex_ids[local] = vertex id in the mesh this was extracted from`. Survives
+     * simplification: the simplifier never creates a vertex, and a pinned one is never moved, so a
+     * vertex two submeshes share still answers to the same source id in both.
+     * @type {Uint32Array}
+     */
+    source_vertex_ids: Uint32Array;
+}
+//# sourceMappingURL=VGeoSubmesh.d.ts.map

package/src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoSubmesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/VGeoSubmesh.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;OAEG;IACH,0BAAY;IAEZ;;;;;OAKG;IACH,mBAFU,WAAW,CAEkB;CAC1C"}

package/src/shade/renderer/geometry/virtual/build/submesh/vgeo_extract_submesh.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extract a face set into a standalone mesh, attributes and all.
+ *
+ * @param {VirtualGeometryMesh} source
+ * @param {number[]} face_ids
+ * @returns {VGeoSubmesh}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_extract_submesh(source: VirtualGeometryMesh, face_ids: number[]): VGeoSubmesh;
+import { VirtualGeometryMesh } from "../mesh/VirtualGeometryMesh.js";
+import { VGeoSubmesh } from "./VGeoSubmesh.js";
+//# sourceMappingURL=vgeo_extract_submesh.d.ts.map

package/src/shade/renderer/geometry/virtual/build/submesh/vgeo_extract_submesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_extract_submesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/submesh/vgeo_extract_submesh.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,6CAPW,mBAAmB,YACnB,MAAM,EAAE,GACN,WAAW,CAyBvB;oCAhCmC,gCAAgC;4BADxC,kBAAkB"}

package/src/shade/renderer/geometry/virtual/build/{vgeo_extract_submesh.js → submesh/vgeo_extract_submesh.js}

@@ -1,12 +1,12 @@
-import { BinaryTopology } from "../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import { BinaryTopology } from "../../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
 import {
     bt_mesh_from_indexed_geometry
-} from "../../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
-import { vgeo_layers_copy_vertex } from "../format/attribute/vgeo_layers_copy_vertex.js";
-import { vgeo_layers_like } from "../format/attribute/vgeo_layers_like.js";
+} from "../../../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
+import { vgeo_layers_copy_vertex } from "../../format/attribute/vgeo_layers_copy_vertex.js";
+import { vgeo_layers_like } from "../../format/attribute/vgeo_layers_like.js";
 import { vgeo_gather_faces } from "./vgeo_gather_faces.js";
 import { VGeoSubmesh } from "./VGeoSubmesh.js";
-import { VirtualGeometryMesh } from "./VirtualGeometryMesh.js";
+import { VirtualGeometryMesh } from "../mesh/VirtualGeometryMesh.js";
 
 /**
  * Extract a face set into a standalone mesh, attributes and all.