@woosh/meep-engine 3.28.0 → 3.30.0

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

@@ -1,20 +0,0 @@
-/**
- * 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/VGeoSubmesh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VGeoSubmesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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/VirtualGeometryMesh.d.ts

@@ -1,73 +0,0 @@
-/**
- * A level of geometry as the builder handles it: a `BinaryTopology` carrying the positions, the
- * connectivity, and the per-vertex attributes all together.
- *
- * Everything per-vertex lives in the topology. It has to: an edge collapse moves and removes
- * vertices, and the topology is the only thing that knows which. A vertex data layer is addressed
- * by vertex id and sized by the vertex pool, so a channel cannot fall out of step with the mesh it
- * describes — there is no second array to resize, no invariant to assert, and no way for the
- * simplifier to leave a live vertex without a slot.
- *
- * The channels are named by their index into {@link VGEO_ATTRIBUTES}, which is the format's frozen
- * table — {@link layers} has one slot per entry, holding a layer or null.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class VirtualGeometryMesh {
-    /**
-     * Take a geometry apart into the form the builder simplifies: its positions and index become a
-     * topology, its other attributes become vertex data layers on that same topology.
-     *
-     * The attribute values are copied in, not adopted. The builder re-derives the shading frame as
-     * it coarsens, and the caller's geometry is no longer where that lands.
-     *
-     * The normal and tangent channels are declared whether or not the geometry carries them: they
-     * are what the shading model reads, so the builder owes an asset both. What it does not have,
-     * {@link synthesized} records, and {@link vgeo_normalize_source} fills.
-     *
-     * @param {Geometry} geometry triangles, with a position attribute; the index is synthesized when
-     *     the geometry does not carry one
-     * @returns {VirtualGeometryMesh}
-     */
-    static from_geometry(geometry: Geometry): VirtualGeometryMesh;
-    /**
-     * @param {BinaryTopology} topology
-     * @param {(BinaryDataLayer|null)[]} layers declared on `topology`
-     */
-    constructor(topology: BinaryTopology, layers: (BinaryDataLayer | null)[]);
-    /**
-     * Positions, connectivity, and the vertex data block the {@link layers} address.
-     * @type {BinaryTopology}
-     */
-    topology: BinaryTopology;
-    /**
-     * One slot per {@link VGEO_ATTRIBUTES} entry, holding the vertex data layer that carries that
-     * channel or null where this geometry does not carry it.
-     * {@link VGEO_ATTRIBUTE.POSITION}'s slot is always null — position is the topology's own.
-     * @type {(BinaryDataLayer|null)[]}
-     */
-    layers: (BinaryDataLayer | null)[];
-    /**
-     * One flag per {@link VGEO_ATTRIBUTES} entry, true where the channel exists because the builder
-     * added it rather than because the source geometry carried it.
-     *
-     * Read once, by {@link vgeo_normalize_source}, and for one reason: a synthesized channel has to
-     * be derived from the *welded* mesh, which does not exist yet when the channel is declared.
-     * Normalization fuses coincident vertices, and a normal derived before that fuse is the average
-     * of one side of a seam — the very defect deriving it is supposed to avoid.
-     *
-     * An authored channel is never among these. A hand-tuned normal is data, and the builder is not
-     * entitled to replace it.
-     *
-     * @type {boolean[]}
-     */
-    synthesized: boolean[];
-    /**
-     * Ids of every allocated face, ascending.
-     * @returns {number[]}
-     */
-    face_ids(): number[];
-}
-import { BinaryTopology } from "../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-//# sourceMappingURL=VirtualGeometryMesh.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"VirtualGeometryMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VirtualGeometryMesh.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH;IA6CI;;;;;;;;;;;;;;OAcG;IACH,0CAFa,mBAAmB,CA8G/B;IAzID;;;OAGG;IACH,sBAHW,cAAc,UACd,CAAC,kBAAgB,IAAI,CAAC,EAAE,EAUlC;IA1CD;;;OAGG;IACH,UAFU,cAAc,CAER;IAEhB;;;;;OAKG;IACH,QAFU,CAAC,kBAAgB,IAAI,CAAC,EAAE,CAEtB;IAEZ;;;;;;;;;;;;;OAaG;IACH,aAFU,OAAO,EAAE,CAEyC;IA6I5D;;;OAGG;IACH,YAFa,MAAM,EAAE,CAcpB;CACJ;+BApN8B,sEAAsE"}

package/src/shade/renderer/geometry/virtual/build/vgeo_assemble_pages.d.ts

@@ -1,13 +0,0 @@
-/**
- * Assign groups to pages.
- *
- * @param {VirtualGeometryGroup[][]} groups_by_level indexed by level; every group of every level,
- *     including the root level's
- * @param {Float32Array} object_bounds `[min xyz, max xyz]` of the whole geometry, for the Morton grid
- * @param {number} nominal_page_size decoded bytes per page, as a hard cap: no returned page decodes
- *     to more, and a group that cannot fit one on its own throws
- * @returns {VirtualGeometryPage[]} in file order, root page first
- */
-export function vgeo_assemble_pages(groups_by_level: VirtualGeometryGroup[][], object_bounds: Float32Array, nominal_page_size: number): VirtualGeometryPage[];
-import { VirtualGeometryPage } from "../format/dag/VirtualGeometryPage.js";
-//# sourceMappingURL=vgeo_assemble_pages.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_assemble_pages.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_assemble_pages.js"],"names":[],"mappings":"AAwMA;;;;;;;;;GASG;AACH,qDAPW,sBAAsB,EAAE,iBAExB,YAAY,qBACZ,MAAM,GAEJ,mBAAmB,EAAE,CAiIjC;oCAzUmC,sCAAsC"}

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

@@ -1,12 +0,0 @@
-/**
- * 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/vgeo_bounding_sphere.d.ts.map

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

package/src/shade/renderer/geometry/virtual/build/vgeo_build_levels.d.ts

@@ -1,36 +0,0 @@
-/**
- * Build the whole DAG, from a source mesh to a single root.
- *
- * @param {VirtualGeometryMesh} mesh the normalized source; consumed, not copied
- * @param {VGeoLevelOptions} options
- * @returns {VGeoLevel[]} leaves first; the last level holds exactly one cluster, the root
- */
-export function vgeo_build_levels(mesh: VirtualGeometryMesh, options: VGeoLevelOptions): VGeoLevel[];
-/**
- * One cluster's geometry expressed against the frontier it came out of, which is what lets the next
- * frontier be stitched from a mixture of freshly simplified clusters and untouched ones.
- */
-export type VGeoContribution = {
-    positions: Float32Array;
-    /**
-     * local to {@link positions }
-     */
-    indices: Uint32Array;
-    /**
-     * ids in the mesh {@link topology } belongs to
-     */
-    local_vertex_ids: Uint32Array;
-    /**
-     * the same vertices, named in the frontier's mesh
-     */
-    source_vertex_ids: Uint32Array;
-    /**
-     * the mesh {@link local_vertex_ids } name vertices of, whose
-     * vertex data block holds their attributes
-     */
-    topology: BinaryTopology;
-};
-import { VirtualGeometryMesh } from "./VirtualGeometryMesh.js";
-import { VGeoLevel } from "./VGeoLevel.js";
-import { BinaryTopology } from "../../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-//# sourceMappingURL=vgeo_build_levels.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_build_levels.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build_levels.js"],"names":[],"mappings":"AAukDA;;;;;;GAMG;AACH,wCAJW,mBAAmB,8BAEjB,SAAS,EAAE,CA6KvB;;;;;;eAxiDa,YAAY;;;;aACZ,WAAW;;;;sBACX,WAAW;;;;uBACX,WAAW;;;;;cACX,cAAc;;oCA5KQ,0BAA0B;0BADpC,gBAAgB;+BAjCI,sEAAsE"}

package/src/shade/renderer/geometry/virtual/build/vgeo_build_page_nodes.d.ts

@@ -1,13 +0,0 @@
-/**
- * Build the tree over a page's groups.
- *
- * Breadth-first, so that a node's children occupy a contiguous run of indices and every parent sits
- * at a lower index than its children — which is what lets the metric be filled in by one backwards
- * sweep, and what lets a reader walk the tree without a stack of anything but indices.
- *
- * @param {VirtualGeometryPage} page whose `groups` are already in the order they will be written
- * @returns {VirtualGeometryPageNode[]} the tree, root first; never empty
- */
-export function vgeo_build_page_nodes(page: VirtualGeometryPage): VirtualGeometryPageNode[];
-import { VirtualGeometryPageNode } from "../format/dag/VirtualGeometryPageNode.js";
-//# sourceMappingURL=vgeo_build_page_nodes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_build_page_nodes.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build_page_nodes.js"],"names":[],"mappings":"AAsDA;;;;;;;;;GASG;AACH,kEAFa,uBAAuB,EAAE,CA8FrC;wCAvJuC,0CAA0C"}

package/src/shade/renderer/geometry/virtual/build/vgeo_build_root_group.d.ts

@@ -1,19 +0,0 @@
-/**
- * The root cluster has no simplification step above it, so nothing grouped it, and the format still
- * wants every cluster in exactly one group. It gets a group of its own: the always-selectable entry
- * point the runtime starts its cut from.
- *
- * There is exactly one of these because the DAG has exactly one root — a build that ends with
- * several parentless clusters has not finished, and bundling them into a synthetic group would only
- * hide that (see `vgeo_build_levels`).
- *
- * @param {VirtualGeometryCluster} cluster the root
- * @param {number} level
- * @returns {VirtualGeometryGroup}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_build_root_group(cluster: VirtualGeometryCluster, level: number): VirtualGeometryGroup;
-import { VirtualGeometryGroup } from "../format/dag/VirtualGeometryGroup.js";
-//# sourceMappingURL=vgeo_build_root_group.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_build_root_group.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_build_root_group.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,8EANW,MAAM,GACJ,oBAAoB,CAYhC;qCAzBoC,uCAAuC"}

package/src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_normals.d.ts

@@ -1,29 +0,0 @@
-/**
- * Area-weighted vertex normals of a mesh, written into its normal channel.
- *
- * The geometry a mesh actually has is the answer for that mesh: carrying a surviving vertex's
- * original normal through a dozen collapses shades a coarse level by whichever vertices happened to
- * win, which is visibly wrong.
- *
- * **Except where the vertex was pinned.** A pinned vertex is one the step was forbidden to move, and
- * every group that touches it carries it — which is exactly what lets a cut place two levels of
- * detail side by side without a crack. That guarantee has to cover what the vertex *carries*, not
- * only where it is: recomputed here, a pinned vertex would get the average of the faces on this
- * side of the seam only, the group across the seam would get the average of its own, and the two
- * would disagree by however much the surface turns. So a pinned vertex keeps what it had, exactly
- * as it keeps where it was, and the frame stays continuous across every cut the DAG admits.
- *
- * The pass itself is {@link bt_mesh_compute_vertex_normals}; all this adds is the pin rule and
- * lifting its result out of the topology's own normal slots and into the format's normal attribute,
- * which is where the encoder reads from.
- *
- * @param {VirtualGeometryMesh} mesh whose normal layer is sized by the vertex pool and so carries a
- *     slot for every live vertex by construction
- * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
- *     locked yet
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_vertex_normals(mesh: VirtualGeometryMesh, pinned: Set<number>): void;
-//# sourceMappingURL=vgeo_compute_vertex_normals.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_compute_vertex_normals.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_normals.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+EANW,IAAI,MAAM,CAAC,QAyCrB"}

package/src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_tangents.d.ts

@@ -1,31 +0,0 @@
-/**
- * Vertex tangents of a mesh, written into its tangent channel.
- *
- * A tangent is a direction *in the texture parameterization*, so where the mesh carries a `UV0` this
- * is Lengyel's per-triangle solve accumulated per vertex and orthogonalized against the normal —
- * {@link geometry_build_tangents}, the same pass {@link Geometry#computeTangents} runs, so an asset
- * that goes through the virtual-geometry builder gets the frame it would have got anywhere else.
- * Where the mesh carries no UVs there is no parameterization to be tangent to, and the frame becomes
- * an arbitrary but well-conditioned basis around the normal — Frisvad's, via
- * {@link build_tangent_from_normal}. That is not a fallback for a broken input: a shading model that
- * reads a tangent frame reads one whether or not the surface is textured, and the alternative is
- * the format's flat default, which is parallel to the normal over a whole band of any closed
- * surface and degenerates the frame there.
- *
- * `pinned` carries the same meaning and the same reason as it does for
- * {@link vgeo_compute_vertex_normals}: a vertex two groups share must carry byte-identical values in
- * both, or the seam a cut is allowed to put between them shades as a crease.
- *
- * The flat arrays this builds are indexed by *vertex id*, holes and all, so a pool with released
- * slots needs no compaction and no remap — a released slot is simply a triangle corner nothing
- * names.
- *
- * @param {VirtualGeometryMesh} mesh whose tangent and normal layers are sized by the vertex pool
- * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
- *     locked yet
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_vertex_tangents(mesh: VirtualGeometryMesh, pinned: Set<number>): void;
-//# sourceMappingURL=vgeo_compute_vertex_tangents.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_compute_vertex_tangents.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_compute_vertex_tangents.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gFANW,IAAI,MAAM,CAAC,QAmGrB"}

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

@@ -1,18 +0,0 @@
-/**
- * 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/vgeo_containing_sphere.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_containing_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_extract_submesh.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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 "./VirtualGeometryMesh.js";
-import { VGeoSubmesh } from "./VGeoSubmesh.js";
-//# sourceMappingURL=vgeo_extract_submesh.d.ts.map

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

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

package/src/shade/renderer/geometry/virtual/build/vgeo_gather_faces.d.ts

@@ -1,12 +0,0 @@
-/**
- * Gather a face set: unique vertices in first-use order, local indices, coordinates copied out.
- *
- * First-use order is what makes the result depend only on the face list, not on the pool's history.
- *
- * @param {VirtualGeometryMesh} mesh
- * @param {number[]} face_ids allocated triangular faces
- * @returns {VGeoGatheredFaces}
- */
-export function vgeo_gather_faces(mesh: VirtualGeometryMesh, face_ids: number[]): VGeoGatheredFaces;
-import { VGeoGatheredFaces } from "./VGeoGatheredFaces.js";
-//# sourceMappingURL=vgeo_gather_faces.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_gather_faces.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_gather_faces.js"],"names":[],"mappings":"AAcA;;;;;;;;GAQG;AACH,uEAHW,MAAM,EAAE,GACN,iBAAiB,CAiD7B;kCAlEiC,wBAAwB"}

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

@@ -1,14 +0,0 @@
-/**
- * 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/vgeo_graph_components.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_graph_components.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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/vgeo_narrow_indices.d.ts

@@ -1,11 +0,0 @@
-/**
- * The 8-bit local index list a cluster payload carries.
- *
- * @param {VGeoGatheredFaces} gathered a face set already within the meshlet limits
- * @returns {Uint8Array}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_narrow_indices(gathered: VGeoGatheredFaces): Uint8Array;
-//# sourceMappingURL=vgeo_narrow_indices.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_narrow_indices.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_narrow_indices.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,kEALa,UAAU,CAiBtB"}

package/src/shade/renderer/geometry/virtual/build/vgeo_normalize_source.d.ts

@@ -1,46 +0,0 @@
-/**
- * Bring a source mesh to the state the level loop assumes: no edge shorter than the weld tolerance,
- * coincident vertices fused, nothing dangling, and consistent topology.
- *
- * The short-edge pass is not optional — the merge's own contract requires it, because merging two
- * vertices that share a face leaves a loop cycle visiting one vertex twice, and no boundary walk can
- * get through the non-manifold edge that produces.
- *
- * It **collapses** those edges rather than killing them, and the difference is the whole surface.
- * `bt_mesh_kill_short_edges` deletes both faces of every edge it names, which is right for a soup
- * and wrong here: the weld behind it closes most of the resulting holes and leaves the rest, and a
- * hole left in the source is a hole in every level of the DAG built on it. Measured on the Stanford
- * dragon, closed to begin with: killing opened 18,438 boundary edges and left 281 of them standing;
- * collapsing leaves none.
- *
- * Neither is the fuse that follows it. The merge re-points vertex references but leaves the two
- * edges that now connect the same pair as two distinct edges, and face adjacency is read off radial
- * cycles — so without the fuse, two triangles welded along a seam still look unrelated to every
- * query downstream, and the clusterer shreds the mesh along every UV seam it has.
- *
- * Nor is the degenerate-face kill. The short-edge pass clears the pairs an *edge* is short enough to
- * name, but the merge is a hash grid: two corners of one face up to twice the tolerance apart can
- * still land on a common master and become one vertex, leaving a face that visits it twice.
- *
- * The tolerance is a fraction of the mesh's own size rather than a distance, and it is resolved here
- * — once, off the source's bounds, before any pass has removed anything — so every pass below welds
- * the same amount of the same surface. A conversion is many geometries at many sizes, and there is
- * no one distance that is right for all of them.
- *
- * The shading frame is regularized too, and last. A geometry that arrived without normals or without
- * tangents is given them here rather than at the door, because *here* is the first point at which
- * the mesh is the one the rest of the build will see: derived before the weld, a normal at a seam
- * vertex would be the average of whichever side of the seam the exporter happened to split it into,
- * and the fuse would then pick one of those halves to keep. Derived after it, the vertex has its
- * whole ring. Channels the source did carry are left exactly as they came.
- *
- * @param {VirtualGeometryMesh} mesh mutated in place
- * @param {number} weld_ratio fraction of the bounding-box diagonal; see
- *     {@link VGeoBuildOptions#weld_ratio}
- * @returns {number} the object-space distance the ratio came to for this mesh
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number): number;
-//# sourceMappingURL=vgeo_normalize_source.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_normalize_source.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,6EAPW,MAAM,GAEJ,MAAM,CAyClB"}

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

@@ -1,22 +0,0 @@
-/**
- * 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/vgeo_page_node_count.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_page_node_count.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_partition_graph.d.ts

@@ -1,29 +0,0 @@
-/**
- * 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/vgeo_partition_graph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_partition_graph.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_sphere_inflate_to_contain.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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/vgeo_sphere_inflate_to_contain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_sphere_inflate_to_contain.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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_split_face_set.d.ts

@@ -1,10 +0,0 @@
-/**
- * @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/vgeo_split_face_set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_split_face_set.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/vgeo_split_face_set.js"],"names":[],"mappings":"AAwHA;;;;;;;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_packed.d.ts

@@ -1,15 +0,0 @@
-/**
- * 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/vgeo_split_face_set_packed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_split_face_set_packed.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/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/format/attribute/vgeo_layers_copy_vertex.d.ts

@@ -1,16 +0,0 @@
-/**
- * Copy one vertex's every channel between two meshes declared from the same template.
- *
- * One run of bytes, not one call per channel: the channels of a vertex are one interleaved record,
- * and {@link vgeo_layers_like} is what guarantees the two records line up.
- *
- * @param {BinaryTopology} target
- * @param {BinaryTopology} source
- * @param {number} source_vertex
- * @param {number} target_vertex
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_layers_copy_vertex(target: BinaryTopology, source: BinaryTopology, source_vertex: number, target_vertex: number): void;
-//# sourceMappingURL=vgeo_layers_copy_vertex.d.ts.map

package/src/shade/renderer/geometry/virtual/format/attribute/vgeo_layers_copy_vertex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vgeo_layers_copy_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/attribute/vgeo_layers_copy_vertex.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,uGANW,MAAM,iBACN,MAAM,QAoBhB"}

package/src/shade/renderer/loader/gltf/fix_up_material_sides.d.ts

@@ -1,10 +0,0 @@
-/**
- *
- * @param {Mesh[]} meshes
- * @returns {{geometries_modified:number, primitives_delta: number}}
- */
-export function fix_up_material_sides(meshes: Mesh[]): {
-    geometries_modified: number;
-    primitives_delta: number;
-};
-//# sourceMappingURL=fix_up_material_sides.d.ts.map

package/src/shade/renderer/loader/gltf/fix_up_material_sides.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fix_up_material_sides.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/fix_up_material_sides.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,8CAHW,MAAM,GACJ;IAAC,mBAAmB,EAAC,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CAoGlE"}

package/src/shade/renderer/rasterize/expand/graph_triangles_filter_by_material_side.d.ts

@@ -1,17 +0,0 @@
-/**
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {GPUCameraContext} options.camera
- * @param {GPUSceneContext} options.scene
- * @param {number} options.input
- * @param {number} options.output_size
- */
-export function graph_triangles_filter_by_material_side({ graph, camera, scene, input, output_size }: {
-    graph: FrameGraph;
-    camera: GPUCameraContext;
-    scene: GPUSceneContext;
-    input: number;
-    output_size: number;
-}): any;
-//# sourceMappingURL=graph_triangles_filter_by_material_side.d.ts.map

package/src/shade/renderer/rasterize/expand/graph_triangles_filter_by_material_side.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_triangles_filter_by_material_side.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/graph_triangles_filter_by_material_side.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH;IAN+B,KAAK;IACC,MAAM;IACP,KAAK;IACd,KAAK,EAArB,MAAM;IACU,WAAW,EAA3B,MAAM;QAiEhB"}

package/src/shade/renderer/rasterize/expand/shader_filter_triangle_by_material_side.d.ts

@@ -1,3 +0,0 @@
-export const shader_filter_triangle_by_material_side: ComputeShader;
-import { ComputeShader } from "../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_filter_triangle_by_material_side.d.ts.map