@woosh/meep-engine 3.58.0 → 3.60.0

package/src/view/elements/progress/segmented/segmented-resource-bar.css

@@ -0,0 +1,142 @@
+/*
+ Default styling for SegmentedResourceBarView.
+
+ Theming: every colour, notch height and the ghost go through a --segmented-bar-* custom property with a
+ fallback, so a game re-skins the bar by defining the properties on the bar or any ancestor, without overriding a
+ selector. Each notch carries its tier's class_name; the three classes below are the ones SEGMENT_TIERS_DEFAULT
+ uses, and a game's own tiers may reuse them or style their own.
+
+ Import this from a style entry point, never from a logic module. Give the bar its width and height there; keep
+ borders off the bar itself (use box-shadow or an outline), so the fill and the notches share one box.
+
+ The ghost's hold and ease are driven from script, which reads prefers-reduced-motion: under it the ghost holds,
+ then snaps.
+*/
+
+.ui-segmented-resource-bar-view {
+    position: relative;
+    overflow: hidden;
+    height: var(--segmented-bar-height, 12px);
+    background: var(--segmented-bar-background, rgba(0, 0, 0, 0.6));
+    box-shadow: var(--segmented-bar-frame, 0 0 0 1px rgba(0, 0, 0, 0.8));
+}
+
+.ui-segmented-resource-bar-view > .ghost {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    width: 0;
+    background: var(--segmented-bar-ghost-color, rgba(255, 236, 196, 0.85));
+}
+
+.ui-segmented-resource-bar-view > .fill-container,
+.ui-segmented-resource-bar-view > .notches,
+.ui-segmented-resource-bar-view > .cells {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+}
+
+.ui-segmented-resource-bar-view > .notches,
+.ui-segmented-resource-bar-view > .highlights {
+    pointer-events: none;
+}
+
+.ui-segmented-resource-bar-view .fill {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    background: var(--segmented-bar-fill-color, #3fae4a);
+}
+
+/* the second and third stacked values, e.g. shield over health */
+.ui-segmented-resource-bar-view .fill.value-1 {
+    background: var(--segmented-bar-fill-1-color, #d8d8d8);
+}
+
+.ui-segmented-resource-bar-view .fill.value-2 {
+    background: var(--segmented-bar-fill-2-color, #7a5fd0);
+}
+
+/* notches */
+
+.ui-segmented-resource-bar-view .notch {
+    position: absolute;
+    top: 0;
+    height: var(--segmented-bar-tick-height, 100%);
+    background: var(--segmented-bar-tick-color, rgba(0, 0, 0, 0.6));
+    box-shadow: var(--segmented-bar-tick-highlight, none);
+}
+
+.ui-segmented-resource-bar-view .notch.segment-tier-minor {
+    height: var(--segmented-bar-tick-minor-height, 45%);
+    background: var(--segmented-bar-tick-minor-color, rgba(0, 0, 0, 0.4));
+}
+
+.ui-segmented-resource-bar-view .notch.segment-tier-major {
+    height: var(--segmented-bar-tick-major-height, 100%);
+    background: var(--segmented-bar-tick-major-color, rgba(0, 0, 0, 0.6));
+}
+
+.ui-segmented-resource-bar-view .notch.segment-tier-super {
+    height: var(--segmented-bar-tick-super-height, 100%);
+    background: var(--segmented-bar-tick-super-color, rgba(0, 0, 0, 0.85));
+}
+
+/* cells */
+
+.ui-segmented-resource-bar-view.mode-cells {
+    /* the gaps between cells show the bar through them */
+    background: var(--segmented-bar-cell-gap-color, transparent);
+    box-shadow: none;
+}
+
+.ui-segmented-resource-bar-view .cell {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    overflow: hidden;
+    background: var(--segmented-bar-cell-empty-color, rgba(0, 0, 0, 0.55));
+}
+
+.ui-segmented-resource-bar-view .cell-ghost,
+.ui-segmented-resource-bar-view .cell-fill {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    width: 0;
+}
+
+.ui-segmented-resource-bar-view .cell-ghost {
+    background: var(--segmented-bar-ghost-color, rgba(255, 236, 196, 0.85));
+}
+
+.ui-segmented-resource-bar-view .cell-fill {
+    background: var(--segmented-bar-cell-filled-color, #e8c25a);
+}
+
+/* a cell filling up one at a time, e.g. a round being loaded */
+.ui-segmented-resource-bar-view .cell.partial > .cell-fill {
+    background: var(--segmented-bar-cell-partial-color, rgba(232, 194, 90, 0.6));
+}
+
+/* highlights (the view's `highlights` list) */
+
+.ui-segmented-resource-bar-view > .highlights {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+}
+
+.ui-segmented-resource-bar-view .highlight {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    background: var(--segmented-bar-highlight-color, rgba(255, 255, 255, 0.25));
+}

package/src/shade/renderer/geometry/sdf/SDF_BUILD_SETTINGS_STRUCT.d.ts

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

package/src/shade/renderer/geometry/sdf/SDF_BUILD_SETTINGS_STRUCT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SDF_BUILD_SETTINGS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/SDF_BUILD_SETTINGS_STRUCT.js"],"names":[],"mappings":"AAGA,qDAIG;6BAN0B,mCAAmC"}

package/src/shade/renderer/geometry/sdf/SFD_BUILD_WORKGROUP_SIZE.d.ts

@@ -1,2 +0,0 @@
-export const SFD_BUILD_WORKGROUP_SIZE: number[];
-//# sourceMappingURL=SFD_BUILD_WORKGROUP_SIZE.d.ts.map

package/src/shade/renderer/geometry/sdf/SFD_BUILD_WORKGROUP_SIZE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SFD_BUILD_WORKGROUP_SIZE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/SFD_BUILD_WORKGROUP_SIZE.js"],"names":[],"mappings":"AAAA,gDAAkD"}

package/src/shade/renderer/geometry/sdf/chunk_blas_query_sdf.d.ts

@@ -1,8 +0,0 @@
-/**
- * Signed Distance Field query
- * Exact, based on the BVH
- * @type {CodeChunk}
- */
-export const chunk_blas_query_sdf: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_blas_query_sdf.d.ts.map

package/src/shade/renderer/geometry/sdf/chunk_blas_query_sdf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_blas_query_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_blas_query_sdf.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,mCAFU,SAAS,CAsClB;0BA5CyB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_blas_query_volume_sign.d.ts

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

package/src/shade/renderer/geometry/sdf/chunk_blas_query_volume_sign.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_blas_query_volume_sign.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_blas_query_volume_sign.js"],"names":[],"mappings":"AAoBA,qDAqEE;0BA7EwB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/shader_build_sdf.d.ts

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

package/src/shade/renderer/geometry/sdf/shader_build_sdf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_build_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_build_sdf.js"],"names":[],"mappings":"AA6HA,6CAA8D;8BArHhC,+BAA+B"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_mesh_brick_object.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAFU,SAAS,CAsBhB;0BAzCuB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.js

@@ -1,42 +0,0 @@
-import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-import { MESH_BRICK_ROW_LIMIT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
-
-/**
- * A world texel's byte and a texel's bid to be its object cell's object
- * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.2, §7.6):
- *
- * ```wgsl
- * fn mesh_brick_encode(distance: f32, band: f32) -> u32     // saturate(d / 2R + 0.5), in a byte
- * fn mesh_brick_object_key(byte: u32, row: u32) -> u32      // larger for a nearer texel
- * fn mesh_brick_object_key_byte(key: u32) -> u32
- * fn mesh_brick_object_key_row(key: u32) -> u32
- * ```
- *
- * A key is the complement of the byte in its high eight bits and the row in its low 24, so the
- * largest of a cell's keys, which workgroup atomics can take, is its nearest texel, and among equally
- * near ones the lowest row: the same object whatever order the lanes ran in. A row past the 24 bits
- * cannot be named and bids as row 0, no object.
- *
- * @type {CodeChunk}
- */
-export const chunk_mesh_brick_object = CodeChunk.from(
-    //language=WGSL
-    `
-fn mesh_brick_encode(distance: f32, band: f32) -> u32 {
-    return u32(round(saturate(distance / (2.0 * band) + 0.5) * 255.0));
-}
-
-fn mesh_brick_object_key(byte: u32, row: u32) -> u32 {
-    let named = select(0u, row, row < ${MESH_BRICK_ROW_LIMIT}u);
-
-    return ~((byte << 24u) | named);
-}
-
-fn mesh_brick_object_key_byte(key: u32) -> u32 {
-    return (~key) >> 24u;
-}
-
-fn mesh_brick_object_key_row(key: u32) -> u32 {
-    return (~key) & ${MESH_BRICK_ROW_LIMIT - 1}u;
-}
-`);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.d.ts

@@ -1,35 +0,0 @@
-/**
- * Words of the mesh provider's statistics, every one an atomic that accumulates.
- */
-export const MESH_BRICK_STATISTIC_INSTANCES_DROPPED: 0;
-export const MESH_BRICK_STATISTIC_CANDIDATES_DROPPED: 1;
-export const MESH_BRICK_STATISTIC_NODES_DROPPED: 2;
-export const MESH_BRICK_STATISTIC_WORDS: 4;
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_BRICK_PROVIDER_SETTINGS: WebGPUStruct;
-/**
- * The mesh provider's pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a 64-lane workgroup a taken
- * cell, dispatched by take.
- *
- * **Gather.** A cooperative TLAS query with the cell grown by the cascade's band, every leaf filtered
- * by `mesh_brick_accept`: in the SDF world, resident, at least half a voxel across. Up to
- * {@link MESH_BRICK_INSTANCE_LIMIT} instances, a lane each, go into workgroup memory; past it they are
- * dropped and counted, as are candidates and subtrees the query itself dropped.
- *
- * **512 texels, eight a lane**, each `mesh_brick_texel`: the minimum over the instances of their
- * sampled distance, and its row. A lane merges its texels into its two staging words, which no other
- * thread touches (contract 1), as the byte minimum (contract 2).
- *
- * **Objects** (contract 3): per 2³-texel cell, the provider's row at its own nearest texel replaces the
- * staged object when the provider's cell minimum is below the staged one from before the merge; ties
- * keep the staged object. A cell's four lanes fold their texels in through workgroup atomics, and the
- * last of them decides, so that no lane waits on another.
- *
- * @type {ComputeShader}
- */
-export const shader_mesh_brick_provider: ComputeShader;
-import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-import { ComputeShader } from "../../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_mesh_brick_provider.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_mesh_brick_provider.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js"],"names":[],"mappings":"AAkCA;;GAEG;AACH,uDAAwD;AACxD,wDAAyD;AACzD,mDAAoD;AACpD,2CAA4C;AAE5C;;GAEG;AACH,2CAFU,YAAY,CAOU;AA4KhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,aAAa,CAMpB;6BAjO0B,yCAAyC;8BAJxC,qCAAqC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js

@@ -1,247 +0,0 @@
-import { assert } from "../../../../../../core/assert.js";
-import { WebGPUExtensionType } from "../../../../../descriptor/WebGPUExtensionType.js";
-import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "../../../../geometry/sdf/MESH_SDF.js";
-import {
-    MESH_SDF_ATLAS_RESOURCE,
-    MESH_SDF_HEADERS_RESOURCE,
-    MESH_SDF_INDIRECTION_RESOURCE,
-    MESH_SDF_SAMPLER_RESOURCE
-} from "../../../../geometry/sdf/MESH_SDF_RESOURCES.js";
-import { BVH2_NODE_STRUCT } from "../../../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_STRUCT } from "../../../../shader/chunk/bvh/BVH_STRUCT.js";
-import { chunk_bvh_query_aabb_cooperative } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js";
-import { BVH_QUERY_AABB_WORKGROUP_SIZE } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js";
-import { CLIPMAP_LEVEL_ARRAY } from "../../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
-import { chunk_mod_v3i } from "../../../../shader/chunk/geometry/vec3/chunk_mod_v3i.js";
-import { chunk_folded_workgroup_index } from "../../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { atomic_u32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-import { BRICK_CELL_WORKGROUP_SIZE, BRICK_OBJECT_CELLS_PER_AXIS } from "../BRICK_CLIPMAP.js";
-import {
-    BRICK_RING_RESOURCE,
-    BRICK_STAGING_RESOURCE,
-    BRICK_TAKE_RESOURCE,
-    chunk_brick_clipmap
-} from "../chunk_brick_clipmap.js";
-import { chunk_mesh_brick_instance } from "./chunk_mesh_brick_instance.js";
-import { chunk_mesh_brick_object } from "./chunk_mesh_brick_object.js";
-import { chunk_mesh_brick_texel } from "./chunk_mesh_brick_texel.js";
-import { MESH_BRICK_INSTANCE_LIMIT, MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
-
-/**
- * Words of the mesh provider's statistics, every one an atomic that accumulates.
- */
-export const MESH_BRICK_STATISTIC_INSTANCES_DROPPED = 0;
-export const MESH_BRICK_STATISTIC_CANDIDATES_DROPPED = 1;
-export const MESH_BRICK_STATISTIC_NODES_DROPPED = 2;
-export const MESH_BRICK_STATISTIC_WORDS = 4;
-
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_BRICK_PROVIDER_SETTINGS = WebGPUStruct.from({
-    /** keys `brick_ring` holds, a power of two */
-    ring_capacity: u32,
-    /** cells a cascade's window has a side */
-    resolution: u32,
-}, "MeshBrickProviderSettings");
-
-// the gather is the whole workgroup's: a cell's workgroup is the query's
-assert.equal(BRICK_CELL_WORKGROUP_SIZE, BVH_QUERY_AABB_WORKGROUP_SIZE, 'a taken cell\'s workgroup runs the cooperative query');
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", MESH_BRICK_PROVIDER_SETTINGS);
-
-resources.createGroup()
-    .add(BRICK_TAKE_RESOURCE)
-    .add(BRICK_RING_RESOURCE)
-    .add(BRICK_STAGING_RESOURCE)
-    .addUniform("brick_levels", CLIPMAP_LEVEL_ARRAY)
-    .addStorageBuffer("mesh_brick_statistics", WebGPUArray.from(atomic_u32), true);
-
-resources.createGroup()
-    .addStorageBuffer("tlas", BVH_STRUCT)
-    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-    .add(MESH_SDF_HEADERS_RESOURCE)
-    .add(MESH_SDF_INDIRECTION_RESOURCE)
-    .add(MESH_SDF_ATLAS_RESOURCE)
-    .add(MESH_SDF_SAMPLER_RESOURCE);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const MESH_BRICK_INSTANCE_LIMIT = ${MESH_BRICK_INSTANCE_LIMIT}u;
-
-/** the cascade's voxel, the same for the whole workgroup: what the gather's resolution cull weighs a box by */
-var<private> mesh_brick_voxel: f32;
-
-var<workgroup> instances: array<${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref}, ${MESH_BRICK_INSTANCE_LIMIT}>;
-var<workgroup> cell_taken: u32;
-
-/** per object cell: its nearest texel's key, its staged minimum (as 255 less the byte), and its lanes done */
-var<workgroup> object_best: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-var<workgroup> object_staged: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-var<workgroup> object_lanes: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-
-fn bvh_query_aabb_node(index: u32) -> ${BVH2_NODE_STRUCT.wgsl_ref} {
-    return tlas.nodes[index];
-}
-
-fn bvh_query_aabb_accept_leaf(payload: u32, bounds: array<f32, 6>) -> bool {
-    return mesh_brick_accept(payload, bounds, mesh_brick_voxel);
-}
-
-fn mesh_brick_instance_at(i: u32) -> ${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref} {
-    return instances[i];
-}
-
-@compute @workgroup_size(${BRICK_CELL_WORKGROUP_SIZE})
-fn main(
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(local_invocation_index) lane: u32,
-) {
-    let build = folded_workgroup_index(workgroup_id);
-
-    if (lane == 0u) {
-        cell_taken = brick_take[BRICK_TAKE_COUNT];
-    }
-
-    // a folded dispatch's tail leaves whole
-    if (build >= workgroupUniformLoad(&cell_taken)) {
-        return;
-    }
-
-    let key = brick_ring[(brick_take[BRICK_TAKE_FIRST] + build) & (settings.ring_capacity - 1u)];
-    let resolution = settings.resolution;
-    let cascade = brick_clipmap_key_cascade(key, resolution);
-    let level = brick_levels[cascade];
-
-    // the world cell the storage cell holds: the window's one congruent to it
-    let cell = level.corner + mod_v3i(vec3<i32>(brick_clipmap_key_storage(key, resolution)) - level.corner, vec3<i32>(i32(resolution)));
-
-    let voxel = level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
-    let band = ${MESH_SDF_BAND_VOXELS}.0 * voxel;
-
-    // texel 0, at voxel 7·cell of the cascade (§7.2)
-    let corner = vec3<f32>(cell) * level.cell_size;
-    let far = corner + vec3<f32>(level.cell_size);
-
-    mesh_brick_voxel = voxel;
-
-    // every instance whose box comes within the band of the cell
-    let gathered = bvh_query_aabb_cooperative(tlas.root, array<f32, 6>(corner.x - band, corner.y - band, corner.z - band, far.x + band, far.y + band, far.z + band), lane);
-    let count = min(gathered.candidate_count, MESH_BRICK_INSTANCE_LIMIT);
-
-    if (lane < count) {
-        instances[lane] = mesh_brick_instance(bvh_query_aabb_candidates[lane], voxel);
-    }
-
-    if (lane == 0u) {
-        if (gathered.candidate_count > count) {
-            atomicAdd(&mesh_brick_statistics[${MESH_BRICK_STATISTIC_INSTANCES_DROPPED}u], gathered.candidate_count - count);
-        }
-
-        if (gathered.candidates_dropped > 0u) {
-            atomicAdd(&mesh_brick_statistics[${MESH_BRICK_STATISTIC_CANDIDATES_DROPPED}u], gathered.candidates_dropped);
-        }
-
-        if (gathered.nodes_dropped > 0u) {
-            atomicAdd(&mesh_brick_statistics[${MESH_BRICK_STATISTIC_NODES_DROPPED}u], gathered.nodes_dropped);
-        }
-    }
-
-    workgroupBarrier();
-
-    // eight texels a lane, x fastest, at y = lane mod 8 and z = lane / 8: the staging's two words
-    let y = lane % 8u;
-    let z = lane / 8u;
-    let first = build * BRICK_STAGING_WORDS + 2u * lane;
-
-    var best = vec4<u32>(0u);
-    var staged_min = vec4<u32>(255u);
-
-    for (var w = 0u; w < 2u; w++) {
-        var word = brick_staging[first + w];
-
-        for (var b = 0u; b < 4u; b++) {
-            let x = 4u * w + b;
-            let shift = 8u * b;
-            let staged = (word >> shift) & 0xffu;
-
-            let texel = mesh_brick_texel(corner + vec3<f32>(f32(x), f32(y), f32(z)) * voxel, count);
-            let byte = mesh_brick_encode(texel.distance, band);
-
-            // contract 2: the encoding is monotone, so the minimum of the bytes is the byte of the minimum
-            word = (word & ~(0xffu << shift)) | (min(staged, byte) << shift);
-
-            // the object cell's two texels of this lane
-            let o = x / 2u;
-
-            staged_min[o] = min(staged_min[o], staged);
-            best[o] = max(best[o], mesh_brick_object_key(byte, texel.row));
-        }
-
-        brick_staging[first + w] = word;
-    }
-
-    // contract 3, per object cell: its four lanes each fold in their texels, and the last decides
-    for (var o = 0u; o < ${BRICK_OBJECT_CELLS_PER_AXIS}u; o++) {
-        let object = o + ${BRICK_OBJECT_CELLS_PER_AXIS}u * ((y / 2u) + ${BRICK_OBJECT_CELLS_PER_AXIS}u * (z / 2u));
-
-        atomicMax(&object_best[object], best[o]);
-        atomicMax(&object_staged[object], 255u - staged_min[o]);
-
-        if (atomicAdd(&object_lanes[object], 1u) != 3u) {
-            continue;
-        }
-
-        // the provider's cell minimum against the staged one from before its merge: ties keep the staged
-        let nearest = atomicLoad(&object_best[object]);
-
-        if (mesh_brick_object_key_byte(nearest) < 255u - atomicLoad(&object_staged[object])) {
-            brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + object] = mesh_brick_object_key_row(nearest);
-        }
-    }
-}
-`, [
-    chunk_brick_clipmap,
-    chunk_folded_workgroup_index,
-    chunk_mod_v3i,
-    chunk_bvh_query_aabb_cooperative,
-    chunk_mesh_brick_instance,
-    chunk_mesh_brick_texel,
-    chunk_mesh_brick_object,
-]);
-
-body.addExtension(WebGPUExtensionType.Subgroups);
-
-/**
- * The mesh provider's pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a 64-lane workgroup a taken
- * cell, dispatched by take.
- *
- * **Gather.** A cooperative TLAS query with the cell grown by the cascade's band, every leaf filtered
- * by `mesh_brick_accept`: in the SDF world, resident, at least half a voxel across. Up to
- * {@link MESH_BRICK_INSTANCE_LIMIT} instances, a lane each, go into workgroup memory; past it they are
- * dropped and counted, as are candidates and subtrees the query itself dropped.
- *
- * **512 texels, eight a lane**, each `mesh_brick_texel`: the minimum over the instances of their
- * sampled distance, and its row. A lane merges its texels into its two staging words, which no other
- * thread touches (contract 1), as the byte minimum (contract 2).
- *
- * **Objects** (contract 3): per 2³-texel cell, the provider's row at its own nearest texel replaces the
- * staged object when the provider's cell minimum is below the staged one from before the merge; ties
- * keep the staged object. A cell's four lanes fold their texels in through workgroup atomics, and the
- * last of them decides, so that no lane waits on another.
- *
- * @type {ComputeShader}
- */
-export const shader_mesh_brick_provider = ComputeShader.from({
-    label: "Brick Clipmap Mesh Provider",
-    resources,
-    body,
-});

package/src/shade/renderer/particles/shaders/shader_particle_init_free_list.d.ts

@@ -1,31 +0,0 @@
-/**
- * The free list as a fresh pool leaves it: every slot free, `dead[i] = i`, bottom to top.
- *
- * It is a stack of slot indices — the emit pass pops `dead[--DEAD]` — so the order within it is
- * arbitrary and identity is simply the cheapest arrangement to write. What matters is that every
- * slot appears exactly once: a repeat hands two particles one record, and a gap strands a slot for
- * the lifetime of the system.
- *
- * ## Why this is a pass and not a host write
- *
- * Zero is not a valid free list — `dead[i] = 0` for every `i` is the same slot half a million times
- * over — so the buffer WebGPU hands back has to be written before the first emit. Writing it from
- * the host means a typed array the size of the list (2 MiB at the default capacity), a loop over
- * every element of it, and a staged upload, all on the frame the system is constructed. Here it is
- * one store per slot with no host memory involved at all, and it leaves the free list `STORAGE`
- * only: nothing else ever writes it from the host, so it needs no `COPY_DST` and stays off the
- * driver's upload-friendly — and slower — path.
- *
- * ## Bounded launch, strided loop
- *
- * The pool capacity belongs to whoever constructs the system, and `capacity / workgroup_size` can
- * pass `maxComputeWorkgroupsPerDimension` — a validation error for a direct dispatch, and worse
- * than that for the indirect ones elsewhere in the engine, which simply do not run. So the caller
- * clamps the launch and every lane strides through the list by the whole grid: the fill covers any
- * capacity, and a grid that happens to cover it in one pass costs one comparison to find out.
- */
-/** Lanes per workgroup. One store each, so this is sized for occupancy and nothing else. */
-export const PARTICLE_INIT_FREE_LIST_WORKGROUP_SIZE: 256;
-export const shader_particle_init_free_list: ComputeShader;
-import { ComputeShader } from "../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_particle_init_free_list.d.ts.map

package/src/shade/renderer/particles/shaders/shader_particle_init_free_list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_particle_init_free_list.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_init_free_list.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,4FAA4F;AAC5F,yDAA0D;AAQ1D,2DAmBG;8BA3D2B,+BAA+B"}

package/src/shade/renderer/shadow/vsm/VSMMoverTracker.d.ts

@@ -1,42 +0,0 @@
-/**
- * The scene's memory of where its casters were and what they were: {@link VSM_LAST_SEEN_WORDS} per
- * row of the `meshes` table — the world box {@link shader_vsm_movers} saw each row with last frame,
- * and its geometry and material — empty for a row that held nothing. Comparing against it is how the
- * mover pass sees a row appear, leave, change shape or change mesh, which no per-row fact of the
- * scene database says.
- *
- * Covers every row the table has ever had — a high-water mark, so a page of rows that was freed
- * still gets compared once more and its casters' old shadows found. Grows by doubling; a grown
- * buffer starts empty and takes the old one's rows by a copy recorded in the next mover pass, in
- * order with the rest of the frame.
- */
-export class VSMMoverTracker {
-    /**
-     * @param {GPUDevice} device
-     */
-    constructor(device: GPUDevice);
-    /**
-     * @returns {GPUBuffer|null}
-     */
-    get buffer(): any;
-    /**
-     * @returns {number} rows the buffer covers
-     */
-    get row_count(): number;
-    /**
-     * Cover at least `rows` rows.
-     *
-     * @param {number} rows
-     */
-    ensure(rows: number): void;
-    /**
-     * Record the copy of the rows the buffer had before it grew, if it did since the last call, and
-     * let the old buffer go once the frame is done with it.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     */
-    encode_growth(encoder: ShadeGPUCommandContext): void;
-    destroy(): void;
-    #private;
-}
-//# sourceMappingURL=VSMMoverTracker.d.ts.map

package/src/shade/renderer/shadow/vsm/VSMMoverTracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VSMMoverTracker.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSMMoverTracker.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH;IAwBI;;OAEG;IACH,+BAIC;IAED;;OAEG;IACH,kBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;;;OAIG;IACH,aAFW,MAAM,QA+ChB;IAED;;;;;OAKG;IACH,qDAWC;IAED,gBAYC;;CACJ"}

package/src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.d.ts

@@ -1,54 +0,0 @@
-/**
- * Movers a frame lists at most: casters whose bounds or transform changed since the last frame, each
- * with the world box it covers now and covered then. Past this many, every occupied page of every
- * virtual shadow map is taken to be stale for the frame, and the overflow is counted.
- *
- * @type {number}
- */
-export const VSM_MOVER_CAPACITY: number;
-/**
- * The scene's mover list, written by the mover passes and read by every map's stale pass.
- *
- * `count` is the atomic the movers appended with, so a count past {@link VSM_MOVER_CAPACITY} says the
- * list overflowed. `boxes` holds two vec4s per mover: the world box's min and max corners in `xyz`.
- *
- * @type {WebGPUStruct}
- */
-export const VSM_MOVERS_STRUCT: WebGPUStruct;
-/**
- * The same buffer as the stale pass reads it: the count as a plain word.
- *
- * @type {WebGPUStruct}
- */
-export const VSM_MOVERS_READ_STRUCT: WebGPUStruct;
-/**
- * Bytes of the mover list at {@link VSM_MOVER_CAPACITY}.
- *
- * @type {number}
- */
-export const VSM_MOVERS_BYTE_SIZE: number;
-/**
- * What a world box holds when it holds nothing: min past max on every axis, so that `min` and `max`
- * against it return the other box unchanged. The largest finite f32, since WGSL will not fold an
- * infinity.
- *
- * @type {number}
- */
-export const VSM_EMPTY_BOUND: number;
-/**
- * Words the mover pass remembers a `meshes` row by, from one frame to the next: the world box it saw
- * the row with — six f32s, by their bits, empty for a row that held nothing — then the row's
- * geometry and material, {@link GPU_DATABASE_NULL} for a row that held nothing.
- *
- * @type {number}
- */
-export const VSM_LAST_SEEN_WORDS: number;
-/**
- * Where a row's geometry and material sit among its {@link VSM_LAST_SEEN_WORDS}.
- *
- * @type {number}
- */
-export const VSM_LAST_SEEN_GEOMETRY: number;
-export const VSM_LAST_SEEN_MATERIAL: 7;
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=VSM_MOVER_LAYOUT.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VSM_MOVER_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,iCAFU,MAAM,CAEuB;AAEvC;;;;;;;GAOG;AACH,gCAFU,YAAY,CAQN;AAEhB;;;;GAIG;AACH,qCAFU,YAAY,CAQF;AAEpB;;;;GAIG;AACH,mCAFU,MAAM,CAEqD;AAErE;;;;;;GAMG;AACH,8BAFU,MAAM,CAE2B;AAE3C;;;;;;GAMG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AACxC,uCAAwC;6BAvEX,mCAAmC"}