@woosh/meep-engine 3.28.0 → 3.30.0

package/src/view/tooltip/DomTooltipManager.d.ts

@@ -29,6 +29,13 @@ export class DomTooltipManager {
      * @private
      */
     private __showDelayTimeout;
+    /**
+     * Whose show the pending {@link __showDelayTimeout} belongs to, so {@link remove} can cancel one
+     * it owns without cancelling another view's.
+     * @type {DomTooltipObserver|null}
+     * @private
+     */
+    private __showDelayObserver;
     /**
      * @readonly
      * @private

package/src/view/tooltip/DomTooltipManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomTooltipManager.d.ts","sourceRoot":"","sources":["../../../../src/view/tooltip/DomTooltipManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAGH;;GAEG;AACH;IAsBI;;;OAGG;IACH,wBAFW,cAAc,EASxB;IAhCD;;;;OAIG;IACH,sBAAqB;IAErB;;;;OAIG;IACH,oBAAkB;IAElB;;;;OAIG;IACH,2BAAwB;IAOpB;;;;OAIG;IACH,4BAA4B;IAGhC;;;OAGG;IACH,iBAFa,cAAc,CAI1B;IAED;;;OAGG;IACH,eAFW,kBAAkB,QAM5B;IAED;;;OAGG;IACH,eAFW,kBAAkB,QAM5B;IAED,wBAQC;IAED;;;;OAIG;IACH,gBAHW,IAAI,GACF,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,aAJW,IAAI,iDAYd;IAED;;;OAGG;IACH,oBAMC;IAED,0BAOC;IAED;;;OAGG;IACH,uBAIC;IAED;;;;;;OAMG;IACH,UAJW,IAAI,iDAmBd;IAED;;;OAGG;IACH,gBAFW,IAAI,QAkBd;CACJ;mBAnMY,OAAO,YAAY,EAAE,OAAO;6BAC5B,OAAO,qBAAqB,EAAE,cAAc;mCAJtB,yBAAyB"}
+{"version":3,"file":"DomTooltipManager.d.ts","sourceRoot":"","sources":["../../../../src/view/tooltip/DomTooltipManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAGH;;GAEG;AACH;IA8BI;;;OAGG;IACH,wBAFW,cAAc,EASxB;IAxCD;;;;OAIG;IACH,sBAAqB;IAErB;;;;OAIG;IACH,oBAAkB;IAElB;;;;OAIG;IACH,2BAAwB;IAExB;;;;;OAKG;IACH,4BAA2B;IAOvB;;;;OAIG;IACH,4BAA4B;IAGhC;;;OAGG;IACH,iBAFa,cAAc,CAI1B;IAED;;;OAGG;IACH,eAFW,kBAAkB,QAM5B;IAED;;;OAGG;IACH,eAFW,kBAAkB,QAM5B;IAED,wBAQC;IAED;;;;OAIG;IACH,gBAHW,IAAI,GACF,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,aAJW,IAAI,iDAYd;IAED;;;OAGG;IACH,oBASC;IAED,0BAQC;IAED;;;OAGG;IACH,uBAIC;IAED;;;;;;OAMG;IACH,UAJW,IAAI,iDAmBd;IAED;;;OAGG;IACH,gBAFW,IAAI,QA4Bd;CACJ;mBAzNY,OAAO,YAAY,EAAE,OAAO;6BAC5B,OAAO,qBAAqB,EAAE,cAAc;mCAJtB,yBAAyB"}

package/src/view/tooltip/DomTooltipManager.js

@@ -31,6 +31,14 @@ export class DomTooltipManager {
      */
     __showDelayTimeout = -1;
 
+    /**
+     * Whose show the pending {@link __showDelayTimeout} belongs to, so {@link remove} can cancel one
+     * it owns without cancelling another view's.
+     * @type {DomTooltipObserver|null}
+     * @private
+     */
+    __showDelayObserver = null;
+
     /**
      *
      * @param {TooltipManager} tipManager
@@ -127,7 +135,10 @@ export class DomTooltipManager {
     requestShow(observer) {
         this.cancelShowRequest();
 
+        this.__showDelayObserver = observer;
         this.__showDelayTimeout = setTimeout(() => {
+            this.__showDelayObserver = null;
+            this.__showDelayTimeout = -1;
             this.show(observer);
         }, this.__showDelay);
     }
@@ -138,6 +149,7 @@ export class DomTooltipManager {
             //cancel timeout
             clearTimeout(this.__showDelayTimeout);
             this.__showDelayTimeout = -1;
+            this.__showDelayObserver = null;
         }
     }
 
@@ -187,6 +199,16 @@ export class DomTooltipManager {
             return;
         }
 
+        /**
+         * A show that is still pending belongs to an observer that is about to stop existing, and
+         * `on.exited` — the only other route to `cancelShowRequest` — cannot fire once the observer
+         * is torn down. Left alone, the timer fired `show` for a view that had already left the
+         * document, appending a tooltip that nothing could dismiss: `live` no longer maps the view.
+         */
+        if (this.__showDelayObserver === observer) {
+            this.cancelShowRequest();
+        }
+
         //hide if shown
         this.hide(observer);
 

package/src/view/tooltip/DomTooltipObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomTooltipObserver.d.ts","sourceRoot":"","sources":["../../../../src/view/tooltip/DomTooltipObserver.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IACI;;;;;OAKG;IACH,kBAJW,IAAI,2CAoEd;IA/DG;;;OAGG;IACH,MAFU,IAAI,CAEE;IAEhB;;;OAGG;IACH,kBAAsB;IAItB;;;OAGG;IACH,oBAFU,SAAS,CAEyB;IAE5C;;;OAGG;IACH,KAFU,SAAS,CAEkD;IAErE;;;MAGC;IAEiB,2BAA2C;IAG7D,8BAAgC;IAGhC,0BAKC;IAGD,6BAOC;IAED,6BAOC;IAIL,yCAIC;IAED,yBAWC;IAED,2BAmBC;IAGD,6BAmBC;IAED,aAUC;IAED,eASC;CACJ;mBAhKY,OAAO,YAAY,EAAE,OAAO;sBATnB,iCAAiC;0BAC7B,gBAAgB;mBACvB,oCAAoC;4BAC3B,qCAAqC;gCACjC,4BAA4B;8BAC9B,2CAA2C"}
+{"version":3,"file":"DomTooltipObserver.d.ts","sourceRoot":"","sources":["../../../../src/view/tooltip/DomTooltipObserver.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IACI;;;;;OAKG;IACH,kBAJW,IAAI,2CAoEd;IA/DG;;;OAGG;IACH,MAFU,IAAI,CAEE;IAEhB;;;OAGG;IACH,kBAAsB;IAItB;;;OAGG;IACH,oBAFU,SAAS,CAEyB;IAE5C;;;OAGG;IACH,KAFU,SAAS,CAEkD;IAErE;;;MAGC;IAEiB,2BAA2C;IAG7D,8BAAgC;IAGhC,0BAKC;IAGD,6BAOC;IAED,6BAOC;IAIL,yCAIC;IAED,yBAWC;IAED,2BAmBC;IAGD,6BAmBC;IAED,aAUC;IAED,eAmBC;CACJ;mBA1KY,OAAO,YAAY,EAAE,OAAO;sBATnB,iCAAiC;0BAC7B,gBAAgB;mBACvB,oCAAoC;4BAC3B,qCAAqC;gCACjC,4BAA4B;8BAC9B,2CAA2C"}

package/src/view/tooltip/DomTooltipObserver.js

@@ -160,9 +160,19 @@ export class DomTooltipObserver {
     unlink() {
         const view = this.view;
 
-        if (view.isLinked) {
-            this.__handleViewUnlinked();
-        }
+        /**
+         * Unconditionally, and not `if (view.isLinked)`. `View.unlink` clears the flag *before* it
+         * sends `on.unlinked`, and the manager's own `remove` handler sits ahead of
+         * `__handleViewUnlinked` on that same signal — so by the time this ran the flag was already
+         * false and the teardown was skipped, and then the line below removed
+         * `__handleViewUnlinked` from the Map the dispatch was still walking, so it never ran
+         * either. Two DOM listeners and four bindings survived every link/unlink cycle.
+         *
+         * Safe to run twice: `removeEventListener` is a no-op for a listener that is gone,
+         * `SignalBinding#unlink` returns early when it is already unlinked, and the mouse-leave is
+         * gated on `isEntered`.
+         */
+        this.__handleViewUnlinked();
 
         view.on.linked.remove(this.__handleViewLinked, this);
         view.on.unlinked.remove(this.__handleViewUnlinked, this);

package/src/core/model/node-graph/visual/layout/LayoutBoxGraph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LayoutBoxGraph.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/LayoutBoxGraph.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;;;;;;GAQG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAyFI;;;OAGG;IACH,wBAHW,MAAM,eACN,MAAM,EAIhB;IA7FD;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,YAAY,CAEhB;IAEN;;;OAGG;IACH,WAFU,UAAU,CAEV;IAEV;;;OAGG;IACH,UAFU,UAAU,CAEX;IAET;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,SAFU,UAAU,CAEZ;IAER;;;OAGG;IACH,aAFU,YAAY,CAEV;IAEZ;;;OAGG;IACH,WAFU,YAAY,CAEZ;IAEV;;;OAGG;IACH,YAFU,UAAU,CAET;IAEX;;OAEG;IACH,UAFU,UAAU,CAEX;IAET;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,SAFU,UAAU,CAEZ;IAUR;;;;;;;;;OASG;IACH,kBAJW,MAAM,cACN,MAAM,GACJ,IAAI,CAwBhB;IAED;;;;;;OAMG;IACH,eANW,MAAM,SACN,MAAM,UACN,MAAM,QACN,MAAM,GACJ,IAAI,CAMhB;IAED;;;;;;;OAOG;IACH,gBAPW,MAAM,QACN,MAAM,MACN,MAAM,UACN,MAAM,QACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;OAQG;IACH,mBAFa,IAAI,CAsChB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;CACJ"}

package/src/core/model/node-graph/visual/layout/layout_assign_coordinates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_assign_coordinates.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_assign_coordinates.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,8EAVW,MAAM,SACN,UAAU,QACV,UAAU,eACV,UAAU,oCAER;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAgC3C"}

package/src/core/model/node-graph/visual/layout/layout_assign_layers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_assign_layers.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_assign_layers.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sEAPW,UAAU,GAER,MAAM,CAsDlB"}

package/src/core/model/node-graph/visual/layout/layout_break_cycles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_break_cycles.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_break_cycles.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4DANa,UAAU,CAmOtB"}

package/src/core/model/node-graph/visual/layout/layout_insert_lanes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_insert_lanes.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_insert_lanes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yEARW,UAAU,GAGR,MAAM,CA8ElB"}

package/src/core/model/node-graph/visual/layout/layout_order_layers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_order_layers.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_order_layers.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wEATW,MAAM,UACN,MAAM,GACJ;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAyJ7F"}

package/src/core/model/node-graph/visual/layout/layout_orient_links.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_orient_links.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_orient_links.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qEANW,UAAU,GACR,MAAM,CAkClB"}

package/src/shade/playground/vgeo_viewer/cut_geometry.d.ts

@@ -1,61 +0,0 @@
-/**
- * Decode the selected clusters into one geometry.
- *
- * @param {VGeoCut} cut
- * @param {VGEO_COLOR_MODE} color_mode
- * @returns {VGeoCutGeometry}
- */
-export function vgeo_build_cut_geometry(cut: VGeoCut, color_mode: VGEO_COLOR_MODE): VGeoCutGeometry;
-/**
- * What a cluster's colour is keyed on.
- *
- * The two normal modes are not keyed on the cluster at all: they paint every vertex with its own
- * direction, and the cluster boundaries go with it. `stored normal` is the container's own
- * {@link VGEO_ATTRIBUTE.NORMAL }, decoded out of the payload — the only mode that shows an attribute
- * the file carries rather than something derived from it. `geometric normal` is the area-weighted
- * normal of the decoded triangles, which is what every other mode shades with. The pair is the
- * point: they agree where the builder's normals still describe the geometry it shipped, and a source
- * with no normals at all makes the first one flat.
- *
- * `clamp` is the streaming one: it paints the clusters a coarser page is standing in for, so the
- * regions still waiting on bytes are visible as regions rather than as a number in a panel.
- */
-export type VGEO_COLOR_MODE = string;
-export namespace VGEO_COLOR_MODE {
-    let Cluster: string;
-    let Group: string;
-    let Page: string;
-    let Level: string;
-    let Error: string;
-    let Clamp: string;
-    let StoredNormal: string;
-    let GeometricNormal: string;
-}
-/**
- * A cut, decoded into one geometry.
- *
- * Nothing about it depends on where the camera is: the mesh is drawn solid and the depth buffer
- * orders it, so the triangle list is uploaded once when the cut is taken and never touched again.
- */
-export class VGeoCutGeometry {
-    /**
-     * Position and colour, indexed by {@link triangles}.
-     * @type {Geometry}
-     */
-    geometry: Geometry;
-    /**
-     * `3 · triangle_count` — the full triangle list, in cluster order, and the geometry's index.
-     * @type {Uint32Array}
-     */
-    triangles: Uint32Array;
-    /**
-     * @type {number}
-     */
-    triangle_count: number;
-    /**
-     * @type {number}
-     */
-    vertex_count: number;
-}
-import { Geometry } from "../../renderer/geometry/Geometry.js";
-//# sourceMappingURL=cut_geometry.d.ts.map

package/src/shade/playground/vgeo_viewer/cut_geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cut_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/cut_geometry.js"],"names":[],"mappings":"AAqOA;;;;;;GAMG;AACH,kEAHW,eAAe,GACb,eAAe,CAsM3B;;;;;;;;;;;;;;;8BArXS,MAAM;;;;;;;;;;;AA4IhB;;;;;GAKG;AACH;IACI;;;OAGG;IACH,UAFU,QAAQ,CAEQ;IAE1B;;;OAGG;IACH,WAFU,WAAW,CAEU;IAE/B;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;CACpB;yBA5NwB,qCAAqC"}

package/src/shade/playground/vgeo_viewer/main.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/main.js"],"names":[],"mappings":""}

package/src/shade/playground/vgeo_viewer/sample_asset.d.ts

@@ -1,18 +0,0 @@
-/**
- * Build a sample container and hand back a source over it.
- *
- * The page size is deliberately far below the 256 KB default: a sample that came out as one page
- * would be a container with nothing to stream, and the point of opening this one is to watch it
- * arrive.
- *
- * @param {number} [major]
- * @param {number} [minor]
- * @param {number} [page_size] target decoded bytes per page
- * @returns {{source: VGeoByteSource, build_ms: number}}
- */
-export function vgeo_sample_source(major?: number, minor?: number, page_size?: number): {
-    source: VGeoByteSource;
-    build_ms: number;
-};
-import { VGeoByteSource } from "../../renderer/geometry/virtual/format/read/VGeoByteSource.js";
-//# sourceMappingURL=sample_asset.d.ts.map

package/src/shade/playground/vgeo_viewer/sample_asset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sample_asset.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/sample_asset.js"],"names":[],"mappings":"AA0GA;;;;;;;;;;;GAWG;AACH,2CALW,MAAM,UACN,MAAM,cACN,MAAM,GACJ;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAiBtD;+BA1HM,+DAA+D"}

package/src/shade/playground/vgeo_viewer/select_cut.d.ts

@@ -1,173 +0,0 @@
-/**
- * Select the cut for a view from whatever the reader currently holds.
- *
- * A traversal rather than a flat pass over every cluster, per design §4 — and it gets the cut rule's
- * first half for free. The rule is `project(parent) > τ AND project(self) ≤ τ`; a group is only ever
- * reached by descending *through* the cluster whose step consumed it, and that descent happened
- * precisely because the step projected above τ. Every cluster of a group shares that step's sphere
- * and error, so the parent test is satisfied by the act of arriving.
- *
- * The residency clamp is the live one here, and it is the reason a cut can be taken at all before
- * the file has finished arriving: a cluster that wants a page nobody has is drawn as it stands.
- *
- * @param {VGeoContainerReader} reader
- * @param {VGeoCutView} view
- * @returns {VGeoCut}
- */
-export function vgeo_select_cut(reader: VGeoContainerReader, view: VGeoCutView): VGeoCut;
-/**
- * Selecting a cut from a partially resident container.
- *
- * The traversal itself is the runtime's rule, not a debug approximation of it: descend the page
- * graph from the root's parentless groups, refine a cluster whose error projects above τ, take it
- * when it does not. What this file adds is the part a whole-file reader never has to think about —
- * what to do when the page a refinement wants is not here.
- *
- * The answer is the format's (`VGEO_FORMAT.md` §10): **draw the coarser cluster and say so**. The
- * result is a genuine surface — watertight, correct, merely coarser in that region — and the want it
- * records carries the exact byte range that would refine it. That is what makes streaming safe in
- * any arrival order, and it is why this file's most interesting number is `clamped`.
- *
- * "Not here" is `VGeoContainerReader.is_selectable`, not `is_resident`, and the difference is the
- * one thing about this traversal that is not obvious: a group is refined into only once every page
- * holding one of its *parents* is installed. Residency alone lets a group be entered through the
- * parents that arrived while a coarse cluster still covers the one that did not, and then both are
- * drawn over the same surface. §10 calls that out by name — "no holes **and no double-draw**, in any
- * arrival order" — and the second half is the one that fails silently.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-/**
- * The view a cut is selected for. `VIRTUAL_GEOMETRY_DESIGN.md` §4: a cut is selected at one camera's
- * distances and pixel budget, and is the wrong cut for any other.
- */
-export class VGeoCutView {
-    /**
-     * Camera position, object space — the viewer draws at identity, so world and object agree.
-     * @type {Float32Array}
-     */
-    eye: Float32Array;
-    /**
-     * Pixels of permitted error. The one quality dial.
-     * @type {number}
-     */
-    tau: number;
-    /**
-     * Height of the render target, in pixels — the projection's numerator.
-     * @type {number}
-     */
-    screen_height: number;
-    /**
-     * @type {number}
-     */
-    fov_y: number;
-    /**
-     * @type {boolean}
-     */
-    cull_enabled: boolean;
-    /**
-     * Six normalized world-space planes, as {@link Camera.frustum} holds them.
-     * @type {Float32Array}
-     */
-    frustum: Float32Array;
-}
-/**
- * What one traversal came to, including what it had to look at to get there and what it could not
- * reach.
- *
- * A cut holds the {@link VGeoPage} objects it selected from rather than page indices, so it stays
- * drawable across an eviction: the bytes it needs are reachable from the cut itself. Nothing here
- * goes stale because residency moved under it.
- */
-export class VGeoCut {
-    /**
-     * The page each selected cluster came from, parallel to {@link clusters}.
-     * @type {VGeoPage[]}
-     */
-    pages: VGeoPage[];
-    /**
-     * Selected clusters, as indices within the page at the same position of {@link pages}. There is
-     * no global cluster id in the format and none in the reader; a cluster is a page and an index.
-     * @type {number[]}
-     */
-    clusters: number[];
-    /**
-     * @type {number}
-     */
-    triangle_count: number;
-    /**
-     * @type {number}
-     */
-    vertex_count: number;
-    /**
-     * @type {number}
-     */
-    groups_visited: number;
-    /**
-     * @type {number}
-     */
-    clusters_tested: number;
-    /**
-     * Clusters whose subtree the frustum threw away, which is a whole region rather than one
-     * cluster — the reason culling belongs in the traversal and not after it.
-     * @type {number}
-     */
-    culled: number;
-    /**
-     * Clusters that projected above τ and were drawn anyway, because the page holding their
-     * refinement is not resident.
-     *
-     * **This is the number that says a cut is still arriving.** Zero means the cut on screen is the
-     * one the container's own metric selects for this view; anything above it means part of the
-     * surface is standing in for something finer, and {@link wants} says exactly what to fetch to
-     * fix it.
-     *
-     * @type {number}
-     */
-    clamped: number;
-    /**
-     * Of those, the ones whose child group's page is **here** and merely not selectable yet, because
-     * a page holding one of that group's other parents is not.
-     *
-     * They carry no want: there is nothing to fetch from a cluster that already has the bytes it
-     * points at. What unblocks them is elsewhere in the same cut — the cluster clamped directly
-     * against the missing page — so this number is not a second streaming frontier, it is how much
-     * of the coarseness on screen is the ancestor rule holding a group back rather than bandwidth.
-     *
-     * @type {number}
-     */
-    clamped_on_activation: number;
-    /**
-     * Which clusters those were, keyed `page · 65536 + cluster`. What the panel counts, a display
-     * can paint — so the regions still waiting on bytes are visible as regions.
-     * @type {Set<number>}
-     */
-    clamped_keys: Set<number>;
-    /**
-     * Clusters whose `child_ref` names an entry outside their page's child table.
-     *
-     * Impossible in a file the validator accepts, and reachable here precisely because validation is
-     * off by default — so it is counted and the cluster is drawn as a leaf, rather than read out of
-     * bounds or thrown out of a traversal that was two thirds of the way to a picture.
-     *
-     * @type {number}
-     */
-    broken_child_refs: number;
-    /**
-     * The pages this cut would need to stop being clamped, one entry per page, most wanted first.
-     * @type {VGeoPageWant[]}
-     */
-    wants: VGeoPageWant[];
-    /**
-     * Distinct pages the traversal read from.
-     * @type {number}
-     */
-    pages_touched: number;
-    /**
-     * @type {number}
-     */
-    duration_ms: number;
-}
-import { VGeoPageWant } from "../../renderer/geometry/virtual/format/read/VGeoPageWant.js";
-//# sourceMappingURL=select_cut.d.ts.map

package/src/shade/playground/vgeo_viewer/select_cut.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select_cut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/select_cut.js"],"names":[],"mappings":"AAsPA;;;;;;;;;;;;;;;GAeG;AACH,mEAHW,WAAW,GACT,OAAO,CAgKnB;AA5ZD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH;IACI;;;OAGG;IACH,KAFU,YAAY,CAEI;IAE1B;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;OAEG;IACH,OAFU,MAAM,CAEQ;IAExB;;OAEG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,SAFU,YAAY,CAES;CAClC;AAED;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,OAFU,UAAU,CAET;IAEX;;;;OAIG;IACH,UAFU,MAAM,EAAE,CAEJ;IAEd;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;;;;;;OAUG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;;;;;OAUG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,cAFU,IAAI,MAAM,CAAC,CAEI;IAEzB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,EAAE,CAEb;IAEX;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,aAFU,MAAM,CAEA;CACnB;6BAjLM,6DAA6D"}

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

@@ -1,52 +0,0 @@
-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/VGeoFaceGraph.d.ts.map

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

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

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

@@ -1,32 +0,0 @@
-/**
- * One band of the DAG.
- *
- * A level is an ordinal, not a generation: `clusters` are the clusters the round of that index
- * created, while `groups` are the groups the round *above* consumed — and those groups may hold
- * clusters from any level at or below their own, because a cluster no round could use waits in the
- * frontier until one can. What the ordinal guarantees is the only thing the format needs from it:
- * every group sits strictly below the group holding its parents, so laying pages out by descending
- * level makes every child reference point forward in the file.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class VGeoLevel {
-    /**
-     * `0` = leaves.
-     * @type {number}
-     */
-    index: number;
-    /**
-     * The clusters this level's round created.
-     * @type {VirtualGeometryCluster[]}
-     */
-    clusters: VirtualGeometryCluster[];
-    /**
-     * The groups that sit in this level's band — the ones the round above consumed. Empty for the
-     * top level until the caller assigns its root group.
-     * @type {VirtualGeometryGroup[]}
-     */
-    groups: VirtualGeometryGroup[];
-}
-//# sourceMappingURL=VGeoLevel.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"VGeoLevel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoLevel.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,UAFU,wBAAwB,CAEpB;IAEd;;;;OAIG;IACH,QAFU,sBAAsB,CAEpB;CACf"}

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

@@ -1,59 +0,0 @@
-/**
- * How the round loop of {@link vgeo_build_levels} is allowed to behave.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class VGeoLevelOptions {
-    /**
-     * Clusters a group starts out holding. Grows when a round fails to make progress — small groups
-     * starve the simplifier (the locked perimeter dominates), large ones lock a big spatial
-     * footprint into LOD lockstep.
-     * @type {number}
-     */
-    group_size: number;
-    /**
-     * Fraction of a group's *clusters* the step above it should come to. The design's halving,
-     * stated as the thing the DAG is actually for.
-     *
-     * A triangle ratio is a means and this is the end, and asking directly is what keeps parents
-     * full: the simplifier is given the triangle count that many clusters hold, rather than half of
-     * whatever the children happened to contain. Where the children are already full the two are the
-     * same number. Where they are not, this asks for less destruction, because the reduction is
-     * available from packing the geometry better instead.
-     * @type {number}
-     */
-    simplification_ratio: number;
-    /**
-     * How much error a single round is allowed to span, as a multiple of the band's floor. `1` would
-     * admit only the exact minimum and turn every distinct error value into its own round; a large
-     * value admits the whole frontier every time and is the level sweep this replaced.
-     *
-     * Four, measured. On a 98k-triangle sphere against a full sweep: 31% fewer clusters merged into
-     * groups more than twice as coarse as themselves, and 8% fewer at four times, for one extra
-     * level. Two is tighter on the first count — 41% fewer — but costs fourteen levels, and every
-     * level is a page band and a dependent fetch on the way down.
-     * @type {number}
-     */
-    error_band_growth: number;
-    /**
-     * Least share of the frontier a round is allowed to work on, whatever the octave says.
-     *
-     * The octave alone offers no guarantee of progress: geometry whose error is spread thinly and
-     * continuously — a UV sphere, whose poles carry triangles a fraction of the size of its
-     * equator's — puts only a handful of clusters in any one octave, and the build inches forward a
-     * few merges per round. That is not merely slow, it is unbounded: `level_count` is a u8, and a
-     * round loop whose count scales with the cluster count rather than its logarithm will run out of
-     * levels on a real asset. Widening the band until it holds a fixed share of the frontier bounds
-     * the depth logarithmically, and costs error uniformity only where the octave had nothing.
-     * @type {number}
-     */
-    error_band_min_fraction: number;
-    /**
-     * Refuse to build past this many levels. `level_count` is a u8 in the container, and a build
-     * that has not converged by then has something else wrong with it.
-     * @type {number}
-     */
-    max_levels: number;
-}
-//# sourceMappingURL=VGeoLevelOptions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"VGeoLevelOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoLevelOptions.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;OAUG;IACH,sBAFU,MAAM,CAEW;IAE3B;;;;;;;;;;OAUG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;OAWG;IACH,yBAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,YAFU,MAAM,CAEC;CACpB"}

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

@@ -1,44 +0,0 @@
-/**
- * What one band of the DAG came to.
- *
- * The counts are not a frontier size and do not have to fall monotonically: `cluster_count` is what
- * the round of this index *created*, and a round merges a band of comparable error rather than the
- * whole frontier, so a later round can produce fewer clusters than an earlier one — or more, when it
- * finally reaches geometry that had been waiting.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class VGeoLevelSummary {
-    level: number;
-    /**
-     * Clusters the round of this index created.
-     * @type {number}
-     */
-    cluster_count: number;
-    /**
-     * Groups sitting in this band — the ones the round above consumed.
-     * @type {number}
-     */
-    group_count: number;
-    triangle_count: number;
-    vertex_count: number;
-    /**
-     * Smallest object-space `r_e` any cluster of this level carries.
-     * @type {number}
-     */
-    min_error: number;
-    /**
-     * Largest object-space `r_e` any cluster of this level carries. The root's is the ceiling for
-     * the whole asset; between two levels there is no ordering, for the same reason the counts have
-     * none.
-     * @type {number}
-     */
-    max_error: number;
-    /**
-     * Largest LOD-metric sphere radius at this level.
-     * @type {number}
-     */
-    max_sphere_radius: number;
-}
-//# sourceMappingURL=VGeoLevelSummary.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"VGeoLevelSummary.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoLevelSummary.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IACI,cAAU;IAEV;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB,uBAAmB;IACnB,qBAAiB;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;OAKG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,mBAFU,MAAM,CAEM;CACzB"}