@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js

@@ -10,16 +10,17 @@ import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENV
 import { SCENE_DATABASE_RESOURCE } from "../../../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
-import { chunk_sample_environment_map } from "../../../shader/chunk/texture/sample/chunk_sample_environment_map.js";
-import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { chunk_sample_environment_map } from "../../../shader/chunk/texture/sample/chunk_sample_environment_map.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { BRICK_TRACE_HIT, BRICK_TRACE_MISS } from "../brick/BRICK_CLIPMAP.js";
 import { BRICK_LEVELS_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
-import { chunk_probe_clipmap_hit_surface } from "./chunk_probe_clipmap_hit_surface.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_ray_origin,
@@ -27,6 +28,7 @@ import {
     PROBE_RAYS_WRITE_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_hit_surface } from "./chunk_probe_clipmap_hit_surface.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 import { PROBE_TRACE_SETTINGS } from "./shader_probe_clipmap_trace.js";
 

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AA+CA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAwBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAoJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAqDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAwBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAoJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js

@@ -2,12 +2,18 @@ import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
 import { LIGHT_DATA_RESOURCE } from "../../../light/LIGHT_DATA_RESOURCE.js";
 import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
 import { LIGHT_FLAGS } from "../../../light/model/io/LIGHT_FLAGS.js";
-import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
-import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
-import { chunk_uv_octahedral_unit_encode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
+import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_uv_octahedral_unit_encode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import { chunk_directional_lights_iteration_mask } from "../../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
 import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
 import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace_command.d.ts

@@ -9,7 +9,8 @@ export const PROBE_TRACE_COMMAND_SETTINGS: WebGPUStruct;
  *   projection;
  * - a thread a texel of their maps, n_r² + n_d² a probe, at `PROBE_DISPATCH_TEXELS`: accumulate;
  * - a thread a row of their radiance maps, n_r a probe, at `PROBE_DISPATCH_ROWS`: the projection's rows;
- * - a thread a texel of their tiles, (n_r + 2)² + (n_d + 2)² a probe, at `PROBE_DISPATCH_PUBLISH`.
+ * - a thread a texel of their tiles, (n_r + 2s)² + (n_d + 2)² a probe, s the radiance's skirt, at
+ *   `PROBE_DISPATCH_PUBLISH`.
  *
  * It writes the count of the ray counts, the ray requests and the rays' layout, the probes listed, which
  * the passes after fill in (`shader_probe_clipmap_ray_layout.js`): a probe's rays are its own update's,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace_command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace_command.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace_command.js"],"names":[],"mappings":"AAeA;;GAEG;AACH,2CAFU,YAAY,CASU;AAahC;;;;;;;;;;;;;;GAcG;AACH,iDAFU,aAAa,CAoDpB;6BAlG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace_command.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace_command.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,2CAFU,YAAY,CAWU;AAahC;;;;;;;;;;;;;;;GAeG;AACH,iDAFU,aAAa,CAsDpB;6BAvG0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace_command.js

@@ -1,4 +1,5 @@
 import { chunk_folded_dispatch } from "../../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -23,6 +24,8 @@ export const PROBE_TRACE_COMMAND_SETTINGS = WebGPUStruct.from({
     radiance_resolution: u32,
     /** octahedral depth texels a side, n_d */
     depth_resolution: u32,
+    /** texels of skirt around a radiance tile's map on each side: 1, or 0 for a clipmap whose radiance is never sampled */
+    radiance_skirt: u32,
 }, "ProbeTraceCommandSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -43,7 +46,8 @@ resources.createGroup()
  *   projection;
  * - a thread a texel of their maps, n_r² + n_d² a probe, at `PROBE_DISPATCH_TEXELS`: accumulate;
  * - a thread a row of their radiance maps, n_r a probe, at `PROBE_DISPATCH_ROWS`: the projection's rows;
- * - a thread a texel of their tiles, (n_r + 2)² + (n_d + 2)² a probe, at `PROBE_DISPATCH_PUBLISH`.
+ * - a thread a texel of their tiles, (n_r + 2s)² + (n_d + 2)² a probe, s the radiance's skirt, at
+ *   `PROBE_DISPATCH_PUBLISH`.
  *
  * It writes the count of the ray counts, the ray requests and the rays' layout, the probes listed, which
  * the passes after fill in (`shader_probe_clipmap_ray_layout.js`): a probe's rays are its own update's,
@@ -60,7 +64,7 @@ export const shader_probe_clipmap_trace_command = ComputeShader.from({
 @compute @workgroup_size(1)
 fn main() {
     let traced = min(probe_trace.count, settings.trace_capacity);
-    let probes = folded_dispatch((traced + PROBE_THREAD_WORKGROUP_SIZE - 1u) / PROBE_THREAD_WORKGROUP_SIZE);
+    let probes = folded_dispatch(divide_round_up_u32(traced, PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_TRACED] = probes.x;
     probe_dispatch[PROBE_DISPATCH_TRACED + 1u] = probes.y;
@@ -73,25 +77,26 @@ fn main() {
     let n = settings.radiance_resolution;
     let m = settings.depth_resolution;
 
-    let texels = folded_dispatch((traced * (n * n + m * m) + PROBE_THREAD_WORKGROUP_SIZE - 1u) / PROBE_THREAD_WORKGROUP_SIZE);
+    let texels = folded_dispatch(divide_round_up_u32(traced * (n * n + m * m), PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_TEXELS] = texels.x;
     probe_dispatch[PROBE_DISPATCH_TEXELS + 1u] = texels.y;
     probe_dispatch[PROBE_DISPATCH_TEXELS + 2u] = texels.z;
 
-    let rows = folded_dispatch((traced * n + PROBE_THREAD_WORKGROUP_SIZE - 1u) / PROBE_THREAD_WORKGROUP_SIZE);
+    let rows = folded_dispatch(divide_round_up_u32(traced * n, PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_ROWS] = rows.x;
     probe_dispatch[PROBE_DISPATCH_ROWS + 1u] = rows.y;
     probe_dispatch[PROBE_DISPATCH_ROWS + 2u] = rows.z;
 
-    let tiles = folded_dispatch((traced * ((n + 2u) * (n + 2u) + (m + 2u) * (m + 2u)) + PROBE_THREAD_WORKGROUP_SIZE - 1u) / PROBE_THREAD_WORKGROUP_SIZE);
+    let side = n + 2u * settings.radiance_skirt;
+    let tiles = folded_dispatch(divide_round_up_u32(traced * (side * side + (m + 2u) * (m + 2u)), PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_PUBLISH] = tiles.x;
     probe_dispatch[PROBE_DISPATCH_PUBLISH + 1u] = tiles.y;
     probe_dispatch[PROBE_DISPATCH_PUBLISH + 2u] = tiles.z;
 
-    let runs = folded_dispatch((traced + PROBE_ORDER_RUN - 1u) / PROBE_ORDER_RUN);
+    let runs = folded_dispatch(divide_round_up_u32(traced, PROBE_ORDER_RUN));
 
     probe_dispatch[PROBE_DISPATCH_ORDER] = runs.x;
     probe_dispatch[PROBE_DISPATCH_ORDER + 1u] = runs.y;
@@ -99,6 +104,7 @@ fn main() {
 }
 `, [
             chunk_probe_clipmap,
+            chunk_divide_round_up_u32,
             chunk_folded_dispatch,
         ]),
 });

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.d.ts

@@ -8,8 +8,7 @@ export const PROBE_WANT_SETTINGS: WebGPUStruct;
  *
  * Each frame a tile wants the probes of one of its pixels, picked by STBN at (tile, frame): the cages
  * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
- * pixel wants nothing. Its points go on the wanted list as the screen's, `PROBE_WANTED_SCREEN`; want runs
- * before the hits' wants, so a point both want is the screen's.
+ * pixel wants nothing.
  *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAUE;AAexB;;;;;;;;;;;;;;GAcG;AACH,wCAFU,aAAa,CAqCpB;6BAtF0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAUE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BAtF0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js

@@ -4,12 +4,12 @@ import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_backgr
 import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
 import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import {
     chunk_probe_clipmap,
     PROBE_LEVELS_RESOURCE,
@@ -28,8 +28,8 @@ export const PROBE_WANT_SETTINGS = WebGPUStruct.from({
     resolution: u32,
     /** the frame's index, what the tile's pixel is picked by */
     frame: u32,
-    /** keys over every cascade: what the wanted list holds at most */
-    key_count: u32,
+    /** what the wanted list holds at most: every key, or fewer where the wants cannot want more */
+    wanted_capacity: u32,
 }, "ProbeWantSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -51,8 +51,7 @@ resources.createGroup()
  *
  * Each frame a tile wants the probes of one of its pixels, picked by STBN at (tile, frame): the cages
  * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
- * pixel wants nothing. Its points go on the wanted list as the screen's, `PROBE_WANTED_SCREEN`; want runs
- * before the hits' wants, so a point both want is the screen's.
+ * pixel wants nothing.
  *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want
@@ -84,7 +83,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
     let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
 
-    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.key_count, PROBE_WANTED_SCREEN);
+    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.wanted_capacity);
 }
 `, [
             chunk_probe_clipmap,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.d.ts

@@ -1,28 +1,24 @@
 /**
- * @type {WebGPUStruct}
- */
-export const PROBE_WANT_HITS_SETTINGS: WebGPUStruct;
-/**
- * The hits' wants (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.7, D31): a thread a ray of the last
- * frame's updates, after want and before admit, through the launch those rays had,
- * `PROBE_DISPATCH_RAYS`, before the frame's trace command writes it over.
+ * The hits' wants (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.7; WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.3):
+ * a thread a ray of another clipmap's last-frame updates, through the launch those rays had,
+ * `PROBE_DISPATCH_RAYS` of that clipmap, before its frame's lifetime writes them over. The points go on this
+ * clipmap's wanted list, through its levels.
  *
- * A front-face hit that bounces anything wants the cages its pick reads, as a pixel does: the light pass
- * takes the hit's next bounce from those probes. So a probe a hit needs is admitted where nothing on
- * screen wanted one, and kept while hits read it. Until its first update a NEW probe weighs nothing and
- * the hit takes no bounce: light is lost for a frame or two, never invented.
+ * A front-face hit whose `row` the light passes left non-zero wants the cages its pick reads in this clipmap:
+ * the bounce pass clears the row of a hit whose first set held probes, so a hit wants only where that set
+ * had none, and this clipmap's probes are its fallback (`shader_probe_clipmap_bounce`). So a probe a hit needs
+ * is admitted where the first set has none, and kept while hits read it. Until its first update a NEW probe
+ * weighs nothing and the hit takes no bounce: light is lost for a frame or two, never invented.
  *
- * Only a probe a pixel wanted in the frame of its update has hits that want, so the probes hits wanted
- * want nothing in turn: the chain stops after one step, as Enshrouded's world-cache probes do. Unstopped,
- * hits would want a probe at every surface the windows hold, the dense lattice D31 turned down.
+ * Only the rays it binds want: this clipmap's own rays want nothing, so the chain stops after one step, as
+ * Enshrouded's world-cache probes do.
  *
- * It binds the last frame's trace list, origins and rays, which the frame's trace writes over later. A ray
- * names its probe, its place in that list, in its flags; a record of no ray (`PROBE_RAY_NONE`) is past
- * that frame's last.
+ * It binds the rays' trace list, origins and rays as their clipmap left them last frame. A ray names its
+ * probe, its place in that list, in its flags; a record of no ray (`PROBE_RAY_NONE`) is past that frame's
+ * last.
  *
  * @type {ComputeShader}
  */
 export const shader_probe_clipmap_want_hits: ComputeShader;
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_probe_clipmap_want_hits.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want_hits.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,uCAFU,YAAY,CAQM;AAe5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,6CAFU,aAAa,CA8CpB;6BAvG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want_hits.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAFU,aAAa,CA+CpB;8BA9F2B,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.js

@@ -1,65 +1,54 @@
-import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.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 { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_ray_origin,
     PROBE_LEVELS_RESOURCE,
     PROBE_ORIGINS_READ_RESOURCE,
     PROBE_RAYS_READ_RESOURCE,
-    PROBE_RECORDS_READ_RESOURCE,
     PROBE_TRACE_READ_RESOURCE,
     PROBE_WANTED_BITS_RESOURCE,
     PROBE_WANTED_WRITE_RESOURCE
 } from "./chunk_probe_clipmap.js";
 import { chunk_probe_clipmap_want } from "./chunk_probe_clipmap_want.js";
 import { PROBE_RECEIVER_BIAS_VIEW, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
-
-/**
- * @type {WebGPUStruct}
- */
-export const PROBE_WANT_HITS_SETTINGS = WebGPUStruct.from({
-    cascade_count: u32,
-    /** lattice points a cascade's window has a side */
-    resolution: u32,
-    /** keys over every cascade: what the wanted list holds at most */
-    key_count: u32,
-}, "ProbeWantHitsSettings");
+import { PROBE_WANT_SETTINGS } from "./shader_probe_clipmap_want.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.setImmediate("settings", PROBE_WANT_HITS_SETTINGS);
+resources.setImmediate("settings", PROBE_WANT_SETTINGS);
 
 resources.createGroup()
     .add(PROBE_TRACE_READ_RESOURCE)
     .add(PROBE_ORIGINS_READ_RESOURCE)
     .add(PROBE_RAYS_READ_RESOURCE)
-    .add(PROBE_RECORDS_READ_RESOURCE)
     .add(PROBE_LEVELS_RESOURCE)
     .add(PROBE_WANTED_BITS_RESOURCE)
     .add(PROBE_WANTED_WRITE_RESOURCE);
 
 /**
- * The hits' wants (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.7, D31): a thread a ray of the last
- * frame's updates, after want and before admit, through the launch those rays had,
- * `PROBE_DISPATCH_RAYS`, before the frame's trace command writes it over.
+ * The hits' wants (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.7; WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.3):
+ * a thread a ray of another clipmap's last-frame updates, through the launch those rays had,
+ * `PROBE_DISPATCH_RAYS` of that clipmap, before its frame's lifetime writes them over. The points go on this
+ * clipmap's wanted list, through its levels.
  *
- * A front-face hit that bounces anything wants the cages its pick reads, as a pixel does: the light pass
- * takes the hit's next bounce from those probes. So a probe a hit needs is admitted where nothing on
- * screen wanted one, and kept while hits read it. Until its first update a NEW probe weighs nothing and
- * the hit takes no bounce: light is lost for a frame or two, never invented.
+ * A front-face hit whose `row` the light passes left non-zero wants the cages its pick reads in this clipmap:
+ * the bounce pass clears the row of a hit whose first set held probes, so a hit wants only where that set
+ * had none, and this clipmap's probes are its fallback (`shader_probe_clipmap_bounce`). So a probe a hit needs
+ * is admitted where the first set has none, and kept while hits read it. Until its first update a NEW probe
+ * weighs nothing and the hit takes no bounce: light is lost for a frame or two, never invented.
  *
- * Only a probe a pixel wanted in the frame of its update has hits that want, so the probes hits wanted
- * want nothing in turn: the chain stops after one step, as Enshrouded's world-cache probes do. Unstopped,
- * hits would want a probe at every surface the windows hold, the dense lattice D31 turned down.
+ * Only the rays it binds want: this clipmap's own rays want nothing, so the chain stops after one step, as
+ * Enshrouded's world-cache probes do.
  *
- * It binds the last frame's trace list, origins and rays, which the frame's trace writes over later. A ray
- * names its probe, its place in that list, in its flags; a record of no ray (`PROBE_RAY_NONE`) is past
- * that frame's last.
+ * It binds the rays' trace list, origins and rays as their clipmap left them last frame. A ray names its
+ * probe, its place in that list, in its flags; a record of no ray (`PROBE_RAY_NONE`) is past that frame's
+ * last.
  *
  * @type {ComputeShader}
  */
@@ -86,19 +75,20 @@ fn main(
         let k = record.flags >> PROBE_RAY_PROBE_SHIFT;
         let slot = probe_trace.elements[k];
 
-        // shade left a front-face hit's albedo in its row and zero in any other ray's: a ray that takes no
-        // bounce, a black hit's among them, wants nothing
-        wants = record.row != 0u && (probe_records[slot].flags & PROBE_RECORD_SCREEN) != 0u;
+        // shade left a front-face hit's albedo in its row and zero in any other ray's, and the bounce pass
+        // cleared the row of a hit its first set served: a ray that takes no bounce, a black hit's among them,
+        // or that had its probes, wants nothing
+        wants = record.row != 0u;
 
         let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
         let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
 
         position = probe_clipmap_ray_origin(probe_origins[k], slot, record.direction) + record.t * direction;
-        // the view back along the ray, as the light pass's pick takes it
+        // the view back along the ray, as the bounce pass's pick takes it
         bias_direction = mix(normal, -direction, ${PROBE_RECEIVER_BIAS_VIEW});
     }
 
-    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.key_count, 0u);
+    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.wanted_capacity);
 }
 `, [
             chunk_probe_clipmap,

package/src/shade/renderer/gpu_primitive/WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bytes of a uniform buffer binding that **every** WebGPU device allows.
+ *
+ * `maxUniformBufferBindingSize` has this as its default, and a device may only report more, never
+ * less — so a uniform whose type is sized to it binds wherever it runs. A uniform's type is fixed when
+ * its shader is written, before any device is asked, which is why a fixed-length table that lives in a
+ * uniform takes its length from this rather than from the device's own figure.
+ *
+ * @see https://www.w3.org/TR/webgpu/#limits
+ * @type {number}
+ */
+export const WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE: number;
+//# sourceMappingURL=WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.d.ts.map

package/src/shade/renderer/gpu_primitive/WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/gpu_primitive/WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,gEAFU,MAAM,CAEuD"}

package/src/shade/renderer/gpu_primitive/WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.js

@@ -0,0 +1,12 @@
+/**
+ * Bytes of a uniform buffer binding that **every** WebGPU device allows.
+ *
+ * `maxUniformBufferBindingSize` has this as its default, and a device may only report more, never
+ * less — so a uniform whose type is sized to it binds wherever it runs. A uniform's type is fixed when
+ * its shader is written, before any device is asked, which is why a fixed-length table that lives in a
+ * uniform takes its length from this rather than from the device's own figure.
+ *
+ * @see https://www.w3.org/TR/webgpu/#limits
+ * @type {number}
+ */
+export const WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE = 65536;

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.d.ts

@@ -8,13 +8,38 @@
 export function cpu_hash_table_get(table: Uint32Array, offset: number, key: number): number;
 /**
  *
- * @param {Uint32Array} result
+ * @param {Uint32Array} result output; its `table_size` slots must be empty (zero)
  * @param {number} result_offset
  * @param {number} table_size table_size of the table
  * @param {number[]} inputs
  * @param {number} input_size
+ * @returns {boolean} false if some input could not be placed within the probe limit: the table is
+ *   then incomplete, and has to be built again with a larger table_size. See {@link cpu_hash_table_create}
  */
-export function cpu_build_hash_table(result: Uint32Array, result_offset: number, table_size: number, inputs: number[], input_size: number): void;
+export function cpu_build_hash_table(result: Uint32Array, result_offset: number, table_size: number, inputs: number[], input_size: number): boolean;
+/**
+ * Length in words of the first table size {@link cpu_hash_table_create} tries for `input_size` keys.
+ *
+ * @param {number} input_size
+ * @returns {number}
+ */
+export function cpu_hash_table_word_count(input_size: number): number;
+/**
+ * Builds a table holding `inputs` into `table`, choosing its size.
+ *
+ * The size is the smallest power of two that is at most half full, places every input within the
+ * probe limit, and fits in `table`. Lookups read it from the header; words past it are left as they
+ * were.
+ *
+ * @param {Uint32Array} table output, header at word 0; any previous table in it is replaced
+ * @param {number[]} inputs keys; each maps to its index in `inputs`
+ * @param {number} input_size number of keys taken from `inputs`
+ * @returns {boolean} false if no such size fits in `table`, whose contents are then unspecified.
+ *   Doubling the length of `table` offers the next size, and a large enough table always succeeds
+ * @see cpu_hash_table_word_count for the length of the first size tried
+ * @see cpu_build_hash_table to build at a given size
+ */
+export function cpu_hash_table_create(table: Uint32Array, inputs: number[], input_size: number): boolean;
 /**
  * Sentinel returned on lookup miss.
  * Must match the WGSL twin ({@link chunk_hash_table_get}).

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cpu_build_hash_table.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js"],"names":[],"mappings":"AAkEA;;;;;;GAMG;AACH,0CALW,WAAW,UACX,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;GAOG;AACH,6CANW,WAAW,iBACX,MAAM,cACN,MAAM,UACN,MAAM,EAAE,cACR,MAAM,QAuBhB;AA5HD;;;;GAIG;AACH,8BAFU,MAAM,CAE0B"}
+{"version":3,"file":"cpu_build_hash_table.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js"],"names":[],"mappings":"AAoEA;;;;;;GAMG;AACH,0CALW,WAAW,UACX,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;;;GASG;AACH,6CARW,WAAW,iBACX,MAAM,cACN,MAAM,UACN,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CA2BnB;AAWD;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,6CARW,WAAW,UACX,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CAkBnB;AAnLD;;;;GAIG;AACH,8BAFU,MAAM,CAE0B"}

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../../core/assert.js";
+import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 import {
     generate_next_linear_congruential_index
 } from "../../../../core/collection/map/generate_next_linear_congruential_index.js";
@@ -8,7 +9,7 @@ import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 /**
  * Maximum number of slots visited per operation.
  * Must match the WGSL twin ({@link chunk_hash_table_get}): a lookup probes at most this many slots,
- * so an insert that cannot place a record within the limit must fail loudly — otherwise it would
+ * so an insert that cannot place a record within the limit must report it — otherwise it would
  * create an entry that lookups can never reach.
  * @type {number}
  */
@@ -28,6 +29,7 @@ export const HASH_TABLE_MISS = 0xFFFFFFFF;
  * @param {number} table_size
  * @param {number} key
  * @param {number} value
+ * @returns {boolean} false if the record could not be placed within {@link PROBE_LIMIT} slots
  */
 function insert(table, table_offset, table_size, key, value) {
 
@@ -49,19 +51,19 @@ function insert(table, table_offset, table_size, key, value) {
             // empty slot, claim it
             table[address] = encoded_key;
             table[address + 1] = value;
-            return;
+            return true;
         }
 
         if (slot_key === encoded_key) {
             // replace
             table[address + 1] = value;
-            return;
+            return true;
         }
 
         index = generate_next_linear_congruential_index(index, bin_mask);
     }
 
-    throw new Error(`hash table insert exceeded probe limit (${PROBE_LIMIT}) for key=${key}; increase table_size to reduce collisions`);
+    return false;
 }
 
 /**
@@ -111,11 +113,13 @@ export function cpu_hash_table_get(table, offset, key) {
 
 /**
  *
- * @param {Uint32Array} result
+ * @param {Uint32Array} result output; its `table_size` slots must be empty (zero)
  * @param {number} result_offset
  * @param {number} table_size table_size of the table
  * @param {number[]} inputs
  * @param {number} input_size
+ * @returns {boolean} false if some input could not be placed within the probe limit: the table is
+ *   then incomplete, and has to be built again with a larger table_size. See {@link cpu_hash_table_create}
  */
 export function cpu_build_hash_table(
     result, result_offset, table_size,
@@ -135,7 +139,59 @@ export function cpu_build_hash_table(
         // hash input
         const key = inputs[i];
 
-        insert(result, data_offset, table_size, key, i);
+        if (!insert(result, data_offset, table_size, key, i)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Smallest power of two that holds `input_size` keys at most half full.
+ * @param {number} input_size
+ * @returns {number}
+ */
+function initial_table_size(input_size) {
+    return ceilPowerOfTwo(Math.max(1, input_size * 2));
+}
+
+/**
+ * Length in words of the first table size {@link cpu_hash_table_create} tries for `input_size` keys.
+ *
+ * @param {number} input_size
+ * @returns {number}
+ */
+export function cpu_hash_table_word_count(input_size) {
+    return initial_table_size(input_size) * 2 + 2;
+}
+
+/**
+ * Builds a table holding `inputs` into `table`, choosing its size.
+ *
+ * The size is the smallest power of two that is at most half full, places every input within the
+ * probe limit, and fits in `table`. Lookups read it from the header; words past it are left as they
+ * were.
+ *
+ * @param {Uint32Array} table output, header at word 0; any previous table in it is replaced
+ * @param {number[]} inputs keys; each maps to its index in `inputs`
+ * @param {number} input_size number of keys taken from `inputs`
+ * @returns {boolean} false if no such size fits in `table`, whose contents are then unspecified.
+ *   Doubling the length of `table` offers the next size, and a large enough table always succeeds
+ * @see cpu_hash_table_word_count for the length of the first size tried
+ * @see cpu_build_hash_table to build at a given size
+ */
+export function cpu_hash_table_create(table, inputs, input_size) {
+    const capacity = (table.length - 2) >> 1;
+
+    for (let table_size = initial_table_size(input_size); table_size <= capacity; table_size *= 2) {
+        // an occupied slot is never claimed, so whatever this size covers starts empty
+        table.fill(0, 2, table_size * 2 + 2);
+
+        if (cpu_build_hash_table(table, 0, table_size, inputs, input_size)) {
+            return true;
+        }
     }
 
+    return false;
 }

package/src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndirectComputeCommandBuildPass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js"],"names":[],"mappings":"AAgMA;;;;;;;;GAQG;AACH,sGAJW,MAAM,QACN,OAAO,GACL,yBAAyB,CAIrC;AACD;;;;;;;;;;;GAWG;AACH,gFAVW,MAAM,iFAGN,MAAM,oDAEN,MAAM,SACN,OAAO,QAqFjB;AAED;;;;;;;GAOG;AACH,gFALW,MAAM,mBACN,MAAM,SACN,OAAO,GACL,MAAM,CAkClB;AAzJD,2EAIE;0CAzLwC,mEAAmE;yCACpE,mDAAmD"}
+{"version":3,"file":"IndirectComputeCommandBuildPass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js"],"names":[],"mappings":"AAuLA;;;;;;;;GAQG;AACH,sGAJW,MAAM,QACN,OAAO,GACL,yBAAyB,CAIrC;AACD;;;;;;;;;;;GAWG;AACH,gFAVW,MAAM,iFAGN,MAAM,oDAEN,MAAM,SACN,OAAO,QAqFjB;AAED;;;;;;;GAOG;AACH,gFALW,MAAM,mBACN,MAAM,SACN,OAAO,GACL,MAAM,CAkClB;AAzJD,2EAIE;0CAhLwC,mEAAmE;yCACpE,mDAAmD"}