@woosh/meep-engine 3.27.0 → 3.28.0

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_PLAN_2026_09_03.md

@@ -61,8 +61,9 @@ stacked-card case the way the reference did and MBOIT did not. MBOIT stays selec
 Its orchestrator [`graph_rasterize_meshes_transparent_oit.js`](../oit/graph_rasterize_meshes_transparent_oit.js)
 records, per frame:
 
-1. `filter_materials_by_bucket` twice — `(Transparent, Triangles, Front)` and `(…, Double)`;
-   `ShadeDrawSide.Back` transparent materials are dropped ([`:545-561`](../oit/graph_rasterize_meshes_transparent_oit.js)).
+1. `filter_materials_by_bucket` twice — `(Transparent, Triangles, Front)` and `(…, Double)`.
+   *2026-09-16: `ShadeDrawSide.Back` transparent materials used to be dropped here. They are not any
+   more — `Back` and `Front` are one bucket now, so asking for either returns both.*
 2. `graph_prepare_meshlet_draw_commands_by_material` twice — copy bucket, HZB mesh filter, expand to meshlets,
    HZB meshlet filter, count/scan/sort by material, build one indirect draw command per material.
 3. `MBOIT/generate moments` twice (front clears, double loads) — additive MRT into `r32float` + `rgba32float`,
@@ -486,8 +487,10 @@ unambiguous, must not break anything else, and must not be situational:
   known to be that.
 - **Sparse voxel texture** (slide 122) — *no*. The deck's own future work.
 - **Chroma skew** (§4).
-- **`ShadeDrawSide.Back` transparent materials** — dropped today by MBOIT; the same filter is used here so the
-  two modes draw the same set. Fixing it is a bucket-filter change that belongs to both.
+- **`ShadeDrawSide.Back` transparent materials** — ~~dropped today by MBOIT; the same filter is used here so
+  the two modes draw the same set. Fixing it is a bucket-filter change that belongs to both.~~ **Done,
+  2026-09-16 (`ca95ad3ac`)**, and it was the bucket-filter change this predicted: `Back` is `Front` with
+  the winding reversed in the vertex shader, so both modes draw it and neither needed a third pass.
 - **Exposing the tunables on `Renderer`** — the constants in `AVBOIT_CONSTANTS.js` are the knobs; whether any
   deserves a public field is a question for after the page in §6 has been looked at. *Revision 2:* one did —
   the transmission tint, because it changes a material's meaning rather than a quality/cost trade; it lives

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAkJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAyN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IAnB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAqRlB;+BA97B8B,qBAAqB;0CA7BV,uCAAuC"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAkJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAyN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IAnB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAsRlB;+BA/7B8B,qBAAqB;0CA7BV,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -768,8 +768,9 @@ export function graph_rasterize_meshes_transparent_avboit({
 
     const scene_materials = scene_ctx.drawn_materials;
 
-    // Front-sided and double-sided materials need different pipeline states, so every raster pass
-    // below runs twice. `ShadeDrawSide.Back` is not drawn, the same as under MBOIT (plan §7).
+    // Single-sided and double-sided materials need different pipeline states, so every raster pass
+    // below runs twice. `ShadeDrawSide.Back` is single-sided and rides in the `Front` bucket — the
+    // vertex shader reverses its winding — so unlike under MBOIT (plan §7) it is drawn.
     const material_count_front = filter_materials_by_bucket(
         materials_front, 0,
         TransparencyMode.Transparent,

package/src/shade/renderer/rasterize/native/chunk_rasterize_triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/chunk_rasterize_triangle.js"],"names":[],"mappings":"AAaA,iDA+CC;0BAlDyB,oCAAoC"}
+{"version":3,"file":"chunk_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/chunk_rasterize_triangle.js"],"names":[],"mappings":"AAiBA,iDAsDC;0BAzDyB,oCAAoC"}

package/src/shade/renderer/rasterize/native/chunk_rasterize_triangle.js

@@ -1,4 +1,8 @@
+import { chunk_triangle_winding_is_reversed } from "../chunk_triangle_winding_is_reversed.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import {
+    chunk_triangle_list_reverse_winding
+} from "../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
 import {
     chunk_encode_meshlet_element
 } from "../../shader/chunk/geometry/meshlet/chunk_encode_meshlet_element.js";
@@ -23,9 +27,17 @@ fn rasterize_triangle(
 
     let meshlet_header = meshlet_metadata[meshlet_id];
 
+    let mesh = scene_read_mesh(&scene_database, mesh_index);
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let draw_index = triangle_list_reverse_winding(
+        meshlet_vertex_id,
+        triangle_winding_is_reversed(node, materials[mesh.material].draw_side)
+    );
+
     let last_draw_index = meshlet_header.primitive_count * 3u - 1u;
 
-    let clamped_vertex = min(meshlet_vertex_id, last_draw_index );
+    let clamped_vertex = min(draw_index, last_draw_index );
 
     let triangle_index = clamped_vertex / 3u;
 
@@ -44,9 +56,6 @@ fn rasterize_triangle(
         index:'meshlet_triangle_index',
     })};
 
-    let mesh = scene_read_mesh(&scene_database, mesh_index);
-    let node = scene_read_node(&scene_database, mesh.node);
-
     let projection_matrix = camera.view_projection_matrix;
 
     return projection_matrix * node.global * vec4(geometry_position, 1.0);
@@ -57,6 +66,8 @@ fn rasterize_triangle(
         chunk_read_meshlet_vertex_position,
         chunk_read_meshlet_resolved_index,
         chunk_scene_database_access,
+        chunk_triangle_winding_is_reversed,
+        chunk_triangle_list_reverse_winding,
     ]
 )
 

package/src/shade/renderer/rasterize/native/depth/shadow_rasterization_alpha_tested_pass_descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow_rasterization_alpha_tested_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/depth/shadow_rasterization_alpha_tested_pass_descriptor.js"],"names":[],"mappings":"AAuIA,qFAA4F;qCAzHvD,8CAA8C"}
+{"version":3,"file":"shadow_rasterization_alpha_tested_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/depth/shadow_rasterization_alpha_tested_pass_descriptor.js"],"names":[],"mappings":"AAkJA,qFAA4F;qCAhIvD,8CAA8C"}

package/src/shade/renderer/rasterize/native/depth/shadow_rasterization_alpha_tested_pass_descriptor.js

@@ -1,6 +1,10 @@
 import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import { chunk_triangle_winding_is_reversed } from "../../chunk_triangle_winding_is_reversed.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import {
+    chunk_triangle_list_reverse_winding
+} from "../../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
 import {
     chunk_read_meshlet_resolved_index
 } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_resolved_index.js";
@@ -88,16 +92,21 @@ fn main(
         return output; // discard vertex outside of meshlet bounds
     }
     
+    let mesh = scene_read_mesh(&scene_database, mesh_id);
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let draw_index = triangle_list_reverse_winding(
+        vertex_draw_index,
+        triangle_winding_is_reversed(node, material.draw_side)
+    );
+
     // resolve vertex from index
-    let resolved_vertex_id = read_meshlet_resolved_index(meshlet_header, vertex_draw_index);
-    
+    let resolved_vertex_id = read_meshlet_resolved_index(meshlet_header, draw_index);
+
     let meshlet_vertex = read_meshlet_vertex_uv_position(
         meshlet_header,
         resolved_vertex_id,
     );
-    
-    let mesh = scene_read_mesh(&scene_database, mesh_id);
-    let node = scene_read_node(&scene_database, mesh.node);
 
     let position_world = node.global * vec4(meshlet_vertex.position, 1.0);
 
@@ -112,6 +121,8 @@ fn main(
             chunk_read_meshlet_vertex_uv_position,
             chunk_read_meshlet_resolved_index,
             chunk_scene_database_access,
+            chunk_triangle_winding_is_reversed,
+            chunk_triangle_list_reverse_winding,
         ]
     )
 });

package/src/shade/renderer/rasterize/native/depth/shadow_rasterization_pass_descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow_rasterization_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/depth/shadow_rasterization_pass_descriptor.js"],"names":[],"mappings":"AAwEA,wEAA+E;qCA3D1C,8CAA8C"}
+{"version":3,"file":"shadow_rasterization_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/depth/shadow_rasterization_pass_descriptor.js"],"names":[],"mappings":"AAmFA,wEAA+E;qCAlE1C,8CAA8C"}

package/src/shade/renderer/rasterize/native/depth/shadow_rasterization_pass_descriptor.js

@@ -1,6 +1,10 @@
 import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import { chunk_triangle_winding_is_reversed } from "../../chunk_triangle_winding_is_reversed.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import {
+    chunk_triangle_list_reverse_winding
+} from "../../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
 import {
     chunk_encode_meshlet_element
 } from "../../../shader/chunk/geometry/meshlet/chunk_encode_meshlet_element.js";
@@ -40,16 +44,21 @@ fn main(
         return vec4f(); // discard vertex outside of meshlet bounds
     }
     
+    let mesh = scene_read_mesh(&scene_database, mesh_id);
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let draw_index = triangle_list_reverse_winding(
+        vertex_draw_index,
+        triangle_winding_is_reversed(node, materials[mesh.material].draw_side)
+    );
+
     // resolve vertex from index
-    let resolved_vertex_id = read_meshlet_resolved_index(meshlet_header, vertex_draw_index);
-    
+    let resolved_vertex_id = read_meshlet_resolved_index(meshlet_header, draw_index);
+
     let geometry_position = read_meshlet_vertex_position(
         meshlet_header,
         resolved_vertex_id,
     );
-    
-    let mesh = scene_read_mesh(&scene_database, mesh_id);
-    let node = scene_read_node(&scene_database, mesh.node);
 
     let projection_matrix = camera.view_projection_matrix;
 
@@ -62,6 +71,8 @@ fn main(
         chunk_read_meshlet_resolved_index,
         MESH_TRIANGLE_REFERENCE_STRUCT.declaration_chunk,
         chunk_scene_database_access,
+        chunk_triangle_winding_is_reversed,
+        chunk_triangle_list_reverse_winding,
     ]
 );
 

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAqaA;;;;;;;;;;;;;;;;GAgBG;AACH,uSAFa,MAAM,CAsOlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAqaA;;;;;;;;;;;;;;;;GAgBG;AACH,uSAFa,MAAM,CAuOlB"}

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js

@@ -484,7 +484,8 @@ export function graph_rasterize_meshes_transparent_oit({
     const scene_materials = scene_ctx.drawn_materials;
 
     // we need to draw with different pipeline states, so the code is a little convoluted
-    // Essentially, we draw Double-side and Front-sided materials
+    // Essentially, we draw double-sided and single-sided materials. `ShadeDrawSide.Back` is
+    // single-sided and rides in the `Front` bucket — the vertex shader reverses its winding.
 
     const material_count_front = filter_materials_by_bucket(
         materials_front, 0,

package/src/shade/renderer/rasterize/native/rasterization_shader_resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rasterization_shader_resources.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/rasterization_shader_resources.js"],"names":[],"mappings":"AASA,yEAAgF;4CALpC,sDAAsD"}
+{"version":3,"file":"rasterization_shader_resources.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/rasterization_shader_resources.js"],"names":[],"mappings":"AAUA,yEAAgF;4CALpC,sDAAsD"}

package/src/shade/renderer/rasterize/native/rasterization_shader_resources.js

@@ -1,6 +1,7 @@
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { MATERIAL_METADATA_STRUCT } from "../../material/MATERIAL_METADATA_STRUCT.js";
 import { MESHLET_COLLECTION_STRUCT } from "../MESHLET_COLLECTION_STRUCT.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
@@ -16,4 +17,7 @@ rasterization_shader_resources.createGroup()
     .addStorageBuffer("meshlets", MESHLET_COLLECTION_STRUCT)
     .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
     .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
+    // one draw covers every material in the bucket, so the side a material draws is per-instance
+    // here rather than per-pass, the way the alpha-tested and forward passes can have it
+    .addStorageBuffer("materials", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
 ;

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viz_rasterization_alpha_tested_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js"],"names":[],"mappings":"AAgLA,kFAAyF;qCA1JpD,8CAA8C"}
+{"version":3,"file":"viz_rasterization_alpha_tested_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js"],"names":[],"mappings":"AAyLA,kFAAyF;qCA/JpD,8CAA8C"}

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js

@@ -1,6 +1,10 @@
 import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import { chunk_triangle_winding_is_reversed } from "../../chunk_triangle_winding_is_reversed.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import {
+    chunk_triangle_list_reverse_winding
+} from "../../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
 import { RENDER_GLOBAL_MIP_BIAS } from "../../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
 import {
     chunk_encode_meshlet_element
@@ -114,17 +118,20 @@ fn main(
     }
     
     let triangle_index = encode_meshlet_element(meshlet_id, vertex_draw_index / 3u);
-    
+
+    let mesh = scene_read_mesh(&scene_database, mesh_id);
+    let node = scene_read_node(&scene_database, mesh.node);
+
     let meshlet_vertex = read_meshlet_vertex_by_draw_index(
         meshlet_header,
-        vertex_draw_index,
+        triangle_list_reverse_winding(
+            vertex_draw_index,
+            triangle_winding_is_reversed(node, material.draw_side)
+        ),
     );
-    
+
     var output: VertexOutput;
-    
-    let mesh = scene_read_mesh(&scene_database, mesh_id);
-    let node = scene_read_node(&scene_database, mesh.node);
-    
+
     let instance_matrix = node.global;
     
     let position_world = instance_matrix * vec4(meshlet_vertex.position, 1.0);
@@ -144,6 +151,8 @@ fn main(
             chunk_encode_meshlet_element,
             chunk_read_meshlet_vertex_by_draw_index,
             chunk_scene_database_access,
+            chunk_triangle_winding_is_reversed,
+            chunk_triangle_list_reverse_winding,
         ]
     )
 });

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CA6MjG"}
+{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAmMjG"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js

@@ -15,13 +15,13 @@ import {
     graph_build_indirect_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
 import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
 import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_meshes_to_meshlets.js";
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { MeshletFilter2WayPassData, pass_filter_meshlets_2way } from "../expand/pass1/pass_filter_meshlets_2way.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
 import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
+import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 
 /**
  *
@@ -144,93 +144,83 @@ export function graph_rasterize_partial_opaque({
 
     let is_first_draw = true;
 
-    for (const draw_mode of Object.values(ShadeDrawMode)) {
-        for (const side of Object.values(ShadeDrawSide)) {
-
-            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
-
-            if (!active_buckets.has(bucket_id)) {
-                // no matching materials, skip
-                continue;
-            }
-
-            const pass_data_instances_0 = {};
-
-            const pass_instances_0 = graph.add("HZB mesh filter", pass_data_instances_0, execute);
-
-            pass_data_instances_0.bucket_index = bucket_id;
-
-            pass_data_instances_0.buckets = pass_instances_0.read(buckets);
-            pass_data_instances_0.command = pass_instances_0.create("indirect dispatch command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR)
-            pass_data_instances_0.camera_previous = pass_instances_0.read(camera_previous);
-            pass_data_instances_0.hzb = pass_instances_0.read(hzb);
-
-            pass_data_instances_0.instances_positive = pass_instances_0.create("positive meshes", BufferResourceDescriptor.from(
-                collection_size_meshes,
-                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-                0, 16
-            ));
-
-            gr_instances_maybe = pass_data_instances_0.instances_maybe = pass_instances_0.write(gr_instances_maybe);
-
-            let meshlet_expansion_0 = graph_expand_meshes_to_meshlets({
-                graph,
-                input_meshes: pass_data_instances_0.instances_positive,
-                scene: scene_ctx,
-                expected_output_size: collection_size_meshlets,
-                limits,
-            });
-
-            // the seam. The instance sets of the two HZB passes are disjoint, so cutting each of
-            // them costs one cut per view in total and no instance is ever cut twice
-            meshlet_expansion_0 = graph_vgeo_expand_if_enabled({
-                graph,
-                input_meshes: pass_data_instances_0.instances_positive,
-                output_meshlets: meshlet_expansion_0,
-                view,
-                limits,
-            });
-
-
-            graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, meshlet_expansion_0);
-
-            // ----------
-
-            const gr_command_iterate_meshlets_0 = graph_build_indirect_dispatch_command(graph, meshlet_expansion_0, COMPUTE_SHADER_DEFAULT_GROUP_SIZE);
-
-            const pass_data_meshlets_1 = new MeshletFilter2WayPassData();
-
-            const pass_meshlets_1 = graph.add("filter meshlets 2 way", pass_data_meshlets_1, pass_filter_meshlets_2way);
-
-            pass_data_meshlets_1.view = view;
-            pass_data_meshlets_1.hzb = pass_meshlets_1.read(hzb);
-            pass_data_meshlets_1.command = pass_meshlets_1.read(gr_command_iterate_meshlets_0);
-            pass_data_meshlets_1.input_meshlets = pass_meshlets_1.read(meshlet_expansion_0);
-            pass_data_meshlets_1.out_meshlets_positive = pass_meshlets_1.create("meshlets positive", BufferResourceDescriptor.from(
-                collection_size_meshlets,
-                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-                0, 16 // clear count
-            ));
-            gr_meshlets_maybe = pass_data_meshlets_1.out_meshlets_maybe = pass_meshlets_1.write(gr_meshlets_maybe);
-
-            const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
-
-            // ----------
-            [viz_depth, raster_color_targets] = graph_meshlets_rasterize({
-                graph,
-                view,
-                input_meshlets: pass_data_meshlets_1.out_meshlets_positive,
-                depth: viz_depth,
-                color_targets: raster_color_targets,
-                pass_descriptor: render_pass_descriptor,
-                clear_targets: is_first_draw,
-                primitive_state,
-                viewport,
-            });
-
-            //
-            is_first_draw = false;
-        }
+    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
+        const pass_data_instances_0 = {};
+
+        const pass_instances_0 = graph.add("HZB mesh filter", pass_data_instances_0, execute);
+
+        pass_data_instances_0.bucket_index = bucket_id;
+
+        pass_data_instances_0.buckets = pass_instances_0.read(buckets);
+        pass_data_instances_0.command = pass_instances_0.create("indirect dispatch command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR)
+        pass_data_instances_0.camera_previous = pass_instances_0.read(camera_previous);
+        pass_data_instances_0.hzb = pass_instances_0.read(hzb);
+
+        pass_data_instances_0.instances_positive = pass_instances_0.create("positive meshes", BufferResourceDescriptor.from(
+            collection_size_meshes,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            0, 16
+        ));
+
+        gr_instances_maybe = pass_data_instances_0.instances_maybe = pass_instances_0.write(gr_instances_maybe);
+
+        let meshlet_expansion_0 = graph_expand_meshes_to_meshlets({
+            graph,
+            input_meshes: pass_data_instances_0.instances_positive,
+            scene: scene_ctx,
+            expected_output_size: collection_size_meshlets,
+            limits,
+        });
+
+        // the seam. The instance sets of the two HZB passes are disjoint, so cutting each of
+        // them costs one cut per view in total and no instance is ever cut twice
+        meshlet_expansion_0 = graph_vgeo_expand_if_enabled({
+            graph,
+            input_meshes: pass_data_instances_0.instances_positive,
+            output_meshlets: meshlet_expansion_0,
+            view,
+            limits,
+        });
+
+
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, meshlet_expansion_0);
+
+        // ----------
+
+        const gr_command_iterate_meshlets_0 = graph_build_indirect_dispatch_command(graph, meshlet_expansion_0, COMPUTE_SHADER_DEFAULT_GROUP_SIZE);
+
+        const pass_data_meshlets_1 = new MeshletFilter2WayPassData();
+
+        const pass_meshlets_1 = graph.add("filter meshlets 2 way", pass_data_meshlets_1, pass_filter_meshlets_2way);
+
+        pass_data_meshlets_1.view = view;
+        pass_data_meshlets_1.hzb = pass_meshlets_1.read(hzb);
+        pass_data_meshlets_1.command = pass_meshlets_1.read(gr_command_iterate_meshlets_0);
+        pass_data_meshlets_1.input_meshlets = pass_meshlets_1.read(meshlet_expansion_0);
+        pass_data_meshlets_1.out_meshlets_positive = pass_meshlets_1.create("meshlets positive", BufferResourceDescriptor.from(
+            collection_size_meshlets,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            0, 16 // clear count
+        ));
+        gr_meshlets_maybe = pass_data_meshlets_1.out_meshlets_maybe = pass_meshlets_1.write(gr_meshlets_maybe);
+
+        const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
+
+        // ----------
+        [viz_depth, raster_color_targets] = graph_meshlets_rasterize({
+            graph,
+            view,
+            input_meshlets: pass_data_meshlets_1.out_meshlets_positive,
+            depth: viz_depth,
+            color_targets: raster_color_targets,
+            pass_descriptor: render_pass_descriptor,
+            clear_targets: is_first_draw,
+            primitive_state,
+            viewport,
+        });
+
+        //
+        is_first_draw = false;
     }
 
     // at this point we have rendered all occluders, and the uncertain cases are all stored in the "maybe" set

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAgGA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CA4GlD"}
+{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAgGA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAkGlD"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js

@@ -7,7 +7,6 @@ import { TransparencyMode } from "../../material/TransparencyMode.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
 import { build_indirect_compute_dispatch_command } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
 import { graph_sort_meshlets_by_bucket_id } from "../expand/bucket/meshlet/graph_sort_meshlets_by_bucket_id.js";
 import { shader_meshlets_extract_bucket } from "../expand/bucket/meshlet/shader_meshlets_extract_bucket.js";
 import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
@@ -18,6 +17,7 @@ import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_mes
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
 import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
+import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 
 /**
  *
@@ -180,38 +180,28 @@ export function graph_rasterize_remaining_opaque({
         limits,
     });
 
-    for (const draw_mode of Object.values(ShadeDrawMode)) {
-        for (const side of Object.values(ShadeDrawSide)) {
+    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
+        const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
 
-            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
-
-            if (!active_buckets.has(bucket_id)) {
-                // no matching materials, skip
-                continue;
-            }
+        // copy out a meshlet set
+        const meshlets = graph_extract_meshlets_from_bucket({
+            graph,
+            buckets: meshlet_buckets,
+            bucket_id,
+            limits,
+        });
 
-            const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
-
-            // copy out a meshlet set
-            const meshlets = graph_extract_meshlets_from_bucket({
-                graph,
-                buckets: meshlet_buckets,
-                bucket_id,
-                limits,
-            });
-
-            [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize({
-                graph,
-                view,
-                input_meshlets: meshlets,
-                depth: gr_depth_texture,
-                color_targets: raster_color_targets,
-                pass_descriptor: render_pass_descriptor,
-                clear_targets: false,
-                primitive_state,
-                viewport,
-            });
-        }
+        [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize({
+            graph,
+            view,
+            input_meshlets: meshlets,
+            depth: gr_depth_texture,
+            color_targets: raster_color_targets,
+            pass_descriptor: render_pass_descriptor,
+            clear_targets: false,
+            primitive_state,
+            viewport,
+        });
     }
 
     return {

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

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAmEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;OAIG;IACH,cAqEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA1pBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;OAIG;IACH,cAqEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA5pBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}

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

@@ -51,6 +51,8 @@ const ROOT_RECORD = {
     global: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
     prev_global: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
     parent: NODE3D_SCENE_ID,
+    // identity does not reflect
+    global_flags: 0,
 };
 
 /**

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

@@ -18,6 +18,25 @@
  * shaders that need it pull in `chunk_mat4_inverse`.
  */
 export const NODE3D_STRUCT: WebGPUStruct;
+/**
+ * `global` reflects: the determinant of its linear part is negative,
+ * because an odd number of negative scale axes appears somewhere in the
+ * chain that composed it.
+ *
+ * Two consequences, and the renderer has to act on both. Every triangle
+ * drawn under the node comes out of the vertex shader wound backwards,
+ * so fixed-function front-face determination culls exactly the faces
+ * pointing at the camera unless the draw reverses them. And the node's
+ * tangent frame changes handedness, so a bitangent reconstructed as
+ * `cross(N, T) * w` needs the other `w`.
+ *
+ * A node is not necessarily a mesh — bones, empties and particle
+ * emitters have rows in the same table — so this says nothing about
+ * geometry, only about the transform.
+ *
+ * @type {number}
+ */
+export const NODE3D_GLOBAL_FLAG_MIRRORED: number;
 /**
  * Reserved row id for the scene root in the GPU `transforms` table.
  *

package/src/shade/renderer/scene/NODE3D_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NODE3D_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/NODE3D_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCA4CU;AAEV;;;;;;;;;;;;;;;GAeG;AACH,8BAFU,MAAM,CAEiB;6BAnFJ,gCAAgC"}
+{"version":3,"file":"NODE3D_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/NODE3D_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCA0DU;AAEV;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,8BAFU,MAAM,CAEiB;6BArHJ,gCAAgC"}