@woosh/meep-engine 3.21.0 → 3.23.0

package/src/engine/physics/cloth/ecs/cloth_write_back_rig.js

@@ -0,0 +1,115 @@
+import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import {
+    TRANSFORM64_ROTATION_OFFSET,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "../../../ecs/transform/Transform64.js";
+import { cloth_reconstruct_pose } from "./cloth_reconstruct_pose.js";
+import { cloth_write_local_pose } from "./cloth_write_back.js";
+
+/**
+ * # Putting the answer back onto a skinned model's joints — §11.2
+ *
+ * The same reconstruction the entity path uses, written onto `Node3D`s instead
+ * of onto entities. **Cloth moves joints; it does not produce vertices** — the
+ * mapping from a simulated joint to a render vertex already exists in this
+ * engine and it is the skin, so the existing skinning pass does the rest,
+ * including bounds refresh and BLAS refit that a bespoke vertex-deformation
+ * path would have to reimplement.
+ *
+ * ## `transform_local` is the output, and `transform_global` is written too
+ *
+ * `transform_local` is a joint's own truth and the handle §11.2 names. It is
+ * also *passive*: a `Node3D` does not track its components, and nothing
+ * downstream sees a change until `updateMatrices` runs — which recurses into
+ * every descendant, so calling it on the anchor would recompose the whole
+ * character every fixed step to move a cape.
+ *
+ * So this pass composes the cloth subtree's `transform_global` itself, which
+ * costs nothing because the pose is already in hand, and bumps each joint's
+ * version through `needsUpdate` so the renderer uploads the row. Nothing above
+ * the anchor is touched and nothing below the garment is walked.
+ *
+ * `transform_global` is derived, so writing it is only ever a shortcut for the
+ * recomposition it saves — and it is a *correct* shortcut only because this
+ * pass has the anchor's world pose and the whole chain under it. Anything that
+ * moves the anchor without telling cloth invalidates it, which is the same
+ * contract every consumer of a derived transform already has.
+ *
+ * ## What is not here
+ *
+ * No announcement, and no pruned boundary. The entity path has both because its
+ * subtree is an entity hierarchy with other things hanging off it; a proxy's
+ * joint list is closed by construction, and a socket parented to a cape joint
+ * follows it through the ordinary node hierarchy.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write one cloth's solved pose onto the joints it drives.
+ *
+ * @param {ClothInstance} instance
+ * @param {Transform64} anchor the anchor joint's **world** pose, evaluated by
+ *   the caller — see `ClothSystem` for why it is not read off the node
+ * @returns {void}
+ */
+export function cloth_write_back_rig(instance, anchor) {
+    cloth_reconstruct_pose(instance);
+
+    const node_count = instance.node_count;
+
+    const blended = instance.blended_position;
+    const reconstructed = instance.blended_rotation;
+
+    const ax = anchor[TRANSFORM64_TRANSLATION_OFFSET];
+    const ay = anchor[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    const az = anchor[TRANSFORM64_TRANSLATION_OFFSET + 2];
+
+    const aqx = anchor[TRANSFORM64_ROTATION_OFFSET];
+    const aqy = anchor[TRANSFORM64_ROTATION_OFFSET + 1];
+    const aqz = anchor[TRANSFORM64_ROTATION_OFFSET + 2];
+    const aqw = anchor[TRANSFORM64_ROTATION_OFFSET + 3];
+
+    const parent = instance.node_parent;
+    const node_joint = instance.node_joint;
+
+    for (let node = 1; node < node_count; node++) {
+        const joint = node_joint[node];
+
+        if (joint === undefined || joint === null) {
+            continue;
+        }
+
+        cloth_write_local_pose(joint.transform_local, instance, node, parent[node]);
+
+        const global = joint.transform_global;
+
+        const n = node * 3;
+
+        v3_quaternion_apply(
+            global, TRANSFORM64_TRANSLATION_OFFSET,
+            blended[n], blended[n + 1], blended[n + 2],
+            aqx, aqy, aqz, aqw
+        );
+
+        global[TRANSFORM64_TRANSLATION_OFFSET] += ax;
+        global[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
+        global[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
+
+        quat3_multiply(
+            global, TRANSFORM64_ROTATION_OFFSET,
+            aqx, aqy, aqz, aqw,
+            reconstructed[node * 4], reconstructed[node * 4 + 1],
+            reconstructed[node * 4 + 2], reconstructed[node * 4 + 3]
+        );
+
+        global.updateMatrix();
+
+        // The version is what the renderer compares against to decide whether
+        // to upload the row, so a joint whose transform changed and whose
+        // version did not is a joint that moved nowhere.
+        joint.needsUpdate = true;
+    }
+}

package/src/engine/physics/cloth/playground/README.md

@@ -0,0 +1,339 @@
+# Cloth playgrounds
+
+```
+npm run dev --workspace @woosh/meep-engine
+```
+
+Four pages, one directory, one layer of the system each. (Vite takes the next
+free port if 5173 is busy — the terminal says which.)
+
+| | |
+|---|---|
+| [`index.html`](./index.html) | **the solver, M0.** `cloth_step` over a `ClothState`, no ECS at all. |
+| [`rig.html`](./rig.html) | **the entity subtree, M1.** A real `EntityManager`, real entities, `ClothSystem` walking and writing back. |
+| [`collide.html`](./collide.html) | **collision, M2.** The solver again, with a packed collider table in the argument list. |
+| [`garment.html`](./garment.html) | **skinned garments, M3, and self-collision, M4.** A `Node3D` skeleton, a `Skin`, and a `Cloth` + `ClothRig` driving some of its joints. |
+
+Both are at
+`http://localhost:5173/src/engine/physics/cloth/playground/<page>`.
+
+---
+
+# The solver page — `index.html`
+
+## What it is
+
+A `while (true) { cloth_step(...) }` with a canvas attached. Every point on
+screen is a `Float32Array` position out of `ClothState`, projected by this page;
+every control writes straight into an argument `cloth_step` takes; the tripwire
+is the same `find_non_finite_cloth_state` the step asserts on. There is no ECS,
+no worker and no renderer between you and the solver, because at M0 none of
+those exist yet.
+
+It is here because M0's findings are behavioural. "A penalty stiffer than a few
+times `m/h²` sustains a limit cycle" is a sentence; watching a curtain breathe
+in and out forever while the energy trace refuses to fall is the thing itself.
+
+## Controls
+
+| | |
+|---|---|
+| drag a particle | pins it and pulls — the solver moves everything around it |
+| drag the background | orbit |
+| shift-drag, or right-drag | pan |
+| wheel | zoom |
+
+**Shape** and **Material** rebuild the cloth. **Budget**, **World** and the
+**Solver constants** are read fresh every step, so dragging one of those sliders
+while it runs changes the thing you are looking at.
+
+## The readout
+
+- **step** — milliseconds for one `cloth_step`, with the window minimum, against
+  §17's 2 ms budget as a bar. The minimum is the honest number; see
+  `MEASUREMENTS.md` §7.
+- **residual** — worst `|C|/L₀` across the stretch rows. §7 P2's rubber number.
+- **kinetic energy**, with a log trace beneath it — the single most informative
+  thing on the page. A cloth that is settling walks it off the bottom of the
+  graph. A cloth that is not, does not, and no amount of waiting changes that.
+- **colours** — how many the particle graph needed. §5.4 budgets 8–10 for a
+  garment; a regular sheet comes out at 4.
+- **finite** — the tripwire. If a solve goes non-finite, or a Hessian pivot
+  comes out non-positive, the page stops and shows what said so rather than
+  painting over it.
+
+## The presets, and what each one is for
+
+- **cape, hard rows** — the shipping configuration. Watch the energy trace fall
+  off the bottom and stay there.
+- **cape, soft rows** — the same cape with a 10 kN/m penalty, which is 740× its
+  own `m/h²`. It never rests, and the step is *adding* energy to it, not merely
+  failing to remove it. This is what makes a soft stretch row unusable for real
+  fabric stiffnesses.
+- **cape, soft and slack** — the same row at 100 N/m, which is 7× `m/h²` and
+  inside the dissipative band. It settles. The difference between this preset
+  and the one above is the whole finding.
+- **chain, 40 links** — depth is how far a constraint force travels in one
+  sweep. Drop `iterations` to 1 and watch the bottom lag.
+- **flag in the wind** — a gusting push, not §10's fluid coupling (that is M6).
+- **the §17 workload** — 1,024 particles at 2×4, the configuration the budget
+  was written against and missed by 1.75×.
+- **α·γ = 0.6** — past the divergence cliff. The tripwire fires within a second
+  or two, which is the point.
+- **one iteration** — §5.1's claim that the solver is stable at one iteration.
+  Softer, not broken.
+
+## What it does not do
+
+Collision, self-collision, slack, tethers, backstops, friction and wind-as-fluid
+are all rows the design has and M0 does not (§6, §17). Neither does damping:
+`ClothDynamics#damping` is M1, and its absence is why the soft presets behave as
+they do.
+
+## Notes
+
+The scene builder here is deliberately not the `__fixtures__` grid the specs and
+the measurement scripts share — `__fixtures__` is excluded from the published
+package and this page is not, so importing across that line would ship a broken
+module.
+
+`globalThis.cloth_playground` exposes `{ control, camera, rebuild, step_once,
+scene }` for a driver script. The browser pages in this tree get screenshot from
+headless Chrome about as often as they get looked at; note that
+`requestAnimationFrame` does not fire while the pane is hidden, so a driver
+should call `step_once` itself rather than waiting for frames.
+
+---
+
+# The rig page — `rig.html`
+
+## What it is
+
+The same idea one layer up. A real `EntityManager` with a
+`TransformAttachmentSystem` and a `ClothSystem` in it, entities carrying
+`TransformAttachment` and `Transform64`, and a `Cloth` component on top of the
+pile. Every point on screen is an entity's **world transform**, read back out
+of the component the system wrote it into — so what you are looking at is the
+write-back, not the solver.
+
+It exists because M1's claims are about a *hierarchy* rather than about an
+array. "Several hanging parts under one `Cloth` are one coupled solve" is a
+sentence; five strands moving together above a readout that says **1 cloth, 91
+particles, 3 colours** is the thing itself.
+
+## The rigs
+
+- **rope** — one strand. The simplest thing the subtree walk does.
+- **chain** — the `CHAIN` library entry, which is the deepest budget in the
+  library at 2×6. Drop `iterations` to 1 and watch the bottom lag.
+- **multi-strand rig** — five strands under **one** `Cloth`. §3.1's claim, and
+  the reason the readout counts cloths separately from particles.
+- **hanging sign** — two ropes off a crossbar, with the sign itself carrying a
+  `ClothExclude`. It is drawn in amber, it is not a particle, and it follows the
+  link it hangs from because the write-back poses it by hand and announces
+  there.
+- **nested cloths** — a rope with a second `Cloth` partway down. Two solves; the
+  outer one prunes the inner anchor and runs first, so the inner cloth reads an
+  anchor that is already where this step put it.
+
+## The readout
+
+- **cloths / particles** — the coupled-solve claim, as two numbers.
+- **rows s / b / leash** — the stretch table (which carries the link rows, the
+  strain limits and the chain's skip rows), the bend table, and M1's leash rows.
+- **worst |x−anchor| / d_geo** — §7 P2's rubber number. Above 1 is a cloth
+  reaching further than its own geometry allows.
+- **asleep** — §7 P5. A settled cloth stops being stepped *and* stops being
+  written back, which is what makes its pose bit-identical rather than merely
+  stable. Turn `never sleep` on to watch it settle instead of watching it stop.
+- **fixed step** — milliseconds for one `ClothSystem#fixedUpdate`. Treat it as
+  an indication only: browser `performance.now()` is deliberately coarse, and a
+  hidden pane throttles the page. `__fixtures__/cloth_library_bench.mjs` under
+  node is the number that means something.
+
+## Driving the anchor
+
+§7 P6 and P7 are both about what the *anchor* does, so that is what the
+**motion** control drives — and it is the only thing on the page that writes a
+transform the cloth does not own, standing in for whatever poses an anchor in a
+real scene.
+
+- **sprint** is P7's own profile: a square wave in velocity. Move `inertia` from
+  1 to 0 while it runs and the cloth stops feeling the locomotion entirely.
+- **teleport 1 km** is P6. With `TeleportKeep` off the cloth re-seeds at the
+  animated pose and the stabilisation window ramps its velocity limit back from
+  nothing; with it on, the shape comes across the jump — which in a frame
+  anchored to the cloth's own entity is the solver doing nothing at all.
+
+## The views
+
+- **links** — the entities and what connects them.
+- **animated pose** — the pose the cloth is leashed to, faint and blue. The gap
+  between the two lines is what `slack` bounds; drag `slack` to 0 and they
+  become one line, which is §3.4's "at `slack = 0` every particle is welded to
+  its animated position".
+- **frames** — the orientation the write-back reconstructed, as an axis triple
+  per entity. A particle has no orientation, so this is §11.1's swing: the
+  minimal rotation from the link's animated direction to its simulated one,
+  half-way between the parent-driven and child-driven answers.
+
+## Notes
+
+`globalThis.cloth_rig_playground` exposes `{ control, camera, ready, rebuild,
+step_once, render, scene }`. Two differences from the solver page and both are
+real: `rebuild` returns a promise, because `EntityManager#startup` does and an
+entity created before it resolves is never linked; and `render` is separate from
+`step_once`, because `requestAnimationFrame` does not fire in a hidden pane and
+everything on the page hangs off it.
+
+---
+
+# The collision page — `collide.html`
+
+## What it is
+
+The solver page again, with a **packed collider table** in `cloth_step`'s
+argument list. There is no `EntityManager`, no `ClothColliderIndex` and no
+`ClothColliderSystem`: `collide_build.js` hands the solver exactly what
+`cloth_gather_colliders` would, already in the cloth's own frame, so what is on
+screen is the layer M2's findings live in and nothing above it.
+
+Two of those findings are things to *watch* rather than read.
+
+**The sweep, which is not really about tunnelling.** Pick **a capsule swept
+through** and press *end-of-step only*. The capsule stops being *noticed*: the
+contact readout drops by four while the capsule visibly passes through the sheet.
+Discovery evaluates the field at the end-of-step pose, so a collider that crossed
+the cloth within the step is nowhere near it by then, and without the travel term
+in the discovery reach no row is ever created for the swept poses to act through.
+At 20 m/s in `MEASUREMENTS.md` §20 the difference is 95 rows a step against none.
+
+**The penalty floor, which decides how hard a new contact hits.** Pick **the
+ground**, drag `k_min ÷ k_max` to 1, and press *reset*: the cape slaps down.
+Drag it back to 1/32 and it lands. Peak contact force across that range measured
+18.9 N against 0.16 N, and the settled energy six orders of magnitude apart —
+with the *penetration improving* at the low end, which is the augmented
+Lagrangian working as designed. §17.
+
+## The scenes
+
+- **sphere under a cape** — the simplest thing a contact row can be right about.
+- **every primitive** — sphere, capsule, box and cylinder side by side, each
+  protruding 25 mm through the sheet. Four different fields, one dispatch, and
+  the same free functions the shape classes now call.
+- **the ground** — `PlaneShape3D`, which §14.3 asked for and did not exist.
+- **a shoulder, animated** — three capsules as an arm, swinging. The swept pose,
+  in the configuration it was designed for.
+- **a capsule swept through** — 3 m/s straight through the sheet. The sweep
+  toggle's scene.
+- **a spinning bar** — a bar turning behind the cape and through its plane. It is
+  also the one scene that does not resolve: a rigid collider driven through cloth
+  that is pinned above it wraps rather than parts, and the 18 mm of resting
+  penetration is the row bounding a case it cannot prevent. That is authoring
+  rather than a solver gap, and it is here so it is visible rather than
+  surprising.
+
+## The readout
+
+- **contacts** — rows the discovery pass created this step. Zero while a collider
+  is visibly passing through the cloth is the finding above.
+- **worst penetration** — the deepest any particle got, over the whole run.
+- **resting penetration** — how deep anything is *now*. This is the number that
+  says whether a screenshot showing a sphere apparently poking through a cape is
+  a simulation problem or a drawing one — the collider outline is dashed and has
+  no depth test, so it is painted over the cloth whether it is in front or behind.
+- **step** — milliseconds for `cloth_contact_find` plus `cloth_step`, window
+  minimum, against §17's 2 ms. Browser `performance.now()` is coarse and a hidden
+  pane throttles the page; `__fixtures__/cloth_m2_measure.mjs` under node is the
+  number that means something.
+
+## Notes
+
+`globalThis.cloth_collide_playground` exposes `{ control, camera, rebuild,
+step_once, penetration, cloth, colliders, contacts }`. `requestAnimationFrame`
+does not fire in a hidden pane, so a driver calls `step_once` itself.
+
+---
+
+# The garment page — `garment.html`
+
+## What it is
+
+`rig.html` is a `Cloth` over an entity subtree; this is a `Cloth` + a `ClothRig`
+over a skinned model's **joints**. Every point on screen is a
+`Node3D.transform_global` — a joint of a `Skin`, not an entity — and it is where
+it is because the solver wrote its `transform_local` and this page composed the
+chain.
+
+`ClothSystem#models` takes a stub rather than a `MeshSystem` for the reason the
+field exists: a `MeshSystem` needs a graphics engine, a scene and a loader, and a
+garment's joints are a `Node3D` tree that needs none of the three. The stub
+answers exactly the one method the system calls.
+
+## The garments
+
+- **cape** — five strips of seven off the chest. The common case and the cheap
+  one: an artist made the joints and skinned the cape to them, so the proxy is
+  joint indices, the topology and the bind pose. No binding step, no generated
+  geometry.
+- **coat tails** — three strips of nine in denim, which is the library entry that
+  spends its two levers on particles rather than iterations.
+- **ponytail** — one chain of twelve off the neck. The rig path is the entity
+  path with `Node3D`s in it, and a single chain is where that is most obviously
+  true.
+- **loincloth** — seven strips of five off the pelvis, and the one preset that
+  spends most of its time against the leg colliders.
+
+## The motion drives the character, and only the character
+
+The buttons write the **character's own bones**. The garment's joints are
+cloth's, and the seed says so: it claims `TransformAuthority.CPU` on every one of
+them, because a joint a clip drives is under GPU authority and its
+`transform_local` is not read by anything. Two writers of one row is the race the
+authority enum exists to prevent, and the claim is where a garment whose joints
+are *also* keyed shows up as an authoring error.
+
+**sprint** is §7 P7's own profile: a square wave in velocity, integrated. Written
+as a position that resets it would be a nine-metre discontinuity, which is a
+teleport wearing a sprint's clothes — and the cloth would be right to treat it as
+one.
+
+## The readout
+
+- **worst |x−anchor| / d_geo** — §7 P2's rubber number. Green at rest and under
+  walking and turning; **sprint takes it past 1.1**, which is P2's own conditional
+  bound showing on a shape M1 did not measure. `MEASUREMENTS.md` §26 has both
+  paths side by side, and they agree to the digit — this is the geometry, not the
+  rig path.
+- **contacts** — with **collide with the body** on. A cape clear of its own
+  torso reads zero here most of the time, which is what a garment that was
+  authored correctly looks like; see below.
+- **self pairs** — M4's, with **collide with itself** on. Zero while the
+  garment hangs and climbing the moment a fold closes, which is the shape of
+  the whole tier: it is a broadphase over particles and it has nothing to do
+  until two of them are near. Three library entries set the flag — silk,
+  cotton and hair — and the button overrides whichever the fabric picker is
+  on, by cloning the frozen entry and moving one bit.
+
+  **The radius is the proxy's resolution, not the fabric's thickness**, and it
+  is the single thing most worth knowing about this tier. Silk is 4 mm thick
+  and this cape's particles are 8 cm apart; at 4 mm the two layers of a fold
+  are never in contact and the feature does nothing at all.
+  `MEASUREMENTS.md` §31 is the sweep, §36 is the clamp at the other end.
+
+## The one thing worth knowing before authoring a garment
+
+A garment authored **inside** its own body collider reads as a *tether* failure.
+The contact row pushes it out, the tether pulls it back, the contact wins, and
+the readout says the tether is failing by thirty per cent. It is not. §11.3
+step 10 validates exactly this at build time — "the skinned bind pose is
+collision-free against the character's `ClothCollider` set" — and M3 does not
+build that check, so this page's geometry is right by hand. `MEASUREMENTS.md` §29
+has the numbers, because it cost an hour to diagnose the first time.
+
+## Notes
+
+`globalThis.cloth_garment_playground` exposes `{ control, camera, ready, rebuild,
+step_once, draw, scene }`. `rebuild` returns a promise, because
+`EntityManager#startup` does and an entity created before it resolves is never
+linked.

package/src/engine/physics/cloth/playground/cloth_playground_build.d.ts

@@ -0,0 +1,58 @@
+/**
+ * # Building the playground's cloth
+ *
+ * Two shapes, because two shapes are what M0's rows can express between them: a
+ * triangulated sheet, which exercises stretch and bend together over a mesh
+ * eight colours wide, and a chain, which is the same stretch row at depth with
+ * no bending at all and is where a solver's convergence shows most plainly.
+ *
+ * This is playground code rather than the `__fixtures__` grid the specs and the
+ * measurement scripts share. It has to be: `__fixtures__` is excluded from the
+ * published package and this page is not, so importing across that line would
+ * ship a broken module. It also wants different things — several pinning
+ * modes, a chain, and a triangle list to draw.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @typedef {object} ClothPlaygroundScene
+ * @property {ClothState} state
+ * @property {Int32Array} triangle vertex triples, in the state's own permuted
+ *   particle numbering, for drawing. Empty for a chain.
+ */
+/**
+ * @param {object} options
+ * @param {'sheet'|'chain'} options.shape
+ * @param {number} options.width particles across a sheet, or links along a chain
+ * @param {number} options.height particles down a sheet; ignored for a chain
+ * @param {number} options.spacing metres between adjacent particles
+ * @param {number} options.mass total mass of the whole cloth, kg
+ * @param {number} options.stretch_stiffness N/m, or `Infinity` for a hard row
+ * @param {number} options.bend_modulus
+ * @param {'top'|'corners'|'edges'|'none'} options.pinned
+ * @param {boolean} options.flat lay a sheet horizontally so it falls and swings,
+ *   rather than hanging in the vertical plane
+ * @returns {ClothPlaygroundScene}
+ */
+export function build_cloth_playground_scene({ shape, width, height, spacing, mass, stretch_stiffness, bend_modulus, pinned, flat }: {
+    shape: 'sheet' | 'chain';
+    width: number;
+    height: number;
+    spacing: number;
+    mass: number;
+    stretch_stiffness: number;
+    bend_modulus: number;
+    pinned: 'top' | 'corners' | 'edges' | 'none';
+    flat: boolean;
+}): ClothPlaygroundScene;
+export type ClothPlaygroundScene = {
+    state: ClothState;
+    /**
+     * vertex triples, in the state's own permuted
+     * particle numbering, for drawing. Empty for a chain.
+     */
+    triangle: Int32Array;
+};
+import { ClothState } from "../solver/ClothState.js";
+//# sourceMappingURL=cloth_playground_build.d.ts.map

package/src/engine/physics/cloth/playground/cloth_playground_build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_playground_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/cloth_playground_build.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAZoC,KAAK,EAA9B,OAAO,GAAC,OAAO;IACC,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,OAAO,EAAvB,MAAM;IACU,IAAI,EAApB,MAAM;IACU,iBAAiB,EAAjC,MAAM;IACU,YAAY,EAA5B,MAAM;IACkC,MAAM,EAA9C,KAAK,GAAC,SAAS,GAAC,OAAO,GAAC,MAAM;IACb,IAAI,EAArB,OAAO;IAEL,oBAAoB,CAgBhC;;WAjCa,UAAU;;;;;cACV,UAAU;;2BAxBG,yBAAyB"}