@woosh/meep-engine 3.43.0 → 3.45.0

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One BC7 mode 1 block from its partition, four endpoints and sixteen indices, as four
+ * little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 1: two mode bits — a zero and a one — then six bits
+ * of partition, then the colour endpoints by channel, red for both ends of the first subset and then
+ * both ends of the second, then green, then blue, six bits each; one parity bit per *subset*, shared
+ * by its two ends; then the indices, three bits each except the two anchors', texel 0 and the
+ * partition's second anchor, whose top bit is implied zero. Honouring that is the encoder's, by
+ * swapping a subset's ends; this drops the top bit, as the JavaScript writer drops it. Mode 1 has no
+ * alpha: it decodes opaque.
+ *
+ * Endpoints are given as the eight-bit values they decode to — six stored bits, the subset's parity
+ * bit below them, the top bit replicated below that — so the stored bits are read off them. The
+ * parity is read off each subset's first end; the encoder gives both ends the same one.
+ *
+ * Each word is composed by shifts at the fields' fixed positions, except the indices: the second
+ * anchor moves with the partition, so the three-bit fields are laid out as if none were short and
+ * the anchor's top bit is then cut out of the run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode1: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bc7_pack_mode1.d.ts.map

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bc7_pack_mode1.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mCAFU,SAAS,CA2EZ;0BAlGmB,oCAAoC"}

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode1.js

@@ -0,0 +1,99 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_bc7_partition_2 } from "./chunk_bc7_partition_2.js";
+
+/**
+ * One BC7 mode 1 block from its partition, four endpoints and sixteen indices, as four
+ * little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 1: two mode bits — a zero and a one — then six bits
+ * of partition, then the colour endpoints by channel, red for both ends of the first subset and then
+ * both ends of the second, then green, then blue, six bits each; one parity bit per *subset*, shared
+ * by its two ends; then the indices, three bits each except the two anchors', texel 0 and the
+ * partition's second anchor, whose top bit is implied zero. Honouring that is the encoder's, by
+ * swapping a subset's ends; this drops the top bit, as the JavaScript writer drops it. Mode 1 has no
+ * alpha: it decodes opaque.
+ *
+ * Endpoints are given as the eight-bit values they decode to — six stored bits, the subset's parity
+ * bit below them, the top bit replicated below that — so the stored bits are read off them. The
+ * parity is read off each subset's first end; the encoder gives both ends the same one.
+ *
+ * Each word is composed by shifts at the fields' fixed positions, except the indices: the second
+ * anchor moves with the partition, so the three-bit fields are laid out as if none were short and
+ * the anchor's top bit is then cut out of the run.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode1 = CodeChunk.from(
+    //language=WGSL
+    `
+fn bc7_pack_mode1(
+    pattern: u32,
+    a0: vec3<u32>, a1: vec3<u32>,
+    b0: vec3<u32>, b1: vec3<u32>,
+    indices: array<u32, 16>
+) -> vec4<u32> {
+    // the six stored bits of each end's channels, and each subset's parity
+    let sa0 = a0 >> vec3<u32>(2u);
+    let sa1 = a1 >> vec3<u32>(2u);
+    let sb0 = b0 >> vec3<u32>(2u);
+    let sb1 = b1 >> vec3<u32>(2u);
+
+    let parity_a = (a0.x >> 1u) & 1u;
+    let parity_b = (b0.x >> 1u) & 1u;
+
+    // texels 1 to 15 at three bits each, as if no anchor were short: forty-five bits over two words
+    var low = 0u;
+    var high = 0u;
+
+    for (var i = 1u; i < 16u; i++) {
+        let shift = 3u * (i - 1u);
+        let index = indices[i] & 7u;
+
+        if (shift < 32u) {
+            low |= index << shift;
+        }
+
+        // texel 11's field straddles the two words, bits 30 to 32
+        if (shift == 30u) {
+            high |= index >> 2u;
+        }
+
+        if (shift > 32u) {
+            high |= index << (shift - 32u);
+        }
+    }
+
+    // cut the second anchor's top bit out of the run: the bits below it stay, the bits above it
+    // move down by one
+    let cut = 3u * (bc7_partition_2_anchor(pattern) - 1u) + 2u;
+
+    let keep_low = select(0xFFFFFFFFu, (1u << cut) - 1u, cut < 32u);
+    let keep_high = select((1u << (cut - 32u)) - 1u, 0u, cut < 32u);
+
+    let shifted_low = (low >> 1u) | (high << 31u);
+    let shifted_high = high >> 1u;
+
+    let run_low = (low & keep_low) | (shifted_low & ~keep_low);
+    let run_high = (high & keep_high) | (shifted_high & ~keep_high);
+
+    // the forty-six index bits: texel 0's two, then the run
+    let stream_low = (indices[0] & 3u) | (run_low << 2u);
+    let stream_high = (run_low >> 30u) | (run_high << 2u);
+
+    // mode 1 is signalled by a zero bit and then a one, bits 0 and 1; the partition from bit 2,
+    // red from bit 8
+    let w0 = 2u | (pattern << 2u) | (sa0.x << 8u) | (sa1.x << 14u) | (sb0.x << 20u) | (sb1.x << 26u);
+
+    // the first subset's second blue straddles bits 62 to 67
+    let w1 = sa0.y | (sa1.y << 6u) | (sb0.y << 12u) | (sb1.y << 18u) | (sa0.z << 24u) | (sa1.z << 30u);
+
+    // the parity bits at 80 and 81, the indices from 82
+    let w2 = (sa1.z >> 2u) | (sb0.z << 4u) | (sb1.z << 10u) | (parity_a << 16u) | (parity_b << 17u) | (stream_low << 18u);
+
+    let w3 = (stream_low >> 14u) | (stream_high << 18u);
+
+    return vec4<u32>(w0, w1, w2, w3);
+}
+`, [
+        chunk_bc7_partition_2,
+    ]);

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.d.ts

@@ -6,14 +6,16 @@
  * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
  * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
  * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
- * check it.
+ * check it: the top bit is dropped, as the JavaScript writer drops it.
  *
  * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
  * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
  * a pair that disagrees with itself.
  *
- * Bit by bit, as the JavaScript writer is, because the fields straddle word boundaries and a
- * hundred and twenty-eight iterations are nothing.
+ * Each word is composed by shifts at the fields' fixed positions, the two that straddle a word
+ * boundary — the second end's green, bits 28 to 34, and the second parity bit, bit 64 — split
+ * across them. The JavaScript writer goes bit by bit; here a hundred and twenty-eight iterations
+ * over two function-local arrays were 13% of a 4096² encode on a 4090.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bc7_pack_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAFU,SAAS,CAmDhB;0BAtEuB,oCAAoC"}
+{"version":3,"file":"chunk_bc7_pack_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mCAFU,SAAS,CAyBhB;0BA9CuB,oCAAoC"}

package/src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js

@@ -1,71 +1,47 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * One BC7 mode 6 block from its two endpoints and sixteen indices, as four little-endian words.
- *
- * The layout `bc7_write_block` states for mode 6, in the same order for every field: seven mode
- * bits — six zeros and a one — then the colour endpoints by channel, red for both ends, then green,
- * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
- * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
- * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
- * check it.
- *
- * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
- * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
- * a pair that disagrees with itself.
- *
- * Bit by bit, as the JavaScript writer is, because the fields straddle word boundaries and a
- * hundred and twenty-eight iterations are nothing.
- *
- * @type {CodeChunk}
- */
-export const chunk_bc7_pack_mode6 = CodeChunk.from(
-    //language=WGSL
-    `
-fn bc7_pack_mode6(e0: vec4<u32>, e1: vec4<u32>, indices: array<u32, 16>) -> vec4<u32> {
-    var values: array<u32, 27>;
-    var counts: array<u32, 27>;
-
-    // mode 6 is signalled by six zero bits and then a one
-    values[0] = 64u;
-    counts[0] = 7u;
-
-    for (var channel = 0u; channel < 4u; channel++) {
-        values[1u + channel * 2u] = e0[channel] >> 1u;
-        values[2u + channel * 2u] = e1[channel] >> 1u;
-        counts[1u + channel * 2u] = 7u;
-        counts[2u + channel * 2u] = 7u;
-    }
-
-    values[9] = e0.x & 1u;
-    values[10] = e1.x & 1u;
-    counts[9] = 1u;
-    counts[10] = 1u;
-
-    for (var texel = 0u; texel < 16u; texel++) {
-        values[11u + texel] = indices[texel];
-        counts[11u + texel] = select(4u, 3u, texel == 0u);
-    }
-
-    var words = array<u32, 4>(0u, 0u, 0u, 0u);
-
-    var bit = 0u;
-
-    for (var field = 0u; field < 27u; field++) {
-        let value = values[field];
-        let count = counts[field];
-
-        for (var k = 0u; k < count; k++) {
-            if (((value >> k) & 1u) != 0u) {
-                let at = bit + k;
-
-                words[at >> 5u] |= 1u << (at & 31u);
-            }
-        }
-
-        bit += count;
-    }
-
-    return vec4<u32>(words[0], words[1], words[2], words[3]);
-}
-`);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * One BC7 mode 6 block from its two endpoints and sixteen indices, as four little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 6, in the same order for every field: seven mode
+ * bits — six zeros and a one — then the colour endpoints by channel, red for both ends, then green,
+ * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
+ * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
+ * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
+ * check it: the top bit is dropped, as the JavaScript writer drops it.
+ *
+ * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
+ * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
+ * a pair that disagrees with itself.
+ *
+ * Each word is composed by shifts at the fields' fixed positions, the two that straddle a word
+ * boundary — the second end's green, bits 28 to 34, and the second parity bit, bit 64 — split
+ * across them. The JavaScript writer goes bit by bit; here a hundred and twenty-eight iterations
+ * over two function-local arrays were 13% of a 4096² encode on a 4090.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode6 = CodeChunk.from(
+    //language=WGSL
+    `
+fn bc7_pack_mode6(e0: vec4<u32>, e1: vec4<u32>, indices: array<u32, 16>) -> vec4<u32> {
+    // the seven stored bits of each end's channels
+    let s0 = e0 >> vec4<u32>(1u);
+    let s1 = e1 >> vec4<u32>(1u);
+
+    // mode 6 is signalled by six zero bits and then a one, bits 0 to 6; red from bit 7
+    let w0 = 64u | (s0.x << 7u) | (s1.x << 14u) | (s0.y << 21u) | (s1.y << 28u);
+
+    // the parity bits are the ends' low bits, the first at bit 63 and the second at bit 64
+    let w1 = (s1.y >> 4u) | (s0.z << 3u) | (s1.z << 10u) | (s0.w << 17u) | (s1.w << 24u) | ((e0.x & 1u) << 31u);
+
+    let w2 = (e1.x & 1u) | ((indices[0] & 7u) << 1u)
+        | (indices[1] << 4u) | (indices[2] << 8u) | (indices[3] << 12u) | (indices[4] << 16u)
+        | (indices[5] << 20u) | (indices[6] << 24u) | (indices[7] << 28u);
+
+    let w3 = indices[8] | (indices[9] << 4u) | (indices[10] << 8u) | (indices[11] << 12u)
+        | (indices[12] << 16u) | (indices[13] << 20u) | (indices[14] << 24u) | (indices[15] << 28u);
+
+    return vec4<u32>(w0, w1, w2, w3);
+}
+`);

package/src/shade/renderer/texture/encode/chunk_bc7_partition_2.d.ts

@@ -0,0 +1,10 @@
+/**
+ * BC7's two-subset partitions as a shader reads them: which texels a pattern puts in the second
+ * subset, and that subset's anchor — the texel whose index is stored a bit short. The first
+ * subset's anchor is always texel 0, which every pattern puts in the first subset.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_partition_2: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bc7_partition_2.d.ts.map

package/src/shade/renderer/texture/encode/chunk_bc7_partition_2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bc7_partition_2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_partition_2.js"],"names":[],"mappings":"AA4BA;;;;;;GAMG;AACH,oCAFU,SAAS,CAgBhB;0BAhDuB,oCAAoC"}

package/src/shade/renderer/texture/encode/chunk_bc7_partition_2.js

@@ -0,0 +1,50 @@
+import { BC7_ANCHOR_2, BC7_PARTITIONS_2 } from "../../../../format/texture/basis/uastc/bc7_tables.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * BC7's sixty-four two-subset partitions, one word each: bit `i` set where texel `i` is in the
+ * second subset, and the second subset's anchor texel from bit 16.
+ *
+ * Built from the tables the UASTC transcoder uses rather than transcribed again, so the encoder and
+ * the transcoders cannot disagree about a shape.
+ *
+ * @returns {string} sixty-four WGSL `u32` literals
+ */
+function partition_words() {
+    const words = [];
+
+    for (let partition = 0; partition < 64; partition++) {
+        let mask = 0;
+
+        for (let texel = 0; texel < 16; texel++) {
+            mask |= BC7_PARTITIONS_2[partition * 16 + texel] << texel;
+        }
+
+        words.push(`${(mask | (BC7_ANCHOR_2[partition] << 16)) >>> 0}u`);
+    }
+
+    return words.join(', ');
+}
+
+/**
+ * BC7's two-subset partitions as a shader reads them: which texels a pattern puts in the second
+ * subset, and that subset's anchor — the texel whose index is stored a bit short. The first
+ * subset's anchor is always texel 0, which every pattern puts in the first subset.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_partition_2 = CodeChunk.from(
+    //language=WGSL
+    `
+const BC7_PARTITION_2 = array<u32, 64>(${partition_words()});
+
+// the texels a two-subset partition puts in its second subset, bit i for texel i
+fn bc7_partition_2_mask(pattern: u32) -> u32 {
+    return BC7_PARTITION_2[pattern] & 0xFFFFu;
+}
+
+// the second subset's anchor texel
+fn bc7_partition_2_anchor(pattern: u32) -> u32 {
+    return BC7_PARTITION_2[pattern] >> 16u;
+}
+`);

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.d.ts

@@ -1,11 +1,10 @@
 /**
  * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
  *
- * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
- * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
- * partitioned modes is a later quality step, and a separate chunk — this shader would call it
- * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
- * {@link shader_texture_encode_bc4}'s; a block is four words.
+ * Each block in mode 6 or mode 1, whichever {@link chunk_bc7_encode_block} estimates loses less:
+ * one line through all four channels with sixteen levels, or two lines through the colour over one
+ * of the sixty-four partitions. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is
+ * four words.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_texture_encode_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc7.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,wCAFU,aAAa,CA2CpB;8BA1D2B,+BAA+B"}
+{"version":3,"file":"shader_texture_encode_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc7.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,wCAFU,aAAa,CA2CpB;8BAzD2B,+BAA+B"}

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.js

@@ -1,7 +1,7 @@
 import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
-import { chunk_bc7_encode_block_mode6 } from "./chunk_bc7_encode_block_mode6.js";
+import { chunk_bc7_encode_block } from "./chunk_bc7_encode_block.js";
 import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
 import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
 import { texture_encode_resources } from "./texture_encode_resources.js";
@@ -9,11 +9,10 @@ import { texture_encode_resources } from "./texture_encode_resources.js";
 /**
  * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
  *
- * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
- * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
- * partitioned modes is a later quality step, and a separate chunk — this shader would call it
- * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
- * {@link shader_texture_encode_bc4}'s; a block is four words.
+ * Each block in mode 6 or mode 1, whichever {@link chunk_bc7_encode_block} estimates loses less:
+ * one line through all four channels with sixteen levels, or two lines through the colour over one
+ * of the sixty-four partitions. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is
+ * four words.
  *
  * @type {ComputeShader}
  */
@@ -44,7 +43,7 @@ fn main(
 
     let texels = texture_encode_load_block(level, block_x, block_y);
 
-    let packed = bc7_encode_block_mode6(texels);
+    let packed = bc7_encode_block(texels);
 
     let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
 
@@ -56,6 +55,6 @@ fn main(
 `, [
             chunk_grid3d_to_index,
             chunk_texture_encode_load_block,
-            chunk_bc7_encode_block_mode6,
+            chunk_bc7_encode_block,
         ]),
 });

package/src/shade/renderer/water/chunk_water_transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,0DAeG;AAEH,8CAsBG;AAGH,mDAS6F;AAI7F,sDAmCoE;0BAxG1C,iCAAiC"}
+{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,0DAeG;AAEH,8CAsBG;AAIH,mDAU6F;AAI7F,sDAmCoE;0BA1G1C,iCAAiC"}

package/src/shade/renderer/water/chunk_water_transport.js

@@ -53,15 +53,17 @@ fn water_transport(event: WaterEvent, original: vec3f, receiver: vec3f,
 }
 `);
 
-// One G-buffer texel in world space: its stored depth, texel-center position and face normal.
+// One G-buffer texel in world space: its stored depth, texel-center position, its triangle's face normal, which
+// is where the surface is, and the normal it was shaded with, which is what lit it.
 export const chunk_water_receiver_texel = CodeChunk.from(/* language=WGSL */ `
-struct WaterReceiverTexel { depth: f32, position: vec3f, normal: vec3f }
+struct WaterReceiverTexel { depth: f32, position: vec3f, face_normal: vec3f, shading_normal: vec3f }
 fn water_receiver_texel(depth: texture_2d<f32>, normals: texture_2d<u32>, coord: vec2i,
     inverse_projection: mat4x4f, inverse_view: mat4x4f) -> WaterReceiverTexel {
     let d = textureLoad(depth, coord, 0).r;
     let center = texel_coordinate_to_uv(vec2f(coord), textureDimensions(depth, 0));
     let position = inverse_view * vec4f(inv_project_position(vec3f(center, d), inverse_projection), 1.0);
-    return WaterReceiverTexel(d, position.xyz, decode_g_buffer_normal(textureLoad(normals, coord, 0).zw));
+    let encoded = textureLoad(normals, coord, 0);
+    return WaterReceiverTexel(d, position.xyz, decode_g_buffer_normal(encoded.zw), decode_g_buffer_normal(encoded.xy));
 }
 `, [chunk_decode_g_buffer_normal, chunk_inv_project_position, chunk_texel_coordinate_to_uv]);
 
@@ -92,8 +94,8 @@ fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, norma
             let coord = clamp(base + vec2i(x,y), vec2i(0), size-1);
             let tap = water_receiver_texel(depth, normals, coord, inverse_projection, inverse_view);
             if (is_background(tap.depth) || (below_interface && dot(tap.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)
-                || dot(center.normal, tap.normal) < 0.95
-                || abs(dot(tap.position - center.position, center.normal)) > 0.02) { continue; }
+                || dot(center.face_normal, tap.face_normal) < 0.95
+                || abs(dot(tap.position - center.position, center.face_normal)) > 0.02) { continue; }
             let w = select(1.0-f.x, f.x, x == 1) * select(1.0-f.y, f.y, y == 1);
             color += w * textureLoad(scene, coord, 0).rgb;
             weight += w;

package/src/shade/renderer/water/medium/GPUWaterBodies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAcA,4FAA4F;AAC5F;IACI;;;;;;OAMG;IACH;;;;;;;;QAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA8ClD;CACJ"}
+{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAkBA,4FAA4F;AAC5F;IACI;;;;;;OAMG;IACH;;;;;;;;QAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAgDlD;CACJ"}

package/src/shade/renderer/water/medium/GPUWaterBodies.js

@@ -1,6 +1,10 @@
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { round_up } from "../../../../core/math/round_up.js";
-import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
 import {
     build_indirect_compute_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
@@ -42,7 +46,9 @@ export class GPUWaterBodies {
         data.command = pass.create('Water lod bodies command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
         data.lod_bodies = pass.create('Water lod bodies', BufferResourceDescriptor.from(capacity * WATER_LOD_BODY_STRUCT.size,
             GPUBufferUsage.STORAGE));
-        const sums = graph_prefix_scan_csdldf({ graph, data: data.counts, element_max_count: capacity });
+        const sums = graph_prefix_scan_csdldf({ graph, input: data.counts,
+            output: graph_create_buffer(graph, 'Water lod body meshlet sums', prefix_scan_csdldf_output_descriptor(capacity)),
+            element_max_count: capacity });
         const command_data = {};
         const command_pass = graph.add('Water / expand command', command_data, (d, resources, { encoder }) => {
             shader_prefix_sum_to_command.dispatch({ encoder, bindings: {

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.d.ts

@@ -5,8 +5,9 @@
  * light that receiver was shaded with survives the water above it.
  *
  * The ratio is of the receiver's irradiance under the water to its irradiance dry, from what the
- * water pass can rebuild at the receiver — its position, G-buffer normal and depth below the
- * surface, the shadow map and the GI mode:
+ * water pass can rebuild at the receiver — its position, the normal it was shaded with (the G-buffer's
+ * shading normal, as deferred lighting takes n·l, the shadow lookup and GI on it; never its triangle's,
+ * which turns at every edge) and depth below the surface, the shadow map and the GI mode:
  *
  * - dry: each directional light × its shadow × n·l, plus the GI mode's irradiance on n;
  * - wet: each light refracted at the surface, so steeper, with the Fresnel transmittance, the beam's

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_receiver_downwelling.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAFU,SAAS,CAyCmE;0BApE5D,oCAAoC"}
+{"version":3,"file":"chunk_water_receiver_downwelling.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+CAFU,SAAS,CAyCmE;0BArE5D,oCAAoC"}

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js

@@ -16,8 +16,9 @@ import { chunk_water_optics } from "./chunk_water_optics.js";
  * light that receiver was shaded with survives the water above it.
  *
  * The ratio is of the receiver's irradiance under the water to its irradiance dry, from what the
- * water pass can rebuild at the receiver — its position, G-buffer normal and depth below the
- * surface, the shadow map and the GI mode:
+ * water pass can rebuild at the receiver — its position, the normal it was shaded with (the G-buffer's
+ * shading normal, as deferred lighting takes n·l, the shadow lookup and GI on it; never its triangle's,
+ * which turns at every edge) and depth below the surface, the shadow map and the GI mode:
  *
  * - dry: each directional light × its shadow × n·l, plus the GI mode's irradiance on n;
  * - wet: each light refracted at the surface, so steeper, with the Fresnel transmittance, the beam's

package/src/shade/renderer/water/shader_water.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAwmBA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AA/jBrK,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CA+EmB;AA6LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA5kBA,8DAA8D;6BAmB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AA0mBA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AAjkBrK,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CA+EmB;AA+LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA9kBA,8DAA8D;6BAmB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}

package/src/shade/renderer/water/shader_water.js

@@ -550,12 +550,14 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     } else { confidence = 0.0; }
     // The opaque scene was shaded dry: what reaches the receiver is what survives the water above it
     // (WATER_OPTICS_PLAN_2026_10_02.md §4.3). Seen from under the surface, the receiver is above it.
+    // Its light is rebuilt on the normal it was shaded with: its triangle's turns at every edge of a
+    // tessellated floor, and every edge would show through the water.
     let receiver_texel = water_receiver_texel(tDepth, tNormal, receiver_coord, camera.projection_matrix_inverse,
         camera.view_matrix_inverse);
     if (above && !is_background(receiver_texel.depth)) {
         let camera_ws = camera.view_matrix_inverse[3].xyz;
         let up = normalize(in.rest_normal);
-        color *= water_receiver_downwelling(body, receiver_texel.position, receiver_texel.normal, up,
+        color *= water_receiver_downwelling(body, receiver_texel.position, receiver_texel.shading_normal, up,
             max(dot(in.world - receiver_texel.position, up), 0.0), normalize(camera_ws - receiver_texel.position));
     }
     // Light in the water body (WATER_OPTICS_PLAN_2026_10_02.md §4.4): the receiver attenuated along

package/src/shade/renderer/water/surface/GPUWaterSurface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterSurface.js"],"names":[],"mappings":"AAmBA,uHAAuH;AACvH,2CAA4C;AAE5C,4EAA4E;AAC5E,6DAKI;AAEJ;;;;;;GAMG;AACH;IACI,4FAA4F;IAC5F,yBAAgC;IAChC,oEAAoE;IACpE,0BAA0B;IAC1B,6EAA6E;IAC7E,eAAc;IACd;;;OAGG;IACH,kBAAiB;IAejB,mCAA0D;IAC1D,kCAAwD;IACxD,kCAA0D;IAC1D,kCAA0D;IAC1D,kHAAkH;IAClH,uBAAmC;IACnC,qGAAqG;IACrG,0BAAyC;IACzC,gHAAgH;IAChH,8BAA2D;IAC3D,mCAA2C;IAE3C;;;OAGG;IACH,YAFW,MAAM,QAKhB;IAED,gBAWC;IAsBD;;;;;;;;;;;OAWG;IACH;QAVsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACT,KAAK,EAArB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI;YACI,MAAM;YACE,UAAU,EAA1C,UAAU,MAAM,CAAC;YACI,MAAM,EAA3B,MAAM;;QACU,MAAM,EAAtB,MAAM;aAsEhB;;CACJ;kCApMiC,kDAAkD;mBAFjE,0CAA0C;kCAI3B,kCAAkC"}
+{"version":3,"file":"GPUWaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterSurface.js"],"names":[],"mappings":"AAoBA,uHAAuH;AACvH,2CAA4C;AAE5C,4EAA4E;AAC5E,6DAKI;AAEJ;;;;;;GAMG;AACH;IACI,4FAA4F;IAC5F,yBAAgC;IAChC,oEAAoE;IACpE,0BAA0B;IAC1B,6EAA6E;IAC7E,eAAc;IACd;;;OAGG;IACH,kBAAiB;IAejB,mCAA0D;IAC1D,kCAAwD;IACxD,kCAA0D;IAC1D,kCAA0D;IAC1D,kHAAkH;IAClH,uBAAmC;IACnC,qGAAqG;IACrG,0BAAyC;IACzC,gHAAgH;IAChH,8BAA2D;IAC3D,mCAA2C;IAE3C;;;OAGG;IACH,YAFW,MAAM,QAKhB;IAED,gBAWC;IAuBD;;;;;;;;;;;OAWG;IACH;QAVsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACT,KAAK,EAArB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI;YACI,MAAM;YACE,UAAU,EAA1C,UAAU,MAAM,CAAC;YACI,MAAM,EAA3B,MAAM;;QACU,MAAM,EAAtB,MAAM;aAsEhB;;CACJ;kCArMiC,kDAAkD;mBAHjE,0CAA0C;kCAK3B,kCAAkC"}

package/src/shade/renderer/water/surface/GPUWaterSurface.js

@@ -1,5 +1,6 @@
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
+import { round_up } from "../../../../core/math/round_up.js";
 import { SamplerDescriptor } from "../../../descriptor/texture/SamplerDescriptor.js";
 import { GPUWaterSpectrum } from "./spectrum/GPUWaterSpectrum.js";
 import { GPUWaterParticles } from "./particles/GPUWaterParticles.js";
@@ -104,7 +105,8 @@ export class GPUWaterSurface {
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | usage });
         this.#steep = buffer('steep bodies', rows * 4);
         this.#activity = buffer('activity', rows * 4);
-        const list = label => buffer(label, WATER_LIST_HEADER_BYTES + rows * 4);
+        // rows are aligned to 16, so WGSL rounds a list up to whole blocks of 4: one row binds 32 bytes, not 20
+        const list = label => buffer(label, WATER_LIST_HEADER_BYTES + round_up(rows, 4) * 4);
         this.#lists = { visible: list('visible rows'), active: list('active rows'), emit: list('emit rows') };
         this.#commands ??= buffer('surface commands', WATER_SURFACE_COMMAND_COUNT * WATER_SURFACE_COMMAND_STRIDE, GPUBufferUsage.INDIRECT);
         this.#rows = rows;

package/src/shade/renderer/water/surface/graph_water_tessellation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/graph_water_tessellation.js"],"names":[],"mappings":"AAiCA;;;;;;;GAOG;AACH,8CAHW;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACtE;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQrH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACjE,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,gBAAgB,EAAhC,MAAM;IAC2E,GAAG,EAApF;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC+B,MAAM,EAA5G;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC;IACzE,KAAK;IACtB;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAsGrF"}
+{"version":3,"file":"graph_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/graph_water_tessellation.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,8CAHW;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACtE;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQrH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACjE,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,gBAAgB,EAAhC,MAAM;IAC2E,GAAG,EAApF;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC+B,MAAM,EAA5G;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC;IACzE,KAAK;IACtB;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAyGrF"}

package/src/shade/renderer/water/surface/graph_water_tessellation.js

@@ -1,11 +1,15 @@
 import { assert } from "../../../../core/assert.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
-import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import {
     build_indirect_compute_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
 import { WATER_LOD_VIEW_STRUCT } from "./lod/WATER_LOD.js";
 import {
     shader_water_lod_candidate_command,
@@ -73,6 +77,9 @@ export function graph_water_tessellation({ graph, scene, camera, meshlets, lod_b
     const geometry_bindings = { scene_database: scene.scene_database_buffer,
         meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data };
     const limits_value = { ...limits };
+    // a counts collection's inclusive sums, into a collection of their own
+    const sums_of = (counts, label, elements) => graph_prefix_scan_csdldf({ graph, input: counts,
+        output: graph_create_buffer(graph, label, prefix_scan_csdldf_output_descriptor(elements)), element_max_count: elements });
 
     // per triangle slot of the drawn meshlets: drawn as itself, or its candidates
     const triangles_data = {};
@@ -88,8 +95,8 @@ export function graph_water_tessellation({ graph, scene, camera, meshlets, lod_b
     triangles_data.command = triangles.create('Water lod triangles command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
     triangles_data.counts = triangles.create('Water lod triangle counts', counts_descriptor(slots));
     triangles_data.flats = triangles.create('Water lod flat counts', counts_descriptor(slots));
-    const triangle_sums = graph_prefix_scan_csdldf({ graph, data: triangles_data.counts, element_max_count: slots });
-    const flat_sums = graph_prefix_scan_csdldf({ graph, data: triangles_data.flats, element_max_count: slots });
+    const triangle_sums = sums_of(triangles_data.counts, 'Water lod triangle sums', slots);
+    const flat_sums = sums_of(triangles_data.flats, 'Water lod flat sums', slots);
 
     // the candidates' dispatch; the flat triangles' records and draw
     const command_data = {};
@@ -133,7 +140,7 @@ export function graph_water_tessellation({ graph, scene, camera, meshlets, lod_b
         budget * WATER_LOD_CANDIDATE_ROW_WORDS * 4, GPUBufferUsage.STORAGE));
     // the interior, boundary and patch counts of every candidate, one region after another, scanned once
     candidates_data.counts = candidates.create('Water lod cell counts', counts_descriptor(3 * budget));
-    const list_sums = graph_prefix_scan_csdldf({ graph, data: candidates_data.counts, element_max_count: 3 * budget });
+    const list_sums = sums_of(candidates_data.counts, 'Water lod cell sums', 3 * budget);
 
     // each list's records; the boundary cells' polygons
     const lists = [

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AA+BA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAuBI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CAuD7G;IAED,gBAcC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aAgGhB;;CACJ"}
+{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IA0BI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA6D7G;IAED,gBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aAmGhB;;CACJ"}