@woosh/meep-engine 3.60.4 → 3.60.6

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aAkGhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBArcY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aA2FhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBA9bY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -180,12 +180,6 @@ export class GPUProbeClipmapGI {
 
         const scene = view.scene;
         const sdf = scene.geometries.sdf;
-        const materials = this.#graphics.materials_resident;
-
-        // the scene's materials as they are this frame: a repack recaptures its pairs
-        materials.ensure_scene_materials(scene);
-        materials.update();
-
         sdf.configure(settings.mesh_sdf_voxel_size, settings.mesh_sdf_max_bricks);
         sdf.trim();
         sdf.cards.capture_mode = settings.card_capture_mode;
@@ -193,7 +187,7 @@ export class GPUProbeClipmapGI {
             graph,
             budget: settings.mesh_sdf_bake_budget,
             capture_budget: settings.card_capture_budget,
-            materials,
+            materials: this.#graphics.materials_resident,
             material_contexts: this.#graphics.materials,
         });
 
@@ -235,7 +229,6 @@ export class GPUProbeClipmapGI {
             brick_clipmap: this.#brick_clipmap,
             bricks,
             scene,
-            materials,
             card_rows: this.#holds.rows_buffer,
             resampling: settings.resampling,
         });

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts

@@ -9,14 +9,15 @@
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
- * virtual geometry's cache is held as a mesh's is, and comes from its own source (`VGeoSDFProxies`).
+ * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
+ * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
  * A skinned row draws a clone: the hold and the pair are its source's,
  * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
  * drawing is never let go in between.
  *
- * When the resident material context repacks a material whose version moved, each of that
- * material's pairs is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * When the material manager restages a material whose version moved, each of that material's pairs
+ * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
  *
  * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
  * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
@@ -25,7 +26,7 @@
 export class ProbeClipmapSceneHolds {
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
      */
     constructor(scene: GPUSceneContext, graphics: GraphicsContext);
     /**
@@ -43,7 +44,7 @@ export class ProbeClipmapSceneHolds {
      */
     get pair_count(): number;
     /**
-     * Recaptures asked for, a pair each time its material was repacked.
+     * Recaptures asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested(): number;
@@ -79,6 +80,6 @@ export type GPUSceneContext = import("../../scene/GPUSceneContext.js").GPUSceneC
 export type MeshletGeometry = import("../../geometry/MeshletGeometry.js").MeshletGeometry;
 export type GPUGeometryMetadata = import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata;
 export type ShadeMaterial = import("../../material/ShadeMaterial.js").ShadeMaterial;
-export type GPUResidentMaterialContext = import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
+export type GPUMaterialManager = import("../../material/GPUMaterialManager.js").GPUMaterialManager;
 export type GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
 //# sourceMappingURL=ProbeClipmapSceneHolds.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA1mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;8BAC1F,OAAO,0BAA0B,EAAE,eAAe"}
+{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA3mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js

@@ -10,7 +10,7 @@ import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
  * @typedef {import("../../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
  * @typedef {import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
  * @typedef {import("../../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
- * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
+ * @typedef {import("../../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 
@@ -65,14 +65,15 @@ class Pair {
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
- * virtual geometry's cache is held as a mesh's is, and comes from its own source (`VGeoSDFProxies`).
+ * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
+ * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
  * A skinned row draws a clone: the hold and the pair are its source's,
  * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
  * drawing is never let go in between.
  *
- * When the resident material context repacks a material whose version moved, each of that
- * material's pairs is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * When the material manager restages a material whose version moved, each of that material's pairs
+ * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
  *
  * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
  * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
@@ -86,7 +87,7 @@ export class ProbeClipmapSceneHolds {
     #scene;
 
     /**
-     * @type {GPUResidentMaterialContext}
+     * @type {GPUMaterialManager}
      */
     #materials;
 
@@ -152,14 +153,14 @@ export class ProbeClipmapSceneHolds {
 
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
      */
     constructor(scene, graphics) {
         assert.defined(scene, 'scene');
         assert.defined(graphics, 'graphics');
 
         this.#scene = scene;
-        this.#materials = graphics.materials_resident;
+        this.#materials = graphics.materials;
         this.#device = graphics.device;
     }
 
@@ -187,7 +188,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * Recaptures asked for, a pair each time its material was repacked.
+     * Recaptures asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested() {
@@ -241,7 +242,7 @@ export class ProbeClipmapSceneHolds {
         this.#scene.geometries.sdf.onBaked.add(this.#baked, this);
         cards.onResident.add(this.#card_set_resident, this);
         cards.onWithdrawn.add(this.#card_set_withdrawn, this);
-        this.#materials.onMaterialRepacked.add(this.#repacked, this);
+        this.#materials.onMaterialRestaged.add(this.#restaged, this);
 
         // a row not yet written is taken now, and moved when it is
         rows.for_each_mesh((entity, geometry, material, skinned, flags) => this.#written(entity, geometry, material, flags));
@@ -263,7 +264,7 @@ export class ProbeClipmapSceneHolds {
         sdf.onBaked.remove(this.#baked, this);
         cards.onResident.remove(this.#card_set_resident, this);
         cards.onWithdrawn.remove(this.#card_set_withdrawn, this);
-        this.#materials.onMaterialRepacked.remove(this.#repacked, this);
+        this.#materials.onMaterialRestaged.remove(this.#restaged, this);
 
         for (const [entity, record] of this.#held) {
             sdf.release(record, this.#pair_of.get(entity).two_sided);
@@ -524,7 +525,7 @@ export class ProbeClipmapSceneHolds {
     /**
      * @param {ShadeMaterial} material
      */
-    #repacked(material) {
+    #restaged(material) {
         const of_material = this.#pairs_of_material.get(material.id);
 
         if (of_material === undefined) {

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.d.ts

@@ -10,8 +10,8 @@
  * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
  * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
  * its source's, the hook), and its box resolves in the cascade (`brick_provider_resolves`). A virtual
- * geometry's field is the one baked for its proxy and adopted into it (§7.8), so its rows are taken as
- * a mesh's are, once it is resident.
+ * geometry's header is an alias of its proxy's (§7.8), so its rows are taken as a mesh's are, once the
+ * proxy's field is resident.
  *
  * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
  * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.js

@@ -19,8 +19,8 @@ import { MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
  * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
  * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
  * its source's, the hook), and its box resolves in the cascade (`brick_provider_resolves`). A virtual
- * geometry's field is the one baked for its proxy and adopted into it (§7.8), so its rows are taken as
- * a mesh's are, once it is resident.
+ * geometry's header is an alias of its proxy's (§7.8), so its rows are taken as a mesh's are, once the
+ * proxy's field is resident.
  *
  * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
  * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,

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

@@ -156,13 +156,11 @@ export class GPUProbeClipmap {
      *   the update orders after
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
      *   light and shade: its lights, its environment, its rows and their geometry caches' cards
-     * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
-     *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
      * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
      *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, resampling }: {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, resampling }: {
         graph: FrameGraph;
         x: number;
         y: number;
@@ -178,7 +176,6 @@ export class GPUProbeClipmap {
         brick_clipmap: import("../brick/GPUBrickClipmap.js").GPUBrickClipmap;
         bricks: number;
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
-        materials: import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
         card_rows: GPUBuffer;
         resampling: boolean;
     }): void;

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

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAwOI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAmGhB;IAjVD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAmTjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;QAxB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAE4C,SAAS,EAAhH,OAAO,0DAA0D,EAAE,0BAA0B;QAE1E,SAAS;QACX,UAAU,EAA3B,OAAO;aAiPjB;IA0eD,gBAcC;;CACJ;mCArvCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAqOI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAmGhB;IA9UD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAgTjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAtB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAExC,SAAS;QACX,UAAU,EAA3B,OAAO;aA+OjB;IAweD,gBAcC;;CACJ;mCA5uCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}

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

@@ -380,9 +380,6 @@ export class GPUProbeClipmap {
      */
     #scene = null;
 
-    /** The frame's resident materials, a hit's fallback. @type {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext|null} */
-    #materials = null;
-
     /** The frame's row → card set table. @type {GPUBuffer|null} */
     #card_rows = null;
 
@@ -599,13 +596,11 @@ export class GPUProbeClipmap {
      *   the update orders after
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
      *   light and shade: its lights, its environment, its rows and their geometry caches' cards
-     * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
-     *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
      * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
      *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, resampling }) {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, resampling }) {
         assert.defined(graph, 'graph');
         assert.defined(camera, 'camera');
         assert.defined(stbn, 'stbn');
@@ -616,7 +611,6 @@ export class GPUProbeClipmap {
         assert.defined(brick_clipmap, 'brick_clipmap');
         assert.isNonNegativeInteger(bricks, 'bricks');
         assert.defined(scene, 'scene');
-        assert.defined(materials, 'materials');
         assert.defined(card_rows, 'card_rows');
         assert.isBoolean(resampling, 'resampling');
         assert.notOk(this.#destroyed, 'destroyed');
@@ -772,7 +766,6 @@ export class GPUProbeClipmap {
 
         this.#brick_clipmap = brick_clipmap;
         this.#scene = scene;
-        this.#materials = materials;
         this.#card_rows = card_rows;
 
         const tiles_x = Math.ceil(resolution[0] / PROBE_WANT_TILE);
@@ -1213,8 +1206,6 @@ export class GPUProbeClipmap {
         b.mesh_card_sets = cards.records;
         b.mesh_card_albedo = cards.atlas.texture_at(0).obtainView();
         b.mesh_card_emissive = cards.atlas.texture_at(1).obtainView();
-        b.materials = this.#materials.buffer_materials;
-        b.texture_means = this.#materials.buffer_texture_means;
         b.tEnvironment = lights.environment.obtainView();
 
         shader_probe_clipmap_shade.dispatchIndirect({

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

@@ -5,16 +5,6 @@
  * @type {number}
  */
 export const PROBE_HIT_SURFACE_TOLERANCE_VOXELS: number;
-/**
- * The resident materials' table, as the ray passes read it: `materials[mesh.material]`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_MATERIALS_RESOURCE: ShaderResourceDescriptor;
-/**
- * Each resident texture slot's mean, `GPUResidentMaterialContext.buffer_texture_means`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_TEXTURE_MEANS_RESOURCE: ShaderResourceDescriptor;
 /**
  * What a GI hit's surface is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6), its diffuse albedo and its
  * emissive, from the `meshes` row the hit is on:
@@ -27,15 +17,15 @@ export const PROBE_HIT_TEXTURE_MEANS_RESOURCE: ShaderResourceDescriptor;
  *   the geometry's local space through its node, the normal by the transpose of the node's linear
  *   part, and the tolerance {@link PROBE_HIT_SURFACE_TOLERANCE_VOXELS} voxels of the hit's cascade,
  *   `voxel`, in local units by the transform's mean scale, the cube root of its determinant.
- * - **The material's mean**, where no card set is resident or no card sees the hit: the colour factor
- *   × the albedo slot's mean colour × (1 − the metallic factor × the ORM slot's mean metalness), and the
- *   emissive factor × the emissive slot's mean. What a card would have held, Lumen's diffuse colour,
- *   from the means of what it is made of.
+ * - **Black**, where no card set is resident or no card sees the hit, as UE's Lumen leaves a hit no
+ *   card covers: a surface whose albedo is not known brings back no light rather than light it may not
+ *   have. The cost is energy, never invented energy: a material's colour factor is all of a flat one's
+ *   albedo but only the bound of a textured one's, and in Sponza it made the bounce-lit gallery 60%
+ *   brighter on screen (§6.6).
  * - **Row 0** names no object, the scene root never being a mesh: the hit is black.
  *
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_hit_surface: CodeChunk;
-import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_probe_clipmap_hit_surface.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_hit_surface.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,iDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,2CAFU,wBAAwB,CAEsF;AAExH;;;GAGG;AACH,+CAFU,wBAAwB,CAE+F;AAEjI;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8CAFU,SAAS,CAoDZ;yCA9FkC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_hit_surface.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,iDAFU,MAAM,CAEsC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,8CAFU,SAAS,CA0CZ;0BAvEmB,uCAAuC"}

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

@@ -1,16 +1,11 @@
 import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
 import { chunk_mesh_card_surface } from "../../../geometry/sdf/cards/chunk_mesh_card_surface.js";
 import { MESH_CARD_ROWS_RESOURCE } from "../../../geometry/sdf/cards/MESH_CARD_RESOURCES.js";
-import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
 import { SCENE_DATABASE_RESOURCE } from "../../../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_mat4_inverse } from "../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_mat4_linear_determinant } from "../../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
-import { chunk_albedo_unpremultiply } from "../../../shader/chunk/material/chunk_albedo_unpremultiply.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
-import { vec4f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 
 /**
  * The tolerance a card's depth is held to at a GI hit, in voxels of the hit's brick cascade: a hit is
@@ -20,18 +15,6 @@ import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
  */
 export const PROBE_HIT_SURFACE_TOLERANCE_VOXELS = 1.5;
 
-/**
- * The resident materials' table, as the ray passes read it: `materials[mesh.material]`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_MATERIALS_RESOURCE = ShaderResourceDescriptor.uniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE);
-
-/**
- * Each resident texture slot's mean, `GPUResidentMaterialContext.buffer_texture_means`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_TEXTURE_MEANS_RESOURCE = ShaderResourceDescriptor.storageBuffer("texture_means", WebGPUArray.from(vec4f));
-
 /**
  * What a GI hit's surface is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6), its diffuse albedo and its
  * emissive, from the `meshes` row the hit is on:
@@ -44,10 +27,11 @@ export const PROBE_HIT_TEXTURE_MEANS_RESOURCE = ShaderResourceDescriptor.storage
  *   the geometry's local space through its node, the normal by the transpose of the node's linear
  *   part, and the tolerance {@link PROBE_HIT_SURFACE_TOLERANCE_VOXELS} voxels of the hit's cascade,
  *   `voxel`, in local units by the transform's mean scale, the cube root of its determinant.
- * - **The material's mean**, where no card set is resident or no card sees the hit: the colour factor
- *   × the albedo slot's mean colour × (1 − the metallic factor × the ORM slot's mean metalness), and the
- *   emissive factor × the emissive slot's mean. What a card would have held, Lumen's diffuse colour,
- *   from the means of what it is made of.
+ * - **Black**, where no card set is resident or no card sees the hit, as UE's Lumen leaves a hit no
+ *   card covers: a surface whose albedo is not known brings back no light rather than light it may not
+ *   have. The cost is energy, never invented energy: a material's colour factor is all of a flat one's
+ *   albedo but only the bound of a textured one's, and in Sponza it made the bounce-lit gallery 60%
+ *   brighter on screen (§6.6).
  * - **Row 0** names no object, the scene root never being a mesh: the hit is black.
  *
  * @type {CodeChunk}
@@ -67,11 +51,10 @@ fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, v
         return out;
     }
 
-    let mesh = scene_read_mesh(&scene_database, row);
     let card_set = mesh_card_rows[row];
 
     if (card_set != ${GPU_DATABASE_NULL}u) {
-        let global = scene_read_node(&scene_database, mesh.node).global;
+        let global = scene_read_node(&scene_database, scene_read_mesh(&scene_database, row).node).global;
         let linear = mat3x3<f32>(global[0].xyz, global[1].xyz, global[2].xyz);
 
         let p = (mat4_inverse(global) * vec4<f32>(position, 1.0)).xyz;
@@ -83,28 +66,17 @@ fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, v
         if (seen.found) {
             out.albedo = seen.albedo;
             out.emissive = seen.emissive;
-
-            return out;
         }
     }
 
-    let material = materials[mesh.material];
-    let metalness = material.metallic_factor * texture_means[material.texture_orm].b;
-
-    out.albedo = albedo_unpremultiply(texture_means[material.texture_albedo]) * material.color_albedo.rgb * (1.0 - metalness);
-    out.emissive = texture_means[material.texture_emissive].rgb * material.emissive_factor;
-
     return out;
 }
 `, [
         chunk_scene_database_access,
         chunk_mat4_inverse,
         chunk_mat4_linear_determinant,
-        chunk_albedo_unpremultiply,
         chunk_mesh_card_surface,
     ]);
 
 chunk_probe_clipmap_hit_surface.requireResource(SCENE_DATABASE_RESOURCE);
 chunk_probe_clipmap_hit_surface.requireResource(MESH_CARD_ROWS_RESOURCE);
-chunk_probe_clipmap_hit_surface.requireResource(PROBE_HIT_MATERIALS_RESOURCE);
-chunk_probe_clipmap_hit_surface.requireResource(PROBE_HIT_TEXTURE_MEANS_RESOURCE);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAxH2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAlH2B,kCAAkC"}

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

@@ -19,11 +19,7 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { BRICK_TRACE_HIT, BRICK_TRACE_MISS } from "../brick/BRICK_CLIPMAP.js";
 import { BRICK_LEVELS_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
-import {
-    chunk_probe_clipmap_hit_surface,
-    PROBE_HIT_MATERIALS_RESOURCE,
-    PROBE_HIT_TEXTURE_MEANS_RESOURCE
-} from "./chunk_probe_clipmap_hit_surface.js";
+import { chunk_probe_clipmap_hit_surface } from "./chunk_probe_clipmap_hit_surface.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_ray_origin,
@@ -49,8 +45,6 @@ resources.createGroup()
 resources.createGroup()
     .add(SCENE_DATABASE_RESOURCE)
     .add(MESH_CARD_ROWS_RESOURCE)
-    .add(PROBE_HIT_MATERIALS_RESOURCE)
-    .add(PROBE_HIT_TEXTURE_MEANS_RESOURCE)
     .add(MESH_SDF_HEADERS_RESOURCE)
     .add(MESH_SDF_INDIRECTION_RESOURCE)
     .add(MESH_CARD_SETS_RESOURCE)

package/src/shade/renderer/hiz/HZBFootprint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How many source texels, along one axis, the mip 0 reduction reads per HZB texel: the widest footprint
+ * any HZB texel of the dispatch has on that axis ({@link hzb_footprint_texels }). Narrower footprints in
+ * the same dispatch read their last texel again.
+ *
+ * Two when the axis halves exactly, three when mip 0 is padded past half the source, which the HZB's
+ * sizing caps at three ({@link HierarchicalZBuffersetViewportSize }).
+ */
+export type HZBFootprint = number;
+export namespace HZBFootprint {
+    let Two: number;
+    let Three: number;
+}
+//# sourceMappingURL=HZBFootprint.d.ts.map

package/src/shade/renderer/hiz/HZBFootprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HZBFootprint.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HZBFootprint.js"],"names":[],"mappings":";;;;;;;;2BAQU,MAAM"}

package/src/shade/renderer/hiz/HZBFootprint.js

@@ -0,0 +1,16 @@
+/**
+ * How many source texels, along one axis, the mip 0 reduction reads per HZB texel: the widest footprint
+ * any HZB texel of the dispatch has on that axis ({@link hzb_footprint_texels}). Narrower footprints in
+ * the same dispatch read their last texel again.
+ *
+ * Two when the axis halves exactly, three when mip 0 is padded past half the source, which the HZB's
+ * sizing caps at three ({@link HierarchicalZBuffer#setViewportSize}).
+ *
+ * @enum {number}
+ */
+export const HZBFootprint = {
+    /** Two texels: the source is exactly twice the HZB's mip 0 on this axis. */
+    Two: 0,
+    /** Three texels: the HZB's mip 0 is padded past half the source on this axis. */
+    Three: 1,
+};

package/src/shade/renderer/hiz/HZB_FOOTPRINT_X.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The mip 0 reduction's footprint across x — decided by {@link chunk_hzb_footprint_x}.
+ *
+ * `HierarchicalZBuffer` sets it from the viewport and its mip 0 width, each time the viewport changes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const HZB_FOOTPRINT_X: ShaderSwitch;
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=HZB_FOOTPRINT_X.d.ts.map

package/src/shade/renderer/hiz/HZB_FOOTPRINT_X.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HZB_FOOTPRINT_X.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HZB_FOOTPRINT_X.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,8BAFU,YAAY,CAE4D;6BAVrD,oCAAoC"}

package/src/shade/renderer/hiz/HZB_FOOTPRINT_X.js

@@ -0,0 +1,11 @@
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+
+/**
+ * The mip 0 reduction's footprint across x — decided by {@link chunk_hzb_footprint_x}.
+ *
+ * `HierarchicalZBuffer` sets it from the viewport and its mip 0 width, each time the viewport changes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const HZB_FOOTPRINT_X = ShaderSwitch.enum('hzb footprint x', HZBFootprint);

package/src/shade/renderer/hiz/HZB_FOOTPRINT_Y.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The mip 0 reduction's footprint across y — decided by {@link chunk_hzb_footprint_y}.
+ *
+ * `HierarchicalZBuffer` sets it from the viewport and its mip 0 height, each time the viewport changes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const HZB_FOOTPRINT_Y: ShaderSwitch;
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=HZB_FOOTPRINT_Y.d.ts.map

package/src/shade/renderer/hiz/HZB_FOOTPRINT_Y.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HZB_FOOTPRINT_Y.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HZB_FOOTPRINT_Y.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,8BAFU,YAAY,CAE4D;6BAVrD,oCAAoC"}

package/src/shade/renderer/hiz/HZB_FOOTPRINT_Y.js

@@ -0,0 +1,11 @@
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+
+/**
+ * The mip 0 reduction's footprint across y — decided by {@link chunk_hzb_footprint_y}.
+ *
+ * `HierarchicalZBuffer` sets it from the viewport and its mip 0 height, each time the viewport changes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const HZB_FOOTPRINT_Y = ShaderSwitch.enum('hzb footprint y', HZBFootprint);

package/src/shade/renderer/hiz/HierarchicalZBuffer.d.ts

@@ -1,10 +1,3 @@
-/**
- * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
- * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
- * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
- * @typedef {import("../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
- * @typedef {import("./hzb_plan_reduction_steps.js").HZBReductionStep} HZBReductionStep
- */
 export class HierarchicalZBuffer {
     /**
      * Offer the pipelines {@link build} dispatches — see {@link PipelineEnquiry}.

package/src/shade/renderer/hiz/HierarchicalZBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HierarchicalZBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HierarchicalZBuffer.js"],"names":[],"mappings":"AAaA;;;;;;GAMG;AAEH;IAkBI;;;;OAIG;IACH,iCAFW,eAAe,QAWzB;IAsBD;;;OAGG;IACH,sBAFW,eAAe,EAczB;IApCD;;;OAGG;IACH,2EAEC;IA8CD;;;;;OAKG;IACH,eAJW,sBAAsB,UACtB,iBAAiB,kBACjB,MAAM,EAAE,QA2HlB;IA6DD;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAkBhB;IA8BD,gBAEC;;CACJ;8BA/UY,OAAO,0CAA0C,EAAE,eAAe;qCAClE,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,uBAAuB,EAAE,eAAe;gCAC/C,OAAO,iCAAiC,EAAE,iBAAiB;+BAC3D,OAAO,+BAA+B,EAAE,gBAAgB"}
+{"version":3,"file":"HierarchicalZBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/HierarchicalZBuffer.js"],"names":[],"mappings":"AAqDA;IAgCI;;;;OAIG;IACH,iCAFW,eAAe,QAazB;IAsBD;;;OAGG;IACH,sBAFW,eAAe,EAczB;IApCD;;;OAGG;IACH,2EAEC;IA8CD;;;;;OAKG;IACH,eAJW,sBAAsB,UACtB,iBAAiB,kBACjB,MAAM,EAAE,QAoHlB;IA6DD;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAgChB;IA8BD,gBAEC;;CACJ;8BAjYY,OAAO,0CAA0C,EAAE,eAAe;qCAClE,OAAO,wCAAwC,EAAE,sBAAsB;8BACvE,OAAO,uBAAuB,EAAE,eAAe;gCAC/C,OAAO,iCAAiC,EAAE,iBAAiB;+BAC3D,OAAO,+BAA+B,EAAE,gBAAgB"}