@woosh/meep-engine 3.14.4 → 3.14.6

package/src/shade/playground/particle_system/particle_scene.js

@@ -4,10 +4,27 @@ import { m4_look_at } from "../../../core/geom/3d/mat4/m4_look_at.js";
 import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../renderer/camera/CAMERA_UNIFORM_STRUCT.js";
-import { PARTICLE_RECORD_WORD_COUNT } from "../../renderer/particles/ParticleConstants.js";
+import {
+    PARTICLE_RECORD_WORD_COUNT,
+    PARTICLE_SIMULATE_WORKGROUP_SIZE,
+} from "../../renderer/particles/ParticleConstants.js";
+import {
+    PREFIX_SCAN_CSDLDF_HEADER_WORDS,
+    PREFIX_SCAN_CSDLDF_PARTITION_SIZE,
+    shader_prefix_scan_csdldf,
+} from "../../renderer/gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js";
+import { build_indirect_compute_dispatch_command } from "../../renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import {
+    shader_particle_bucket_fill,
+    shader_particle_bucket_histogram,
+    shader_particle_bucket_pad,
+    shader_particle_bucket_reset,
+    shader_particle_bucket_scatter,
+} from "../../renderer/particles/coherence/shader_particle_bucket.js";
 import { PARTICLE_COUNTER_COUNT } from "../../renderer/particles/data/PARTICLE_COUNTERS.js";
 import { EMITTER_BLEND, EMITTER_PROJECTION } from "../../renderer/particles/data/PARTICLE_EMITTER_LAYOUT.js";
-import { ParticleGraph } from "../../renderer/particles/graph/ParticleGraph.js";
+import { NodeGraph } from "../../../core/model/node-graph/NodeGraph.js";
+import { particle_node, particle_wire } from "../../renderer/particles/graph/particle_graph_authoring.js";
 import { VM_BUILTIN, VM_RANDOM_MODE } from "../../renderer/particles/isa/ParticleVMISA.js";
 import { ParticleLayout } from "../../renderer/particles/layout/ParticleLayout.js";
 import { GPUParticleSystem } from "../../renderer/particles/GPUParticleSystem.js";
@@ -22,10 +39,7 @@ import {
     shader_particle_build_indirect,
     shader_particle_reset_counters,
 } from "../../renderer/particles/shaders/shader_particle_finalize.js";
-import {
-    PARTICLE_SIMULATE_WORKGROUP_SIZE,
-    shader_particle_simulate,
-} from "../../renderer/particles/shaders/shader_particle_simulate.js";
+import { shader_particle_simulate } from "../../renderer/particles/shaders/shader_particle_simulate.js";
 
 /**
  * The scene the particle playground draws, with every reference to the page removed: it takes a
@@ -49,6 +63,12 @@ import {
  * billboard draw via `drawIndirect`, both from args the build-indirect pass writes on the GPU. No
  * CPU readback participates in sizing anything — a stale CPU count would orphan alive-list entries
  * when the population grows and double-free slots when it shrinks.
+ *
+ * The four emitters run four distinct compiled programs, so this is also where the simulation-order
+ * bucketing has something to do: without it a simulate wave holds fire, smoke, spark and dust
+ * particles side by side, each wanting different opcodes out of the interpreter's switch. The
+ * bucketing passes are encoded directly here rather than through `graph_particles`, which is the
+ * frame-graph wiring of the same sequence.
  */
 
 /** Maximum simultaneous particles across every emitter — they share one pool. */
@@ -74,7 +94,10 @@ const STATS_OFFSET_DRAW_ARGS = 48;
  * @typedef {object} ParticleSceneStats
  * @property {number} alive particles alive at the end of the captured frame
  * @property {number} dead free slots left in the pool
- * @property {number} alive_in the snapshot next frame's simulate reads as its input length
+ * @property {number} alive_in the snapshot next frame's simulate reads as its input length — the
+ *   PADDED length of the coherence list, so it is `sim_padded` from the captured frame, not `alive`
+ * @property {number} sim_padded length of the program-coherent list the coherence pass built this
+ *   frame; the gap to `alive` is the lanes padding costs to keep each wave on one VM program
  * @property {number[]} dispatch simulate's indirect dispatch args, `[x, y, z]` workgroups
  * @property {number[]} draw the billboard draw's indirect args, `[vertices, instances]`
  */
@@ -147,6 +170,37 @@ export function create_particle_scene(graphics, { color_format, capacity = PARTI
     const dispatch_args = device.createBuffer({ label: "particles/dispatch_args", size: 3 * 4, usage: args_usage });
     const draw_args = device.createBuffer({ label: "particles/draw_args", size: 4 * 4, usage: args_usage });
 
+    // --- simulation-order (coherence) buffers -------------------------------------------------
+    //
+    // A separate set from the render-order sort's, on purpose: one list is grouped by VM program and
+    // camera-independent, the other is back-to-front by view depth. Sharing a buffer between them
+    // would couple a camera-driven ordering to a program-driven one.
+    const sizes = system.bufferSizes();
+    const buckets = system.bucketCount();
+    const sim_list = device.createBuffer({ label: "particles/sim_list", size: sizes.sim_list, usage: storage });
+    const sim_keys = device.createBuffer({ label: "particles/sim_keys", size: sizes.sim_keys, usage: storage });
+    const sim_histogram = device.createBuffer({ label: "particles/sim_histogram", size: sizes.sim_histogram, usage: storage });
+    const sim_bucket_counts = device.createBuffer({ label: "particles/sim_bucket_counts", size: sizes.sim_bucket_counts, usage: storage });
+    const sim_cursor = device.createBuffer({ label: "particles/sim_cursor", size: sizes.sim_cursor, usage: storage });
+    const sim_dispatch_args = device.createBuffer({ label: "particles/sim_dispatch_args", size: sizes.sim_dispatch_args, usage: args_usage });
+
+    // Scratch the reused CSDLDF scan needs: the indirect command it is dispatched with, and its
+    // decoupled-lookback spine. One partition covers every plausible bucket count.
+    const scan_command = device.createBuffer({
+        label: "particles/sim_scan_command",
+        size: 3 * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    });
+    // Cleared at the top of every frame, not just on creation: the spine carries per-partition
+    // flags, and a stale FLAG_INCLUSIVE left over from last frame is read as this frame's answer.
+    // The frame-graph wiring gets this for free from `BufferResourceDescriptor.empty`; encoding by
+    // hand has to ask. Rounded to a 256-byte allocation rather than the 8 bytes one partition needs.
+    const scan_spine = device.createBuffer({
+        label: "particles/sim_scan_spine",
+        size: Math.max(256, Math.ceil(buckets / PREFIX_SCAN_CSDLDF_PARTITION_SIZE) * 2 * 4),
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+
     const initial = system.initialFreeList();
     device.queue.writeBuffer(dead, 0, initial.dead);
     device.queue.writeBuffer(counters, 0, initial.counters);
@@ -204,7 +258,12 @@ export function create_particle_scene(graphics, { color_format, capacity = PARTI
         capacity,
 
         /** Buffers a harness may inspect. Not for the frame loop, which never reads them back. */
-        buffers: { pool, alive_a, alive_b, dead, counters, spawn_requests, emitters, program, constants, dispatch_args, draw_args },
+        buffers: {
+            pool, alive_a, alive_b, dead, counters, spawn_requests, emitters, program, constants,
+            dispatch_args, draw_args,
+            sim_list, sim_keys, sim_histogram, sim_bucket_counts, sim_cursor, sim_dispatch_args,
+            sim_scan_command: scan_command, sim_scan_spine: scan_spine,
+        },
 
         /**
          * Encode one whole frame: geometry, then emit + simulate + build-indirect, then the
@@ -258,13 +317,59 @@ export function create_particle_scene(graphics, { color_format, capacity = PARTI
                 encoder: cmd,
                 bindings: {
                     emitters, program, vm_constants: constants, pool,
-                    alive_in: alive_read, alive_out: alive_write, dead, counters,
+                    sim_list, alive_out: alive_write, dead, counters,
                     settings: { u_dt: dt, u_time: time, u_frame: system.frame },
                 },
                 command: dispatch_args,
             });
 
-            // Snapshot the final alive count (next frame's simulate input) + write this frame's draw args.
+            // --- coherence: regroup the finished alive list by VM program for NEXT frame's simulate ---
+            //
+            // Reads the list emit and simulate have both finished appending to, and rewrites
+            // `sim_list` — the buffer simulate read a few lines above. Consecutive dispatches are
+            // ordered, so the read is complete before the write lands.
+            shader_particle_bucket_reset.dispatchThreads({
+                encoder: cmd,
+                bindings: { counters, histogram: sim_histogram, cursor: sim_cursor, sim_dispatch_args, u_bucket_count: buckets },
+                thread_count_x: bucket_reset_thread_count(buckets),
+            });
+
+            shader_particle_bucket_histogram.dispatchIndirect({
+                encoder: cmd,
+                bindings: { emitters, pool, alive: alive_write, keys: sim_keys, histogram: sim_histogram, counters },
+                command: sim_dispatch_args,
+            });
+
+            shader_particle_bucket_pad.dispatchThreads({
+                encoder: cmd,
+                bindings: { histogram: sim_histogram, bucket_counts: sim_bucket_counts, u_bucket_count: buckets },
+                thread_count_x: buckets,
+            });
+
+            // The same scan the radix sort runs its spine through, reused unmodified.
+            cmd.clearBuffer(scan_spine, 0, scan_spine.size);
+            build_indirect_compute_dispatch_command(
+                PREFIX_SCAN_CSDLDF_PARTITION_SIZE, cmd, sim_histogram, 0, scan_command, 0,
+            );
+            shader_prefix_scan_csdldf.dispatchIndirect({
+                encoder: cmd,
+                command: scan_command,
+                bindings: { scan_in: sim_histogram, spine: scan_spine },
+            });
+
+            shader_particle_bucket_scatter.dispatchIndirect({
+                encoder: cmd,
+                bindings: { keys: sim_keys, alive: alive_write, scanned: sim_histogram, cursor: sim_cursor, sim_list, counters },
+                command: sim_dispatch_args,
+            });
+
+            shader_particle_bucket_fill.dispatchThreads({
+                encoder: cmd,
+                bindings: { bucket_counts: sim_bucket_counts, scanned: sim_histogram, sim_list, counters, u_bucket_count: buckets },
+                thread_count_x: buckets * PARTICLE_SIMULATE_WORKGROUP_SIZE,
+            });
+
+            // Snapshot the padded list length (next frame's simulate input) + write this frame's draw args.
             shader_particle_build_indirect.dispatch({
                 encoder: cmd,
                 bindings: { counters, dispatch_args, draw_args, u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE },
@@ -319,6 +424,7 @@ export function create_particle_scene(graphics, { color_format, capacity = PARTI
                 alive: words[0],
                 dead: words[1],
                 alive_in: words[4],
+                sim_padded: words[5],
                 dispatch: [words[dispatch_base], words[dispatch_base + 1], words[dispatch_base + 2]],
                 draw: [words[draw_base], words[draw_base + 1]],
             };
@@ -342,49 +448,49 @@ function make_effect({ velocity, velocityJitter = 0, posJitter = 0, accel = 0, l
         { name: "size", components: 1 }, { name: "color", components: 4 },
     ]);
 
-    const spawn = new ParticleGraph();
-    let posN = spawn.add("builtin", { id: VM_BUILTIN.EMITTER_POSITION });
+    const spawn = new NodeGraph();
+    let posN = particle_node(spawn, "builtin", { id: VM_BUILTIN.EMITTER_POSITION });
     if (posJitter > 0) {
-        const d = spawn.add("random", { mode: VM_RANDOM_MODE.UNIT_DISK });
-        const j = spawn.add("scale"); spawn.wire(j, "v", d); spawn.wire(j, "s", [posJitter]);
-        const p = spawn.add("add"); spawn.wire(p, "a", posN); spawn.wire(p, "b", j); posN = p;
+        const d = particle_node(spawn, "random", { mode: VM_RANDOM_MODE.UNIT_DISK });
+        const j = particle_node(spawn, "scale"); particle_wire(spawn, j, "v", d); particle_wire(spawn, j, "s", [posJitter]);
+        const p = particle_node(spawn, "add"); particle_wire(spawn, p, "a", posN); particle_wire(spawn, p, "b", j); posN = p;
     }
-    spawn.wire(spawn.add("setAttribute", { name: "position" }), "value", posN);
+    particle_wire(spawn, particle_node(spawn, "setAttribute", { name: "position" }), "value", posN);
 
-    let velN = spawn.add("const", { value: [velocity[0], velocity[1], velocity[2], 0] });
+    let velN = particle_node(spawn, "const", { value: [velocity[0], velocity[1], velocity[2], 0] });
     if (velocityJitter > 0) {
-        const r = spawn.add("random", { mode: VM_RANDOM_MODE.UNIFORM_SIGNED });
-        const rs = spawn.add("scale"); spawn.wire(rs, "v", r); spawn.wire(rs, "s", [velocityJitter]);
-        const vv = spawn.add("add"); spawn.wire(vv, "a", velN); spawn.wire(vv, "b", rs); velN = vv;
+        const r = particle_node(spawn, "random", { mode: VM_RANDOM_MODE.UNIFORM_SIGNED });
+        const rs = particle_node(spawn, "scale"); particle_wire(spawn, rs, "v", r); particle_wire(spawn, rs, "s", [velocityJitter]);
+        const vv = particle_node(spawn, "add"); particle_wire(spawn, vv, "a", velN); particle_wire(spawn, vv, "b", rs); velN = vv;
     }
-    spawn.wire(spawn.add("setAttribute", { name: "velocity" }), "value", velN);
-    spawn.wire(spawn.add("setAttribute", { name: "age" }), "value", [0]);
-    const lr = spawn.add("random", { mode: VM_RANDOM_MODE.UNIFORM });
-    const lm = spawn.add("mad"); spawn.wire(lm, "a", lr); spawn.wire(lm, "b", [life[1] - life[0]]); spawn.wire(lm, "c", [life[0]]);
-    spawn.wire(spawn.add("setAttribute", { name: "lifetime" }), "value", lm);
-    spawn.wire(spawn.add("setAttribute", { name: "size" }), "value", [size]);
-    spawn.wire(spawn.add("setAttribute", { name: "color" }), "value", color);
-
-    const update = new ParticleGraph();
-    const dt = update.add("builtin", { id: VM_BUILTIN.DELTA_TIME });
-    const age = update.add("attribute", { name: "age" });
-    const nage = update.add("add"); update.wire(nage, "a", age); update.wire(nage, "b", dt);
-    update.wire(update.add("setAttribute", { name: "age" }), "value", nage);
-    const lifeA = update.add("attribute", { name: "lifetime" });
-    const na = update.add("div"); update.wire(na, "a", nage); update.wire(na, "b", lifeA);
-    const dead = update.add("compare", { op: "ge" }); update.wire(dead, "a", na); update.wire(dead, "b", [1]);
-    update.wire(update.add("kill"), "condition", dead);
-    let velN2 = update.add("attribute", { name: "velocity" });
+    particle_wire(spawn, particle_node(spawn, "setAttribute", { name: "velocity" }), "value", velN);
+    particle_wire(spawn, particle_node(spawn, "setAttribute", { name: "age" }), "value", [0]);
+    const lr = particle_node(spawn, "random", { mode: VM_RANDOM_MODE.UNIFORM });
+    const lm = particle_node(spawn, "mad"); particle_wire(spawn, lm, "a", lr); particle_wire(spawn, lm, "b", [life[1] - life[0]]); particle_wire(spawn, lm, "c", [life[0]]);
+    particle_wire(spawn, particle_node(spawn, "setAttribute", { name: "lifetime" }), "value", lm);
+    particle_wire(spawn, particle_node(spawn, "setAttribute", { name: "size" }), "value", [size]);
+    particle_wire(spawn, particle_node(spawn, "setAttribute", { name: "color" }), "value", color);
+
+    const update = new NodeGraph();
+    const dt = particle_node(update, "builtin", { id: VM_BUILTIN.DELTA_TIME });
+    const age = particle_node(update, "attribute", { name: "age" });
+    const nage = particle_node(update, "add"); particle_wire(update, nage, "a", age); particle_wire(update, nage, "b", dt);
+    particle_wire(update, particle_node(update, "setAttribute", { name: "age" }), "value", nage);
+    const lifeA = particle_node(update, "attribute", { name: "lifetime" });
+    const na = particle_node(update, "div"); particle_wire(update, na, "a", nage); particle_wire(update, na, "b", lifeA);
+    const dead = particle_node(update, "compare", { op: "ge" }); particle_wire(update, dead, "a", na); particle_wire(update, dead, "b", [1]);
+    particle_wire(update, particle_node(update, "kill"), "condition", dead);
+    let velN2 = particle_node(update, "attribute", { name: "velocity" });
     if (accel !== 0) {
-        const g = update.add("const", { value: [0, accel, 0, 0] });
-        const gd = update.add("scale"); update.wire(gd, "v", g); update.wire(gd, "s", dt);
-        const nv = update.add("add"); update.wire(nv, "a", velN2); update.wire(nv, "b", gd);
-        update.wire(update.add("setAttribute", { name: "velocity" }), "value", nv); velN2 = nv;
+        const g = particle_node(update, "const", { value: [0, accel, 0, 0] });
+        const gd = particle_node(update, "scale"); particle_wire(update, gd, "v", g); particle_wire(update, gd, "s", dt);
+        const nv = particle_node(update, "add"); particle_wire(update, nv, "a", velN2); particle_wire(update, nv, "b", gd);
+        particle_wire(update, particle_node(update, "setAttribute", { name: "velocity" }), "value", nv); velN2 = nv;
     }
-    const pos = update.add("attribute", { name: "position" });
-    const pd = update.add("scale"); update.wire(pd, "v", velN2); update.wire(pd, "s", dt);
-    const np = update.add("add"); update.wire(np, "a", pos); update.wire(np, "b", pd);
-    update.wire(update.add("setAttribute", { name: "position" }), "value", np);
+    const pos = particle_node(update, "attribute", { name: "position" });
+    const pd = particle_node(update, "scale"); particle_wire(update, pd, "v", velN2); particle_wire(update, pd, "s", dt);
+    const np = particle_node(update, "add"); particle_wire(update, np, "a", pos); particle_wire(update, np, "b", pd);
+    particle_wire(update, particle_node(update, "setAttribute", { name: "position" }), "value", np);
 
     return create_particle_effect({ layout, spawn, update });
 }
@@ -528,6 +634,18 @@ function translation(x, y, z) {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1];
 }
 
+/**
+ * Threads the bucket reset pass needs: enough to cover the scan's header plus its bins, rounded up
+ * to the whole `vec4` the last bin lands in (the scan reads whole `vec4`s, so the tail has to be
+ * cleared too or garbage joins the sums).
+ *
+ * @param {number} bucket_count
+ * @returns {number}
+ */
+function bucket_reset_thread_count(bucket_count) {
+    return PREFIX_SCAN_CSDLDF_HEADER_WORDS + ((bucket_count + 3) & ~3);
+}
+
 function data_buffer(device, label, data, usage) {
     const buffer = device.createBuffer({ label, size: Math.max(data.byteLength, 4), usage });
     device.queue.writeBuffer(buffer, 0, data);

package/src/shade/playground/skinned_mesh_soup/README.md

@@ -41,12 +41,12 @@ zero** by the `max`. The rotation it extracts is not the matrix's rotation, and
 depends on the matrix — so it is wrong differently for every joint. That is the soup: not one
 transform applied badly, but sixty-five of them disagreeing.
 
-The two modes make the mechanism visible:
+The two modes made the mechanism visible:
 
-| `?skin=` | what you see | why |
+| `?skin=` | what it did | why |
 | --- | --- | --- |
-| `bind` | the right character, exactly 1/100 the size | every joint folds to the *same* matrix, `100·Rx(90°)`. Its `w` and `x` terms are both `1 + 100`, its `y` and `z` both clamp to zero, and the normalize recovers `Rx(90°)` — by luck. Only the scale is lost. Sampled output is `expected / 100` to the digit. |
-| `animated` | soup | the joints' matrices differ, each loses a different amount, and the mesh comes apart. Mean error 121 in a mesh-local space where the body is 224 across; worst 165, on vertices bound to **a single joint at weight 1** — so the blend is not even involved. |
+| `bind` | the right character, exactly 1/100 the size | every joint folds to the *same* matrix, `100·Rx(90°)`. Its `w` and `x` terms are both `1 + 100`, its `y` and `z` both clamp to zero, and the normalize recovers `Rx(90°)` — by luck. Only the scale is lost. Sampled output was `expected / 100` to the digit. |
+| `animated` | soup | the joints' matrices differ, each loses a different amount, and the mesh comes apart. Mean error 121 in a mesh-local space where the body is 224 across; worst 165, on vertices bound to **a single joint at weight 1** — so the blend was not even involved. |
 
 `__soup_blend_probe.spec.js` is that measurement: the WGSL of `dual_quat_from_m4`,
 `dual_quat_blend4` and `dual_quat_transform_point` ported to JS, run over the character's own
@@ -71,22 +71,42 @@ against the bounds chain's box, and **both are derived from the clone's vertex r
 that are wrong in the same way agree with each other perfectly. A green `verify()` and a soup
 picture are consistent.
 
-## The fix, and why it is a choice
+## What was done about it
 
-The scale is uniform, so it factors: `M = s · Rigid` means `M · p = s · (Rigid · p)`. Dividing the
-folded matrix's 3×3 and its translation by `s = length(column 0)` before the conversion, and scaling
-the transformed position by `s` after, is exact for any uniform scale and costs a length and three
-multiplies per joint. It does not help a *non-uniform* one, which a dual quaternion cannot carry
-either — that would want the linear-blend path the DQ one replaced.
+`renderer/animation/SKINNING_FRAME_PLAN.md`. The short version: glTF says a skinned mesh's node
+transform is ignored, so the frame is not the asset's to choose — it is the engine's.
+`register_skin` now sets it to the skin's own bind transform (`skin_normalize_mesh_frame`), which
+makes the fold the identity at bind and a rigid displacement under a clip, for **both** shapes a
+glTF file arrives in. One matrix per skin, once, at registration. No shader change and no
+per-vertex cost, and a file that was already right is not touched.
 
-The other end is the loader: normalise a skin on load so `joint.global × inverse_bind` and
-`mesh.global` always agree about the scale, and the shader's precondition becomes true by
-construction rather than by the exporter's habits. That is a bigger change and it touches every
-asset, not just this one.
+Same measurement, after:
 
-Not taken here — this page is the repro and the measurement. Whichever end it is fixed at,
-`chunk_skin_blend_mesh_local.spec.js` is where the red test belongs: a folded matrix carrying a
-uniform scale, and the position it must still produce.
+| | folded scale | mean error | worst | worst on a single-joint vertex |
+| --- | --- | --- | --- | --- |
+| bind, mesh node as the file gave it | 100.0000 | 121.2470 | 165.4281 | 165.4281 |
+| posed at 0.5 s, the same | 100.0000 | 121.6197 | 165.5332 | — |
+| bind, on the skin frame | 1.0000 | 0.0002 | 0.0016 | 0.0014 |
+| posed at 0.5 s, on the skin frame | 1.0000 | 0.0001 | 0.0062 | 0.000014 |
+| bind, skin frame and §9 | 1.0000 | 0.0000 | 0.0000 | **0** |
+| posed at 0.5 s, skin frame and §9 | 1.0000 | 0.0001 | 0.0062 | **0.000001** |
+
+Neither residual was the frame. The blended ones are dual-quaternion skinning declining to be a
+linear blend, which is what it is for. The `0.0014` at bind was `dual_quat_from_m4`'s square-root
+conditioning near the identity — pre-existing, and maximally exposed by a fold that now lands every
+joint *on* the identity. Plan §9 moved the conversion onto `quat_from_m3`'s branch-picking form,
+which was already in the tree and used by nothing, and it went to zero.
+
+Confirmed on an NVIDIA RTX 4090: the frame correction fires and logs, `?skin=bind` draws a full-size
+character, `?skin=animated` dances, and §9's WGSL — which nothing offline type-checks — compiles.
+
+So the modes now read the other way round:
+
+| `?skin=` | what it should be |
+| --- | --- |
+| `off` | a 1.7 cm figure on her side — nothing deforms the clone, so the mesh node's own transform is all there is. Unchanged by the fix, and still the control for "is the geometry upload sound". |
+| `bind` | a full-size character standing in bind pose, and `await diagnose()` clean |
+| `animated` | dancing, with the traced and rasterized silhouettes the same silhouette |
 
 ## The switches
 
@@ -101,7 +121,8 @@ uniform scale, and the position it must still produce.
   vertex-slot range says the workgroup stride loop, whole meshlets say addressing, and a uniform
   factor says this bug. It checks the clone's meshlet records address a region of their own first —
   a clone still pointing at the source's vertex data would be deforming the shared rest pose in
-  place.
+  place. Since the frame is now the skin's, `inverse(mesh.global)` is the identity here and the
+  clone should come back holding the source's own positions.
 - **`?skin=animated`** — the file's dance, as `skinned_blas_refit` runs it.
 - **Path tracer** — off by default. The rasterizer reads the deformed vertices directly, with no
   tree in the way, so it is the reading to establish the answer on: soup in *both* is the vertices,

package/src/shade/playground/skinned_mesh_soup/index.html

@@ -107,10 +107,11 @@
     <p class="note">
         <strong>The answer, for the record.</strong> <code>chunk_skin_blend_mesh_local</code> needs
         <code>inverse(mesh.global) × joint.global × inverse_bind</code> to be rigid; for this file
-        it carries a uniform <strong>100×</strong>, and a dual quaternion cannot carry a scale. So
-        <code>bind</code> below is the right character at 1/100 size — one shared matrix, one shared
-        error — and <code>animated</code> is soup, sixty-five matrices each losing a different
-        amount. The README has the measurement.
+        it carried a uniform <strong>100×</strong>, and a dual quaternion cannot carry a scale.
+        <code>register_skin</code> now puts the mesh on the skin's own bind transform, so the fold
+        is the identity at bind and a rigid displacement under a clip. The README and
+        <code>SKINNING_FRAME_PLAN.md</code> have the measurement; this page is where it is confirmed
+        on a device.
     </p>
 
     <hr>
@@ -135,12 +136,14 @@
             The skinning pass runs every frame over a pose that never moves — and that pose has an
             answer the CPU knows exactly. <code>await diagnose()</code> reads the clone's vertices
             back and says which are wrong, and whether the wrong ones are a vertex-slot range (the
-            workgroup stride loop) or whole meshlets (addressing).
+            workgroup stride loop) or whole meshlets (addressing). Should be a full-size character
+            standing still, and a clean report.
         </dd>
         <dt>animated</dt>
         <dd>
             Soup only in this mode is the pose: the joint matrices, their range, or the order the
-            skin's joints resolved in.
+            skin's joints resolved in. Should be dancing, with the traced and rasterized silhouettes
+            the same silhouette.
         </dd>
     </dl>
 

package/src/shade/playground/skinned_mesh_soup/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/main.js"],"names":[],"mappings":"AA8PA;;;;GAIG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAkTzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/main.js"],"names":[],"mappings":"AAiQA;;;;GAIG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAkTzB"}

package/src/shade/playground/skinned_mesh_soup/main.js

@@ -50,22 +50,25 @@ import { load_default_environment } from "../load_default_environment.js";
  * - **`?skin=animated`** — the dance, as `skinned_blas_refit` runs it. Soup only here is the pose:
  *   the joint matrices, their range, or the order the skin's joints were resolved in.
  *
- * ## What the bisect found
+ * ## What the bisect found, and what was done
  *
  * `chunk_skin_blend_mesh_local` folds `inverse(mesh.transform_global)` into each joint matrix and
- * converts the product to a dual quaternion, which can only carry a rigid motion. Its doc comment
- * says so and names the precondition: the joints and the mesh node must share the scaling
- * ancestors, so that `joint.global × inverse_bind` carries the same scale `mesh.global` does and
- * the fold cancels it. Michelle is the other legal shape — her positions and inverse-bind matrices
- * are authored in the already-scaled space, `joint.global × inverse_bind` is the *identity*, and
- * the fold is a bare 100×. `dual_quat_from_m4` reads `sqrt(max(0, 1 ± m00 ± m11 ± m22))` over terms
- * of `1 + 100·(…)`, clamps whichever go negative and normalizes the rest, so the rotation it
- * extracts is wrong — and wrong differently per joint, which is what tears the mesh apart.
+ * converts the product to a dual quaternion, which can only carry a rigid motion. Michelle's
+ * positions and inverse-bind matrices are authored in the already-scaled space, so
+ * `joint.global × inverse_bind` is the *identity* and the fold was a bare 100×.
+ * `dual_quat_from_m4` reads `sqrt(max(0, 1 ± m00 ± m11 ± m22))` over terms of `1 + 100·(…)`, clamps
+ * whichever go negative and normalizes the rest, so the rotation it extracted was wrong — and wrong
+ * differently per joint, which is what tore the mesh apart. `?skin=bind` was the right character at
+ * 1/100 size (one shared matrix, one shared error) and `?skin=animated` was soup.
  *
- * So `?skin=bind` is the right character at 1/100 size (one shared matrix, one shared error) and
- * `?skin=animated` is soup (sixty-five matrices disagreeing). The README carries the numbers, and
- * `__soup_blend_probe.spec.js` is where they came from — the shader's own blend, ported to JS and
- * run over this character's own matrices, with no device involved.
+ * The frame is now the engine's rather than the asset's: `register_skin` puts each skinned mesh on
+ * its skin's own bind transform, so the fold is the identity at bind and a rigid displacement under
+ * a clip, for every shape a glTF file arrives in. See `renderer/animation/SKINNING_FRAME_PLAN.md`.
+ *
+ * All of which was established without a device — `__soup_blend_probe.spec.js` runs the shader's own
+ * blend over this character's own matrices, and the emulator tier in
+ * `chunk_skin_blend_mesh_local.spec.js` runs the real WGSL over both shapes. This page is where that
+ * is confirmed against pixels, which by then is a formality.
  *
  * ## Why through the asset framework
  *

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.d.ts

@@ -10,8 +10,14 @@
  * @param {Renderer} options.renderer
  * @param {Scene} options.scene
  * @param {SkinnedMesh} options.mesh
- * @param {number} [options.tolerance] in mesh-local units — the space the clone is written in,
- *        which for a glTF character carrying a centimetre scale is a hundred times its world size
+ * @param {number} [options.tolerance] in mesh-local units. Since `register_skin` puts the mesh on
+ *        the skin's bind transform, mesh-local *is* world scale — a metre is a metre here, and at
+ *        bind the clone should hold the source's own positions. `1e-4` is f32 headroom over a
+ *        chain — a matrix product, a quaternion conversion and a screw motion, all at single
+ *        precision — against a smallest real violation of `1.6`, so there are four orders between
+ *        the two. It was `5e-3` while `dual_quat_from_m4` amplified a near-identity matrix's error
+ *        by its square root; `SKINNING_FRAME_PLAN.md` §9 took that out, and the same measurement on
+ *        the CPU now reads zero at bind.
  * @returns {Promise<object>}
  */
 export function verify_clone_vertices({ renderer, scene, mesh, tolerance }: {

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify_clone_vertices.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js"],"names":[],"mappings":"AAsJA;;;;;;;;;;;;;;;GAeG;AACH;IAP6B,QAAQ;IACX,KAAK;IACC,IAAI;IACR,SAAS,GAA1B,MAAM;IAEJ,QAAQ,MAAM,CAAC,CAoP3B"}
+{"version":3,"file":"verify_clone_vertices.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js"],"names":[],"mappings":"AAyJA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAb6B,QAAQ;IACX,KAAK;IACC,IAAI;IACR,SAAS,GAA1B,MAAM;IAQJ,QAAQ,MAAM,CAAC,CA8P3B"}

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js

@@ -33,6 +33,9 @@ import {
 import {
     GEOMETRY_METADATA_STRUCT
 } from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
+import {
+    SKINNING_WORKGROUP_SIZE
+} from "../../renderer/animation/skinning/shader_meshlet_apply_skinning.js";
 
 /**
  * Copy a slice of a GPU buffer back to the CPU.
@@ -160,11 +163,17 @@ function runs_of(values) {
  * @param {Renderer} options.renderer
  * @param {Scene} options.scene
  * @param {SkinnedMesh} options.mesh
- * @param {number} [options.tolerance] in mesh-local units — the space the clone is written in,
- *        which for a glTF character carrying a centimetre scale is a hundred times its world size
+ * @param {number} [options.tolerance] in mesh-local units. Since `register_skin` puts the mesh on
+ *        the skin's bind transform, mesh-local *is* world scale — a metre is a metre here, and at
+ *        bind the clone should hold the source's own positions. `1e-4` is f32 headroom over a
+ *        chain — a matrix product, a quaternion conversion and a screw motion, all at single
+ *        precision — against a smallest real violation of `1.6`, so there are four orders between
+ *        the two. It was `5e-3` while `dual_quat_from_m4` amplified a near-identity matrix's error
+ *        by its square root; `SKINNING_FRAME_PLAN.md` §9 took that out, and the same measurement on
+ *        the CPU now reads zero at bind.
  * @returns {Promise<object>}
  */
-export async function verify_clone_vertices({ renderer, scene, mesh, tolerance = 1e-3 }) {
+export async function verify_clone_vertices({ renderer, scene, mesh, tolerance = 1e-4 }) {
     assert.defined(mesh, 'mesh');
     assert.equal(mesh.isSkinnedMesh, true, 'mesh.isSkinnedMesh !== true');
 
@@ -227,6 +236,14 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
     */
     const source_record = geometries.get_metadata(mesh.geometry);
 
+    if (source_record === undefined) {
+        return {
+            geometry_index,
+            verdict: `FAIL — the mesh's source geometry is not registered, so there is nothing for `
+                + `its clone to be a clone of. The scene has not been built with this mesh in it.`,
+        };
+    }
+
     const source_metadata = new DataView(await read_back(
         device,
         geometries.meshlets.buffer_metadata,
@@ -404,6 +421,8 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
             ? `pass — all ${vertices} of the clone's vertices are the bind pose, worst error ${worst}`
             : `FAIL — ${wrong} of ${vertices} vertices in ${wrong_meshlets.length} of `
                 + `${meshlets_count} meshlets are not the bind pose (worst ${worst}); `
-                + `lowest wrong vertex slot ${lowest_wrong_slot}`,
+                + `lowest wrong vertex slot ${lowest_wrong_slot}. `
+                + `A lowest slot of ${SKINNING_WORKGROUP_SIZE} is the stride loop; whole meshlets `
+                + `wrong is addressing; a uniform factor is the frame.`,
     };
 }

package/src/shade/renderer/GraphicsContext.d.ts

@@ -118,6 +118,7 @@ export class GraphicsContext {
     readonly isGraphicsContext: boolean;
     #private;
 }
+export type BinaryBuffer = import("../../core/binary/BinaryBuffer.js").BinaryBuffer;
 import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUMaterialManager } from "./material/GPUMaterialManager.js";
 import { GPUSamplerManager } from "./GPUSamplerManager.js";

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAwBA;IAoJI,yBA8BC;IAjLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;OAQG;IACH,gGALW,oBAAoB,EAAE,cACtB;QAAC,MAAM,eAAe;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,mDAFa,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;mCA9UkC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AA4BA;IAoJI,yBA8BC;IAjLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;OAQG;IACH,gGALW,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,mDAFa,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;2BAtUY,OAAO,mCAAmC,EAAE,YAAY;mCAZlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -20,6 +20,10 @@ import { GPUTextureAllocator } from "./texture/GPUTextureAllocator.js";
 import { TextureManager } from "./texture/TextureManager.js";
 import { VirtualTextureManager } from "./texture/virtual/VirtualTextureManager.js";
 
+
+/**
+ * @typedef {import("../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer
+ */
 const DEBUG_LOGGING = false;
 
 export class GraphicsContext {

package/src/shade/renderer/Renderer.d.ts

@@ -11,7 +11,7 @@ export class Renderer {
      *
      * @returns {HTMLCanvasElement|OffscreenCanvas|undefined}
      */
-    get canvas(): OffscreenCanvas | HTMLCanvasElement;
+    get canvas(): HTMLCanvasElement | OffscreenCanvas;
     /**
      * @type {GPUDevice}
      */

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA0NI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BAjwD2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA6OI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA0FlB;IAyLD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAsElB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAoChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA6ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BAn6D2B,gCAAgC"}