@woosh/meep-engine 3.60.4 → 3.60.6

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GTAO's own spatial filter: one 3x3 edge-stopped pass over visibility and the bend.
+ *
+ * Its input and output are `rgba16float`: visibility in `x`, and in `yzw` the world-space bend, the bent normal
+ * minus the shading normal. The bend is what is filtered, never the bent normal, so an unoccluded texel, whose
+ * bend is zero, keeps the normal map's detail exactly however much its neighbours are averaged in.
+ *
+ * Visibility is filtered as `fragment_shader_denoise_ao` filters it — the A-trous step, its edge-stopping
+ * weights and phi values — with the variance taken from visibility alone, since the input carries no second
+ * moment. That shader stays as it is: it is shared with denoisers that do keep moments.
+ *
+ * @type {ImageShader}
+ */
+export const shader_gtao_spatial_denoise: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+//# sourceMappingURL=shader_gtao_spatial_denoise.d.ts.map

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_gtao_spatial_denoise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js"],"names":[],"mappings":"AA+HA;;;;;;;;;;;;GAYG;AACH,0CAFU,WAAW,CAiBlB;4BAvJyB,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js

@@ -0,0 +1,156 @@
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { chunk_compute_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("tInput")
+    .addTexture("tDepth")
+    .addTexture("tNormal", "uint");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const phi_visibility = 4.0;
+const phi_normal = 128.0;
+const sigma_depth = 1.0;
+
+const offsets = array< vec2<i32>, 8 >(
+    vec2( -1, -1 ),
+    vec2(  0, -1 ),
+    vec2(  1, -1 ),
+    vec2( -1,  0 ),
+    vec2(  1,  0 ),
+    vec2( -1,  1 ),
+    vec2(  0,  1 ),
+    vec2(  1,  1 ),
+);
+
+// Visibility's spatial variance over a 3x3 Gaussian. The input carries visibility alone, so its second moment
+// is the square of each texel's.
+fn gtao_visibility_variance(ipos: vec2<i32>) -> f32 {
+    let kernel = array<f32, 3>(0.25, 0.125, 0.0625);
+
+    var moments = vec2<f32>(0.0);
+
+    for (var yy = -1; yy <= 1; yy++) {
+        for (var xx = -1; xx <= 1; xx++) {
+            let v = textureLoad(tInput, ipos + vec2<i32>(xx, yy), 0).x;
+
+            moments += vec2(v, v * v) * kernel[ abs(xx) + abs(yy) ];
+        }
+    }
+
+    return max(moments.y - moments.x * moments.x, 0.0);
+}
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let ipos = vec2<i32>(coord.xy);
+    let screen_size = vec2<i32>(textureDimensions(tInput));
+
+    const eps_variance = 1e-10;
+    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
+
+    let center = textureLoad(tInput, ipos, 0);
+
+    let std_dev = sqrt(max(0.0, eps_variance + gtao_visibility_variance(ipos)));
+
+    let phi_luma = phi_visibility * std_dev;
+
+    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).xy);
+    let center_depth   = textureLoad(tDepth, ipos, 0).r;
+
+    // the centre at weight 1, so the edge-stopping functions cannot leave nothing
+    var sum_w_visibility = 1.0;
+    var sum_visibility   = center.x;
+
+    // The bend is averaged weighted by visibility as well. A bent normal stands for the visible directions;
+    // the bent normal of several texels together is the sum of each one's scaled by how much it sees,
+    // normalized, and with neighbours whose normals agree that is the shading normal plus this average.
+    var sum_w_bend = center.x;
+    var sum_bend   = center.yzw * center.x;
+
+    for (var i = 0; i < 8; i++) {
+        let offset = offsets[i];
+
+        let p = ipos + offset;
+
+        if (any(p < vec2(0)) || any(p >= screen_size)) {
+            continue;
+        }
+
+        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
+
+        let texel = textureLoad(tInput, p, 0);
+
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_depth  = textureLoad(tDepth, p, 0).r;
+
+        let w = compute_edge_stopping_weight(
+            center_depth,
+            sample_depth,
+            sigma_depth,
+
+            current_normal,
+            sample_normal,
+            phi_normal,
+
+            center.x,
+            texel.x,
+            phi_luma
+        ) * kernel;
+
+        sum_w_visibility += w;
+        sum_visibility   += w * texel.x;
+
+        let w_bend = w * texel.x;
+
+        sum_w_bend += w_bend;
+        sum_bend   += w_bend * texel.yzw;
+    }
+
+    return vec4(sum_visibility / sum_w_visibility, sum_bend / sum_w_bend);
+}
+    `,
+    [
+        chunk_decode_g_buffer_normal,
+        chunk_compute_edge_stopping_weight,
+    ]);
+
+/**
+ * GTAO's own spatial filter: one 3x3 edge-stopped pass over visibility and the bend.
+ *
+ * Its input and output are `rgba16float`: visibility in `x`, and in `yzw` the world-space bend, the bent normal
+ * minus the shading normal. The bend is what is filtered, never the bent normal, so an unoccluded texel, whose
+ * bend is zero, keeps the normal map's detail exactly however much its neighbours are averaged in.
+ *
+ * Visibility is filtered as `fragment_shader_denoise_ao` filters it — the A-trous step, its edge-stopping
+ * weights and phi values — with the variance taken from visibility alone, since the input carries no second
+ * moment. That shader stays as it is: it is shared with denoisers that do keep moments.
+ *
+ * @type {ImageShader}
+ */
+export const shader_gtao_spatial_denoise = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "GTAO Spatial Denoise",
+        resources,
+        body
+    }),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [
+        {
+            format: "rgba16float",
+            // Background is skipped, so it keeps the clear: not occluded, not bent. Downstream neighbourhoods
+            // read across silhouettes and must see background as unoccluded.
+            clearValue: [1, 0, 0, 0],
+        }
+    ]
+});

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -105,8 +105,8 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
-     * of a virtual geometry is baked from a proxy cut from it.
+     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -399,8 +399,8 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
-     * of a virtual geometry is baked from a proxy cut from it.
+     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`
@@ -448,8 +448,8 @@ export class GPUSceneContext {
 
             feedback = new VGeoFeedbackLoop({ runtime, residency: tiers });
 
-            // last: it makes its buffers and subscribes to the caches as it is made
-            proxies = new VGeoSDFProxies({ device: this.#device, runtime, geometries: this.geometries });
+            // last: it subscribes to the caches as it is made
+            proxies = new VGeoSDFProxies({ geometries: this.geometries });
         } catch (error) {
             // the pool is the only one holding anything yet: the fetcher spawns its workers on its
             // first fetch, and the runtime makes its buffer on its first frame
@@ -874,7 +874,7 @@ export class GPUSceneContext {
             return;
         }
 
-        // its proxies out of the geometry manager, and its cut's buffers, ahead of the runtime's
+        // it hears no more of the caches; its proxies stay with the geometry manager, destroyed with it
         this.#virtual_geometry_proxies.destroy();
 
         this.#virtual_geometry_feedback.destroy();

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA0JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCAruEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA+JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCA1uEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js

@@ -95,11 +95,16 @@ const DEFAULT_SHADOWMAP_ATLAS_RESOLUTION = 4096;
 /**
  * Resolution by cascade.
  * If the number of cascades is greater than the array length, the last resolution is used.
+ *
+ * 1536 is chosen for the cascade's HZB: half of it, 768 = 3·2⁸, is a mip 0 the HZB takes as it is, with
+ * no padding, so mip 0 halves the cascade exactly (a 2x2 footprint) and the rest of the pyramid is two
+ * 4-mip SPD passes and one single-mip pass. 1740 and 1440 padded mip 0 to 880 and 736, a 3x3 footprint
+ * and five single-mip passes each. Three cascades at 1536² hold about the texels 1740² + 2·1440² did.
+ *
  * @type {number[]}
  */
 const DEFAULT_SHADOWMAP_DIRECTIONAL_RESOLUTION = [
-    1740, // first cascade
-    1440,
+    1536,
 ];
 
 /**

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -17,12 +17,6 @@ export class GPUWaterRenderer {
         inscatter_segments: number;
         tessellation_pixels: number;
     };
-    /**
-     * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
-     * each drawable surface carries its row as `body_index`.
-     * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
-     */
-    bodies: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
     /**
      * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
      * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.

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

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAoBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAmBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAuIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCA3X+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAtX+B,uCAAuC"}

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

@@ -4,6 +4,7 @@ import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.
 import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
 import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
 import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
+import { graph_water_meshlets } from "./medium/graph_water_meshlets.js";
 import { graph_water_tessellation } from "./surface/graph_water_tessellation.js";
 import { water_lod_view, WATER_LOD_VIEW_STRUCT } from "./surface/lod/WATER_LOD.js";
 import { WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_INDICES, WATER_LOD_STATISTICS_WORDS,
@@ -28,12 +29,6 @@ export class GPUWaterRenderer {
     settings = { enabled: true, max_distance: 300, distance_tolerance: 0.15,
         max_updates: 4, fallback_steps: 48, mode: 0, reflections: 1, debug_view: 0, inscatter_segments: 4,
         tessellation_pixels: 4 };
-    /**
-     * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
-     * each drawable surface carries its row as `body_index`.
-     * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
-     */
-    bodies = null;
     #pipeline = create_water_pipeline();
     /** The optics pipelines, each by the shader switch set it was built for. */
     #finalize_pipelines = new Map();
@@ -169,7 +164,7 @@ export class GPUWaterRenderer {
         // the lattice is chosen from the camera's position and its pixel angle, not its jittered projection's offset:
         // raster jitter moves samples, not the mesh
         const lod = water_lod_view(view_ctx.camera.camera.projection_matrix, resolution[1], Math.max(0.5, settings.tessellation_pixels));
-        const { meshlets, lod_bodies } = this.bodies.meshlets({ graph, view: view_ctx, camera, meshlet_capacity: this.meshlet_capacity,
+        const { meshlets, lod_bodies } = graph_water_meshlets({ graph, scene, camera, meshlet_capacity: this.meshlet_capacity,
             visible_rows: surface.visible_rows, lod, steep: surface.steep });
         const limits = { ...this.lod_budgets, triangles: Math.max(this.meshlet_capacity, 1) * GEOMETRY_MESHLET_TRIANGLE_LIMIT };
         const patches = graph_water_tessellation({ graph, scene, camera, meshlets, lod_bodies, meshlet_capacity: this.meshlet_capacity,
@@ -225,7 +220,8 @@ export class GPUWaterRenderer {
         data.commands = pass.read(patches.commands);
         // Keep the accepted UV and both paths at f32 precision through final shading.
         data.receiver = target("receiver", "rgba32float");
-        data.trace_metadata = target("trace metadata", "rgba32float");
+        // the fragment's control path, shaded surface, coverage and body, bit-packed (shader_water.js WaterReceiver)
+        data.trace_metadata = target("trace metadata", "rgba32uint");
         data.interface_depth = target("interface depth", "depth32float");
         let states = this.#prepared.get(graph);
         if (states === undefined) { states = new Map(); this.#prepared.set(graph, states); }
@@ -264,9 +260,10 @@ export class GPUWaterRenderer {
             const bindings = WATER_FINALIZE_RESOURCES.generateBindings(shared, encoder);
             const copy_pipeline = shader_water_background_copy.pipeline;
             const copy_bindings = shader_water_background_copy.descriptor.resources.generateBindings({tScene: shared.tScene}, encoder);
+            // away from water nothing is transmitted through and nothing is added: the background copy leaves both
             const render = encoder.constructRenderPass({label: 'Water / coherent optics', pipeline: finalize_pipeline, bindings: [],
-                colorAttachments: [d.transmission,d.radiance,d.background].map(handle => ({
-                    view: resources.get(handle).obtainView(), loadOp: 'clear', storeOp: 'store', clearValue: [0,0,0,0],
+                colorAttachments: [[d.transmission, [1,1,1,0]], [d.radiance, [0,0,0,0]], [d.background, [0,0,0,0]]].map(([handle, clearValue]) => ({
+                    view: resources.get(handle).obtainView(), loadOp: 'clear', storeOp: 'store', clearValue,
                 })), depthStencilAttachment: {view: resources.get(d.interface_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW), depthReadOnly: true},
             });
             render.setPipeline(graphics.render_pipelines.obtain(copy_pipeline)); render.record_pipeline(copy_pipeline);
@@ -353,7 +350,7 @@ export class GPUWaterRenderer {
         const [color] = graph_image_pass({ graph, shader: shader_water_debug, output_resolution: resolution,
             inputs: { inspection: { mode, resolution }, camera: data.camera, warp: data.warp, tIntegral: data.integral,
                 transmission: data.transmission, radiance: data.radiance,
-                receiver: data.receiver, interface_depth: data.interface_depth, trace_metadata: data.trace_metadata } });
+                receiver: data.receiver, interface_depth: data.interface_depth } });
         return color;
     }
 
@@ -362,7 +359,7 @@ export class GPUWaterRenderer {
         const pass = graph.add("Water / pixel probe", data, (data, resources, { encoder, graphics }) => {
             const buffer = graphics.device.createBuffer({ size: 1024, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
             const pixel = probe.uv.map((v, i) => Math.min(resolution[i]-1, Math.max(0, Math.floor(v*resolution[i]))));
-            [data.receiver, data.transmission, data.radiance, data.trace_metadata].forEach((handle, i) => {
+            [data.receiver, data.transmission, data.radiance].forEach((handle, i) => {
                 encoder.copyTextureToBuffer({ texture: resources.get(handle).gpu_texture, origin: [...pixel, 0] },
                     { buffer, offset: i*256, bytesPerRow: 256 }, [1,1,1]);
             });
@@ -370,16 +367,14 @@ export class GPUWaterRenderer {
                 try {
                     await buffer.mapAsync(GPUMapMode.READ);
                     const mapped = buffer.getMappedRange();
-                    const half = offset => Array.from(new Float16Array(mapped, offset, 4));
-                    const radiance = half(512);
-                    radiance[3] = new Float32Array(mapped, 768, 4)[1];
                     probe.resolve({ pixel, resolution, frame_time: optical.frame_time, receiver: Array.from(new Float32Array(mapped, 0, 4)),
-                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance, stale: false });
+                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance: Array.from(new Float16Array(mapped, 512, 4)),
+                        stale: false });
                 } catch (error) { probe.reject(error); }
                 finally { buffer.destroy(); }
             });
         });
-        for (const key of ["receiver", "transmission", "radiance", "trace_metadata"]) { data[key] = pass.read(optical[key]); }
+        for (const key of ["receiver", "transmission", "radiance"]) { data[key] = pass.read(optical[key]); }
         pass.make_side_effect();
     }
 }

package/src/shade/renderer/water/medium/graph_water_meshlets.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A view's water bodies: which the view draws and how, and their meshlets in row order.
+ *
+ * Draw culling over the frame's visible list (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3), each drawn
+ * body's lattice frame at its row, and the drawn bodies' meshlets. The expansion is an ordered prefix scan over the
+ * rows, which preserves equal-depth ownership, including after holes and reuse.
+ *
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {object} options.scene GPU scene context
+ * @param {number} options.camera the view's camera uniform resource
+ * @param {number} options.meshlet_capacity every water meshlet the scene holds
+ * @param {GPUBuffer} options.visible_rows the frame's visible water rows
+ * @param {{ranges: number, orthographic: number, level: number, distance: number}} options.lod the view's lattice choice
+ * @param {GPUBuffer} options.steep per wave row: set for a body with a triangle too steep for the lattice
+ * @returns {{meshlets: number, lod_bodies: number}} resources
+ */
+export function graph_water_meshlets({ graph, scene, camera, meshlet_capacity, visible_rows, lod, steep }: {
+    graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    scene: object;
+    camera: number;
+    meshlet_capacity: number;
+    visible_rows: GPUBuffer;
+    lod: {
+        ranges: number;
+        orthographic: number;
+        level: number;
+        distance: number;
+    };
+    steep: GPUBuffer;
+}): {
+    meshlets: number;
+    lod_bodies: number;
+};
+//# sourceMappingURL=graph_water_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_water_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/graph_water_meshlets.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH;IATsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACjE,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACa,YAAY;IACkD,GAAG,EAApF;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACpD,KAAK;IACtB;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAmDlD"}

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

@@ -0,0 +1,89 @@
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { round_up } from "../../../../core/math/round_up.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
+} from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { shader_prefix_sum_to_command } from "../../rasterize/expand/mesh/shader_prefix_sum_to_command.js";
+import { shader_increment_count_by_prefix_sum } from "../../rasterize/expand/mesh/shader_increment_count_by_prefix_sum.js";
+import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
+import { shader_water_meshlets_expand } from "./shader_water_meshlets.js";
+import { shader_water_lod_bodies } from "../surface/lod/shader_water_lod.js";
+import { WATER_LOD_BODY_STRUCT, WATER_LOD_VIEW_STRUCT } from "../surface/lod/WATER_LOD.js";
+import { MESHLET_COLLECTION_STRUCT } from "../../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { MESHLET_DEFINITION_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
+
+const MESHLETS_OFFSET = MESHLET_COLLECTION_STRUCT.get('elements').offset;
+
+/**
+ * A view's water bodies: which the view draws and how, and their meshlets in row order.
+ *
+ * Draw culling over the frame's visible list (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3), each drawn
+ * body's lattice frame at its row, and the drawn bodies' meshlets. The expansion is an ordered prefix scan over the
+ * rows, which preserves equal-depth ownership, including after holes and reuse.
+ *
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {object} options.scene GPU scene context
+ * @param {number} options.camera the view's camera uniform resource
+ * @param {number} options.meshlet_capacity every water meshlet the scene holds
+ * @param {GPUBuffer} options.visible_rows the frame's visible water rows
+ * @param {{ranges: number, orthographic: number, level: number, distance: number}} options.lod the view's lattice choice
+ * @param {GPUBuffer} options.steep per wave row: set for a body with a triangle too steep for the lattice
+ * @returns {{meshlets: number, lod_bodies: number}} resources
+ */
+export function graph_water_meshlets({ graph, scene, camera, meshlet_capacity, visible_rows, lod, steep }) {
+    const table = scene.scene_database.get('water_bodies');
+    const capacity = Math.max(table.element_capacity, 1);
+    const data = {};
+    const pass = graph.add('Water / lod bodies', data, (d, resources, { encoder }) => {
+        const command = resources.get(d.command);
+        build_indirect_compute_dispatch_command(64, encoder, visible_rows, 0, command, 0, true);
+        shader_water_lod_bodies.dispatchIndirect({ encoder, command, bindings: {
+            capacity: round_up(capacity, 4), lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod),
+            camera: resources.get(d.camera), scene_database: scene.scene_database_buffer,
+            geometries: scene.geometries.buffer_metadata, visible_rows, steep,
+            lod_bodies: resources.get(d.lod_bodies), counts: resources.get(d.counts),
+        } });
+    });
+    data.camera = pass.read(camera);
+    // The shared scan reads vec4u blocks, including the padded final block.
+    const bytes = 16 + round_up(capacity, 4) * 4;
+    data.counts = pass.create('counts', BufferResourceDescriptor.from(bytes, GPUBufferUsage.STORAGE, 0, bytes));
+    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, 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: {
+            prefix_sums: resources.get(d.sums), command: resources.get(d.command),
+        } });
+    });
+    command_data.sums = command_pass.read(sums);
+    const command = command_data.command = command_pass.create('command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+    const expand_data = {};
+    const expand = graph.add('Water / expand meshlets', expand_data, (d, resources, { encoder }) => {
+        shader_water_meshlets_expand.dispatchIndirect({ encoder, command: resources.get(d.command), bindings: {
+            prefix_sums: resources.get(d.sums), output: resources.get(d.output),
+            scene_database: scene.scene_database_buffer, geometries: scene.geometries.buffer_metadata,
+        } });
+    });
+    expand_data.command = expand.read(command);
+    expand_data.sums = expand.read(sums);
+    // The collection struct holding this many meshlets, padded to its alignment: one meshlet is the binding's minimum.
+    const meshlets_bytes = round_up(MESHLETS_OFFSET + Math.max(meshlet_capacity, 1) * MESHLET_DEFINITION_STRUCT.aligned_size,
+        MESHLET_COLLECTION_STRUCT.align);
+    expand_data.output = expand.create('meshlets', BufferResourceDescriptor.from(meshlets_bytes,
+        GPUBufferUsage.STORAGE, 0, MESHLETS_OFFSET));
+    const { output } = graph_compute_pass({ graph, shader: shader_increment_count_by_prefix_sum,
+        bindings: { prefix_sums: sums, output: expand_data.output } });
+    return { meshlets: output, lod_bodies: data.lod_bodies };
+}

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#273@#execute"(pass: any, resources: any, context: any): void;
+    static "__#275@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

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":"AA+oBA,kEAAuH;AACvH,gFAAgF;AAChF,wFAEC;AA9lBD,8CAKwB;AAwCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AAoMnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCAnnBA,8DAA8D;6BAyB1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAwpBA,kEAAsH;AACtH,gFAAgF;AAChF,wFAEC;AArmBD,8CAKwB;AAwCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AA2MnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCA5nBA,8DAA8D;6BA2B1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}

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

@@ -7,6 +7,8 @@ import { BRICK4_DATA_STRUCT } from "../global_illumination/brick4/gpu/BRICK4_DAT
 import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { chunk_F_dielectric } from "../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
 import { chunk_direction_view_to_world } from "../shader/chunk/camera/chunk_direction_view_to_world.js";
+import { chunk_uv_octahedral_unit_decode } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_uv_octahedral_unit_encode } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_direction_world_to_view } from "../shader/chunk/camera/chunk_direction_world_to_view.js";
 import { chunk_ray_at } from "../shader/chunk/geometry/ray/chunk_ray_at.js";
 import { chunk_ffx_sssr_advance_ray } from "../shader/chunk/screen_space/chunk_ffx_sssr_advance_ray.js";
@@ -90,7 +92,7 @@ function water_resources(finalize = false) {
         .add(WATER_PARTICLE_OFFSETS_RESOURCE)
         .add(WATER_PARTICLE_ENTRIES_RESOURCE);
     if (finalize) {
-        group.addTexture('receiver').addTexture('trace_metadata');
+        group.addTexture('receiver').addTexture('trace_metadata', 'uint');
     }
     return resources;
 }
@@ -435,9 +437,12 @@ for (const resource of [CAMERA_RESOURCE, TRACE_RESOURCE, SCREEN_DEPTH_RESOURCE,
 
 const body = CodeChunk.from(/* language=WGSL */ `
 struct WaterReceiver {
-    @location(0) receiver: vec4<f32>,
-    @location(1) metadata: vec4<f32>,
     // Receiver UV, bounded path, classified status + Newton updates / 32. Readback is opt-in.
+    @location(0) receiver: vec4<f32>,
+    // The fragment's control path (f32 bits); the surface it was shaded with, its normal octahedral in two unorm16
+    // and its slope variance beside its shore coverage in two f16; its body + 1. The optics take that surface from
+    // here rather than evaluate it again.
+    @location(1) metadata: vec4<u32>,
 }
 
 // A screen-space receiver must lie below the surface point the ray entered at: the refracted ray runs
@@ -515,10 +520,11 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterRecei
     else if (status == 8u) { status = 24u + newton_failure; }
     else if (status == 9u) { status = 31u; }
     return WaterReceiver(vec4f(hit.uv, hit.distance, f32(status) + f32(newton_updates)/32.0),
-        vec4f(control_path, min(hit.residual, 65504.0), coverage, f32(in.body_index + 1u)));
+        vec4<u32>(bitcast<u32>(control_path), pack2x16unorm(uv_octahedral_unit_encode(pixel.normal)),
+            pack2x16float(vec2f(pixel.variance, coverage)), in.body_index + 1u));
 }
 `, [surface_body, chunk_water_screen_ray, chunk_direction_view_to_world,
-    chunk_water_receiver_texel, WATER_LEVEL_TOLERANCE_DECLARATION]);
+    chunk_water_receiver_texel, WATER_LEVEL_TOLERANCE_DECLARATION, chunk_uv_octahedral_unit_encode]);
 
 const finalize_body = CodeChunk.from(/* language=WGSL */ `
 struct WaterOptics {
@@ -528,12 +534,15 @@ struct WaterOptics {
 }
 @fragment
 fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptics {
-    let pixel = water_pixel_surface(in, in.pixel_footprint);
-    let water = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, in.body_index);
     let coord = vec2i(in.clip.xy);
     let metadata = textureLoad(trace_metadata, coord, 0);
     // Equal-depth surfaces must retain the same deterministic owner as receiver selection.
-    if (metadata.w != f32(in.body_index + 1u)) { discard; }
+    if (metadata.w != in.body_index + 1u) { discard; }
+    // the surface the receivers shaded this fragment with
+    let shading = unpack2x16float(metadata.z);
+    let pixel = WaterPixelSurface(uv_octahedral_unit_decode(unpack2x16unorm(metadata.y)), shading.x);
+    let coverage = shading.y;
+    let water = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, in.body_index);
     let dimensions = vec2f(textureDimensions(tDepth, 0));
     let uv = in.clip.xy / dimensions;
     let receiver_data = textureLoad(receiver, coord, 0);
@@ -577,7 +586,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     // wave height across a few metres, against a tolerance the gather already allows.
     let gathered = water_receiver_radiance(tScene, tDepth, tNormal, lookup,
         camera.projection_matrix_inverse, camera.view_matrix_inverse, in.world, interface_normal, above);
-    var path = metadata.x;
+    var path = bitcast<f32>(metadata.x);
     var color = original.rgb;
     // the receiver seen through the surface: refracted, or the pixel's own when there is none
     var receiver_coord = coord;
@@ -612,8 +621,8 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
         scattered = exit * water_inscatter(body, in.world, direction, normalize(in.rest_normal), max(path, 0.0), trace.inscatter_segments);
     }
     let event = water_event(transmitted, fresnel * reflection + scattered);
-    let optical = water_transport(event, original.rgb, color, metadata.z);
-    return WaterOptics(vec4f(optical.transmission, metadata.z), vec4f(optical.radiance, 0.0),
+    let optical = water_transport(event, original.rgb, color, coverage);
+    return WaterOptics(vec4f(optical.transmission, coverage), vec4f(optical.radiance, 0.0),
         vec4f(optical.background, original.a));
 }
 `, [surface_body, chunk_water_screen_ray, chunk_F_dielectric, chunk_ffx_sssr_validate_hit,
@@ -621,7 +630,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     chunk_water_receiver_downwelling, chunk_water_receiver_texel,
     chunk_water_transport, chunk_water_receiver_radiance,
     // water_gi_specular here, and water_gi_irradiance for the in-scatter and the downwelling light
-    chunk_water_gi]);
+    chunk_water_gi, chunk_uv_octahedral_unit_decode]);
 
 export const water_shader = ShaderDescriptor.from({ label: "Water / receivers", resources, body });
 /** The optics pass; its variants differ in the indirect lighting they fall back to, and bind alike. */
@@ -653,7 +662,7 @@ function water_pipeline(shader, targets, finalize) {
         primitive: { topology: "triangle-list", cullMode: "none" },
     });
 }
-export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32float'], false); }
+export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32uint'], false); }
 /** The optics pipeline, its shader built for `switches` (a ShaderSwitchSet). */
 export function create_water_finalize_pipeline(switches) {
     return water_pipeline(water_finalize_shader.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water_avboit.js"],"names":[],"mappings":"AAkCA,mDAwBG;AAQH,+CAqCG;AAUH,4CA4BG;AAMH,uDAYG;AAOH,6CAsCG;8BA3L2B,4BAA4B;4BAC9B,0BAA0B"}
+{"version":3,"file":"shader_water_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water_avboit.js"],"names":[],"mappings":"AAkCA,mDAwBG;AAQH,+CAqCG;AAUH,4CA4BG;AAOH,uDAYG;AAOH,6CAqCG;8BA3L2B,4BAA4B;4BAC9B,0BAA0B"}