@woosh/meep-engine 3.60.6 → 3.60.8

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

@@ -1,56 +1,69 @@
 import { assert } from "../../../../../core/assert.js";
+import { ceil_log2 } from "../../../../../core/binary/operations/ceil_log2.js";
+import { ceilPowerOfTwo } from "../../../../../core/binary/operations/ceilPowerOfTwo.js";
 import { ClipmapCascadePlacement } from "../../../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 import { BufferDescriptor } from "../../../../descriptor/buffer/BufferDescriptor.js";
 import { graph_read_buffer } from "../../../buffer/graph_read_buffer.js";
-import { graph_build_world_light_clusters } from "../../../light/world_cluster/graph_build_world_light_clusters.js";
-import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import {
+    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
+} from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import {
     PREFIX_SCAN_CSDLDF_PARTITION_SIZE,
     shader_prefix_scan_csdldf,
     shader_prefix_scan_csdldf_prepare
 } from "../../../gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js";
-import { shader_slot_stack_fill, SLOT_STACK_FILL_WORKGROUP_SIZE } from "../../../gpu_primitive/slot_stack/shader_slot_stack_fill.js";
+import {
+    shader_slot_stack_fill,
+    SLOT_STACK_FILL_WORKGROUP_SIZE
+} from "../../../gpu_primitive/slot_stack/shader_slot_stack_fill.js";
 import {
     shader_slot_stack_push_range,
     SLOT_STACK_PUSH_RANGE_WORKGROUP_SIZE
 } from "../../../gpu_primitive/slot_stack/shader_slot_stack_push_range.js";
-import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
-import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
+import {
+    CLIPMAP_LEVEL_ARRAY,
+    CLIPMAP_LEVEL_LIMIT,
+    CLIPMAP_LEVEL_STRUCT
+} from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
+import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
 import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
 import {
-    PROBE_CLIPMAP_CASCADE_COUNT_MAX,
-    PROBE_CLIPMAP_CASCADE_RESOLUTIONS,
-    PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX,
-    PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN
-} from "../ProbeClipmapSettings.js";
-import { PROBE_EVICTION_STRUCT, PROBE_PROJECTION_ROW_STRUCT, PROBE_RAY_STRUCT, PROBE_RECORD_STRUCT, PROBE_REQUEST_STRUCT } from "./chunk_probe_clipmap.js";
+    PROBE_CANDIDATE_STRUCT,
+    PROBE_EVICTION_STRUCT,
+    PROBE_PROJECTION_ROW_STRUCT,
+    PROBE_RAY_STRUCT,
+    PROBE_RECORD_STRUCT,
+    PROBE_REQUEST_STRUCT
+} from "./chunk_probe_clipmap.js";
 import { PROBE_SAMPLING_STRUCT } from "./chunk_probe_clipmap_pick.js";
 import {
+    probe_clipmap_guide_words,
+    probe_clipmap_maps_words,
     PROBE_COUNTER_FREE,
     PROBE_COUNTER_STARVED,
     PROBE_COUNTER_WORDS,
+    PROBE_DEAD_RAYS,
     PROBE_DISPATCH_ACTIVE,
     PROBE_DISPATCH_ADMIT,
+    PROBE_DISPATCH_ORDER,
     PROBE_DISPATCH_PUBLISH,
     PROBE_DISPATCH_RAYS,
     PROBE_DISPATCH_ROWS,
     PROBE_DISPATCH_TEXELS,
-    PROBE_DISPATCH_ORDER,
     PROBE_DISPATCH_TRACED,
     PROBE_DISPATCH_WORDS,
     PROBE_FREE_SLACK,
     PROBE_RAYS_PER_TEXEL_MAX,
     PROBE_RAYS_PER_TEXEL_MIN,
+    PROBE_RECORD_CASCADE_SHIFT,
     PROBE_THREAD_WORKGROUP_SIZE,
-    PROBE_WANT_TILE,
-    PROBE_WANT_WORKGROUP_TILES,
-    PROBE_UNIFORM_PERIOD,
-    probe_clipmap_guide_words,
-    probe_clipmap_maps_words
+    PROBE_UNIFORM_PERIOD
 } from "./PROBE_CLIPMAP.js";
+import { PROBE_CLIPMAP_RESAMPLING } from "./PROBE_CLIPMAP_RESAMPLING.js";
 import { shader_probe_clipmap_accumulate } from "./shader_probe_clipmap_accumulate.js";
 import { shader_probe_clipmap_admit, shader_probe_clipmap_admit_command } from "./shader_probe_clipmap_admit.js";
+import { shader_probe_clipmap_bounce } from "./shader_probe_clipmap_bounce.js";
 import { shader_probe_clipmap_due } from "./shader_probe_clipmap_due.js";
 import { shader_probe_clipmap_fill } from "./shader_probe_clipmap_fill.js";
 import {
@@ -58,29 +71,29 @@ import {
     shader_probe_clipmap_guide_starts,
     shader_probe_clipmap_guide_weights
 } from "./shader_probe_clipmap_guide.js";
+import { shader_probe_clipmap_light } from "./shader_probe_clipmap_light.js";
+import { shader_probe_clipmap_order } from "./shader_probe_clipmap_order.js";
 import { shader_probe_clipmap_project, shader_probe_clipmap_project_rows } from "./shader_probe_clipmap_project.js";
 import { shader_probe_clipmap_publish } from "./shader_probe_clipmap_publish.js";
-import { shader_probe_clipmap_relocate } from "./shader_probe_clipmap_relocate.js";
-import { shader_probe_clipmap_resample } from "./shader_probe_clipmap_resample.js";
-import { shader_probe_clipmap_retire } from "./shader_probe_clipmap_retire.js";
-import { shader_probe_clipmap_schedule } from "./shader_probe_clipmap_schedule.js";
-import { shader_probe_clipmap_light } from "./shader_probe_clipmap_light.js";
 import {
     shader_probe_clipmap_ray_command,
     shader_probe_clipmap_ray_counts,
     shader_probe_clipmap_ray_layout
 } from "./shader_probe_clipmap_ray_layout.js";
+import { shader_probe_clipmap_relocate } from "./shader_probe_clipmap_relocate.js";
+import { shader_probe_clipmap_candidate } from "./shader_probe_clipmap_candidate.js";
+import { shader_probe_clipmap_resample } from "./shader_probe_clipmap_resample.js";
+import { shader_probe_clipmap_resample_rays } from "./shader_probe_clipmap_resample_rays.js";
+import { shader_probe_clipmap_retire } from "./shader_probe_clipmap_retire.js";
+import { shader_probe_clipmap_schedule } from "./shader_probe_clipmap_schedule.js";
 import { shader_probe_clipmap_shade } from "./shader_probe_clipmap_shade.js";
 import { shader_probe_clipmap_trace } from "./shader_probe_clipmap_trace.js";
-import { shader_probe_clipmap_order } from "./shader_probe_clipmap_order.js";
 import { shader_probe_clipmap_trace_command } from "./shader_probe_clipmap_trace_command.js";
-import { shader_probe_clipmap_want } from "./shader_probe_clipmap_want.js";
-import { shader_probe_clipmap_want_hits } from "./shader_probe_clipmap_want_hits.js";
-import { PROBE_CLIPMAP_RESAMPLING } from "./PROBE_CLIPMAP_RESAMPLING.js";
 
 /**
  * @typedef {import("../ProbeClipmapSettings.js").ProbeClipmapSettings} ProbeClipmapSettings
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("./ProbeClipmapScreenWants.js").ProbeClipmapScreenWants|import("./ProbeClipmapHitWants.js").ProbeClipmapHitWants} ProbeClipmapWants
  */
 
 /**
@@ -117,9 +130,12 @@ const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("ra
 /**
  * What shading samples (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8): {@link cascade_count} cascades of
  * {@link resolution}³ lattice points around the view, {@link spacing} metres apart in the finest
- * cascade and twice as far apart in each one around it. A point gets a probe when a pixel wants it, or
- * a hit of a probe a pixel wants, and keeps it until its window leaves it or the slots are wanted for
- * others, so probes are a sparse cache over the lattice.
+ * cascade and twice as far apart in each one around it. A point gets a probe when its wants want it, and
+ * keeps it until its window leaves it or the slots are wanted for others, so probes are a sparse cache
+ * over the lattice. Two of them make the mode (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md): the frustum's probes,
+ * wanted by the frame's pixels ({@link ProbeClipmapScreenWants}), and the world cache, wanted by the
+ * frustum's hits where the frustum has no probe ({@link ProbeClipmapHitWants}), its windows the frustum's at
+ * 2^k its lattice ({@link place_within}).
  *
  * **Storage** (§8.2):
  * - {@link indirection}, `r32uint`, a texel a lattice point in storage that wraps, the cascades
@@ -127,22 +143,25 @@ const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("ra
  *   from the structure alone.
  * - a slot each: a state of two words, the kind and updates and then where relocation moved it
  *   (`PROBE_CLIPMAP.js`), a 48-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
- *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², each with
- *   a one-texel skirt, in two 2-D tile atlases. The slots are handed out by a free list on the device.
+ *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², in two 2-D
+ *   tile atlases. The depth tile has a one-texel skirt, which the pick's bilinear tap reads; the radiance
+ *   tile has one where {@link radiance_skirt}, for the specular's tap, and none where nothing samples it.
+ *   The slots are handed out by a free list on the device.
  * - the active lists, double-buffered: each frame's retire reads the last frame's and writes the
  *   frame's; a wanted bit a lattice point and the wanted list, made again every frame; the trace list
  *   of the frame's updates, at most U = ⌊ray_budget / rays_per_probe⌋.
  *
- * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): the windows are placed around the anchor,
- * coarsest first, each a parent cell inside its parent. Retire frees the probes whose points left
- * their windows and those the last frame's schedule evicted, want marks the cages one pixel of each
- * screen tile reads, the hits' wants the cages the last frame's hits read their bounce from, admit
+ * **A frame's windows** ({@link place}, {@link place_within}): around the anchor, coarsest first, each a
+ * parent cell inside its parent; or another clipmap's.
+ *
+ * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): retire frees the probes whose points left
+ * their windows and those the last frame's schedule evicted, the wants mark the cages they read, admit
  * gives each wanted point without a probe a NEW one, schedule sets the period T from the probes waiting
  * for an update and the next frame's eviction from the pressure on the slots (`PROBE_FREE_SLACK`), and
  * the due passes list the frame's updates, NEW probes first.
  *
  * **The frame's rays** (§8.6): the lifetime's last passes lay them out. Each listed probe's rays this update
- * are a count the budget does not scale (a uniform update's R, a DEAD probe's fewest) and a request it
+ * are a count the budget does not scale (a uniform update's R, a DEAD probe's `PROBE_DEAD_RAYS`) and a request it
  * does (a guided update's, `probe_requests`, which projection sets after each update). Both are scanned
  * (`graph_prefix_scan_csdldf`'s shaders), the requests are scaled into what the budget leaves, and the
  * sums of the two are `probe_ray_sums`: a probe's rays follow one another in the trace list's order, and
@@ -150,13 +169,13 @@ const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("ra
  *
  * **The frame's update** (§8.4, §8.6), once the brick clipmap is built: relocate; then the guide, the
  * CDF over each listed probe's history that its guided updates' rays follow (`PROBE_UNIFORM_PERIOD`);
- * then trace, a ray a thread, each with its hit and the suns' shadow rays from there.
+ * then trace, a ray a thread, each with its hit and the suns' shadow rays from there; shade, the local
+ * lights, and the bounce from two clipmaps, the second where the first has no probe (§8.7).
  *
- * Retire, admit, due and the update run through commands written on the device, want over the screen's
+ * Retire, admit, due and the update run through commands written on the device, the screen's wants over its
  * tiles: nothing is sized by the capacity.
  *
- * **Capacity** starts at `2·N²·C` slots, rounded up to a power of two: a visible surface crosses each
- * cascade as a shell a cell thick, doubled for the cage. An admission the free list could not serve is
+ * **Capacity** starts at what its maker gives, a power of two. An admission the free list could not serve is
  * counted on the device and read back, and the next frame doubles the capacity (§7.10's pattern). Nothing
  * shrinks.
  */
@@ -195,12 +214,30 @@ export class GPUProbeClipmap {
      */
     depth_resolution;
 
+    /**
+     * Whether a radiance tile has a skirt of a texel, which a reader's bilinear tap needs; a clipmap whose
+     * radiance is only loaded texel by texel, never sampled, has none.
+     * @type {boolean}
+     * @readonly
+     */
+    radiance_skirt;
+
+    /**
+     * What its GPU objects' labels begin with.
+     * @type {string}
+     * @readonly
+     */
+    label;
+
     /** @type {GPUDevice} */
     #device;
 
     /** @type {ClipmapCascadePlacement} */
     #placement;
 
+    /** The frame {@link place} or {@link place_within} last placed the windows in, of {@link graph_update}'s count. */
+    #placed_frame = -1;
+
     /** @type {GPUTexture} */
     #indirection;
 
@@ -261,8 +298,21 @@ export class GPUProbeClipmap {
      */
     #resamples = null;
 
-    /** Whether the frame's updates re-sample their neighbours, and the switches accumulate is recorded with. */
-    #resampling = false;
+    /**
+     * Each listed probe's candidate, the place in the list of the neighbour whose rays it re-samples and their weight,
+     * as many as the trace list holds. @type {GPUBuffer|null}
+     */
+    #candidates = null;
+
+    /** A word a slot: its place in the frame's trace list, as relocation writes it. @type {GPUBuffer|null} */
+    #listed = null;
+
+    /**
+     * Whether the frame's updates re-sample their neighbours' histories, and their rays, and the switches accumulate
+     * is recorded with.
+     */
+    #history_resampling = false;
+    #ray_resampling = false;
     #accumulate_switches = ShaderSwitchSet.EMPTY;
 
     /** The listed probes' projected rows, n_r a probe, as many as the trace list holds. @type {GPUBuffer|null} */
@@ -311,6 +361,9 @@ export class GPUProbeClipmap {
     /** Lattice points over every cascade. */
     #key_count = 0;
 
+    /** Points the wanted list holds: the fewer of the keys and what the wants can want, as it last grew. */
+    #wanted_capacity = 0;
+
     /** Whether the next frame is the first, which fills the indirection and the free list. */
     #fill_pending = true;
 
@@ -338,37 +391,48 @@ export class GPUProbeClipmap {
     #levels_f32 = new Float32Array(this.#levels_data);
 
     #retire_settings = { capacity: 0, resolution: 0, frame: 0 };
-    #want_settings = { cascade_count: 0, resolution: 0, frame: 0, key_count: 0 };
-    #want_hits_settings = { cascade_count: 0, resolution: 0, key_count: 0 };
-    #admit_command_settings = { key_count: 0 };
-    #admit_settings = { capacity: 0, resolution: 0, key_count: 0, frame: 0 };
-    #schedule_settings = { capacity: 0, key_count: 0, trace_capacity: 0, slack: 0 };
+    #want_settings = { cascade_count: 0, resolution: 0, frame: 0, wanted_capacity: 0 };
+    #admit_command_settings = { wanted_capacity: 0 };
+    #admit_settings = { capacity: 0, resolution: 0, wanted_capacity: 0, frame: 0 };
+    #schedule_settings = { capacity: 0, wanted_capacity: 0, trace_capacity: 0, slack: 0 };
     #due_settings = { capacity: 0, trace_capacity: 0, frame: 0, new_only: 0 };
-    #trace_command_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0 };
+    #trace_command_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_skirt: 0 };
     #order_settings = { trace_capacity: 0, resolution: 0, axis_bits: 0 };
-    #ray_counts_settings = { trace_capacity: 0, rays_per_probe: 0, rays_min: 0, radiance_resolution: 0, uniform_period: PROBE_UNIFORM_PERIOD };
+    #ray_counts_settings = { trace_capacity: 0, rays_per_probe: 0, rays_min: 0, rays_dead: 0, radiance_resolution: 0, uniform_period: PROBE_UNIFORM_PERIOD };
     #ray_layout_settings = { trace_capacity: 0, ray_budget: 0 };
     #relocate_settings = { trace_capacity: 0, brick_cascade_count: 0 };
-    #guide_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, radiance_tiles_per_row: 0 };
+    #guide_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, radiance_tiles_per_row: 0, radiance_skirt: 0 };
     #trace_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, brick_cascade_count: 0, t_max: 0, uniform_period: PROBE_UNIFORM_PERIOD };
-    #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0, frame: 0, response_frames: 0, uniform_period: PROBE_UNIFORM_PERIOD };
-    #project_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, uniform_period: PROBE_UNIFORM_PERIOD, rays_min: 0, rays_max: 0, response_frames: 0 };
-    #publish_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0 };
+    #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, radiance_skirt: 0, depth_tiles_per_row: 0, uniform_period: PROBE_UNIFORM_PERIOD };
+    #project_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, uniform_period: PROBE_UNIFORM_PERIOD, rays_min: 0, rays_max: 0 };
+    #publish_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, radiance_skirt: 0, depth_tiles_per_row: 0 };
     #resample_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, response_frames: 0 };
+    #candidate_settings = { trace_capacity: 0 };
+    #resample_rays_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, rays_per_probe: 0, uniform_period: PROBE_UNIFORM_PERIOD };
     #push_settings = { first: 0, count: 0, counter: PROBE_COUNTER_FREE };
 
     #bindings = {};
 
+    /** What a want binds of this clipmap: its levels, wanted list and bits, and its want settings. */
+    #want_bindings = {};
+
+    /** The bounce's sets as their clipmaps hold them, under the bounce pass's names. */
+    #set_bindings = {};
+
     /** The ray counts' scan's, which names its buffers its own way. */
     #ray_scan_bindings = { scan_in: null, scan_out: null, spine: null, command: null };
 
-    #lifetime_data = { counters: -1, depth: -1, normal: -1, stbn: -1 };
+    #lifetime_data = { counters: -1, stbn: -1, want_depth: -1, want_normal: -1 };
 
     #update_data = { counters: -1, bricks: -1, world_cluster_lookup: -1, world_cluster_data: -1 };
 
-    /** The coarsest brick window's box, metres, which the world light clusters cull lights against. */
-    #clusters_min = [0, 0, 0];
-    #clusters_max = [0, 0, 0];
+    /** The frame's wants. @type {ProbeClipmapWants|null} */
+    #wants = null;
+
+    /** The clipmaps the frame's hits take their bounce from, the second where the first has no probe. @type {GPUProbeClipmap|null} */
+    #bounce_first = null;
+    /** @type {GPUProbeClipmap|null} */
+    #bounce_fallback = null;
 
     /** The frame's brick clipmap, which the update's rays read. @type {import("../brick/GPUBrickClipmap.js").GPUBrickClipmap|null} */
     #brick_clipmap = null;
@@ -383,37 +447,50 @@ export class GPUProbeClipmap {
     /** The frame's row → card set table. @type {GPUBuffer|null} */
     #card_rows = null;
 
-    /** The frame's: the want's launch and what it reads. */
-    #want_groups = [0, 0];
-
-    /** @type {GPUBuffer|null} */
-    #camera = null;
-
     /**
      * @param {GPUDevice} device
      * @param {object} options
-     * @param {number} options.cascade_count
-     * @param {number} options.resolution one of {@link PROBE_CLIPMAP_CASCADE_RESOLUTIONS}
+     * @param {number} options.cascade_count at most the levels table holds, {@link CLIPMAP_LEVEL_LIMIT}, and
+     *        the record's cascade field, {@link PROBE_RECORD_CASCADE_SHIFT}
+     * @param {number} options.resolution a power of two, at most 1024: the order's Morton code takes 10 bits
+     *        an axis; the indirection's height, resolution · cascade_count, at most the device's
+     *        `maxTextureDimension3D`
      * @param {number} options.spacing metres
-     * @param {number} options.radiance_resolution a power of two
+     * @param {number} options.radiance_resolution a power of two from 2, which the update's bit-reversed
+     *        walk of the texels needs
      * @param {number} options.depth_resolution a power of two
+     * @param {boolean} options.radiance_skirt whether a radiance tile has a skirt for a reader's bilinear tap
+     *   (`chunk_probe_clipmap_sample_radiance`): a clipmap whose radiance nothing samples has none
+     * @param {string} options.label what its GPU objects' labels begin with
+     * @param {number} options.capacity the slots it starts with, a power of two: a start, which admissions the
+     *   free list cannot serve grow
      */
-    constructor(device, { cascade_count, resolution, spacing, radiance_resolution, depth_resolution }) {
+    constructor(device, { cascade_count, resolution, spacing, radiance_resolution, depth_resolution, radiance_skirt, label, capacity }) {
         assert.isPositiveInteger(cascade_count, 'cascade_count');
-        assert.lessThanOrEqual(cascade_count, PROBE_CLIPMAP_CASCADE_COUNT_MAX, 'cascade_count');
-        assert.isOneOf(resolution, PROBE_CLIPMAP_CASCADE_RESOLUTIONS, 'resolution');
+        assert.lessThanOrEqual(cascade_count, CLIPMAP_LEVEL_LIMIT, "cascade_count, the levels table's length");
+        assert.lessThanOrEqual(cascade_count, 2 ** (32 - PROBE_RECORD_CASCADE_SHIFT), "cascade_count, the record's cascade field");
+        assert.isPositiveInteger(resolution, 'resolution');
+        assert.lessThanOrEqual(ceil_log2(resolution), 10, "resolution, the order's Morton code's 10 bits an axis");
+        // the order's key: the cascade above the Morton code of a lattice point in its window
+        assert.lessThanOrEqual(3 * ceil_log2(resolution) + ceil_log2(cascade_count), 32, 'the order key fits a word');
+        assert.lessThanOrEqual(resolution * cascade_count, device.limits.maxTextureDimension3D, "resolution · cascade_count, the indirection's height, past maxTextureDimension3D");
         assert.isFinite(spacing, 'spacing');
         assert.greaterThan(spacing, 0, 'spacing');
-        assert.greaterThanOrEqual(radiance_resolution, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN, 'radiance_resolution');
-        assert.lessThanOrEqual(radiance_resolution, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX, 'radiance_resolution');
-        assert.greaterThanOrEqual(depth_resolution, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN, 'depth_resolution');
-        assert.lessThanOrEqual(depth_resolution, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX, 'depth_resolution');
+        assert.isPositiveInteger(radiance_resolution, 'radiance_resolution');
+        assert.greaterThanOrEqual(radiance_resolution, 2, 'radiance_resolution');
+        assert.isPositiveInteger(depth_resolution, 'depth_resolution');
+        assert.isBoolean(radiance_skirt, 'radiance_skirt');
+        assert.isString(label, 'label');
+        assert.isPositiveInteger(capacity, 'capacity');
+        assert.equal(ceilPowerOfTwo(capacity), capacity, 'capacity must be a power of two');
 
         this.cascade_count = cascade_count;
         this.resolution = resolution;
         this.spacing = spacing;
         this.radiance_resolution = radiance_resolution;
         this.depth_resolution = depth_resolution;
+        this.radiance_skirt = radiance_skirt;
+        this.label = label;
 
         this.#device = device;
 
@@ -427,7 +504,7 @@ export class GPUProbeClipmap {
         });
 
         this.#indirection = device.createTexture({
-            label: 'Probe clipmap / probe indirection',
+            label: `${label} / probe indirection`,
             size: [resolution, resolution, resolution * cascade_count],
             dimension: '3d',
             format: 'r32uint',
@@ -436,17 +513,16 @@ export class GPUProbeClipmap {
 
         this.#indirection_view = this.#indirection.createView();
 
-        // a power of two at least 2·N²·C
-        const capacity = this.#capacity = 2 ** Math.ceil(Math.log2(2 * resolution * resolution * cascade_count));
+        this.#capacity = capacity;
         const keys = this.#key_count = resolution ** 3 * cascade_count;
 
         this.#radiance = new GPUTileAtlas2D({
             device,
             formats: ['rgba16float'],
-            tile_size: [radiance_resolution + 2, radiance_resolution + 2],
+            tile_size: [radiance_resolution + 2 * this.#radiance_skirt_texels(), radiance_resolution + 2 * this.#radiance_skirt_texels()],
             // sampled by the readers and the accumulation's history, stored into by publish
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
-            label: 'Probe clipmap / probe radiance',
+            label: `${label} / probe radiance`,
             capacity,
         });
 
@@ -455,7 +531,7 @@ export class GPUProbeClipmap {
             formats: ['rg16float'],
             tile_size: [depth_resolution + 2, depth_resolution + 2],
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
-            label: 'Probe clipmap / probe depth',
+            label: `${label} / probe depth`,
             capacity,
         });
 
@@ -465,11 +541,12 @@ export class GPUProbeClipmap {
         this.#requests = this.#create_buffer('probe requests', PROBE_REQUEST_STRUCT.size * capacity, GPUBufferUsage.COPY_SRC);
         this.#records = this.#create_buffer('probe records', PROBE_RECORD_STRUCT.size * capacity, GPUBufferUsage.COPY_SRC);
         this.#free = this.#create_buffer('probe free list', 4 * capacity, GPUBufferUsage.COPY_SRC);
+        // anything: only the trace list confirms an entry
+        this.#listed = this.#create_buffer('probe listed', 4 * capacity, GPUBufferUsage.COPY_SRC);
         this.#active.push(
             this.#create_buffer('probe active 0', LIST_HEADER_BYTES + 4 * capacity, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST),
             this.#create_buffer('probe active 1', LIST_HEADER_BYTES + 4 * capacity, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST),
         );
-        this.#wanted = this.#create_buffer('probe wanted', LIST_HEADER_BYTES + 4 * keys, GPUBufferUsage.COPY_DST);
         this.#wanted_bits = this.#create_buffer('probe wanted bits', 4 * Math.ceil(keys / 32), GPUBufferUsage.COPY_DST);
         this.#counters = this.#create_buffer('probe counters', 4 * PROBE_COUNTER_WORDS, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
         // zero: the first frame's retire dispatches nothing
@@ -485,13 +562,13 @@ export class GPUProbeClipmap {
         device.queue.writeBuffer(this.#counters, 0, counters);
 
         this.#levels = device.createBuffer(BufferDescriptor.fromJSON({
-            label: 'Probe clipmap / probe levels',
+            label: `${label} / probe levels`,
             size: CLIPMAP_LEVEL_ARRAY.size,
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         }));
 
         this.#sampling = device.createBuffer(BufferDescriptor.fromJSON({
-            label: 'Probe clipmap / probe sampling',
+            label: `${label} / probe sampling`,
             size: PROBE_SAMPLING_STRUCT.size,
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         }));
@@ -525,6 +602,41 @@ export class GPUProbeClipmap {
         return this.#indirection;
     }
 
+    /**
+     * The last update's probes, in its order: the list the rays name their probe by. With {@link origins},
+     * {@link rays} and {@link dispatch}, what another clipmap's hits' wants read (`ProbeClipmapHitWants`),
+     * before this clipmap's next lifetime writes them over.
+     * @returns {GPUBuffer}
+     */
+    get trace() {
+        return this.#trace;
+    }
+
+    /**
+     * Where relocation left each of the last update's probes, `vec4<f32>(origin, spacing)`.
+     * @returns {GPUBuffer}
+     */
+    get origins() {
+        return this.#origins;
+    }
+
+    /**
+     * The last update's rays, `PROBE_RAY_STRUCT`.
+     * @returns {GPUBuffer}
+     */
+    get rays() {
+        return this.#rays;
+    }
+
+
+    /**
+     * The indirect commands, `PROBE_DISPATCH_RAYS` the last update's rays' launch among them.
+     * @returns {GPUBuffer}
+     */
+    get dispatch() {
+        return this.#dispatch;
+    }
+
     /**
      * The cascades' cage windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first, as placed by
      * the last {@link graph_update}: a cell is a cage of eight lattice points, so a window is one cell
@@ -546,10 +658,10 @@ export class GPUProbeClipmap {
     /**
      * @param {number} cascade
      * @param {number} axis
-     * @returns {number} the cascade's lattice window's least point on the axis, in its spacing
+     * @returns {number} the cascade's lattice window's least point on the axis, in its spacing, as last placed
      */
     corner(cascade, axis) {
-        return this.#placement.corner(cascade, axis);
+        return this.#levels_i32[((cascade * CLIPMAP_LEVEL_STRUCT.aligned_size) >>> 2) + axis];
     }
 
     /**
@@ -557,7 +669,7 @@ export class GPUProbeClipmap {
      * @returns {number} metres between the cascade's probes
      */
     cell_size(cascade) {
-        return this.#placement.cell_size(cascade);
+        return this.spacing * 2 ** cascade;
     }
 
     /**
@@ -573,21 +685,87 @@ export class GPUProbeClipmap {
     }
 
     /**
-     * Record the frame's lifetime (§8.3): place the windows around the anchor, retire, want from the
-     * G-buffer, admit and schedule; then, once the bricks are built, its updates: relocate, trace and
-     * shade the listed probes' rays (§8.4–§8.7). Allocates nothing per frame.
+     * Place the windows around the anchor, coarsest first, each a parent cell inside its parent, for the
+     * frame's {@link graph_update}.
+     *
+     * @param {number} x the anchor, world metres
+     * @param {number} y
+     * @param {number} z
+     */
+    place(x, y, z) {
+        assert.isFinite(x, 'x');
+        assert.isFinite(y, 'y');
+        assert.isFinite(z, 'z');
+
+        const placement = this.#placement;
+        const n = this.resolution;
+
+        placement.begin();
+
+        for (let c = this.cascade_count - 1; c >= 0; c--) {
+            placement.place(c, x, y, z);
+        }
+
+        for (let c = 0; c < this.cascade_count; c++) {
+            const level = (c * CLIPMAP_LEVEL_STRUCT.aligned_size) >>> 2;
+
+            for (let axis = 0; axis < 3; axis++) {
+                this.#levels_i32[level + axis] = placement.corner(c, axis);
+                // the cages: a cell between two lattice points
+                this.#levels_i32[level + 4 + axis] = n - 1;
+            }
+
+            this.#levels_f32[level + 3] = placement.cell_size(c);
+        }
+
+        this.#placed_frame = this.#frame;
+    }
+
+    /**
+     * Take another clipmap's windows, as {@link place} last placed them, at 2^k this clipmap's lattice
+     * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.2): the same cascades, each the other's window and spacing over
+     * 2^k, its corner 2^k the other's, so every point of the other's lattice is one of this clipmap's and the
+     * two scroll together. k is the ratio of the resolutions, a power of two from 2.
+     *
+     * @param {GPUProbeClipmap} clipmap placed this frame
+     */
+    place_within(clipmap) {
+        assert.defined(clipmap, 'clipmap');
+        assert.equal(clipmap.cascade_count, this.cascade_count, 'cascade_count, the other clipmap\'s');
+
+        const ratio = this.resolution / clipmap.resolution;
+        const shift = Math.log2(ratio);
+
+        assert.isPositiveInteger(shift, 'resolution, the other clipmap\'s times a power of two from 2');
+        assert.equal(this.spacing * ratio, clipmap.spacing, 'spacing, the other clipmap\'s over the ratio of the resolutions');
+
+        const n = clipmap.resolution;
+
+        for (let c = 0; c < this.cascade_count; c++) {
+            const level = (c * CLIPMAP_LEVEL_STRUCT.aligned_size) >>> 2;
+
+            for (let axis = 0; axis < 3; axis++) {
+                this.#levels_i32[level + axis] = clipmap.corner(c, axis) * ratio;
+                // the other's cages, each 2^k of this clipmap's cells across
+                this.#levels_i32[level + 4 + axis] = (n - 1) * ratio;
+            }
+
+            this.#levels_f32[level + 3] = this.cell_size(c);
+        }
+
+        this.#placed_frame = this.#frame;
+    }
+
+    /**
+     * Record the frame's lifetime in the windows {@link place} or {@link place_within} placed this frame
+     * (§8.3): retire, the wants, admit and schedule; then, once the bricks are built, its updates: relocate,
+     * trace, shade, light and bounce the listed probes' rays (§8.4–§8.7). Allocates nothing per frame.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
-     * @param {number} options.x the anchor, world metres
-     * @param {number} options.y
-     * @param {number} options.z
-     * @param {number} options.depth graph handle of the frame's depth
-     * @param {number} options.normal graph handle of the G-buffer's normals
-     * @param {GPUBuffer} options.camera the view's camera uniform
+     * @param {ProbeClipmapWants} options.wants who wants the frame's probes
      * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
-     * @param {ArrayLike<number>} options.resolution the frame's pixels, x and y
-     * @param {number} options.response_frames frames of the blend's response, τ (§8.8)
+     * @param {number} options.response_frames frames over which a re-sampled neighbour's history goes stale, τ
      * @param {number} options.ray_budget rays a frame
      * @param {number} options.rays_per_probe rays an update, R: the frame updates ⌊ray_budget / R⌋ probes at most
      * @param {import("../brick/GPUBrickClipmap.js").GPUBrickClipmap} options.brick_clipmap the world the
@@ -597,12 +775,18 @@ export class GPUProbeClipmap {
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
      *   light and shade: its lights, its environment, its rows and their geometry caches' cards
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
-     * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
-     *   seen to its rays (`shader_probe_clipmap_resample`)
+     * @param {boolean} options.history_resampling whether each update re-samples its neighbours' histories, adding
+     *   what they have seen to its rays (`shader_probe_clipmap_resample`); never where the radiance has no skirt
+     * @param {boolean} options.ray_resampling whether each update re-samples one neighbour's rays of the frame,
+     *   adding them to its own (`shader_probe_clipmap_candidate`, `shader_probe_clipmap_resample_rays`)
+     * @param {{lookup: number, data: number}} options.clusters graph handles of the world light clusters over the
+     *   bricks' cascades, which the hits' local lights come from
+     * @param {GPUProbeClipmap} options.bounce_first the clipmap a hit takes its next bounce from first
+     * @param {GPUProbeClipmap} options.bounce_fallback the clipmap it takes it from where the first has no probe
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, resampling }) {
+    graph_update({ graph, wants, stbn, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback }) {
         assert.defined(graph, 'graph');
-        assert.defined(camera, 'camera');
+        assert.defined(wants, 'wants');
         assert.defined(stbn, 'stbn');
         assert.isFinite(response_frames, 'response_frames');
         assert.greaterThan(response_frames, 0, 'response_frames');
@@ -612,7 +796,14 @@ export class GPUProbeClipmap {
         assert.isNonNegativeInteger(bricks, 'bricks');
         assert.defined(scene, 'scene');
         assert.defined(card_rows, 'card_rows');
-        assert.isBoolean(resampling, 'resampling');
+        assert.isBoolean(history_resampling, 'history_resampling');
+        assert.ok(!history_resampling || this.radiance_skirt, 'history_resampling taps the neighbours\' radiance, which a clipmap without a skirt cannot');
+        assert.isBoolean(ray_resampling, 'ray_resampling');
+        assert.isNonNegativeInteger(clusters.lookup, 'clusters.lookup');
+        assert.isNonNegativeInteger(clusters.data, 'clusters.data');
+        assert.defined(bounce_first, 'bounce_first');
+        assert.defined(bounce_fallback, 'bounce_fallback');
+        assert.equal(this.#placed_frame, this.#frame, 'windows placed this frame: place() or place_within() first');
         assert.notOk(this.#destroyed, 'destroyed');
 
         if (this.#grow_pending) {
@@ -622,16 +813,15 @@ export class GPUProbeClipmap {
 
         const trace_capacity = Math.floor(ray_budget / rays_per_probe);
         const texels = this.radiance_resolution * this.radiance_resolution;
-        const rays_min = PROBE_RAYS_PER_TEXEL_MIN * texels;
+        const rays_min = Math.min(PROBE_RAYS_PER_TEXEL_MIN * texels, rays_per_probe);
+        const rays_dead = Math.min(PROBE_DEAD_RAYS, rays_per_probe);
         const rays_max = PROBE_RAYS_PER_TEXEL_MAX * texels;
 
         this.#ensure_trace(trace_capacity);
         // the requests share what the counts leave of the budget, so the frame's rays are at most it
         this.#ensure_rays(ray_budget);
 
-        this.#place(x, y, z);
-
-        this.#device.queue.writeBuffer(this.#levels, 0, this.#levels_data);
+        this.#device.queue.writeBuffer(this.#levels, 0, this.#levels_data, 0, this.cascade_count * CLIPMAP_LEVEL_STRUCT.aligned_size);
 
         // the readers' view of the clipmap: its shape, and the depth and radiance atlases', which grow by rows
         const depth_texture = this.#depth.texture_at(0);
@@ -660,24 +850,20 @@ export class GPUProbeClipmap {
         this.#want_settings.cascade_count = this.cascade_count;
         this.#want_settings.resolution = this.resolution;
         this.#want_settings.frame = this.#frame;
-        this.#want_settings.key_count = this.#key_count;
+        this.#ensure_wanted(Math.min(this.#key_count, wants.wanted_bound()));
 
-        // the hits' wants read the last frame's rays, each naming its probe
-        const want_hits = this.#want_hits_settings;
+        this.#want_settings.wanted_capacity = this.#wanted_capacity;
 
-        want_hits.cascade_count = this.cascade_count;
-        want_hits.resolution = this.resolution;
-        want_hits.key_count = this.#key_count;
 
-        this.#admit_command_settings.key_count = this.#key_count;
+        this.#admit_command_settings.wanted_capacity = this.#wanted_capacity;
 
         this.#admit_settings.capacity = this.#capacity;
         this.#admit_settings.resolution = this.resolution;
-        this.#admit_settings.key_count = this.#key_count;
+        this.#admit_settings.wanted_capacity = this.#wanted_capacity;
         this.#admit_settings.frame = this.#frame;
 
         this.#schedule_settings.capacity = this.#capacity;
-        this.#schedule_settings.key_count = this.#key_count;
+        this.#schedule_settings.wanted_capacity = this.#wanted_capacity;
         this.#schedule_settings.trace_capacity = trace_capacity;
         this.#schedule_settings.slack = Math.ceil(this.#capacity * PROBE_FREE_SLACK);
 
@@ -688,19 +874,18 @@ export class GPUProbeClipmap {
         this.#trace_command_settings.trace_capacity = trace_capacity;
         this.#trace_command_settings.radiance_resolution = this.radiance_resolution;
         this.#trace_command_settings.depth_resolution = this.depth_resolution;
+        this.#trace_command_settings.radiance_skirt = this.#radiance_skirt_texels();
 
         const order = this.#order_settings;
 
         order.trace_capacity = trace_capacity;
         order.resolution = this.resolution;
-        order.axis_bits = Math.ceil(Math.log2(this.resolution));
-
-        // the order's key: the cascade above the Morton code of a lattice point in its window
-        assert.lessThanOrEqual(3 * order.axis_bits + Math.ceil(Math.log2(this.cascade_count)), 32, 'the order key fits a word');
+        order.axis_bits = ceil_log2(this.resolution);
 
         this.#ray_counts_settings.trace_capacity = trace_capacity;
         this.#ray_counts_settings.rays_per_probe = rays_per_probe;
         this.#ray_counts_settings.rays_min = rays_min;
+        this.#ray_counts_settings.rays_dead = rays_dead;
         this.#ray_counts_settings.radiance_resolution = this.radiance_resolution;
 
         this.#ray_layout_settings.trace_capacity = trace_capacity;
@@ -712,6 +897,7 @@ export class GPUProbeClipmap {
         guide.rays_per_probe = rays_per_probe;
         guide.radiance_resolution = this.radiance_resolution;
         guide.radiance_tiles_per_row = this.#radiance.tiles_per_row;
+        guide.radiance_skirt = this.#radiance_skirt_texels();
 
         // past the coarsest window's far corner every ray has left the clipmap
         const coarsest = brick_clipmap.cascade_count - 1;
@@ -732,9 +918,8 @@ export class GPUProbeClipmap {
         accumulate.radiance_resolution = this.radiance_resolution;
         accumulate.depth_resolution = this.depth_resolution;
         accumulate.radiance_tiles_per_row = this.#radiance.tiles_per_row;
+        accumulate.radiance_skirt = this.#radiance_skirt_texels();
         accumulate.depth_tiles_per_row = this.#depth.tiles_per_row;
-        accumulate.frame = this.#frame;
-        accumulate.response_frames = response_frames;
 
         this.#project_settings.trace_capacity = trace_capacity;
         this.#project_settings.rays_per_probe = rays_per_probe;
@@ -743,7 +928,6 @@ export class GPUProbeClipmap {
         this.#project_settings.frame = this.#frame;
         this.#project_settings.rays_min = rays_min;
         this.#project_settings.rays_max = rays_max;
-        this.#project_settings.response_frames = response_frames;
 
         const resample = this.#resample_settings;
 
@@ -753,8 +937,18 @@ export class GPUProbeClipmap {
         resample.frame = this.#frame;
         resample.response_frames = response_frames;
 
-        this.#resampling = resampling;
-        this.#accumulate_switches = ShaderSwitchSet.EMPTY.with(PROBE_CLIPMAP_RESAMPLING, resampling);
+        this.#candidate_settings.trace_capacity = trace_capacity;
+
+        const resample_rays = this.#resample_rays_settings;
+
+        resample_rays.trace_capacity = trace_capacity;
+        resample_rays.radiance_resolution = this.radiance_resolution;
+        resample_rays.depth_resolution = this.depth_resolution;
+        resample_rays.rays_per_probe = rays_per_probe;
+
+        this.#history_resampling = history_resampling;
+        this.#ray_resampling = ray_resampling;
+        this.#accumulate_switches = ShaderSwitchSet.EMPTY.with(PROBE_CLIPMAP_RESAMPLING, history_resampling || ray_resampling);
 
         const publish = this.#publish_settings;
 
@@ -762,53 +956,30 @@ export class GPUProbeClipmap {
         publish.radiance_resolution = this.radiance_resolution;
         publish.depth_resolution = this.depth_resolution;
         publish.radiance_tiles_per_row = this.#radiance.tiles_per_row;
+        publish.radiance_skirt = this.#radiance_skirt_texels();
         publish.depth_tiles_per_row = this.#depth.tiles_per_row;
 
         this.#brick_clipmap = brick_clipmap;
         this.#scene = scene;
         this.#card_rows = card_rows;
 
-        const tiles_x = Math.ceil(resolution[0] / PROBE_WANT_TILE);
-        const tiles_y = Math.ceil(resolution[1] / PROBE_WANT_TILE);
-
-        this.#want_groups[0] = Math.ceil(tiles_x / PROBE_WANT_WORKGROUP_TILES);
-        this.#want_groups[1] = Math.ceil(tiles_y / PROBE_WANT_WORKGROUP_TILES);
-
-        this.#camera = camera;
+        this.#wants = wants;
+        this.#bounce_first = bounce_first;
+        this.#bounce_fallback = bounce_fallback;
 
         const data = this.#lifetime_data;
-        const pass = graph.add("Probe Clipmap Lifetime", data, this.#execute_lifetime);
+        const pass = graph.add(`${this.label} Lifetime`, data, this.#execute_lifetime);
 
-        data.counters = pass.write(graph_import_buffer(graph, this.#counters, "probe_counters"));
-        data.depth = pass.read(depth);
-        data.normal = pass.read(normal);
+        data.counters = pass.write(graph_import_buffer(graph, this.#counters, `${this.label} counters`));
         data.stbn = stbn;
 
-        pass.make_side_effect();
-
-        // the local lights the rays' hits take, clustered over the bricks' cascades, where every hit is (§8.7)
-        const coarsest_cell = brick_clipmap.cell_size(coarsest);
-
-        for (let axis = 0; axis < 3; axis++) {
-            const corner = brick_clipmap.corner(coarsest, axis);
-
-            this.#clusters_min[axis] = corner * coarsest_cell;
-            this.#clusters_max[axis] = (corner + brick_clipmap.resolution) * coarsest_cell;
-        }
+        wants.graph_declare(pass, data);
 
-        const clusters = graph_build_world_light_clusters({
-            graph,
-            lights: scene.lights,
-            levels: graph_import_buffer(graph, brick_clipmap.levels, "probe_brick_levels"),
-            cascade_count: brick_clipmap.cascade_count,
-            border: 0,
-            coarsest_min: this.#clusters_min,
-            coarsest_max: this.#clusters_max,
-        });
+        pass.make_side_effect();
 
         // the frame's updates, once its bricks are built
         const update_data = this.#update_data;
-        const update = graph.add("Probe Clipmap Update", update_data, this.#execute_update);
+        const update = graph.add(`${this.label} Update`, update_data, this.#execute_update);
 
         update_data.counters = update.write(data.counters);
         update_data.bricks = update.read(bricks);
@@ -839,29 +1010,10 @@ export class GPUProbeClipmap {
     }
 
     /**
-     * Place every window, coarsest first, and write the cage windows the readers take.
+     * @returns {number} texels of skirt on each side of a radiance tile's map
      */
-    #place(x, y, z) {
-        const placement = this.#placement;
-        const n = this.resolution;
-
-        placement.begin();
-
-        for (let c = this.cascade_count - 1; c >= 0; c--) {
-            placement.place(c, x, y, z);
-        }
-
-        for (let c = 0; c < this.cascade_count; c++) {
-            const level = (c * CLIPMAP_LEVEL_STRUCT.aligned_size) >>> 2;
-
-            for (let axis = 0; axis < 3; axis++) {
-                this.#levels_i32[level + axis] = placement.corner(c, axis);
-                // the cages: a cell between two lattice points
-                this.#levels_i32[level + 4 + axis] = n - 1;
-            }
-
-            this.#levels_f32[level + 3] = placement.cell_size(c);
-        }
+    #radiance_skirt_texels() {
+        return this.radiance_skirt ? 1 : 0;
     }
 
     /**
@@ -884,6 +1036,7 @@ export class GPUProbeClipmap {
         this.#requests = this.#regrow(this.#requests, 'probe requests', PROBE_REQUEST_STRUCT.size * capacity);
         this.#records = this.#regrow(this.#records, 'probe records', PROBE_RECORD_STRUCT.size * capacity);
         this.#free = this.#regrow(this.#free, 'probe free list', 4 * capacity);
+        this.#listed = this.#regrow(this.#listed, 'probe listed', 4 * capacity);
         this.#active[0] = this.#regrow(this.#active[0], 'probe active 0', LIST_HEADER_BYTES + 4 * capacity);
         this.#active[1] = this.#regrow(this.#active[1], 'probe active 1', LIST_HEADER_BYTES + 4 * capacity);
 
@@ -905,6 +1058,7 @@ export class GPUProbeClipmap {
         this.#maps?.destroy();
         this.#guide?.destroy();
         this.#resamples?.destroy();
+        this.#candidates?.destroy();
         this.#projection?.destroy();
         this.#ray_counts?.destroy();
         this.#ray_requests?.destroy();
@@ -927,10 +1081,26 @@ export class GPUProbeClipmap {
         this.#origins = this.#create_buffer('probe origins', 16 * trace_capacity, 0);
         this.#maps = this.#create_buffer('probe maps', 4 * probe_clipmap_maps_words(this.radiance_resolution, this.depth_resolution) * trace_capacity, 0);
         this.#guide = this.#create_buffer('probe guide', 4 * probe_clipmap_guide_words(this.radiance_resolution) * trace_capacity, 0);
-        this.#resamples = this.#create_buffer('probe resamples', 16 * this.radiance_resolution * this.radiance_resolution * trace_capacity, 0);
+        // cleared where the rays add to it without the history pass's stores
+        this.#resamples = this.#create_buffer('probe resamples', 16 * this.radiance_resolution * this.radiance_resolution * trace_capacity, GPUBufferUsage.COPY_DST);
+        this.#candidates = this.#create_buffer('probe candidates', PROBE_CANDIDATE_STRUCT.size * trace_capacity, 0);
         this.#projection = this.#create_buffer('probe projection', PROBE_PROJECTION_ROW_STRUCT.size * this.radiance_resolution * trace_capacity, 0);
     }
 
+    /**
+     * A wanted list of at least `capacity` points: a frame's wants list each point once, at most every key, and
+     * at most what the wants can want (`wanted_bound`), which follows the screen or the other clipmap's rays.
+     */
+    #ensure_wanted(capacity) {
+        if (this.#wanted !== undefined && this.#wanted_capacity >= capacity) {
+            return;
+        }
+
+        this.#wanted?.destroy();
+        this.#wanted_capacity = capacity;
+        this.#wanted = this.#create_buffer('probe wanted', LIST_HEADER_BYTES + 4 * capacity, GPUBufferUsage.COPY_DST);
+    }
+
     /**
      * Room for `ray_count` rays, U·R, which the ray settings size, to the next whole workgroup: the last
      * workgroup's threads past the frame's last ray write a record of no ray.
@@ -992,7 +1162,7 @@ export class GPUProbeClipmap {
         this.#parity = 1 - this.#parity;
 
         // the frame's lists start empty, and no point is wanted yet; the trace list holds the last frame's
-        // updates until the hits' wants have read their rays
+        // updates until the wants have run, as another clipmap's hits' wants recorded before this lifetime read them
         encoder.clearBuffer(active_write, 0, 4);
         encoder.clearBuffer(this.#wanted, 0, 4);
         encoder.clearBuffer(this.#wanted_bits);
@@ -1003,6 +1173,7 @@ export class GPUProbeClipmap {
         b.probe_records = this.#records;
         b.probe_counters = counters;
         b.probe_free = this.#free;
+        b.probe_listed = this.#listed;
         b.probe_active_read = active_read;
         b.probe_active_write = active_write;
         b.probe_wanted = this.#wanted;
@@ -1020,31 +1191,17 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_ACTIVE,
         });
 
-        b.gBufferDepth = resources.get(data.depth);
-        b.gBufferNormals = resources.get(data.normal);
-        b.camera = this.#camera;
         b.tSTBN_vec2 = data.stbn;
-        b.settings = this.#want_settings;
 
-        shader_probe_clipmap_want.dispatch({
-            encoder,
-            group_count_x: this.#want_groups[0],
-            group_count_y: this.#want_groups[1],
-            bindings: b,
-        });
+        // the frame's wants, into the wanted bits and list
+        const want = this.#want_bindings;
 
-        // the last frame's hits want the probes their bounce reads, through the launch their rays had,
-        // before the frame's trace command writes it over
-        b.probe_origins = this.#origins;
-        b.probe_rays = this.#rays;
-        b.settings = this.#want_hits_settings;
+        want.probe_levels = this.#levels;
+        want.probe_wanted = this.#wanted;
+        want.probe_wanted_bits = this.#wanted_bits;
+        want.settings = this.#want_settings;
 
-        shader_probe_clipmap_want_hits.dispatchIndirect({
-            encoder,
-            bindings: b,
-            command: this.#dispatch,
-            command_offset: 4 * PROBE_DISPATCH_RAYS,
-        });
+        this.#wants.encode(encoder, data, resources, want);
 
         encoder.clearBuffer(this.#trace, 0, 4);
 
@@ -1158,6 +1315,7 @@ export class GPUProbeClipmap {
         b.probe_counters = resources.get(data.counters);
         b.probe_origins = this.#origins;
         b.probe_ray_sums = this.#ray_sums;
+        b.probe_listed = this.#listed;
         b.settings = this.#relocate_settings;
 
         shader_probe_clipmap_relocate.dispatchIndirect({
@@ -1215,9 +1373,7 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
-        // the light each hit takes from beyond the trace: one of its cell's local lights through the bricks, and
-        // the next bounce from last frame's probes
-        this.write_sampling_bindings(b);
+        // the light each hit takes from beyond the trace: one of its cell's local lights through the bricks
         b.world_cluster_lookup = resources.get(data.world_cluster_lookup);
         b.world_cluster_data = resources.get(data.world_cluster_data);
         b.settings = this.#trace_settings;
@@ -1229,12 +1385,43 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
+        // and the next bounce, from the first clipmap's probes, or the fallback's where the first has none, as
+        // their clipmaps hold them now
+        const sets = this.#set_bindings;
+
+        this.#bounce_first.write_sampling_bindings(sets);
+        b.bounce_first_levels = sets.probe_levels;
+        b.bounce_first_sampling = sets.probe_sampling;
+        b.bounce_first_indirection = sets.probe_indirection;
+        b.bounce_first_states = sets.probe_states;
+        b.bounce_first_records = sets.probe_records;
+        b.bounce_first_depth = sets.probe_depth;
+
+        this.#bounce_fallback.write_sampling_bindings(sets);
+        b.bounce_fallback_levels = sets.probe_levels;
+        b.bounce_fallback_sampling = sets.probe_sampling;
+        b.bounce_fallback_indirection = sets.probe_indirection;
+        b.bounce_fallback_states = sets.probe_states;
+        b.bounce_fallback_records = sets.probe_records;
+        b.bounce_fallback_depth = sets.probe_depth;
+
+        b.probe_states = this.#states;
+        b.probe_ray_sums = this.#ray_sums;
+
+        shader_probe_clipmap_bounce.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#dispatch,
+            command_offset: 4 * PROBE_DISPATCH_RAYS,
+        });
+
         // what each listed probe's neighbours have already seen, from the atlases and estimators as they were,
         // where the frame re-samples; accumulate's variant without it reads none
+        this.write_sampling_bindings(b);
         b.probe_resamples = this.#resamples;
         b.probe_estimators = this.#estimators;
 
-        if (this.#resampling) {
+        if (this.#history_resampling) {
             b.settings = this.#resample_settings;
 
             shader_probe_clipmap_resample.dispatchIndirect({
@@ -1243,6 +1430,33 @@ export class GPUProbeClipmap {
                 command: this.#dispatch,
                 command_offset: 4 * PROBE_DISPATCH_TEXELS,
             });
+        } else if (this.#ray_resampling) {
+            // the rays add to the re-samples, here to nothing
+            encoder.clearBuffer(this.#resamples);
+        }
+
+        // every ray one neighbour of each listed probe traced this frame, drawn by its radiance and the probe's sight
+        // of it, added in the texels the probe sees their hits in
+        if (this.#ray_resampling) {
+            b.probe_listed = this.#listed;
+            b.probe_candidates = this.#candidates;
+            b.settings = this.#candidate_settings;
+
+            shader_probe_clipmap_candidate.dispatchIndirect({
+                encoder,
+                bindings: b,
+                command: this.#dispatch,
+                command_offset: 4 * PROBE_DISPATCH_TRACED,
+            });
+
+            b.settings = this.#resample_rays_settings;
+
+            shader_probe_clipmap_resample_rays.dispatchIndirect({
+                encoder,
+                bindings: b,
+                command: this.#dispatch,
+                command_offset: 4 * PROBE_DISPATCH_TEXELS,
+            });
         }
 
         // the probes' maps from their rays, against the atlases as they were; their SH and kind from the
@@ -1294,8 +1508,11 @@ export class GPUProbeClipmap {
      * @returns {GPUBuffer}
      */
     #create_buffer(name, size, usage) {
+        // bound whole, as storage
+        assert.lessThanOrEqual(size, this.#device.limits.maxStorageBufferBindingSize, `${name} past maxStorageBufferBindingSize`);
+
         return this.#device.createBuffer(BufferDescriptor.fromJSON({
-            label: `Probe clipmap / ${name}`,
+            label: `${this.label} / ${name}`,
             size,
             usage: GPUBufferUsage.STORAGE | usage,
         }));
@@ -1314,7 +1531,7 @@ export class GPUProbeClipmap {
         const device = this.#device;
         const buffer = this.#create_buffer(name, size, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
 
-        const encoder = device.createCommandEncoder({ label: `Probe clipmap / ${name} growth` });
+        const encoder = device.createCommandEncoder({ label: `${this.label} / ${name} growth` });
 
         encoder.copyBufferToBuffer(old, 0, buffer, 0, old.size);
         device.queue.submit([encoder.finish()]);
@@ -1335,7 +1552,7 @@ export class GPUProbeClipmap {
         this.#radiance.destroy();
         this.#depth.destroy();
 
-        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#resamples, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
+        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#listed, this.#candidates, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#resamples, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
             buffer?.destroy();
         }
     }