From 91cef4b43637fc70e2e03cd440aef85a7fa0c18d Mon Sep 17 00:00:00 2001
From: towneh <25694892+towneh@users.noreply.github.com>
Date: Sun, 24 May 2026 15:10:14 +0100
Subject: [PATCH 1/6] docs: add scalable avatar dynamics analysis and
 BasisAuthoredMotion design spec
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Problem analysis for the per-avatar cosmetic Animator scaling cost at high
CCU, and the design spec for BasisAuthoredMotion — a data-only SDK component
plus a batched Burst job system (mirroring RemoteBoneJobSystem) that replaces
the Animator for authored secondary motion on non-humanoid transforms.
---
 BasisAuthoredMotion-Design-Spec.md            | 231 ++++++++++++++++++
 ...-Dynamics-Animator-Performance-Analysis.md | 123 ++++++++++
 2 files changed, 354 insertions(+)
 create mode 100644 BasisAuthoredMotion-Design-Spec.md
 create mode 100644 Leona-Dynamics-Animator-Performance-Analysis.md

diff --git a/BasisAuthoredMotion-Design-Spec.md b/BasisAuthoredMotion-Design-Spec.md
new file mode 100644
index 000000000..ee36f72fe
--- /dev/null
+++ b/BasisAuthoredMotion-Design-Spec.md
@@ -0,0 +1,231 @@
+# `BasisAuthoredMotion` — native authored-motion driver (design spec)
+
+**Problem.** Basis avatars commonly drive *cosmetic and secondary* motion — looping idles, tail and ear movement, spinning accessories — with a Unity Animator. Each Animator carries high *fixed* per-instance overhead (Playable-graph setup and evaluation, state-machine and transition processing, the per-Animator update pass) that is independent of how trivial the motion is, and it is paid on **every replicated copy of every avatar in the instance**. That overhead scales linearly with player count, so at high CCU it becomes a substantial share of frame time: a 1000-CCU load test measured a single avatar's cosmetic Animator at roughly **1/5 of scene frame time**. The motion itself is trivially simple — the cost is almost entirely Animator machinery, not animation. This doc proposes what to build instead. (Background measurement and the options weighed: see the analysis doc in the appendix.)
+
+**Names are provisional** (`BasisAuthoredMotion`, `BasisAuthoredMotionSystem`) — final naming is the maintainer's call.
+
+**Scope.** This is a general facility for **authored, deterministic dynamic movement on transforms the humanoid rig and IK don't drive** — non-humanoid *rigged* bones (tail and ear chains, extra bones) and standalone accessory objects. The boundary is the humanoid/IK-driven, networked skeleton — *not* bones in general, so rigged chains like tails are squarely in scope. It's a third category of avatar motion: the rigged skeleton is the primary networked/IK-driven pose, jiggle physics adds *emergent* physics-driven follow-through, and this is the *authored* motion the avatar (or prop) declares. The three **stack rather than compete** — authored motion supplies the animated base and **jiggle physics layers on top of it** (see *Jiggle physics ordering*). Cosmetic looping idle sequences or secondary animations (tail flicks, ears twitching, accessories spinning) are among the first use cases driving this, not the limit: any set-sequence or continuously-animated movement on those non-humanoid transforms belongs here.
+
+---
+
+## What we're building
+
+**One deliverable**, in two co-shipped pieces:
+
+1. A whitelisted, **data-only** SDK component (`BasisAuthoredMotion`) the avatar carries — pure serialized configuration, no per-instance runtime `Update`.
+2. A **batched, Burst-compiled job system** (`BasisAuthoredMotionSystem`) that evaluates every registered avatar's movements in one parallel pass per frame and writes the target transforms directly — no Playable graph, no state machine, no per-instance dispatch.
+
+All runtime work happens in the shared job; the component just declares what to do. It mirrors the existing `RemoteBoneJobSystem` (`Packages/com.basis.framework/Drivers/Remote/BasisRemoteBoneDriver.cs`), which already proves the batched-transform pattern at thousand-avatar scale. Optimization is a hard requirement, not a later pass (see *Performance requirements*).
+
+---
+
+## Authoring surface — the component
+
+A whitelisted SDK component following the established `BasisParameterDriver` pattern (`Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`) — a serializable array of reusable, parameterised **movements**. These are general primitives, not avatar-specific behaviours: the same set drives a tail, hair, antennae, ear, cloth strip, halo, orbiting gem, blink, or ambient micro-gesture. Any avatar declares whatever combination it needs.
+
+```csharp
+public class BasisAuthoredMotion : MonoBehaviour   // names provisional
+{
+    public Movement[] movements = Array.Empty<Movement>();
+
+    [Serializable]
+    public class Movement
+    {
+        // Open, extensible set — new kinds slot in without changing the
+        // registration / scheduling model (see "Extensibility").
+        public enum Kind { Oscillate, Rotate, Orbit, RandomSelect, Sequence }
+        public enum Channel { Rotation, Position, Scale }  // what Oscillate drives
+
+        public Kind kind = Kind.Oscillate;
+        public string label;              // author-facing identifier only
+        public bool enabled = true;       // runtime-toggleable (see open question on toggles)
+        public Vector3 axis = Vector3.up; // local axis the movement acts about
+
+        // Oscillate — periodic (sine) motion on `channel`, optionally propagated
+        // down a chain to form a travelling wave (1 entry = simple sway).
+        public Channel channel = Channel.Rotation; // amplitude unit: deg | metres | scale-factor
+        public Transform[] chain;
+        public float amplitude      = 15f;
+        public float frequencyHz    = 0.5f;
+        public float phase          = 0f;
+        public float chainPhaseStep = 0f; // phase delay per element down the chain
+        public float chainFalloff   = 1f; // amplitude scale per element down the chain
+
+        // Rotate — constant angular velocity about `axis`, in place.
+        public Transform target;
+        public float speedDeg = 36f;      // deg/sec
+
+        // Orbit — revolve `target` around `pivot` at `radius` (not a spin-in-place).
+        public Transform pivot;
+        public float radius = 0.1f;
+        public float orbitSpeedDeg = 90f; // deg/sec around the pivot
+
+        // RandomSelect — on a randomised interval pick one weighted option, ease in/out.
+        public Transform selectTarget;
+        public Option[] options = Array.Empty<Option>();
+        public Vector2 intervalRange = new Vector2(2f, 6f);  // seconds between picks
+        public float attack = 0.06f, release = 0.25f;        // ease in / out seconds
+        public bool preventRepeats = true;
+        public uint seed = 0;             // 0 = derive from registration index
+
+        // Sequence — authored timeline of pose deltas; loop or one-shot. Short
+        // motion uses inline keyframes; complex/converted clips reference a
+        // shared, read-only baked-curve asset instead (see Migration).
+        public Transform sequenceTarget;
+        public Keyframe[] keyframes = Array.Empty<Keyframe>();
+        public BasisMotionClip bakedClip; // shared baked curves; null when using inline keyframes
+        public bool loop = true;
+    }
+
+    [Serializable]
+    public class Option   { public Vector3 axis; public float angleDeg; public float weight = 1f; }
+    [Serializable]
+    public class Keyframe { public float time; public Vector3 eulerDelta; public Vector3 positionDelta; public Vector3 scaleDelta; }
+}
+```
+
+As a concrete mapping, a common cosmetic Animator setup — a swaying tail, an orbiting accessory, and randomly twitching ears across three layers — reduces to three movements here: a tail bone chain → `Oscillate`, an accessory circling the body → `Orbit` (or `Rotate` if it spins in place), and each ear → a `RandomSelect` over a couple of pose options. The authored config is flattened into the job system's SoA at registration.
+
+### Supported motion types
+
+The initial supported set. Every type is a **delta from a captured rest pose** on its channel, evaluated in the batched job.
+
+| Type | What it does | Channel(s) | Key parameters | Example uses |
+|------|--------------|-----------|----------------|--------------|
+| **Oscillate** | periodic (sine) motion, optionally a travelling wave down a chain | rotation / position / scale | `axis`, `amplitude`, `frequencyHz`, `phase`, `chainPhaseStep`, `chainFalloff` | tail / hair / ear sway, floating bob, breathing & glow pulse |
+| **Rotate** | constant angular velocity, spinning in place | rotation | `axis`, `speedDeg` | halos, fans, spinning gems/coins |
+| **Orbit** | revolve a transform around a pivot at a radius | position (+ optional facing) | `pivot`, `radius`, `orbitSpeedDeg`, `axis` | accessory circling the body/tail, orbiting orbs or particles |
+| **RandomSelect** | stochastic weighted pick among pose options on a randomised interval | rotation (pose deltas) | `options` (+`weight`), `intervalRange`, `attack`/`release`, `preventRepeats`, `seed` | ear flicks, blinks, idle micro-gestures |
+| **Sequence** | authored keyframed timeline of pose deltas, looping or one-shot; inline keys for short hand-authored motion, or a shared baked-curve asset for complex/converted clips | rotation + position + scale | `keyframes` (`time` + per-channel deltas) *or* baked-clip ref, `loop` | scripted flourishes, set-piece accessory animations, **any converted AnimationClip** (see Migration) |
+
+The math, per type:
+
+- **Oscillate** — `value = rest ⊕ (amplitude * sin(t*frequencyHz*2π + phase))` on `axis`, where `⊕` applies to the chosen channel (rotation = `AngleAxis`, position = offset along axis, scale = scalar along axis). For a chain, element *n* uses `phase + n*chainPhaseStep` and `amplitude * chainFalloffⁿ` → a wave travelling down the chain.
+- **Rotate** — `localRotation = rest * AngleAxis((t * speedDeg) mod 360, axis)`.
+- **Orbit** — `localPosition = pivotLocal + radius * (cos θ, sin θ)` in the plane normal to `axis`, `θ = t * orbitSpeedDeg`; optionally face the pivot.
+- **RandomSelect** — deterministic, no managed callback and no animator parameter. A per-movement `Unity.Mathematics.Random` (seeded by `seed`, or registration index) schedules the next pick from `intervalRange`, chooses a weighted `Option` (honouring `preventRepeats`), and eases its pose delta `0 → angleDeg → 0` over `attack`/`release`. This replaces the `BasisParameterDriver` state-machine-behaviour + RNG int + threshold-transition machinery entirely.
+- **Sequence** — sample the timeline at `t` (wrapping when `loop`), interpolate the per-channel deltas, apply over rest. A lightweight authored clip without an Animator/Playable graph. Short sequences use inline keyframes; complex/converted clips reference a shared, read-only baked curve buffer (see Migration).
+
+All RNG and trig is `Unity.Mathematics`, so the routine is Burst-legal as written.
+
+### Extensibility & candidate future kinds
+
+The kind set is open. A new type = a new `Kind` enum value + a branch in the evaluation routine + its fields in the flattened struct; a kind with a very different data shape gets its own SoA array + sub-job. Registration, scheduling, culling, and toggles are all kind-agnostic, so adding a type never disturbs the system around it — which is what makes this a general avatar-motion facility rather than a fix for one avatar.
+
+Kinds deliberately **out of the initial set**, listed so the trajectory is visible (build when a real consumer needs them):
+
+- **Noise** — organic drift via Perlin/simplex (smoother than `RandomSelect`, more lifelike than pure sine).
+- **Oscillate waveform variants** — triangle / square / pulse as an `Oscillate` option rather than separate kinds.
+- **Reactive kinds** — audio- or velocity-driven motion (need an input feed; defer until that plumbing exists).
+- **LookAt / aim** — track a target or the camera (overlaps with skeletal concerns; evaluate separately).
+
+---
+
+## The runtime — batched Burst job system
+
+`BasisAuthoredMotionSystem`, a static orchestrator built as a sibling to `RemoteBoneJobSystem`:
+
+| Concern | Reuse from `RemoteBoneJobSystem` |
+|---|---|
+| Per-entry config | SoA `NativeList<MovementData>` (the `Movement` flattened to a blittable struct), one slot per driven transform |
+| Driven transforms | flat `TransformAccessArray` across all avatars |
+| RNG / select state | read-write `NativeArray` indexed by the flat slot, advanced in-job |
+| Registry | `Add`/`Remove` keyed by avatar id, dense swap-back, deferred adds committed at the frame sync |
+| Per-frame work | `Schedule()` → one Burst `IJobParallelForTransform` computing delta-from-rest and writing the target channel (`localRotation` / `localPosition` / `localScale`), with a uniform `time` field |
+| Cull / disable | `ValidMask`-style `NativeArray<byte>` — toggled movements and culled avatars become no-ops, no array churn |
+| Threading | adaptive `innerloopBatchCount = min(maxBatch, ceil(count / workerCount))` |
+
+**Registration** — co-locate with the bone system: `BasisRemoteAvatarDriver.RemoteCalibration` already calls `RemoteBoneJobSystem.AddRemotePlayer`; the local path (`BasisLocalAvatarDriver`) is the analogue. At calibration, if the avatar has a `BasisAuthoredMotion` (`TryGetComponent`), flatten its movements + targets into the SoA and register; deregister on teardown/recalibration (the bone system's synchronous-remove rationale applies — drop the TAA entry while the transform is alive). **Rest poses** are captured at registration and stored in the SoA; movements compose as deltas from rest, never baked absolutes. Registration is driven by the calibration hook — **no scene discovery** (`FindObjectsOfType` et al.).
+
+**Frame schedule** — schedule in the same phase as `RemoteBoneJobSystem`, after the avatar pose apply, completing before render.
+
+**A single compute-and-write job, deliberately simpler than the bone system.** `IJobParallelForTransform` serialises transforms per hierarchy root onto one worker — that's why the 51-bone skeleton needed a compute/apply split. A movement touches ~2–6 bones per avatar, so a single compute-and-write `IJobParallelForTransform` parallelises cleanly across avatars; no split needed.
+
+**Variable-length data** (`RandomSelect` options, `Oscillate` chains, baked `Sequence` curves) flattens into shared buffers with per-movement start/count indices (or a fixed cap), the same way the bone system holds all avatars' bones in one flat array.
+
+**Development practice** — build the job with Burst compilation *off* first (Jobs → Burst → Enable Compilation off). It then runs as plain managed C# — steppable, `Debug.Log` works — so the math is debugged directly. Validate it visually against the reference avatar's existing cosmetic Animator (the Animator is the correctness oracle), then enable Burst (the math is already Burst-legal: `Unity.Mathematics`, no managed types in the job).
+
+**Logging** — `BasisDebug.Log*` with a new `BasisDebug.LogTag`, never `UnityEngine.Debug`.
+
+---
+
+## Performance requirements (the maintainer's bar)
+
+Maintainer feedback: an SDK driver component is acceptable, **but it must be heavily optimized.** Concrete targets this design commits to:
+
+- **Data-only component at runtime.** `BasisAuthoredMotion` holds serialized config and runs **no per-instance `Update`** — all runtime evaluation is the single batched Burst job. (An optional editor-only preview path may evaluate in edit mode; see open questions.)
+- **One job set per frame for all avatars**, parallel across workers, cost scaling with total movement count — not a per-avatar dispatch. Mirrors `RemoteBoneJobSystem`.
+- **Zero per-frame GC** — persistent SoA `NativeArray`/`NativeList` + `TransformAccessArray`; no managed allocation in the frame loop.
+- **Burst with fast math** (`[BurstCompile(FloatMode = FloatMode.Fast, FloatPrecision = FloatPrecision.Low)]`, as `BasisRemoteBoneJob` uses).
+- **Shared read-only data** — config and baked `Sequence` curves shared per avatar/clip; per-instance state is minimal (playhead, RNG state, enabled mask) and cache-packed.
+- **Visibility + distance LOD.** Off-screen avatars skip via a `ValidMask` (no array churn). Because this motion is *cosmetic and non-critical*, distant avatars can update at a reduced rate (every N frames) — a temporal-LOD lever the skeletal bone system can't take, and a cheap way to cut the on-screen-crowd cost the culling stop-gap doesn't.
+- **Minimal writes** — only enabled movements write; driven-transform count kept modest; the `IJobParallelForTransform` write is the floor cost.
+- **Batched structural changes** — registration deferred and committed at the frame sync; removal swap-back — no mid-frame job stalls (the bone system's exact approach).
+
+**Acceptance bar:** at the 1000-CCU profile, the whole authored-motion pass is a small fraction of frame time and demonstrably far below the per-instance Animator it replaces (~1/5 of scene frame time at that scale). Profile against that baseline.
+
+---
+
+## Cross-cutting design points
+
+- **Rest-pose capture** is the correctness linchpin — capture at registration, compose all motion as deltas, never bake absolute rotations.
+- **Jiggle physics ordering.** Avatars frequently run `JiggleRig` physics on the same chains authored motion drives (a tail, say), wired up in the remote driver. The authored-motion write must land **before** jiggle samples its input pose, so the two compose (authored movement = animated base, jiggle = secondary motion on top), matching how jiggle previously layered on the Animator output. Confirm the job phase orders correctly against the jiggle update (and the editor-preview path, if present).
+- **Non-humanoid targets.** Driven bones (tail, ears, accessories) aren't in the networked bone set (`BasisBoneRotationCompression.SyncBoneCount` / `RemoteBoneJobSystem`) and aren't touched by local IK — the job owns them outright, so there's no write contention with the skeletal pipeline.
+
+---
+
+## Migration & authoring journey
+
+If we're pitching this as a replacement for traditional Animator-driven cosmetic and secondary motion, the on-ramp from an *existing* animation has to be easy. Not all motion is parametric, so the system needs both a describable path and a faithful fallback — plus a tool that picks between them.
+
+**What moves here, and what doesn't.** This replaces *self-contained, continuously-running* dynamic motion — looping idles, ambient sway, spins, scripted flourishes — that runs independent of gameplay state. It does **not** replace parameter/gameplay-driven graphs (locomotion blend trees, gesture/expression layers, contact reactions); those stay in the Animator. This refines the Scope boundary: the motion must be on non-humanoid transforms *and* authored/self-contained — gameplay- or parameter-driven motion stays in the Animator even when it touches a non-humanoid bone.
+
+**Route 1 — parametric (describable motion).** A sine sway, a constant spin, an orbit: author directly as `Oscillate` / `Rotate` / `Orbit`. A few numbers, tiny data, infinitely tweakable (frequency / amplitude / phase), cheapest at runtime.
+
+**Route 2 — baked (arbitrary authored motion).** Complex hand-keyed motion a primitive can't describe — *e.g. a precise 15-second loop rotating a bone chain through a bespoke path* — is captured as a **`Sequence` backed by a baked clip asset**: the source curves sampled to a fixed-rate, blittable buffer (per driven transform, per channel). The baked data is a **shared, read-only asset** — every instance of the avatar references the same buffer; per-instance runtime state is just a playhead. The batched Burst job samples the shared curve at each instance's playhead and writes the channel. So even a faithful recording of a complex clip scales: the heavy data is shared once, per-instance cost is one interpolated sample per bone — none of the Animator's per-instance Playable-graph / state-machine / retarget overhead. (`AnimationCurve` isn't Burst-usable directly, hence the sampled buffer; rotations bake to quaternions and `nlerp`/`slerp` in-job.)
+
+**The converter tool — the actual on-ramp.** An editor utility takes an existing `AnimationClip` (+ its root) and emits a populated `BasisAuthoredMotion`:
+- For each animated curve, a cheap fit test: near-constant-rate rotation → offer `Rotate`; near-single-frequency sinusoid → offer `Oscillate`; otherwise **bake** into a shared `Sequence` asset.
+- The result mixes compact primitives where motion is describable and faithful baked sequences where it isn't — all reviewable and tweakable afterward.
+- Default is faithful (bake); primitive-fitting is an opt-in *suggestion*, so nothing is silently approximated.
+- It's an editor-only tool independent of the runtime, so it can land alongside the core or immediately after.
+
+**Worked example — the 15s bone-chain loop.** The converter bakes each bone's rotation curve into one shared `Sequence` asset (sampled at the clip's framerate, looped) and plays it back in the same batched job as every other movement. If some bones turn out near-sinusoidal on inspection, the tool can offer to swap those for `Oscillate` (lighter, tweakable) — but the default reproduces the original exactly.
+
+**Expectation-setting tradeoff:** parametric = tiny, tweakable, infinite variation; baked = faithful to any motion, larger (but shared) data, a fixed recording. Both shed the per-instance Animator overhead, which is the 1000-CCU win — so "we can always bake it" means *no* existing cosmetic or secondary animation is un-portable.
+
+---
+
+## Open questions for the maintainer
+
+1. **Whitelist — ✅ RESOLVED.** Maintainer confirmed an SDK driver component is acceptable, with a hard optimization bar (see *Performance requirements*).
+2. **Package home — open** (the remaining gate before scaffolding). Three options:
+   - **(A — recommended) Split across existing packages.** Authoring component in `com.basis.sdk` (beside `BasisParameterDriver`, the whitelisted-component precedent); batched system in `com.basis.framework` (beside `RemoteBoneJobSystem`). Matches both precedents and keeps registration co-located with the bone system. Relies on the existing direction where the framework runtime reads SDK-defined avatar components at calibration. Trade-off: the feature spans two packages.
+   - **(B) One dedicated package** (e.g. `com.basis.authoredmotion`) holding component + system + converter together. Most cohesive, clearest home for the converter, easy to version or disable as a unit. Wrinkle: the calibration registration hook lives in `com.basis.framework`, which shouldn't depend on a feature package — so the package would register via a framework-exposed "avatar ready" event rather than an inline call (a clean seam to add, but one that doesn't exist yet).
+   - **(C) Both in `com.basis.framework`.** Runtime and registration co-located, simplest layering. Trade-off: the authoring component diverges from the `com.basis.sdk` convention for whitelisted avatar components.
+3. **Runtime toggles.** The original exposes per-movement on/off to the avatar menu via animator bools. How should menu/expression parameters toggle `Movement.enabled` (a thin parameter→component bridge, or the component reading avatar parameters)?
+4. **Jiggle update ordering** relative to the authored-motion write (see above).
+5. **Editor preview.** The runtime job runs at play time, but authors need to see motion in edit mode. Provide a lightweight editor-only evaluation path on the component for preview?
+6. **Converter scope.** How much should the `AnimationClip` → component tool do for a first pass — bake-only (faithful, simplest), or also auto-fit primitives (`Rotate`/`Oscillate`) where curves allow? Bake-only is the smaller lift and still makes every clip portable.
+
+---
+
+## Build approach
+
+One reviewable deliverable, not a staged rollout:
+
+1. Confirm package home (open question 2) — the last gate.
+2. Build the data-only `BasisAuthoredMotion` component, the `BasisAuthoredMotionSystem` batched Burst job, and the calibration-time registration **together**. Develop the job Burst-off for debuggability, validate against the reference avatar's current Animator, then enable Burst and load-test at 1000 CCU against the *Performance requirements* acceptance bar.
+3. The `AnimationClip` → component converter (Migration) lands with or immediately after the core — it's an editor-only tool, independent of the runtime.
+
+The validation target is the Animator baseline this replaces: visually equivalent on the reference avatar, and measurably far cheaper at 1000 CCU.
+
+---
+
+## Appendix — references
+
+- Analysis / rationale: `Leona-Dynamics-Animator-Performance-Analysis.md`
+- Burst batched-transform template: `Packages/com.basis.framework/Drivers/Remote/BasisRemoteBoneDriver.cs` (`RemoteBoneJobSystem`, the gather/compute/apply jobs)
+- Registration precedent: `Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs` (`RemoteCalibration` → `RemoteBoneJobSystem.AddRemotePlayer`)
+- Whitelisted SDK component pattern: `Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`
+- Already applied (stop-gap): cosmetic Animator `Culling Mode` set to `Cull Completely`.
diff --git a/Leona-Dynamics-Animator-Performance-Analysis.md b/Leona-Dynamics-Animator-Performance-Analysis.md
new file mode 100644
index 000000000..a335790ae
--- /dev/null
+++ b/Leona-Dynamics-Animator-Performance-Analysis.md
@@ -0,0 +1,123 @@
+# LeonaDynamics cosmetic Animator — performance analysis
+
+**Context:** During a 1000-CCU load test, the `LeonaDynamics` Animator on the Leona avatar was measured at roughly **1/5 of the scene's frame time**. This document explains what that animator does, why it costs what it does at scale, and three routes to bring the cost down — in increasing order of effort and payoff.
+
+---
+
+## TL;DR
+
+- `LeonaDynamics` is a **second, non-humanoid Animator** on the avatar's `Armature` GameObject, separate from the humanoid `BasisAvatar.Animator`. It runs three cosmetic idle layers: tail wag, tail-adornment orbit, and random ear twitch.
+- Basis's remote path **disables the humanoid animator** on every remote avatar and drives its bones via the networked job system (`BasisRemoteAvatarDriver.RemoteCalibration`, `Animator.enabled = false`). **It does not touch the secondary cosmetic animator.**
+- That secondary animator is set to **`Culling Mode = Always Animate`**, so it runs full state-machine evaluation *and* transform writes every frame on **all ~1000 remote instances, on-screen or not**. That is the cost.
+- **First pass (no code):** set its culling mode to *Cull Completely* and trim the layer/transition churn. Reclaims the cost of every off-screen instance immediately.
+- **Real fix at scale:** the per-instance Unity Animator is the wrong tool for trivial procedural motion replicated 1000×. A **native, data-oriented batched driver** (config on the avatar, one Burst/Jobs pass over all instances) collapses N heavyweight graphs into one tight pass.
+- **Cilbox was considered and rejected** for this: it's an interpreter, so a per-frame interpreted `Update` across 1000 avatars would likely be *worse* than the Animator, not better.
+
+---
+
+## What the animator does
+
+`LeonaDynamics` is an `AnimatorController` with **3 layers, all weight 1, none masked** — so all three evaluate and blend every frame the animator ticks.
+
+**Parameters:** `Settings/Idles/Tail Wag` (bool), `Settings/Idles/Tail Orbit` (bool), `Settings/Idles/Tail Wag Speed` (float), `Settings/Idles/Ear Twitch` (bool), `Settings/Idles/Ear Twitch RNG` (int).
+
+| Layer | States | Behaviour |
+|---|---|---|
+| **Tail Wag** | `Wag On` / `Wag Off` | `Wag On` plays one clip with **both Speed and Time driven by `Tail Wag Speed`** — a looping back-and-forth. Toggled by the `Tail Wag` bool. |
+| **Tail Orbit** | `Orbit` (default) / `Orbit On` | Slow spin of the tail adornment (`Orbit On` at speed 0.1). Toggled by `Tail Orbit`. |
+| **Ear Twitch** | `Buffer` → `Interval` → `RNG` → `Twitch Left/Right` → `Reset` | The `RNG` state hosts a **`BasisParameterDriver`** StateMachineBehaviour (op type *Random*, `localOnly`) that writes a random `0–255` into `Ear Twitch RNG`. Int-threshold transitions then pick Left / Right / no-twitch. Most of the time it idles in `Buffer`/`Interval` playing a near-empty clip. |
+
+The motion these layers produce is *procedurally trivial*: a periodic wag, a constant slow rotation, and an occasional random pose.
+
+> Note: the `.controller` also carries **two orphaned `Locomotion` BlendTrees** not referenced by any layer — leftover sub-assets. They don't drive runtime cost but are dead weight in the asset and worth removing.
+
+---
+
+## Why it costs what it does at 1000 CCU
+
+Unity's Animator is a fully-general evaluator with **high fixed per-instance overhead** — the Playable graph, `Animators.Update`, the parameter buffer, and per-frame transition evaluation (the Ear Twitch layer constantly re-checks several int thresholds). That fixed cost is paid **per Animator instance**, independent of how trivial the motion is.
+
+The decisive detail is **where this animator sits in the Basis avatar lifecycle**:
+
+- In `BasisRemoteAvatarDriver.RemoteCalibration` the **humanoid** animator is taken out of the loop on every remote avatar:
+  ```csharp
+  RemotePlayer.BasisAvatar.Animator.speed = 0;
+  RemotePlayer.BasisAvatar.Animator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
+  ...
+  RemotePlayer.BasisAvatar.Animator.enabled = false;   // bones driven by RemoteBoneJobSystem instead
+  ```
+  (`BasisRemoteAvatarDriver.cs`, lines ~109–112 and ~229.)
+
+- **`LeonaDynamics` is a different component** — a second Animator on the `Armature` child — and the remote path only ever references `BasisAvatar.Animator` (the root humanoid one). So the cosmetic animator is **never disabled, never throttled, never culled** by the framework. It keeps running normally on every client's copy of every remote Leona.
+
+- Its serialized culling mode is **`m_CullingMode: 0` = Always Animate** (verified in `LeonaDynamics.prefab` and in the avatar scene). Always Animate means the state machine evaluates **and** transforms are written **even when the avatar's renderers are off-screen**.
+
+So at 1000 CCU you have up to ~1000 of these graphs each doing full heavyweight evaluation for near-zero motion, regardless of visibility. The cost scales with instance count, which is exactly the regime the load test exercises.
+
+The tail and ear bones are **not** humanoid bones, so they are not part of the networked bone set — the cosmetic motion is produced *locally* on each client by this animator. That's why it has to run on remotes at all (otherwise everyone else's Leona has a frozen tail); it just shouldn't run the way it currently does.
+
+---
+
+## Option A — First pass: tune the existing animator (no code)
+
+Lowest effort, immediate win, stays entirely in avatar content.
+
+1. **Culling Mode: `Always Animate` → `Cull Completely`.**
+   `Cull Completely` *fully* disables the animator when the avatar's renderers aren't visible (state machine included), versus `Cull Update Transforms`, which keeps the state machine running and only skips transform writes. For a purely cosmetic idle, `Cull Completely` is correct — off-screen instances stop costing anything, and motion resumes seamlessly when they come back on screen. In a 1000-CCU scene most instances are off-screen at any moment, so this reclaims the bulk of the cost on its own.
+
+2. **Collapse the three layers where possible.** The layers touch disjoint bones (ears, tail, adornment), so much of the three-state-machine evaluation is avoidable. Fewer always-on layers = less per-frame evaluation for the instances that *are* on screen.
+
+3. **Trim the Ear Twitch transition churn.** The RNG-threshold transitions are evaluated every frame while that layer is active; simplifying the graph reduces fixed per-frame work.
+
+4. **Remove the two orphaned `Locomotion` BlendTrees** from the controller asset.
+
+**Caveat:** culling only helps instances that are *off-screen*. A worst-case crowd test where everyone is visible at once still pays the on-screen cost — which is what Options B/C address.
+
+---
+
+## Option B — Native, data-oriented batched driver (the real fix at scale)
+
+Replace the per-instance Animator graph with **one batched native system**.
+
+- The avatar carries a small **config component** (the same way `BasisParameterDriver` is a whitelisted SDK component today): "this bone wags at frequency/amplitude X, this bone orbits at rate Y, these ear bones twitch on interval Z."
+- A single Basis runtime system iterates a `NativeArray` of all registered cosmetic-idle avatars and computes every wag/orbit/twitch in **one Burst-compiled job**, writing the bone transforms in bulk — conceptually alongside the existing `RemoteBoneJobSystem` apply.
+- This turns "1000 heavyweight Playable graphs" into "one tight job over 1000 transform targets," which is the only thing that meaningfully changes the slope of the cost curve at high CCU.
+
+This is **SDK/engine-side** work, not avatar content. It's the largest effort of the three but the only one that scales to crowds. It also generalises: any avatar with simple procedural idles (tails, ears, floating accessories) could opt into the same batched path instead of shipping its own Animator.
+
+---
+
+## Option C — Native per-avatar driver component (middle ground)
+
+A whitelisted **native** idle-driver MonoBehaviour doing the `sin`/rotate/interval math directly in `LateUpdate`.
+
+- Still per-instance (no batching), but native trivial math has a tiny fraction of the Animator's fixed overhead, so it's a large win over the current setup even before culling.
+- Whether avatars can carry a native whitelisted component for this depends on the avatar content whitelist — i.e. it would be an SDK-provided component the avatar references, not arbitrary user code.
+- Good stepping stone if the full batched system (Option B) is more than is wanted right now; the config surface designed here could later be fed into the batched job without changing the avatar-side authoring.
+
+---
+
+## Why not a Cilbox avatar script
+
+Cilbox is the right mechanism for *untrusted custom logic on an avatar* — it sandboxes arbitrary scripts. But it executes by **interpreting CIL bytecode** op-by-op: `CilboxProxy.Update()` calls `box.InterpretIID(...)` every frame, and the interpreter carries per-instruction timeout accounting. Running an interpreted per-frame `Update` across ~1000 avatars would very plausibly cost *more* than the native Animator it's meant to replace — the work simply moves from `Animators.Update` to `InterpretIID`, at a higher per-unit price. (It also exposes only `Update`/`FixedUpdate`, not `LateUpdate`, which is where bone writes ideally land relative to the rig.)
+
+Cilbox is built for safety and flexibility of untrusted content, not for being a hot path replicated 1000×. It's the wrong tool for *this* goal.
+
+---
+
+## Recommended staged plan
+
+1. **Now (Option A):** flip the cosmetic animator to `Cull Completely`, collapse layers, trim the Ear Twitch graph, drop the orphaned blend trees. Cheap, ships as avatar content, reclaims all off-screen cost.
+2. **Next (Option B or C):** decide whether to invest in the batched native driver (B, scales to on-screen crowds) or a native per-avatar component (C, simpler, still a large per-instance win). The Option C config surface is forward-compatible with the Option B job, so starting at C and graduating to B is viable.
+
+The framing worth landing with the maintainer: **the secondary cosmetic animator currently bypasses the same lifecycle management that already neutralises the humanoid animator on remotes.** Even just bringing it under that management (cull/disable when not needed) is most of the win; a batched driver is the principled long-term home for procedural avatar idles.
+
+---
+
+## Appendix — file references
+
+- Animator controller: `Assets/_UserContent/Avatars/! E L I Z A/Leona/Controllers/Quest/LeonaDynamics.controller`
+- Animator component (culling mode): `.../Controllers/Quest/LeonaDynamics.prefab` (`m_CullingMode: 0`) and the avatar scene `! LEONA - OPEN ME.unity`
+- Remote lifecycle (humanoid animator disabled, bones job-driven): `Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs` (~109–112, ~229)
+- Existing whitelisted SDK StateMachineBehaviour pattern: `Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`
+- Cilbox interpreter per-frame hook: `Packages/com.cnlohr.cilbox/CilboxProxy.cs` (`Update`/`FixedUpdate` → `box.InterpretIID`)

From d7ae92da01998ede3aadd7fa7331904ce85d6975 Mon Sep 17 00:00:00 2001
From: towneh <25694892+towneh@users.noreply.github.com>
Date: Sun, 24 May 2026 21:34:25 +0100
Subject: [PATCH 2/6] docs: resolve design decisions and refine
 BasisAuthoredMotion spec

Add Noise and Oscillate waveform variants (sine/triangle/square/pulse) to the supported motion set.

Record the resolved design decisions: component in com.basis.sdk + batched system in com.basis.framework; runtime toggling via the component's own enabled state; authored-motion write before jiggle physics; Test In Editor as the preview path; bake-only converter for the first pass.

Correct the BasisParameterDriver reference to a data-model precedent only (it is a StateMachineBehaviour) and name the Content Police as the avatar-component whitelist; tighten the jiggle-ordering note to the verified LateUpdate frame-phase constraint.
---
 BasisAuthoredMotion-Design-Spec.md | 91 ++++++++++++++++--------------
 1 file changed, 50 insertions(+), 41 deletions(-)

diff --git a/BasisAuthoredMotion-Design-Spec.md b/BasisAuthoredMotion-Design-Spec.md
index ee36f72fe..72a859aff 100644
--- a/BasisAuthoredMotion-Design-Spec.md
+++ b/BasisAuthoredMotion-Design-Spec.md
@@ -2,7 +2,7 @@
 
 **Problem.** Basis avatars commonly drive *cosmetic and secondary* motion — looping idles, tail and ear movement, spinning accessories — with a Unity Animator. Each Animator carries high *fixed* per-instance overhead (Playable-graph setup and evaluation, state-machine and transition processing, the per-Animator update pass) that is independent of how trivial the motion is, and it is paid on **every replicated copy of every avatar in the instance**. That overhead scales linearly with player count, so at high CCU it becomes a substantial share of frame time: a 1000-CCU load test measured a single avatar's cosmetic Animator at roughly **1/5 of scene frame time**. The motion itself is trivially simple — the cost is almost entirely Animator machinery, not animation. This doc proposes what to build instead. (Background measurement and the options weighed: see the analysis doc in the appendix.)
 
-**Names are provisional** (`BasisAuthoredMotion`, `BasisAuthoredMotionSystem`) — final naming is the maintainer's call.
+**Names confirmed**: `BasisAuthoredMotion` (component) and `BasisAuthoredMotionSystem` (batched system).
 
 **Scope.** This is a general facility for **authored, deterministic dynamic movement on transforms the humanoid rig and IK don't drive** — non-humanoid *rigged* bones (tail and ear chains, extra bones) and standalone accessory objects. The boundary is the humanoid/IK-driven, networked skeleton — *not* bones in general, so rigged chains like tails are squarely in scope. It's a third category of avatar motion: the rigged skeleton is the primary networked/IK-driven pose, jiggle physics adds *emergent* physics-driven follow-through, and this is the *authored* motion the avatar (or prop) declares. The three **stack rather than compete** — authored motion supplies the animated base and **jiggle physics layers on top of it** (see *Jiggle physics ordering*). Cosmetic looping idle sequences or secondary animations (tail flicks, ears twitching, accessories spinning) are among the first use cases driving this, not the limit: any set-sequence or continuously-animated movement on those non-humanoid transforms belongs here.
 
@@ -21,10 +21,10 @@ All runtime work happens in the shared job; the component just declares what to
 
 ## Authoring surface — the component
 
-A whitelisted SDK component following the established `BasisParameterDriver` pattern (`Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`) — a serializable array of reusable, parameterised **movements**. These are general primitives, not avatar-specific behaviours: the same set drives a tail, hair, antennae, ear, cloth strip, halo, orbiting gem, blink, or ambient micro-gesture. Any avatar declares whatever combination it needs.
+A **data-only SDK MonoBehaviour** whose configuration model mirrors `BasisParameterDriver` (`Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`) — a serializable array of reusable, parameterised **movements**, the same `Operation[]`-style shape (an enum kind + per-kind fields). Only the *data model* is borrowed: `BasisParameterDriver` is a `StateMachineBehaviour`, not an avatar component, so it's a shape precedent, not a lifecycle or whitelist one. Allowing a component onto an avatar is the Content Police's job — add the type to `ContentPoliceSelector.selectedTypes` in `AvatarContentPoliceSelector.asset` (`Packages/com.basis.sdk/Scripts/Content Police/`). The movements are general primitives, not avatar-specific behaviours: the same set drives a tail, hair, antennae, ear, cloth strip, halo, orbiting gem, blink, or ambient micro-gesture. Any avatar declares whatever combination it needs.
 
 ```csharp
-public class BasisAuthoredMotion : MonoBehaviour   // names provisional
+public class BasisAuthoredMotion : MonoBehaviour
 {
     public Movement[] movements = Array.Empty<Movement>();
 
@@ -33,17 +33,21 @@ public class BasisAuthoredMotion : MonoBehaviour   // names provisional
     {
         // Open, extensible set — new kinds slot in without changing the
         // registration / scheduling model (see "Extensibility").
-        public enum Kind { Oscillate, Rotate, Orbit, RandomSelect, Sequence }
-        public enum Channel { Rotation, Position, Scale }  // what Oscillate drives
+        public enum Kind { Oscillate, Rotate, Orbit, RandomSelect, Sequence, Noise }
+        public enum Channel  { Rotation, Position, Scale } // what Oscillate / Noise drive
+        public enum Waveform { Sine, Triangle, Square, Pulse } // Oscillate waveform
 
         public Kind kind = Kind.Oscillate;
         public string label;              // author-facing identifier only
-        public bool enabled = true;       // runtime-toggleable (see open question on toggles)
+        public bool enabled = true;       // author default; runtime toggle rides the component's own enabled (any toggle system, e.g. HVR.Vixxy)
         public Vector3 axis = Vector3.up; // local axis the movement acts about
 
-        // Oscillate — periodic (sine) motion on `channel`, optionally propagated
-        // down a chain to form a travelling wave (1 entry = simple sway).
+        // Oscillate — periodic motion on `channel`, optionally propagated down a
+        // chain to form a travelling wave (1 entry = simple sway). `waveform`
+        // selects sine (default) or triangle / square / pulse.
         public Channel channel = Channel.Rotation; // amplitude unit: deg | metres | scale-factor
+        public Waveform waveform = Waveform.Sine;
+        public float pulseWidth = 0.5f;    // square/pulse duty cycle (0–1)
         public Transform[] chain;
         public float amplitude      = 15f;
         public float frequencyHz    = 0.5f;
@@ -75,6 +79,12 @@ public class BasisAuthoredMotion : MonoBehaviour   // names provisional
         public Keyframe[] keyframes = Array.Empty<Keyframe>();
         public BasisMotionClip bakedClip; // shared baked curves; null when using inline keyframes
         public bool loop = true;
+
+        // Noise — organic Perlin/simplex drift on `channel` about `axis`;
+        // smoother than RandomSelect, less repetitive than Oscillate. Reuses
+        // `amplitude`, `chain`, `chainFalloff`, and `seed`; `noiseSpeed` sets
+        // how fast the noise field is sampled.
+        public float noiseSpeed = 0.5f;
     }
 
     [Serializable]
@@ -92,32 +102,29 @@ The initial supported set. Every type is a **delta from a captured rest pose** o
 
 | Type | What it does | Channel(s) | Key parameters | Example uses |
 |------|--------------|-----------|----------------|--------------|
-| **Oscillate** | periodic (sine) motion, optionally a travelling wave down a chain | rotation / position / scale | `axis`, `amplitude`, `frequencyHz`, `phase`, `chainPhaseStep`, `chainFalloff` | tail / hair / ear sway, floating bob, breathing & glow pulse |
+| **Oscillate** | periodic motion (sine / triangle / square / pulse), optionally a travelling wave down a chain | rotation / position / scale | `axis`, `amplitude`, `frequencyHz`, `phase`, `waveform`, `chainPhaseStep`, `chainFalloff` | tail / hair / ear sway, floating bob, breathing & glow pulse, mechanical ticks |
 | **Rotate** | constant angular velocity, spinning in place | rotation | `axis`, `speedDeg` | halos, fans, spinning gems/coins |
 | **Orbit** | revolve a transform around a pivot at a radius | position (+ optional facing) | `pivot`, `radius`, `orbitSpeedDeg`, `axis` | accessory circling the body/tail, orbiting orbs or particles |
 | **RandomSelect** | stochastic weighted pick among pose options on a randomised interval | rotation (pose deltas) | `options` (+`weight`), `intervalRange`, `attack`/`release`, `preventRepeats`, `seed` | ear flicks, blinks, idle micro-gestures |
 | **Sequence** | authored keyframed timeline of pose deltas, looping or one-shot; inline keys for short hand-authored motion, or a shared baked-curve asset for complex/converted clips | rotation + position + scale | `keyframes` (`time` + per-channel deltas) *or* baked-clip ref, `loop` | scripted flourishes, set-piece accessory animations, **any converted AnimationClip** (see Migration) |
+| **Noise** | organic Perlin/simplex drift, optionally down a chain | rotation / position / scale | `axis`, `amplitude`, `noiseSpeed`, `seed`, `chainFalloff` | idle wander, flame / cloth flutter, lifelike micro-sway |
 
 The math, per type:
 
-- **Oscillate** — `value = rest ⊕ (amplitude * sin(t*frequencyHz*2π + phase))` on `axis`, where `⊕` applies to the chosen channel (rotation = `AngleAxis`, position = offset along axis, scale = scalar along axis). For a chain, element *n* uses `phase + n*chainPhaseStep` and `amplitude * chainFalloffⁿ` → a wave travelling down the chain.
+- **Oscillate** — `value = rest ⊕ (amplitude * w(t*frequencyHz*2π + phase))` on `axis`, where `w` is the selected `waveform` (sine, or triangle / square / pulse derived from the same phase — square/pulse using `pulseWidth` as the duty cycle) and `⊕` applies to the chosen channel (rotation = `AngleAxis`, position = offset along axis, scale = scalar along axis). For a chain, element *n* uses `phase + n*chainPhaseStep` and `amplitude * chainFalloffⁿ` → a wave travelling down the chain.
 - **Rotate** — `localRotation = rest * AngleAxis((t * speedDeg) mod 360, axis)`.
 - **Orbit** — `localPosition = pivotLocal + radius * (cos θ, sin θ)` in the plane normal to `axis`, `θ = t * orbitSpeedDeg`; optionally face the pivot.
 - **RandomSelect** — deterministic, no managed callback and no animator parameter. A per-movement `Unity.Mathematics.Random` (seeded by `seed`, or registration index) schedules the next pick from `intervalRange`, chooses a weighted `Option` (honouring `preventRepeats`), and eases its pose delta `0 → angleDeg → 0` over `attack`/`release`. This replaces the `BasisParameterDriver` state-machine-behaviour + RNG int + threshold-transition machinery entirely.
 - **Sequence** — sample the timeline at `t` (wrapping when `loop`), interpolate the per-channel deltas, apply over rest. A lightweight authored clip without an Animator/Playable graph. Short sequences use inline keyframes; complex/converted clips reference a shared, read-only baked curve buffer (see Migration).
+- **Noise** — `value = rest ⊕ (amplitude * noise.snoise(float2(t*noiseSpeed, seedOffset)))` on `axis` (simplex noise, range ≈ [-1, 1]); applies to the channel exactly as Oscillate does, and propagates down a chain via `chainFalloffⁿ` with a per-element `seedOffset`.
 
-All RNG and trig is `Unity.Mathematics`, so the routine is Burst-legal as written.
+All RNG, trig, and noise is `Unity.Mathematics`, so the routine is Burst-legal as written.
 
-### Extensibility & candidate future kinds
+### Extensibility
 
 The kind set is open. A new type = a new `Kind` enum value + a branch in the evaluation routine + its fields in the flattened struct; a kind with a very different data shape gets its own SoA array + sub-job. Registration, scheduling, culling, and toggles are all kind-agnostic, so adding a type never disturbs the system around it — which is what makes this a general avatar-motion facility rather than a fix for one avatar.
 
-Kinds deliberately **out of the initial set**, listed so the trajectory is visible (build when a real consumer needs them):
-
-- **Noise** — organic drift via Perlin/simplex (smoother than `RandomSelect`, more lifelike than pure sine).
-- **Oscillate waveform variants** — triangle / square / pulse as an `Oscillate` option rather than separate kinds.
-- **Reactive kinds** — audio- or velocity-driven motion (need an input feed; defer until that plumbing exists).
-- **LookAt / aim** — track a target or the camera (overlaps with skeletal concerns; evaluate separately).
+The initial set already exercises the full range of shapes — clock-driven (**Oscillate**, **Rotate**, **Orbit**), stochastic (**RandomSelect**), baked (**Sequence**), and procedural-noise (**Noise**) — all self-contained, with no external input feeds. Further kinds slot in by the same mechanism whenever a real consumer needs one — none are committed speculatively here.
 
 ---
 
@@ -135,7 +142,7 @@ Kinds deliberately **out of the initial set**, listed so the trajectory is visib
 | Cull / disable | `ValidMask`-style `NativeArray<byte>` — toggled movements and culled avatars become no-ops, no array churn |
 | Threading | adaptive `innerloopBatchCount = min(maxBatch, ceil(count / workerCount))` |
 
-**Registration** — co-locate with the bone system: `BasisRemoteAvatarDriver.RemoteCalibration` already calls `RemoteBoneJobSystem.AddRemotePlayer`; the local path (`BasisLocalAvatarDriver`) is the analogue. At calibration, if the avatar has a `BasisAuthoredMotion` (`TryGetComponent`), flatten its movements + targets into the SoA and register; deregister on teardown/recalibration (the bone system's synchronous-remove rationale applies — drop the TAA entry while the transform is alive). **Rest poses** are captured at registration and stored in the SoA; movements compose as deltas from rest, never baked absolutes. Registration is driven by the calibration hook — **no scene discovery** (`FindObjectsOfType` et al.).
+**Registration** — co-locate with the bone system: `BasisRemoteAvatarDriver.RemoteCalibration` already calls `RemoteBoneJobSystem.AddRemotePlayer`; the local path (`BasisLocalAvatarDriver`) is the analogue. At calibration, walk the avatar's `BasisAuthoredMotion` components (`GetComponents` — an avatar may carry several, one per toggle group; see *Maintainer decisions* #3), flatten their movements + targets into the SoA and register; deregister on teardown/recalibration (the bone system's synchronous-remove rationale applies — drop the TAA entry while the transform is alive). Each component owns the `ValidMask` slice for its movements and toggles it in `OnEnable`/`OnDisable`, so any toggle-system-driven enable/disable is an event, not per-frame work. **Rest poses** are captured at registration and stored in the SoA; movements compose as deltas from rest, never baked absolutes. Registration is driven by the calibration hook — **no scene discovery** (`FindObjectsOfType` et al.).
 
 **Frame schedule** — schedule in the same phase as `RemoteBoneJobSystem`, after the avatar pose apply, completing before render.
 
@@ -153,7 +160,7 @@ Kinds deliberately **out of the initial set**, listed so the trajectory is visib
 
 Maintainer feedback: an SDK driver component is acceptable, **but it must be heavily optimized.** Concrete targets this design commits to:
 
-- **Data-only component at runtime.** `BasisAuthoredMotion` holds serialized config and runs **no per-instance `Update`** — all runtime evaluation is the single batched Burst job. (An optional editor-only preview path may evaluate in edit mode; see open questions.)
+- **Data-only component at runtime.** `BasisAuthoredMotion` holds serialized config and runs **no per-instance `Update`** — all runtime evaluation is the single batched Burst job. Editor preview rides the same runtime job during Test In Editor (see *Maintainer decisions*); there's no separate edit-mode evaluation path.
 - **One job set per frame for all avatars**, parallel across workers, cost scaling with total movement count — not a per-avatar dispatch. Mirrors `RemoteBoneJobSystem`.
 - **Zero per-frame GC** — persistent SoA `NativeArray`/`NativeList` + `TransformAccessArray`; no managed allocation in the frame loop.
 - **Burst with fast math** (`[BurstCompile(FloatMode = FloatMode.Fast, FloatPrecision = FloatPrecision.Low)]`, as `BasisRemoteBoneJob` uses).
@@ -169,7 +176,7 @@ Maintainer feedback: an SDK driver component is acceptable, **but it must be hea
 ## Cross-cutting design points
 
 - **Rest-pose capture** is the correctness linchpin — capture at registration, compose all motion as deltas, never bake absolute rotations.
-- **Jiggle physics ordering.** Avatars frequently run `JiggleRig` physics on the same chains authored motion drives (a tail, say), wired up in the remote driver. The authored-motion write must land **before** jiggle samples its input pose, so the two compose (authored movement = animated base, jiggle = secondary motion on top), matching how jiggle previously layered on the Animator output. Confirm the job phase orders correctly against the jiggle update (and the editor-preview path, if present).
+- **Jiggle physics ordering.** Avatars frequently run `JiggleRig` physics on the same chains authored motion drives (a tail, say), wired up in the remote driver. The authored-motion write must land **before** jiggle samples its input pose, so the two compose (authored movement = animated base, jiggle = secondary motion on top), matching how jiggle previously layered on the Animator output. Jiggle is advanced by `JigglePhysicsUpdater` in LateUpdate, so the authored write must be applied earlier in the frame (Update / early-LateUpdate) and **not** in `AfterSimulateOnRender` (which fires at `onBeforeRender`, after LateUpdate); confirm the execution order against the jiggle updater in implementation.
 - **Non-humanoid targets.** Driven bones (tail, ears, accessories) aren't in the networked bone set (`BasisBoneRotationCompression.SyncBoneCount` / `RemoteBoneJobSystem`) and aren't touched by local IK — the job owns them outright, so there's no write contention with the skeletal pipeline.
 
 ---
@@ -185,38 +192,37 @@ If we're pitching this as a replacement for traditional Animator-driven cosmetic
 **Route 2 — baked (arbitrary authored motion).** Complex hand-keyed motion a primitive can't describe — *e.g. a precise 15-second loop rotating a bone chain through a bespoke path* — is captured as a **`Sequence` backed by a baked clip asset**: the source curves sampled to a fixed-rate, blittable buffer (per driven transform, per channel). The baked data is a **shared, read-only asset** — every instance of the avatar references the same buffer; per-instance runtime state is just a playhead. The batched Burst job samples the shared curve at each instance's playhead and writes the channel. So even a faithful recording of a complex clip scales: the heavy data is shared once, per-instance cost is one interpolated sample per bone — none of the Animator's per-instance Playable-graph / state-machine / retarget overhead. (`AnimationCurve` isn't Burst-usable directly, hence the sampled buffer; rotations bake to quaternions and `nlerp`/`slerp` in-job.)
 
 **The converter tool — the actual on-ramp.** An editor utility takes an existing `AnimationClip` (+ its root) and emits a populated `BasisAuthoredMotion`:
-- For each animated curve, a cheap fit test: near-constant-rate rotation → offer `Rotate`; near-single-frequency sinusoid → offer `Oscillate`; otherwise **bake** into a shared `Sequence` asset.
-- The result mixes compact primitives where motion is describable and faithful baked sequences where it isn't — all reviewable and tweakable afterward.
-- Default is faithful (bake); primitive-fitting is an opt-in *suggestion*, so nothing is silently approximated.
+- **v1 is bake-only:** every animated curve is baked into a shared, read-only `Sequence` asset — a faithful recording, nothing silently approximated.
+- Primitives stay a *manual* authoring route (Route 1): an author who wants the tiny, tweakable `Oscillate` / `Rotate` / `Orbit` form sets it up by hand. The converter doesn't auto-detect them in v1.
+- Auto-fitting curves to primitives (near-constant-rate rotation → `Rotate`, near-single-frequency sinusoid → `Oscillate`) is a later enhancement layered on the same tool — an opt-in suggestion, never a silent substitution.
 - It's an editor-only tool independent of the runtime, so it can land alongside the core or immediately after.
 
-**Worked example — the 15s bone-chain loop.** The converter bakes each bone's rotation curve into one shared `Sequence` asset (sampled at the clip's framerate, looped) and plays it back in the same batched job as every other movement. If some bones turn out near-sinusoidal on inspection, the tool can offer to swap those for `Oscillate` (lighter, tweakable) — but the default reproduces the original exactly.
+**Worked example — the 15s bone-chain loop.** The converter bakes each bone's rotation curve into one shared `Sequence` asset (sampled at the clip's framerate, looped) and plays it back in the same batched job as every other movement — reproducing the original exactly. Where a bone is actually a simple sway, an author can re-author it as a hand-tuned `Oscillate` afterward (lighter, tweakable); auto-detecting that case is the later converter enhancement.
 
 **Expectation-setting tradeoff:** parametric = tiny, tweakable, infinite variation; baked = faithful to any motion, larger (but shared) data, a fixed recording. Both shed the per-instance Animator overhead, which is the 1000-CCU win — so "we can always bake it" means *no* existing cosmetic or secondary animation is un-portable.
 
 ---
 
-## Open questions for the maintainer
+## Maintainer decisions
+
+All resolved — nothing gating scaffolding.
 
-1. **Whitelist — ✅ RESOLVED.** Maintainer confirmed an SDK driver component is acceptable, with a hard optimization bar (see *Performance requirements*).
-2. **Package home — open** (the remaining gate before scaffolding). Three options:
-   - **(A — recommended) Split across existing packages.** Authoring component in `com.basis.sdk` (beside `BasisParameterDriver`, the whitelisted-component precedent); batched system in `com.basis.framework` (beside `RemoteBoneJobSystem`). Matches both precedents and keeps registration co-located with the bone system. Relies on the existing direction where the framework runtime reads SDK-defined avatar components at calibration. Trade-off: the feature spans two packages.
-   - **(B) One dedicated package** (e.g. `com.basis.authoredmotion`) holding component + system + converter together. Most cohesive, clearest home for the converter, easy to version or disable as a unit. Wrinkle: the calibration registration hook lives in `com.basis.framework`, which shouldn't depend on a feature package — so the package would register via a framework-exposed "avatar ready" event rather than an inline call (a clean seam to add, but one that doesn't exist yet).
-   - **(C) Both in `com.basis.framework`.** Runtime and registration co-located, simplest layering. Trade-off: the authoring component diverges from the `com.basis.sdk` convention for whitelisted avatar components.
-3. **Runtime toggles.** The original exposes per-movement on/off to the avatar menu via animator bools. How should menu/expression parameters toggle `Movement.enabled` (a thin parameter→component bridge, or the component reading avatar parameters)?
-4. **Jiggle update ordering** relative to the authored-motion write (see above).
-5. **Editor preview.** The runtime job runs at play time, but authors need to see motion in edit mode. Provide a lightweight editor-only evaluation path on the component for preview?
-6. **Converter scope.** How much should the `AnimationClip` → component tool do for a first pass — bake-only (faithful, simplest), or also auto-fit primitives (`Rotate`/`Oscillate`) where curves allow? Bake-only is the smaller lift and still makes every clip portable.
+1. **Whitelist — ✅ RESOLVED.** An SDK driver component is acceptable, with a hard optimization bar (see *Performance requirements*).
+2. **Package home — ✅ RESOLVED (option A — split across existing packages).** Authoring component in `com.basis.sdk` (alongside `BasisParameterDriver` — the SDK avatar-config precedent; whitelisted for avatars via the Content Police, see *Authoring surface*); batched system in `com.basis.framework` (beside `RemoteBoneJobSystem`), with registration co-located at calibration. The feature spans two packages, matching both precedents, and relies on the existing direction where the framework runtime reads SDK-defined avatar components at calibration.
+3. **Runtime toggles — ✅ RESOLVED (component `enabled`, toggle-system-agnostic).** The component's toggle contract is its own `MonoBehaviour.enabled`: it flips its slice of the system's `ValidMask` in `OnEnable`/`OnDisable` — event-driven, not a per-frame `Update`, so the data-only guarantee holds. **Anything that can set a `Behaviour.enabled` drives it; `BasisAuthoredMotion` holds no reference to any toggle package**, so swapping the toggle system later leaves the component unchanged. HVR.Vixxy is the current consumer: a Vixxy *activation* sets the component's `enabled` (`SetToggleState` → `Behaviour.enabled`), which needs `BasisAuthoredMotion` added to Vixxy's `HVR_VixxyPermitted.PermittedTypeNames` — a by-name string entry on comms' side, so the dependency arrow points comms → SDK, never the reverse. This permitted-list entry is a **second, separate allowlist** from the Content Police entry that lets the component exist on an avatar at all (see *Authoring surface*) — shipping the toggle needs both. Authors group movements that toggle together into one component; an avatar can carry several. Per-*individual*-movement toggling (finer than grouping) would need the component to read an external parameter/variable address and map it to per-movement mask bits — revisit only if grouping proves insufficient.
+4. **Jiggle update ordering — ✅ RESOLVED (requirement); phase to lock in implementation.** The authored-motion write must land **before** `JiggleRig` physics samples its input pose (authored = animated base, jiggle = follow-through on top). Verified constraint: jiggle is advanced by `JigglePhysicsUpdater` in **LateUpdate**, so authored motion must be applied earlier in the frame (Update / early-LateUpdate, the way `RemoteBoneJobSystem` schedules from the network update) — **not** in `AfterSimulateOnRender`, which fires at `onBeforeRender`, after LateUpdate. Lock the execution order against the jiggle updater during implementation (see *Cross-cutting design points*).
+5. **Editor preview — ✅ RESOLVED.** Scope is: motion must at least be visible during **Test In Editor** (the SDK inspector's button, `BasisAvatarSDKInspector` → play mode). That path goes through normal calibration-time registration and runs the standard runtime job, so it's covered by the runtime with no extra work; a separate edit-mode (non-play) preview path is out of v1.
+6. **Converter scope — ✅ RESOLVED.** First pass is **bake-only** — every `AnimationClip` becomes a faithful baked `Sequence`. Primitive auto-fitting (`Rotate`/`Oscillate` where curves allow) is a later enhancement, not v1.
 
 ---
 
 ## Build approach
 
-One reviewable deliverable, not a staged rollout:
+One reviewable deliverable, not a staged rollout. All maintainer decisions are settled (see above), so nothing gates the start:
 
-1. Confirm package home (open question 2) — the last gate.
-2. Build the data-only `BasisAuthoredMotion` component, the `BasisAuthoredMotionSystem` batched Burst job, and the calibration-time registration **together**. Develop the job Burst-off for debuggability, validate against the reference avatar's current Animator, then enable Burst and load-test at 1000 CCU against the *Performance requirements* acceptance bar.
-3. The `AnimationClip` → component converter (Migration) lands with or immediately after the core — it's an editor-only tool, independent of the runtime.
+1. Place the pieces per the resolved package home (option A): the data-only `BasisAuthoredMotion` component in `com.basis.sdk`, the `BasisAuthoredMotionSystem` batched Burst job in `com.basis.framework`.
+2. Build the component, the batched Burst job, and the calibration-time registration **together**. Develop the job Burst-off for debuggability, validate against the reference avatar's current Animator, then enable Burst and load-test at 1000 CCU against the *Performance requirements* acceptance bar.
+3. The `AnimationClip` → component converter (Migration) lands with or immediately after the core — it's an editor-only tool, independent of the runtime. First pass is bake-only.
 
 The validation target is the Animator baseline this replaces: visually equivalent on the reference avatar, and measurably far cheaper at 1000 CCU.
 
@@ -226,6 +232,9 @@ The validation target is the Animator baseline this replaces: visually equivalen
 
 - Analysis / rationale: `Leona-Dynamics-Animator-Performance-Analysis.md`
 - Burst batched-transform template: `Packages/com.basis.framework/Drivers/Remote/BasisRemoteBoneDriver.cs` (`RemoteBoneJobSystem`, the gather/compute/apply jobs)
-- Registration precedent: `Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs` (`RemoteCalibration` → `RemoteBoneJobSystem.AddRemotePlayer`)
-- Whitelisted SDK component pattern: `Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`
+- Registration precedent (remote): `Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs` (`RemoteCalibration` → `RemoteBoneJobSystem.AddRemotePlayer`)
+- Registration seam (local): `Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs` (`Calibration`, plus the static `CalibrationComplete` action)
+- Config data-model precedent (shape only — it's a `StateMachineBehaviour`, not an avatar component): `Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`
+- Avatar-component whitelist mechanism: `Packages/com.basis.sdk/Scripts/Content Police/ContentPoliceSelector.cs` + `Packages/com.basis.sdk/Settings/AvatarContentPoliceSelector.asset`
+- Toggle precedent (component `enabled` via Vixxy's separate allowlist): `Packages/dev.hai-vr.basis.comms/Scripts/Systems/Runtime/Vixxy/Internal/HVR_VixxyPermitted.cs` (`PermittedTypeNames`)
 - Already applied (stop-gap): cosmetic Animator `Culling Mode` set to `Cull Completely`.

From d9d4dfc718ace88c76bcae01a740f5dd84536cbf Mon Sep 17 00:00:00 2001
From: towneh <25694892+towneh@users.noreply.github.com>
Date: Sun, 24 May 2026 23:04:02 +0100
Subject: [PATCH 3/6] feat: add BasisAuthoredMotion component and batched Burst
 motion system

Data-only SDK component (BasisAuthoredMotion) declaring authored motion on non-humanoid transforms the rig and IK don't drive, plus the shared baked-curve BasisMotionClip asset. Movement model: Oscillate, Rotate, Orbit, RandomSelect, Sequence, Noise.

BasisAuthoredMotionSystem evaluates every registered avatar's movements in one batched Burst IJobParallelForTransform per frame (a sibling to RemoteBoneJobSystem): rest poses captured at registration, motion composed as deltas, valid-mask culling, and a TransformAccessArray resync that survives avatar teardown. Oscillate (incl. chain travelling waves and triangle/square/pulse), Rotate, Orbit and Noise are implemented; RandomSelect and Sequence are stubbed pending their side buffers.

BasisAuthoredMotionDriver pumps the pass in LateUpdate, ordered before the jiggle updater so authored motion is the animated base and jiggle layers on top. Components register at local and remote calibration and unregister on remote teardown.

Allow the component via the Content Police and let an HVR.Vixxy activation toggle its enabled state; add an AuthoredMotion log tag.
---
 .../Drivers/AuthoredMotion.meta               |   8 +
 .../BasisAuthoredMotionDriver.cs              |  40 ++
 .../BasisAuthoredMotionDriver.cs.meta         |   2 +
 .../BasisAuthoredMotionSystem.cs              | 439 ++++++++++++++++++
 .../BasisAuthoredMotionSystem.cs.meta         |   2 +
 .../Drivers/Local/BasisLocalAvatarDriver.cs   |   8 +
 .../Drivers/Remote/BasisRemoteAvatarDriver.cs |   9 +
 .../Players/Remote/BasisRemotePlayer.cs       |  11 +
 .../Scripts/Basis Logger/BasisDebug.cs        |   2 +
 .../Scripts/BasisAuthoredMotion.cs            |  91 ++++
 .../Scripts/BasisAuthoredMotion.cs.meta       |   2 +
 .../com.basis.sdk/Scripts/BasisMotionClip.cs  |  30 ++
 .../Scripts/BasisMotionClip.cs.meta           |   2 +
 .../AvatarContentPoliceSelector.asset         |   1 +
 .../Vixxy/Internal/HVR_VixxyPermitted.cs      |   2 +
 15 files changed, 649 insertions(+)
 create mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion.meta
 create mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs
 create mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta
 create mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs
 create mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs.meta
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs.meta
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs.meta

diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion.meta b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion.meta
new file mode 100644
index 000000000..12abc5e23
--- /dev/null
+++ b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9cd51cc56e1f6104fac61b892a4f4666
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs
new file mode 100644
index 000000000..59e342222
--- /dev/null
+++ b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs
@@ -0,0 +1,40 @@
+using Unity.Jobs;
+using UnityEngine;
+
+/// <summary>
+/// Per-frame pump for <see cref="BasisAuthoredMotionSystem"/>. A single hidden, persistent object
+/// schedules and completes the batched authored-motion pass each frame. The negative execution
+/// order makes its <c>LateUpdate</c> run before <c>JiggleUpdateExample</c> (default order 0), so
+/// the driven transforms are written and the job is completed before jiggle physics samples them
+/// — authored motion is the animated base, jiggle layers on top.
+/// </summary>
+[DefaultExecutionOrder(-100)]
+public class BasisAuthoredMotionDriver : MonoBehaviour
+{
+    static BasisAuthoredMotionDriver sInstance;
+
+    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
+    static void Bootstrap()
+    {
+        if (sInstance != null) return;
+        var go = new GameObject("[BasisAuthoredMotionDriver]") { hideFlags = HideFlags.HideAndDontSave };
+        DontDestroyOnLoad(go);
+        sInstance = go.AddComponent<BasisAuthoredMotionDriver>();
+    }
+
+    private void LateUpdate()
+    {
+        // Complete here (not just schedule) so the writes land before the jiggle updater's
+        // LateUpdate samples the bones. TODO (perf): split to schedule-early / complete-here once
+        // the kinds are validated, to overlap the job with other main-thread work.
+        JobHandle handle = BasisAuthoredMotionSystem.Schedule();
+        BasisAuthoredMotionSystem.Complete(handle);
+    }
+
+    private void OnDestroy()
+    {
+        if (sInstance != this) return;
+        BasisAuthoredMotionSystem.Dispose();
+        sInstance = null;
+    }
+}
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta
new file mode 100644
index 000000000..a303c9c54
--- /dev/null
+++ b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e70fde70a6c4b3248b59f70365c73336
\ No newline at end of file
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs
new file mode 100644
index 000000000..86d91d9a0
--- /dev/null
+++ b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs
@@ -0,0 +1,439 @@
+using System.Collections.Generic;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using Unity.Mathematics;
+using UnityEngine;
+using UnityEngine.Jobs;
+using Movement = BasisAuthoredMotion.Movement;
+using Kind = BasisAuthoredMotion.Movement.Kind;
+using Channel = BasisAuthoredMotion.Movement.Channel;
+using Waveform = BasisAuthoredMotion.Movement.Waveform;
+
+/// <summary>
+/// Blittable, flattened <see cref="BasisAuthoredMotion.Movement"/> plus the captured rest pose.
+/// One slot per driven transform — a chain element is its own slot, with its element phase /
+/// falloff baked in at registration. Parallel to the system's <c>TransformAccessArray</c>.
+/// </summary>
+public struct AuthoredMovementData
+{
+    public int kind;       // (int)Movement.Kind
+    public int channel;    // (int)Movement.Channel
+    public int waveform;   // (int)Movement.Waveform
+
+    public float3 axis;
+    public float amplitude;
+    public float frequencyHz;
+    public float phase;
+    public float pulseWidth;
+
+    public float speedDeg;       // Rotate
+    public float radius;         // Orbit
+    public float orbitSpeedDeg;  // Orbit
+    public float3 pivotLocal;    // Orbit pivot, in the target's parent space
+    public float noiseSpeed;     // Noise
+    public uint seed;            // Noise / RandomSelect
+
+    // Captured rest pose (local space); motion composes as a delta from this.
+    public quaternion restRotation;
+    public float3 restPosition;
+    public float3 restScale;
+}
+
+/// <summary>
+/// Single compute-and-write pass for all avatars' authored movements. One movement touches only
+/// a few transforms, so a single <see cref="IJobParallelForTransform"/> parallelises cleanly
+/// across avatars (no compute/apply split like the 51-bone skeleton needs). Every kind is a delta
+/// from the captured rest pose. All math is <c>Unity.Mathematics</c>, so the routine is Burst-legal.
+/// </summary>
+[BurstCompile(FloatMode = FloatMode.Fast, FloatPrecision = FloatPrecision.Low)]
+public struct AuthoredMotionJob : IJobParallelForTransform
+{
+    [ReadOnly] public NativeArray<AuthoredMovementData> Movements;
+    [ReadOnly] public NativeArray<byte> ValidMask;
+    public float Time;
+
+    public void Execute(int index, TransformAccess transform)
+    {
+        if (ValidMask[index] == 0) return;
+
+        AuthoredMovementData m = Movements[index];
+        float t = Time;
+
+        switch ((Kind)m.kind)
+        {
+            case Kind.Oscillate:
+            {
+                float w = Wave(m.waveform, t * m.frequencyHz * 2f * math.PI + m.phase, m.pulseWidth);
+                ApplyChannel(transform, m, m.amplitude * w);
+                break;
+            }
+            case Kind.Noise:
+            {
+                float n = noise.snoise(new float2(t * m.noiseSpeed, m.seed * 0.7283f));
+                ApplyChannel(transform, m, m.amplitude * n);
+                break;
+            }
+            case Kind.Rotate:
+            {
+                float angle = math.radians((t * m.speedDeg) % 360f);
+                transform.localRotation = math.mul(m.restRotation, quaternion.AxisAngle(math.normalizesafe(m.axis), angle));
+                break;
+            }
+            case Kind.Orbit:
+            {
+                float theta = math.radians(t * m.orbitSpeedDeg);
+                float3 n = math.normalizesafe(m.axis, new float3(0f, 1f, 0f));
+                float3 u = math.cross(n, new float3(0f, 1f, 0f));
+                if (math.lengthsq(u) < 1e-6f) u = math.cross(n, new float3(1f, 0f, 0f));
+                u = math.normalizesafe(u);
+                float3 v = math.cross(n, u);
+                transform.localPosition = m.pivotLocal + m.radius * (math.cos(theta) * u + math.sin(theta) * v);
+                break;
+            }
+
+            // TODO (iterative Burst-off pass): RandomSelect needs a per-slot RNG + interval/ease
+            // state buffer; Sequence needs the shared baked-curve buffer + a per-instance playhead.
+            // Both add a side NativeArray the job reads — wired once the deterministic kinds are
+            // validated against the reference avatar. No-op until then.
+            case Kind.RandomSelect:
+            case Kind.Sequence:
+            default:
+                break;
+        }
+    }
+
+    static void ApplyChannel(TransformAccess transform, in AuthoredMovementData m, float value)
+    {
+        float3 axis = math.normalizesafe(m.axis, new float3(0f, 1f, 0f));
+        switch ((Channel)m.channel)
+        {
+            case Channel.Rotation:
+                transform.localRotation = math.mul(m.restRotation, quaternion.AxisAngle(axis, math.radians(value)));
+                break;
+            case Channel.Position:
+                transform.localPosition = m.restPosition + axis * value;
+                break;
+            case Channel.Scale:
+                transform.localScale = m.restScale + axis * value;
+                break;
+        }
+    }
+
+    // phase is in radians; pulseWidth is the square/pulse duty cycle (0–1).
+    static float Wave(int waveform, float phase, float pulseWidth)
+    {
+        switch ((Waveform)waveform)
+        {
+            case Waveform.Sine: return math.sin(phase);
+            case Waveform.Triangle: { float x = math.frac(phase / (2f * math.PI)); return 4f * math.abs(x - 0.5f) - 1f; }
+            case Waveform.Square: { float x = math.frac(phase / (2f * math.PI)); return x < pulseWidth ? 1f : -1f; }
+            case Waveform.Pulse: { float x = math.frac(phase / (2f * math.PI)); return x < pulseWidth ? 1f : 0f; }
+            default: return math.sin(phase);
+        }
+    }
+}
+
+/// <summary>
+/// Static orchestrator for authored-motion evaluation — a sibling to <c>RemoteBoneJobSystem</c>.
+/// Holds the persistent SoA + <see cref="TransformAccessArray"/> for every registered avatar's
+/// driven transforms and schedules one batched Burst pass per frame. Drives transforms outside the
+/// networked humanoid skeleton, so there's no write contention with the bone pipeline.
+///
+/// <para>Registration is calibration-driven (no scene discovery): the local/remote avatar drivers
+/// call <see cref="Register"/> for each <see cref="BasisAuthoredMotion"/> on the avatar and
+/// <see cref="Unregister"/> on teardown/recalibration. Authoritative state lives in managed
+/// <c>Registration</c> records (rest poses captured once at registration); a structural change
+/// rebuilds the native containers from them.</para>
+/// </summary>
+public static class BasisAuthoredMotionSystem
+{
+    sealed class Registration
+    {
+        public BasisAuthoredMotion Component;
+        public Transform[] Targets;          // one per slot
+        public AuthoredMovementData[] Data;  // parallel to Targets
+        public bool[] MovementEnabled;       // per-slot author default (Movement.enabled)
+        public bool ComponentEnabled;        // mirrors the component's runtime enabled state
+        public int Offset;                   // current start index in the native containers
+    }
+
+    // Persistent SoA, parallel to sTargets.
+    static NativeList<AuthoredMovementData> sMovements;
+    static NativeList<byte> sValidMask;
+    static TransformAccessArray sTargets;
+
+    static readonly List<Registration> sRegistrations = new List<Registration>();
+    static readonly Dictionary<BasisAuthoredMotion, Registration> sLookup = new Dictionary<BasisAuthoredMotion, Registration>();
+
+    static JobHandle sPending;
+    static bool sInitialized;
+
+    public static int SlotCount => sInitialized ? sMovements.Length : 0;
+
+    public static void Initialize(int initialCapacity = 0)
+    {
+        if (sInitialized) return;
+        sMovements = new NativeList<AuthoredMovementData>(initialCapacity, Allocator.Persistent);
+        sValidMask = new NativeList<byte>(initialCapacity, Allocator.Persistent);
+        sTargets = new TransformAccessArray(math.max(1, initialCapacity));
+        sRegistrations.Clear();
+        sLookup.Clear();
+        sInitialized = true;
+    }
+
+    public static void Dispose()
+    {
+        if (!sInitialized) return;
+        CompletePending();
+        if (sMovements.IsCreated) sMovements.Dispose();
+        if (sValidMask.IsCreated) sValidMask.Dispose();
+        if (sTargets.isCreated) sTargets.Dispose();
+        sRegistrations.Clear();
+        sLookup.Clear();
+        sInitialized = false;
+    }
+
+    /// <summary>
+    /// Registers every movement on <paramref name="component"/>, capturing rest poses from the
+    /// avatar's current (calibration TPose) state. Re-registering an already-known component
+    /// refreshes it. Safe to call with a null/empty component.
+    /// </summary>
+    public static void Register(BasisAuthoredMotion component)
+    {
+        if (component == null) return;
+        if (!sInitialized) Initialize();
+        if (sLookup.ContainsKey(component)) Unregister(component);
+
+        Registration reg = Build(component);
+        if (reg == null || reg.Data.Length == 0) return;
+
+        sRegistrations.Add(reg);
+        sLookup[component] = reg;
+        component.EnabledStateChanged += OnEnabledStateChanged;
+        Rebuild();
+    }
+
+    public static void Unregister(BasisAuthoredMotion component)
+    {
+        if (!sInitialized || component == null) return;
+        if (!sLookup.TryGetValue(component, out Registration reg)) return;
+        component.EnabledStateChanged -= OnEnabledStateChanged;
+        sRegistrations.Remove(reg);
+        sLookup.Remove(component);
+        Rebuild();
+    }
+
+    /// <summary>
+    /// Schedules the single compute-and-write pass for all registered movements. Call once per
+    /// frame, before the jiggle updater's LateUpdate samples the bones (so authored motion is the
+    /// animated base and jiggle layers on top). Returns the handle for dependency chaining;
+    /// the caller (or the next <see cref="Schedule"/>) completes it via <see cref="Complete"/>.
+    /// </summary>
+    public static JobHandle Schedule()
+    {
+        if (!sInitialized || sMovements.Length == 0) return default;
+
+        // Complete the previous frame's writes before rescheduling over the same containers.
+        CompletePending();
+
+        // A destroyed driven transform is auto-removed from the TransformAccessArray, desyncing it
+        // from the parallel SoA — rebuild (pruning dead entries) to resync before scheduling.
+        if (sTargets.length != sMovements.Length)
+        {
+            Rebuild();
+            if (sMovements.Length == 0) return default;
+        }
+
+        // TODO: a shared/networked clock would keep remote copies bit-identical; Time.timeAsDouble
+        // is adequate while validating the deterministic kinds locally.
+        float time = (float)Time.timeAsDouble;
+
+        sPending = new AuthoredMotionJob
+        {
+            Movements = sMovements.AsDeferredJobArray(),
+            ValidMask = sValidMask.AsDeferredJobArray(),
+            Time = time,
+        }.Schedule(sTargets);
+
+        return sPending;
+    }
+
+    public static void Complete(JobHandle handle)
+    {
+        handle.Complete();
+        CompletePending();
+    }
+
+    static void CompletePending()
+    {
+        sPending.Complete();
+        sPending = default;
+    }
+
+    // ── Internals ──────────────────────────────────────────────────────────────
+
+    static Registration Build(BasisAuthoredMotion component)
+    {
+        var data = new List<AuthoredMovementData>();
+        var targets = new List<Transform>();
+        var movementEnabled = new List<bool>();
+
+        Movement[] movements = component.movements;
+        for (int i = 0; i < movements.Length; i++)
+        {
+            Movement mv = movements[i];
+            uint seed = mv.seed != 0 ? mv.seed : (uint)(i + 1);
+
+            switch (mv.kind)
+            {
+                case Kind.Oscillate:
+                case Kind.Noise:
+                    // Chain kinds: one slot per element, element phase/falloff baked in.
+                    if (mv.chain != null)
+                    {
+                        for (int n = 0; n < mv.chain.Length; n++)
+                        {
+                            Transform tf = mv.chain[n];
+                            if (tf == null) continue;
+                            AuthoredMovementData d = Base(mv, seed, tf);
+                            d.phase = mv.phase + n * mv.chainPhaseStep;
+                            d.amplitude = mv.amplitude * Mathf.Pow(mv.chainFalloff, n);
+                            AddSlot(data, targets, movementEnabled, d, tf, mv.enabled);
+                        }
+                    }
+                    break;
+
+                case Kind.Rotate:
+                    if (mv.target != null)
+                        AddSlot(data, targets, movementEnabled, Base(mv, seed, mv.target), mv.target, mv.enabled);
+                    break;
+
+                case Kind.Orbit:
+                    if (mv.target != null)
+                    {
+                        AuthoredMovementData d = Base(mv, seed, mv.target);
+                        Vector3 pivotWorld = mv.pivot != null ? mv.pivot.position : mv.target.position;
+                        d.pivotLocal = mv.target.parent != null
+                            ? (float3)mv.target.parent.InverseTransformPoint(pivotWorld)
+                            : (float3)pivotWorld;
+                        AddSlot(data, targets, movementEnabled, d, mv.target, mv.enabled);
+                    }
+                    break;
+
+                case Kind.RandomSelect:
+                    // TODO: side state buffer (see job). Slot reserved so the target is tracked.
+                    if (mv.selectTarget != null)
+                        AddSlot(data, targets, movementEnabled, Base(mv, seed, mv.selectTarget), mv.selectTarget, mv.enabled);
+                    break;
+
+                case Kind.Sequence:
+                    // TODO: shared baked-curve buffer + per-instance playhead (see job).
+                    if (mv.sequenceTarget != null)
+                        AddSlot(data, targets, movementEnabled, Base(mv, seed, mv.sequenceTarget), mv.sequenceTarget, mv.enabled);
+                    break;
+            }
+        }
+
+        if (data.Count == 0) return null;
+
+        return new Registration
+        {
+            Component = component,
+            Targets = targets.ToArray(),
+            Data = data.ToArray(),
+            MovementEnabled = movementEnabled.ToArray(),
+            ComponentEnabled = component.isActiveAndEnabled,
+            Offset = 0,
+        };
+    }
+
+    // Builds the common fields and captures the rest pose from the driven transform.
+    static AuthoredMovementData Base(Movement mv, uint seed, Transform tf)
+    {
+        return new AuthoredMovementData
+        {
+            kind = (int)mv.kind,
+            channel = (int)mv.channel,
+            waveform = (int)mv.waveform,
+            axis = mv.axis,
+            amplitude = mv.amplitude,
+            frequencyHz = mv.frequencyHz,
+            phase = mv.phase,
+            pulseWidth = mv.pulseWidth,
+            speedDeg = mv.speedDeg,
+            radius = mv.radius,
+            orbitSpeedDeg = mv.orbitSpeedDeg,
+            noiseSpeed = mv.noiseSpeed,
+            seed = seed,
+            restRotation = tf.localRotation,
+            restPosition = tf.localPosition,
+            restScale = tf.localScale,
+        };
+    }
+
+    static void AddSlot(List<AuthoredMovementData> data, List<Transform> targets, List<bool> enabledList,
+        AuthoredMovementData d, Transform tf, bool movementEnabled)
+    {
+        data.Add(d);
+        targets.Add(tf);
+        enabledList.Add(movementEnabled);
+    }
+
+    // Rebuilds the native containers from the managed registrations after a structural change.
+    // O(total slots), only on register/unregister (rare, calibration-time) — the per-frame
+    // Schedule never rebuilds.
+    static void Rebuild()
+    {
+        CompletePending();
+
+        // Prune registrations whose component was destroyed (Unity fake-null) without an
+        // explicit Unregister — keeps the containers from carrying dead avatars.
+        for (int i = sRegistrations.Count - 1; i >= 0; i--)
+        {
+            if (sRegistrations[i].Component == null)
+            {
+                sLookup.Remove(sRegistrations[i].Component);
+                sRegistrations.RemoveAt(i);
+            }
+        }
+
+        int total = 0;
+        for (int i = 0; i < sRegistrations.Count; i++) total += sRegistrations[i].Data.Length;
+
+        sMovements.Clear();
+        sValidMask.Clear();
+        if (sTargets.isCreated) sTargets.Dispose();
+        sTargets = new TransformAccessArray(math.max(1, total));
+
+        for (int r = 0; r < sRegistrations.Count; r++)
+        {
+            Registration reg = sRegistrations[r];
+            reg.Offset = sMovements.Length;
+            for (int i = 0; i < reg.Data.Length; i++)
+            {
+                Transform tf = reg.Targets[i];
+                if (tf == null) continue; // UGC: a target may have been destroyed
+                sMovements.Add(reg.Data[i]);
+                sTargets.Add(tf);
+                sValidMask.Add((byte)(reg.ComponentEnabled && reg.MovementEnabled[i] ? 1 : 0));
+            }
+        }
+    }
+
+    // Toggle-system-agnostic: any actuator that flips the component's enabled state lands here
+    // (via BasisAuthoredMotion.EnabledStateChanged), and we patch just this component's mask slice.
+    static void OnEnabledStateChanged(BasisAuthoredMotion component, bool enabled)
+    {
+        if (!sLookup.TryGetValue(component, out Registration reg)) return;
+        reg.ComponentEnabled = enabled;
+
+        CompletePending(); // the job reads ValidMask
+        for (int i = 0; i < reg.Data.Length; i++)
+        {
+            int slot = reg.Offset + i;
+            if (slot < sValidMask.Length)
+                sValidMask[slot] = (byte)(enabled && reg.MovementEnabled[i] ? 1 : 0);
+        }
+    }
+}
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs.meta b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs.meta
new file mode 100644
index 000000000..bb0a081a2
--- /dev/null
+++ b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5def080570cda5245b9a9f6b41aab67d
\ No newline at end of file
diff --git a/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs b/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs
index 9d043aaab..42cfe0523 100644
--- a/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs
+++ b/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs
@@ -149,6 +149,14 @@ public void InitialLocalCalibration(BasisLocalPlayer player, List<BasisHeadChop.
                 Rig.OnInitialize();
             }
 
+            // Register authored cosmetic/secondary motion on the local avatar (drives non-humanoid
+            // transforms IK doesn't touch). Rest poses are captured from the current TPose.
+            var authoredMotions = player.BasisAvatar.GetComponentsInChildren<BasisAuthoredMotion>(true);
+            for (int i = 0; i < authoredMotions.Length; i++)
+            {
+                BasisAuthoredMotionSystem.Register(authoredMotions[i]);
+            }
+
             player.LocalRigDriver.Builder = BasisHelpers.GetOrAddComponent<RigBuilder>(AvatarAnimatorParent);
             player.LocalRigDriver.Builder.enabled = false;
 
diff --git a/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs b/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs
index 4ccb9efec..8fb01fb14 100644
--- a/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs
+++ b/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs
@@ -138,6 +138,15 @@ public void RemoteCalibration(BasisRemotePlayer RemotePlayer)
                 Rig.OnInitialize();
             }
 
+            // Register authored cosmetic/secondary motion on this avatar (drives non-humanoid
+            // transforms the bone job and IK don't touch). Rest poses are captured from the
+            // current TPose; re-registration refreshes on recalibration.
+            var authoredMotions = RemotePlayer.BasisAvatar.GetComponentsInChildren<BasisAuthoredMotion>(true);
+            for (int i = 0; i < authoredMotions.Length; i++)
+            {
+                BasisAuthoredMotionSystem.Register(authoredMotions[i]);
+            }
+
             // Face visibility setup
             Player.FaceIsVisible = false;
             if (RemotePlayer.BasisAvatar == null)
diff --git a/Basis/Packages/com.basis.framework/Players/Remote/BasisRemotePlayer.cs b/Basis/Packages/com.basis.framework/Players/Remote/BasisRemotePlayer.cs
index 0252b1285..b14258511 100644
--- a/Basis/Packages/com.basis.framework/Players/Remote/BasisRemotePlayer.cs
+++ b/Basis/Packages/com.basis.framework/Players/Remote/BasisRemotePlayer.cs
@@ -529,6 +529,17 @@ public void OnDestroy()
 
             OnRemotePlayerDestroying?.Invoke();
 
+            // Unregister authored motion while the avatar transforms are still alive, so the
+            // TransformAccessArray entries drop cleanly before Unity destroys them.
+            if (BasisAvatar != null)
+            {
+                var authoredMotions = BasisAvatar.GetComponentsInChildren<BasisAuthoredMotion>(true);
+                for (int i = 0; i < authoredMotions.Length; i++)
+                {
+                    BasisAuthoredMotionSystem.Unregister(authoredMotions[i]);
+                }
+            }
+
             RemoveFromBoneDriver();
         }
 
diff --git a/Basis/Packages/com.basis.sdk/Scripts/Basis Logger/BasisDebug.cs b/Basis/Packages/com.basis.sdk/Scripts/Basis Logger/BasisDebug.cs
index 6159cc880..22a91584b 100644
--- a/Basis/Packages/com.basis.sdk/Scripts/Basis Logger/BasisDebug.cs	
+++ b/Basis/Packages/com.basis.sdk/Scripts/Basis Logger/BasisDebug.cs	
@@ -92,6 +92,7 @@ public static string GetTagColor(LogTag logTag)
             LogTag.Shims => "#FF00FF",        // Magenta
             LogTag.Props => "#FFB6C1",        // Light Pink
             LogTag.LocalNetwork => "#ff0055",
+            LogTag.AuthoredMotion => "#BA55D3", // Medium Orchid
             _ => "#FFFFFF"                    // Default White
         };
     }
@@ -141,6 +142,7 @@ public enum LogTag
         Shims,
         Props,
         LocalNetwork,
+        AuthoredMotion,
     }
 
     public enum MessageType
diff --git a/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs b/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs
new file mode 100644
index 000000000..4624f3cc6
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs
@@ -0,0 +1,91 @@
+using System;
+using UnityEngine;
+
+/// <summary>
+/// Data-only avatar component declaring authored, deterministic dynamic motion on transforms
+/// the humanoid rig and IK don't drive (tail/ear chains, accessories, etc.). It holds pure
+/// serialized configuration and runs no per-instance per-frame <c>Update</c> — all runtime
+/// evaluation happens in the batched <c>BasisAuthoredMotionSystem</c> job, which reads this
+/// component at calibration. The config model mirrors <see cref="BasisParameterDriver"/>'s
+/// <c>Operation[]</c> shape (an enum kind + per-kind fields).
+///
+/// Allow it onto an avatar by adding its type to the Content Police
+/// (<c>ContentPoliceSelector.selectedTypes</c> in <c>AvatarContentPoliceSelector.asset</c>).
+/// Group movements that toggle together into one component; an avatar may carry several.
+/// </summary>
+public class BasisAuthoredMotion : MonoBehaviour
+{
+    /// <summary>
+    /// Raised on enable/disable so a registered motion system can flip this component's slice
+    /// of its valid-mask without a per-frame poll. The system subscribes at registration; the
+    /// component holds no reference to any toggle package, so any actuator that flips
+    /// <see cref="Behaviour.enabled"/> (e.g. an HVR.Vixxy activation) drives it unchanged.
+    /// </summary>
+    public event Action<BasisAuthoredMotion, bool> EnabledStateChanged;
+
+    public Movement[] movements = Array.Empty<Movement>();
+
+    private void OnEnable() => EnabledStateChanged?.Invoke(this, true);
+    private void OnDisable() => EnabledStateChanged?.Invoke(this, false);
+
+    [Serializable]
+    public class Movement
+    {
+        // Open, extensible set — new kinds slot into the system's evaluation routine without
+        // disturbing registration / scheduling / culling / toggles.
+        public enum Kind { Oscillate, Rotate, Orbit, RandomSelect, Sequence, Noise }
+        public enum Channel { Rotation, Position, Scale }   // what Oscillate / Noise drive
+        public enum Waveform { Sine, Triangle, Square, Pulse }
+
+        public Kind kind = Kind.Oscillate;
+        public string label;              // author-facing identifier only
+        public bool enabled = true;       // author default; runtime toggle rides the component's own enabled
+        public Vector3 axis = Vector3.up; // local axis the movement acts about
+
+        // Oscillate — periodic motion on `channel`, optionally a travelling wave down a chain
+        // (1 entry = simple sway). `waveform` selects sine (default) or triangle / square / pulse.
+        public Channel channel = Channel.Rotation; // amplitude unit: deg | metres | scale-factor
+        public Waveform waveform = Waveform.Sine;
+        public float pulseWidth = 0.5f;   // square/pulse duty cycle (0–1)
+        public Transform[] chain;
+        public float amplitude = 15f;
+        public float frequencyHz = 0.5f;
+        public float phase = 0f;
+        public float chainPhaseStep = 0f; // phase delay per element down the chain
+        public float chainFalloff = 1f;   // amplitude scale per element down the chain
+
+        // Rotate — constant angular velocity about `axis`, in place.
+        public Transform target;
+        public float speedDeg = 36f;      // deg/sec
+
+        // Orbit — revolve `target` around `pivot` at `radius` (not a spin-in-place).
+        public Transform pivot;
+        public float radius = 0.1f;
+        public float orbitSpeedDeg = 90f; // deg/sec around the pivot
+
+        // RandomSelect — on a randomised interval pick one weighted option, ease in/out.
+        public Transform selectTarget;
+        public Option[] options = Array.Empty<Option>();
+        public Vector2 intervalRange = new Vector2(2f, 6f);  // seconds between picks
+        public float attack = 0.06f, release = 0.25f;        // ease in / out seconds
+        public bool preventRepeats = true;
+        public uint seed = 0;             // 0 = derive from registration index
+
+        // Sequence — authored timeline of pose deltas; loop or one-shot. Short motion uses inline
+        // keyframes; complex/converted clips reference a shared, read-only baked-curve asset.
+        public Transform sequenceTarget;
+        public Keyframe[] keyframes = Array.Empty<Keyframe>();
+        public BasisMotionClip bakedClip; // shared baked curves; null when using inline keyframes
+        public bool loop = true;
+
+        // Noise — organic Perlin/simplex drift on `channel` about `axis`; reuses `amplitude`,
+        // `chain`, `chainFalloff`, and `seed`. `noiseSpeed` sets how fast the field is sampled.
+        public float noiseSpeed = 0.5f;
+    }
+
+    [Serializable]
+    public class Option { public Vector3 axis; public float angleDeg; public float weight = 1f; }
+
+    [Serializable]
+    public class Keyframe { public float time; public Vector3 eulerDelta; public Vector3 positionDelta; public Vector3 scaleDelta; }
+}
diff --git a/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs.meta b/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs.meta
new file mode 100644
index 000000000..c49a96276
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 835a1ddaf3b9f114381928926d08f795
\ No newline at end of file
diff --git a/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs b/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs
new file mode 100644
index 000000000..d682cc892
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs
@@ -0,0 +1,30 @@
+using UnityEngine;
+
+/// <summary>
+/// Shared, read-only baked motion for a <see cref="BasisAuthoredMotion.Movement"/> of kind
+/// <c>Sequence</c>: an AnimationClip's curves sampled to a fixed-rate, blittable buffer so the
+/// batched Burst job can interpolate without touching a managed <c>AnimationCurve</c>. One asset
+/// is referenced by every instance of an avatar; per-instance runtime state is just a playhead.
+/// Rotations bake to quaternion deltas; position/scale bake as deltas from the captured rest pose.
+/// </summary>
+[CreateAssetMenu(fileName = "BasisMotionClip", menuName = "Basis/Authored Motion Clip")]
+public class BasisMotionClip : ScriptableObject
+{
+    [Tooltip("Samples per second the curves were baked at.")]
+    public float frameRate = 30f;
+
+    [Tooltip("Number of frames per driven transform.")]
+    public int frameCount;
+
+    [Tooltip("Number of driven transforms this clip covers.")]
+    public int transformCount;
+
+    // Flattened samples, laid out [transform0_frame0..frameN-1, transform1_...].
+    // Index a (transform, frame) as transformIndex * frameCount + frame.
+    public Vector4[] rotationSamples;   // xyzw quaternion deltas from rest
+    public Vector3[] positionSamples;   // local position deltas from rest
+    public Vector3[] scaleSamples;      // local scale deltas from rest
+
+    /// <summary>Clip length in seconds (<c>frameCount / frameRate</c>).</summary>
+    public float Length => frameRate > 0f ? frameCount / frameRate : 0f;
+}
diff --git a/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs.meta b/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs.meta
new file mode 100644
index 000000000..53faa5a82
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 684e9ad2c8c35704b958f572a0b97540
\ No newline at end of file
diff --git a/Basis/Packages/com.basis.sdk/Settings/AvatarContentPoliceSelector.asset b/Basis/Packages/com.basis.sdk/Settings/AvatarContentPoliceSelector.asset
index aa732f456..f64f31670 100644
--- a/Basis/Packages/com.basis.sdk/Settings/AvatarContentPoliceSelector.asset
+++ b/Basis/Packages/com.basis.sdk/Settings/AvatarContentPoliceSelector.asset
@@ -14,6 +14,7 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   AudioMixer: {fileID: -8890091482760681975, guid: 1ff7d045b2e32054aad6c5815495d8b8, type: 2}
   selectedTypes:
+  - BasisAuthoredMotion
   - BasisMediaPlayer
   - BasisMediaPlayerNetworked
   - BasisSDKMirror
diff --git a/Basis/Packages/dev.hai-vr.basis.comms/Scripts/Systems/Runtime/Vixxy/Internal/HVR_VixxyPermitted.cs b/Basis/Packages/dev.hai-vr.basis.comms/Scripts/Systems/Runtime/Vixxy/Internal/HVR_VixxyPermitted.cs
index 5f20ada42..d403df053 100644
--- a/Basis/Packages/dev.hai-vr.basis.comms/Scripts/Systems/Runtime/Vixxy/Internal/HVR_VixxyPermitted.cs
+++ b/Basis/Packages/dev.hai-vr.basis.comms/Scripts/Systems/Runtime/Vixxy/Internal/HVR_VixxyPermitted.cs
@@ -53,6 +53,8 @@ public static class HVR_VixxyPermitted
             "UnityEngine.Rendering.Universal.DecalProjector",
             // Jiggle
             "GatorDragonGames.JigglePhysics.JiggleRig",
+            // Authored motion (toggle the component's enabled state per movement group)
+            "BasisAuthoredMotion",
             // UI
             "TMPro.TextMeshPro",
             "TMPro.TextMeshProUGUI",

From e660b641a74147bf10a210d7fc2ff6008267c20c Mon Sep 17 00:00:00 2001
From: towneh <25694892+towneh@users.noreply.github.com>
Date: Mon, 25 May 2026 02:28:02 +0100
Subject: [PATCH 4/6] feat: implement RandomSelect and Sequence authored-motion
 kinds

RandomSelect drives one or many targets: each weighted Option may name its own transform (falling back to the shared select target), plus an idle weight for the "pose nothing" outcome. Each fixed-period cycle picks one option deterministically from the shared clock and the options' cumulative weight bands, so every driven bone resolves the same winner with no cross-slot state, easing in and out around rest.

Sequence plays a baked BasisMotionClip: absolute local rotations sampled per bone into a shared buffer, the clip's transform paths resolved under a sequence root and interpolated at a clock-derived playhead.

Schedule and complete the pass from BasisEventDriver.LateUpdate just before the jiggle pass, so authored motion is the animated base and jiggle layers on top; dispose alongside RemoteBoneJobSystem.
---
 .../com.basis.eventdriver/BasisEventDriver.cs |   4 +
 .../BasisAuthoredMotionDriver.cs              |  40 ---
 .../BasisAuthoredMotionDriver.cs.meta         |   2 -
 .../BasisAuthoredMotionSystem.cs              | 241 ++++++++++++++++--
 .../Drivers/Local/BasisLocalAvatarDriver.cs   |   3 +-
 .../Drivers/Remote/BasisRemoteAvatarDriver.cs |   4 +-
 .../Scripts/BasisAuthoredMotion.cs            |  48 +++-
 .../com.basis.sdk/Scripts/BasisMotionClip.cs  |  12 +-
 8 files changed, 265 insertions(+), 89 deletions(-)
 delete mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs
 delete mode 100644 Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta

diff --git a/Basis/Packages/com.basis.eventdriver/BasisEventDriver.cs b/Basis/Packages/com.basis.eventdriver/BasisEventDriver.cs
index 8888ad1dc..8e0d896d1 100644
--- a/Basis/Packages/com.basis.eventdriver/BasisEventDriver.cs
+++ b/Basis/Packages/com.basis.eventdriver/BasisEventDriver.cs
@@ -119,6 +119,7 @@ public void OnDestroy()
             BasisObjectSyncDriver.OnDestroy();
             Application.onBeforeRender -= OnBeforeRender;
             RemoteBoneJobSystem.Dispose();
+            BasisAuthoredMotionSystem.Dispose();
             BasisAvatarBufferPool.Deinitialize();
         }
 
@@ -310,6 +311,9 @@ public void LateUpdate()
             }
             ProfileEnd(PROF_BLENDSHAPE_APPLY);
 
+            // ── Authored motion: write non-humanoid authored bones before jiggle samples them ──
+            BasisAuthoredMotionSystem.Complete(BasisAuthoredMotionSystem.Schedule());
+
             // ── JigglePhysics schedule ──
             ProfileBegin(PROF_JIGGLE_SCHEDULE);
 
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs
deleted file mode 100644
index 59e342222..000000000
--- a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-using Unity.Jobs;
-using UnityEngine;
-
-/// <summary>
-/// Per-frame pump for <see cref="BasisAuthoredMotionSystem"/>. A single hidden, persistent object
-/// schedules and completes the batched authored-motion pass each frame. The negative execution
-/// order makes its <c>LateUpdate</c> run before <c>JiggleUpdateExample</c> (default order 0), so
-/// the driven transforms are written and the job is completed before jiggle physics samples them
-/// — authored motion is the animated base, jiggle layers on top.
-/// </summary>
-[DefaultExecutionOrder(-100)]
-public class BasisAuthoredMotionDriver : MonoBehaviour
-{
-    static BasisAuthoredMotionDriver sInstance;
-
-    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
-    static void Bootstrap()
-    {
-        if (sInstance != null) return;
-        var go = new GameObject("[BasisAuthoredMotionDriver]") { hideFlags = HideFlags.HideAndDontSave };
-        DontDestroyOnLoad(go);
-        sInstance = go.AddComponent<BasisAuthoredMotionDriver>();
-    }
-
-    private void LateUpdate()
-    {
-        // Complete here (not just schedule) so the writes land before the jiggle updater's
-        // LateUpdate samples the bones. TODO (perf): split to schedule-early / complete-here once
-        // the kinds are validated, to overlap the job with other main-thread work.
-        JobHandle handle = BasisAuthoredMotionSystem.Schedule();
-        BasisAuthoredMotionSystem.Complete(handle);
-    }
-
-    private void OnDestroy()
-    {
-        if (sInstance != this) return;
-        BasisAuthoredMotionSystem.Dispose();
-        sInstance = null;
-    }
-}
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta
deleted file mode 100644
index a303c9c54..000000000
--- a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionDriver.cs.meta
+++ /dev/null
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: e70fde70a6c4b3248b59f70365c73336
\ No newline at end of file
diff --git a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs
index 86d91d9a0..f69637157 100644
--- a/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs
+++ b/Basis/Packages/com.basis.framework/Drivers/AuthoredMotion/BasisAuthoredMotionSystem.cs
@@ -34,12 +34,40 @@ public struct AuthoredMovementData
     public float noiseSpeed;     // Noise
     public uint seed;            // Noise / RandomSelect
 
+    // RandomSelect — selection is deterministic per cycle, so each slot evaluates independently.
+    public float period;         // seconds per pick cycle
+    public float totalWeight;    // sum of option weights + idle weight
+    public float attack;         // ease-in seconds
+    public float release;        // ease-out seconds
+    public int optionStart;      // first option index in the shared options buffer
+    public int optionCount;      // options targeting this slot
+
+    // Sequence — a playhead over a shared baked-sample buffer; rotation written absolutely.
+    public int sampleStart;      // first frame index in the shared rotation-sample buffer
+    public int frameCount;       // frames for this slot's transform
+    public float frameRate;      // samples per second
+    public int loop;             // 0 = one-shot, 1 = loop
+
     // Captured rest pose (local space); motion composes as a delta from this.
     public quaternion restRotation;
     public float3 restPosition;
     public float3 restScale;
 }
 
+/// <summary>
+/// One weighted <c>RandomSelect</c> option. The slot's target eases to this rotation when a
+/// cycle's deterministic roll lands in <c>[bandLo, bandHi)</c> of the movement's total weight;
+/// the gap up to <c>totalWeight</c> is the idle band (pose nothing). Held in a buffer shared by
+/// every slot so the per-transform job stays allocation-free.
+/// </summary>
+public struct AuthoredOptionData
+{
+    public float bandLo;
+    public float bandHi;
+    public float3 axis;
+    public float angleDeg;
+}
+
 /// <summary>
 /// Single compute-and-write pass for all avatars' authored movements. One movement touches only
 /// a few transforms, so a single <see cref="IJobParallelForTransform"/> parallelises cleanly
@@ -50,6 +78,8 @@ public struct AuthoredMovementData
 public struct AuthoredMotionJob : IJobParallelForTransform
 {
     [ReadOnly] public NativeArray<AuthoredMovementData> Movements;
+    [ReadOnly] public NativeArray<AuthoredOptionData> Options;
+    [ReadOnly] public NativeArray<float4> RotationSamples;
     [ReadOnly] public NativeArray<byte> ValidMask;
     public float Time;
 
@@ -92,17 +122,77 @@ public void Execute(int index, TransformAccess transform)
                 break;
             }
 
-            // TODO (iterative Burst-off pass): RandomSelect needs a per-slot RNG + interval/ease
-            // state buffer; Sequence needs the shared baked-curve buffer + a per-instance playhead.
-            // Both add a side NativeArray the job reads — wired once the deterministic kinds are
-            // validated against the reference avatar. No-op until then.
             case Kind.RandomSelect:
+            {
+                if (m.optionCount == 0) break;
+                float period = m.period > 1e-4f ? m.period : 1f;
+                float cyclesF = t / period;
+                int cycle = (int)math.floor(cyclesF);
+                float intoCycle = (cyclesF - cycle) * period; // seconds since this cycle began
+
+                quaternion now = PickDelta(m, cycle, out bool posedNow);
+                quaternion prev = PickDelta(m, cycle - 1, out bool posedPrev);
+
+                // Ease out (release) when this cycle picks rest after being posed; ease in (attack) otherwise.
+                float ease = (!posedNow && posedPrev) ? m.release : m.attack;
+                float blend = ease > 1e-4f ? math.saturate(intoCycle / ease) : 1f;
+                transform.localRotation = math.mul(m.restRotation, math.slerp(prev, now, blend));
+                break;
+            }
+
             case Kind.Sequence:
+            {
+                if (m.frameCount <= 0) break;
+                float fr = m.frameRate > 1e-4f ? m.frameRate : 30f;
+                float length = m.frameCount / fr;
+                float pt = m.loop != 0 ? math.fmod(t, length) : math.min(math.max(t, 0f), length);
+                if (pt < 0f) pt += length; // fmod can return negative for negative t
+
+                float frameF = pt * fr;
+                int f0 = (int)math.floor(frameF);
+                float frac = frameF - f0;
+                int f1;
+                if (m.loop != 0)
+                {
+                    f0 = ((f0 % m.frameCount) + m.frameCount) % m.frameCount;
+                    f1 = (f0 + 1) % m.frameCount;
+                }
+                else
+                {
+                    f0 = math.clamp(f0, 0, m.frameCount - 1);
+                    f1 = math.min(f0 + 1, m.frameCount - 1);
+                }
+
+                quaternion q0 = new quaternion(RotationSamples[m.sampleStart + f0]);
+                quaternion q1 = new quaternion(RotationSamples[m.sampleStart + f1]);
+                transform.localRotation = math.slerp(q0, q1, frac);
+                break;
+            }
+
             default:
                 break;
         }
     }
 
+    // Deterministic weighted pick for one cycle: this slot's winning rotation delta, or identity if idle / another target won.
+    quaternion PickDelta(in AuthoredMovementData m, int cycle, out bool posed)
+    {
+        uint h = math.hash(new int2((int)m.seed, cycle)) | 1u;
+        float r = new Unity.Mathematics.Random(h).NextFloat() * m.totalWeight;
+
+        for (int o = 0; o < m.optionCount; o++)
+        {
+            AuthoredOptionData opt = Options[m.optionStart + o];
+            if (r >= opt.bandLo && r < opt.bandHi)
+            {
+                posed = true;
+                return quaternion.AxisAngle(math.normalizesafe(opt.axis, new float3(0f, 1f, 0f)), math.radians(opt.angleDeg));
+            }
+        }
+        posed = false;
+        return quaternion.identity;
+    }
+
     static void ApplyChannel(TransformAccess transform, in AuthoredMovementData m, float value)
     {
         float3 axis = math.normalizesafe(m.axis, new float3(0f, 1f, 0f));
@@ -153,6 +243,8 @@ sealed class Registration
         public BasisAuthoredMotion Component;
         public Transform[] Targets;          // one per slot
         public AuthoredMovementData[] Data;  // parallel to Targets
+        public AuthoredOptionData[] Options; // RandomSelect options, rebased into sOptions on rebuild
+        public float4[] RotationSamples;     // Sequence rotation frames, rebased into sRotationSamples on rebuild
         public bool[] MovementEnabled;       // per-slot author default (Movement.enabled)
         public bool ComponentEnabled;        // mirrors the component's runtime enabled state
         public int Offset;                   // current start index in the native containers
@@ -160,6 +252,8 @@ sealed class Registration
 
     // Persistent SoA, parallel to sTargets.
     static NativeList<AuthoredMovementData> sMovements;
+    static NativeList<AuthoredOptionData> sOptions;   // shared RandomSelect option bands
+    static NativeList<float4> sRotationSamples;       // shared Sequence rotation frames (absolute, xyzw)
     static NativeList<byte> sValidMask;
     static TransformAccessArray sTargets;
 
@@ -175,6 +269,8 @@ public static void Initialize(int initialCapacity = 0)
     {
         if (sInitialized) return;
         sMovements = new NativeList<AuthoredMovementData>(initialCapacity, Allocator.Persistent);
+        sOptions = new NativeList<AuthoredOptionData>(0, Allocator.Persistent);
+        sRotationSamples = new NativeList<float4>(0, Allocator.Persistent);
         sValidMask = new NativeList<byte>(initialCapacity, Allocator.Persistent);
         sTargets = new TransformAccessArray(math.max(1, initialCapacity));
         sRegistrations.Clear();
@@ -187,6 +283,8 @@ public static void Dispose()
         if (!sInitialized) return;
         CompletePending();
         if (sMovements.IsCreated) sMovements.Dispose();
+        if (sOptions.IsCreated) sOptions.Dispose();
+        if (sRotationSamples.IsCreated) sRotationSamples.Dispose();
         if (sValidMask.IsCreated) sValidMask.Dispose();
         if (sTargets.isCreated) sTargets.Dispose();
         sRegistrations.Clear();
@@ -237,21 +335,21 @@ public static JobHandle Schedule()
         // Complete the previous frame's writes before rescheduling over the same containers.
         CompletePending();
 
-        // A destroyed driven transform is auto-removed from the TransformAccessArray, desyncing it
-        // from the parallel SoA — rebuild (pruning dead entries) to resync before scheduling.
+        // A destroyed transform auto-drops from the TransformAccessArray, desyncing the parallel SoA — rebuild to resync.
         if (sTargets.length != sMovements.Length)
         {
             Rebuild();
             if (sMovements.Length == 0) return default;
         }
 
-        // TODO: a shared/networked clock would keep remote copies bit-identical; Time.timeAsDouble
-        // is adequate while validating the deterministic kinds locally.
+        // TODO: a shared/networked clock for bit-identical remote copies; Time.timeAsDouble is fine for local validation.
         float time = (float)Time.timeAsDouble;
 
         sPending = new AuthoredMotionJob
         {
             Movements = sMovements.AsDeferredJobArray(),
+            Options = sOptions.AsDeferredJobArray(),
+            RotationSamples = sRotationSamples.AsDeferredJobArray(),
             ValidMask = sValidMask.AsDeferredJobArray(),
             Time = time,
         }.Schedule(sTargets);
@@ -278,6 +376,8 @@ static Registration Build(BasisAuthoredMotion component)
         var data = new List<AuthoredMovementData>();
         var targets = new List<Transform>();
         var movementEnabled = new List<bool>();
+        var options = new List<AuthoredOptionData>();
+        var rotSamples = new List<float4>();
 
         Movement[] movements = component.movements;
         for (int i = 0; i < movements.Length; i++)
@@ -322,16 +422,88 @@ static Registration Build(BasisAuthoredMotion component)
                     break;
 
                 case Kind.RandomSelect:
-                    // TODO: side state buffer (see job). Slot reserved so the target is tracked.
-                    if (mv.selectTarget != null)
-                        AddSlot(data, targets, movementEnabled, Base(mv, seed, mv.selectTarget), mv.selectTarget, mv.enabled);
+                {
+                    if (mv.options == null || mv.options.Length == 0) break;
+
+                    // Cumulative weight bands in declaration order; the idle weight takes the remainder.
+                    float running = 0f;
+                    var resolved = new List<(Transform tf, float3 axis, float angle, float lo, float hi)>();
+                    for (int o = 0; o < mv.options.Length; o++)
+                    {
+                        var opt = mv.options[o];
+                        float w = Mathf.Max(0f, opt.weight);
+                        Transform tf = opt.target != null ? opt.target : mv.selectTarget;
+                        if (tf == null || w <= 0f) continue;
+                        float lo = running; running += w;
+                        resolved.Add((tf, opt.axis, opt.angleDeg, lo, running));
+                    }
+                    float total = running + Mathf.Max(0f, mv.idleWeight);
+                    if (resolved.Count == 0 || total <= 0f) break;
+
+                    // One slot per distinct target; lay its options out contiguously in the buffer.
+                    var done = new HashSet<Transform>();
+                    for (int o = 0; o < resolved.Count; o++)
+                    {
+                        Transform tf = resolved[o].tf;
+                        if (!done.Add(tf)) continue;
+
+                        int start = options.Count;
+                        int count = 0;
+                        for (int p = 0; p < resolved.Count; p++)
+                        {
+                            if (resolved[p].tf != tf) continue;
+                            options.Add(new AuthoredOptionData
+                            {
+                                bandLo = resolved[p].lo,
+                                bandHi = resolved[p].hi,
+                                axis = resolved[p].axis,
+                                angleDeg = resolved[p].angle,
+                            });
+                            count++;
+                        }
+
+                        AuthoredMovementData d = Base(mv, seed, tf);
+                        d.period = Mathf.Max(1e-4f, mv.intervalRange.x);
+                        d.totalWeight = total;
+                        d.attack = mv.attack;
+                        d.release = mv.release;
+                        d.optionStart = start;
+                        d.optionCount = count;
+                        AddSlot(data, targets, movementEnabled, d, tf, mv.enabled);
+                    }
                     break;
+                }
 
                 case Kind.Sequence:
-                    // TODO: shared baked-curve buffer + per-instance playhead (see job).
-                    if (mv.sequenceTarget != null)
-                        AddSlot(data, targets, movementEnabled, Base(mv, seed, mv.sequenceTarget), mv.sequenceTarget, mv.enabled);
+                {
+                    BasisMotionClip clip = mv.bakedClip;
+                    if (clip == null || clip.transformCount <= 0 || clip.frameCount <= 0 || clip.rotationSamples == null)
+                        break;
+
+                    Transform root = mv.sequenceRoot != null ? mv.sequenceRoot : component.transform;
+                    int fc = clip.frameCount;
+                    for (int ti = 0; ti < clip.transformCount; ti++)
+                    {
+                        string path = (clip.paths != null && ti < clip.paths.Length) ? clip.paths[ti] : null;
+                        Transform tf = ResolvePath(root, path);
+                        if (tf == null) continue;
+
+                        int start = rotSamples.Count;
+                        for (int f = 0; f < fc; f++)
+                        {
+                            Vector4 q = clip.rotationSamples[ti * fc + f];
+                            rotSamples.Add(new float4(q.x, q.y, q.z, q.w));
+                        }
+
+                        AuthoredMovementData d = Base(mv, seed, tf);
+                        d.sampleStart = start;
+                        d.frameCount = fc;
+                        d.frameRate = clip.frameRate;
+                        d.loop = mv.loop ? 1 : 0;
+                        AddSlot(data, targets, movementEnabled, d, tf, mv.enabled);
+                    }
                     break;
+                }
             }
         }
 
@@ -342,6 +514,8 @@ static Registration Build(BasisAuthoredMotion component)
             Component = component,
             Targets = targets.ToArray(),
             Data = data.ToArray(),
+            Options = options.ToArray(),
+            RotationSamples = rotSamples.ToArray(),
             MovementEnabled = movementEnabled.ToArray(),
             ComponentEnabled = component.isActiveAndEnabled,
             Offset = 0,
@@ -351,6 +525,7 @@ static Registration Build(BasisAuthoredMotion component)
     // Builds the common fields and captures the rest pose from the driven transform.
     static AuthoredMovementData Base(Movement mv, uint seed, Transform tf)
     {
+        tf.GetLocalPositionAndRotation(out Vector3 restPos, out Quaternion restRot);
         return new AuthoredMovementData
         {
             kind = (int)mv.kind,
@@ -366,8 +541,8 @@ static AuthoredMovementData Base(Movement mv, uint seed, Transform tf)
             orbitSpeedDeg = mv.orbitSpeedDeg,
             noiseSpeed = mv.noiseSpeed,
             seed = seed,
-            restRotation = tf.localRotation,
-            restPosition = tf.localPosition,
+            restRotation = restRot,
+            restPosition = restPos,
             restScale = tf.localScale,
         };
     }
@@ -380,15 +555,19 @@ static void AddSlot(List<AuthoredMovementData> data, List<Transform> targets, Li
         enabledList.Add(movementEnabled);
     }
 
-    // Rebuilds the native containers from the managed registrations after a structural change.
-    // O(total slots), only on register/unregister (rare, calibration-time) — the per-frame
-    // Schedule never rebuilds.
+    // Resolves a baked-clip path under root (empty = root itself), matching how an AnimationClip binds curves.
+    static Transform ResolvePath(Transform root, string path)
+    {
+        if (root == null) return null;
+        return string.IsNullOrEmpty(path) ? root : root.Find(path);
+    }
+
+    // Rebuilds the native containers from the managed registrations on a structural change — never per-frame.
     static void Rebuild()
     {
         CompletePending();
 
-        // Prune registrations whose component was destroyed (Unity fake-null) without an
-        // explicit Unregister — keeps the containers from carrying dead avatars.
+        // Prune registrations whose component was destroyed without an explicit Unregister (Unity fake-null).
         for (int i = sRegistrations.Count - 1; i >= 0; i--)
         {
             if (sRegistrations[i].Component == null)
@@ -402,6 +581,8 @@ static void Rebuild()
         for (int i = 0; i < sRegistrations.Count; i++) total += sRegistrations[i].Data.Length;
 
         sMovements.Clear();
+        sOptions.Clear();
+        sRotationSamples.Clear();
         sValidMask.Clear();
         if (sTargets.isCreated) sTargets.Dispose();
         sTargets = new TransformAccessArray(math.max(1, total));
@@ -410,19 +591,31 @@ static void Rebuild()
         {
             Registration reg = sRegistrations[r];
             reg.Offset = sMovements.Length;
+
+            // Concatenate this registration's side buffers; slots reference them via a rebased offset.
+            int optionBase = sOptions.Length;
+            if (reg.Options != null)
+                for (int o = 0; o < reg.Options.Length; o++) sOptions.Add(reg.Options[o]);
+
+            int sampleBase = sRotationSamples.Length;
+            if (reg.RotationSamples != null)
+                for (int s = 0; s < reg.RotationSamples.Length; s++) sRotationSamples.Add(reg.RotationSamples[s]);
+
             for (int i = 0; i < reg.Data.Length; i++)
             {
                 Transform tf = reg.Targets[i];
                 if (tf == null) continue; // UGC: a target may have been destroyed
-                sMovements.Add(reg.Data[i]);
+                AuthoredMovementData d = reg.Data[i];
+                if ((Kind)d.kind == Kind.RandomSelect) d.optionStart += optionBase;
+                else if ((Kind)d.kind == Kind.Sequence) d.sampleStart += sampleBase;
+                sMovements.Add(d);
                 sTargets.Add(tf);
                 sValidMask.Add((byte)(reg.ComponentEnabled && reg.MovementEnabled[i] ? 1 : 0));
             }
         }
     }
 
-    // Toggle-system-agnostic: any actuator that flips the component's enabled state lands here
-    // (via BasisAuthoredMotion.EnabledStateChanged), and we patch just this component's mask slice.
+    // Toggle-system-agnostic: any actuator flipping the component's enabled lands here; patch just its mask slice.
     static void OnEnabledStateChanged(BasisAuthoredMotion component, bool enabled)
     {
         if (!sLookup.TryGetValue(component, out Registration reg)) return;
diff --git a/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs b/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs
index 42cfe0523..a8a621d46 100644
--- a/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs
+++ b/Basis/Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs
@@ -149,8 +149,7 @@ public void InitialLocalCalibration(BasisLocalPlayer player, List<BasisHeadChop.
                 Rig.OnInitialize();
             }
 
-            // Register authored cosmetic/secondary motion on the local avatar (drives non-humanoid
-            // transforms IK doesn't touch). Rest poses are captured from the current TPose.
+            // Register authored motion (drives non-humanoid transforms IK doesn't touch); rest captured at the current TPose.
             var authoredMotions = player.BasisAvatar.GetComponentsInChildren<BasisAuthoredMotion>(true);
             for (int i = 0; i < authoredMotions.Length; i++)
             {
diff --git a/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs b/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs
index 8fb01fb14..30eca3656 100644
--- a/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs
+++ b/Basis/Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs
@@ -138,9 +138,7 @@ public void RemoteCalibration(BasisRemotePlayer RemotePlayer)
                 Rig.OnInitialize();
             }
 
-            // Register authored cosmetic/secondary motion on this avatar (drives non-humanoid
-            // transforms the bone job and IK don't touch). Rest poses are captured from the
-            // current TPose; re-registration refreshes on recalibration.
+            // Register authored motion (drives non-humanoid transforms the bone job / IK don't touch); rest captured at the current TPose.
             var authoredMotions = RemotePlayer.BasisAvatar.GetComponentsInChildren<BasisAuthoredMotion>(true);
             for (int i = 0; i < authoredMotions.Length; i++)
             {
diff --git a/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs b/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs
index 4624f3cc6..06027f59c 100644
--- a/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs
+++ b/Basis/Packages/com.basis.sdk/Scripts/BasisAuthoredMotion.cs
@@ -31,8 +31,7 @@ public class BasisAuthoredMotion : MonoBehaviour
     [Serializable]
     public class Movement
     {
-        // Open, extensible set — new kinds slot into the system's evaluation routine without
-        // disturbing registration / scheduling / culling / toggles.
+        // Open, extensible set — new kinds slot in without disturbing registration / scheduling / toggles.
         public enum Kind { Oscillate, Rotate, Orbit, RandomSelect, Sequence, Noise }
         public enum Channel { Rotation, Position, Scale }   // what Oscillate / Noise drive
         public enum Waveform { Sine, Triangle, Square, Pulse }
@@ -42,8 +41,7 @@ public enum Waveform { Sine, Triangle, Square, Pulse }
         public bool enabled = true;       // author default; runtime toggle rides the component's own enabled
         public Vector3 axis = Vector3.up; // local axis the movement acts about
 
-        // Oscillate — periodic motion on `channel`, optionally a travelling wave down a chain
-        // (1 entry = simple sway). `waveform` selects sine (default) or triangle / square / pulse.
+        // Oscillate — periodic motion on `channel`; a chain makes a travelling wave (1 entry = simple sway).
         public Channel channel = Channel.Rotation; // amplitude unit: deg | metres | scale-factor
         public Waveform waveform = Waveform.Sine;
         public float pulseWidth = 0.5f;   // square/pulse duty cycle (0–1)
@@ -63,29 +61,51 @@ public enum Waveform { Sine, Triangle, Square, Pulse }
         public float radius = 0.1f;
         public float orbitSpeedDeg = 90f; // deg/sec around the pivot
 
-        // RandomSelect — on a randomised interval pick one weighted option, ease in/out.
-        public Transform selectTarget;
+        // RandomSelect — every `intervalRange.x` seconds, deterministically pick one weighted option (or idle)
+        // and ease the target in/out. Each Option may set its own `target`, else falls back to `selectTarget`.
+        public Transform selectTarget;   // default target for options that leave their own target null
         public Option[] options = Array.Empty<Option>();
-        public Vector2 intervalRange = new Vector2(2f, 6f);  // seconds between picks
+        public float idleWeight = 0f;     // relative weight of the "pose nothing" outcome
+        public Vector2 intervalRange = new Vector2(2f, 6f);  // x = fixed period (seconds between picks)
         public float attack = 0.06f, release = 0.25f;        // ease in / out seconds
         public bool preventRepeats = true;
         public uint seed = 0;             // 0 = derive from registration index
 
-        // Sequence — authored timeline of pose deltas; loop or one-shot. Short motion uses inline
-        // keyframes; complex/converted clips reference a shared, read-only baked-curve asset.
-        public Transform sequenceTarget;
+        // Sequence — authored timeline, loop or one-shot. A baked clip drives many bones via paths under
+        // `sequenceRoot`; inline keyframes (deferred) use `sequenceTarget`.
+        public Transform sequenceTarget; // single-bone inline-keyframe target (inline path; deferred)
+        public Transform sequenceRoot;   // baked-clip paths resolve under this (defaults to the avatar root)
         public Keyframe[] keyframes = Array.Empty<Keyframe>();
         public BasisMotionClip bakedClip; // shared baked curves; null when using inline keyframes
         public bool loop = true;
 
-        // Noise — organic Perlin/simplex drift on `channel` about `axis`; reuses `amplitude`,
-        // `chain`, `chainFalloff`, and `seed`. `noiseSpeed` sets how fast the field is sampled.
+        // Noise — simplex drift on `channel` about `axis`; reuses amplitude / chain / chainFalloff / seed; `noiseSpeed` = sample rate.
         public float noiseSpeed = 0.5f;
     }
 
     [Serializable]
-    public class Option { public Vector3 axis; public float angleDeg; public float weight = 1f; }
+    public class Option
+    {
+        [Tooltip("Transform this option poses. Falls back to the movement's Select Target when null.")]
+        public Transform target;
+        [Tooltip("Local axis to rotate about.")]
+        public Vector3 axis = Vector3.up;
+        [Tooltip("Rotation applied about Axis when this option is selected, in degrees.")]
+        public float angleDeg;
+        [Tooltip("Relative likelihood this option is picked.")]
+        public float weight = 1f;
+    }
 
     [Serializable]
-    public class Keyframe { public float time; public Vector3 eulerDelta; public Vector3 positionDelta; public Vector3 scaleDelta; }
+    public class Keyframe
+    {
+        [Tooltip("Time of this key, in seconds from the start of the sequence.")]
+        public float time;
+        [Tooltip("Rotation delta from rest at this key, in euler degrees.")]
+        public Vector3 eulerDelta;
+        [Tooltip("Local position delta from rest at this key.")]
+        public Vector3 positionDelta;
+        [Tooltip("Local scale delta from rest at this key.")]
+        public Vector3 scaleDelta;
+    }
 }
diff --git a/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs b/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs
index d682cc892..a7d484825 100644
--- a/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs
+++ b/Basis/Packages/com.basis.sdk/Scripts/BasisMotionClip.cs
@@ -5,7 +5,8 @@
 /// <c>Sequence</c>: an AnimationClip's curves sampled to a fixed-rate, blittable buffer so the
 /// batched Burst job can interpolate without touching a managed <c>AnimationCurve</c>. One asset
 /// is referenced by every instance of an avatar; per-instance runtime state is just a playhead.
-/// Rotations bake to quaternion deltas; position/scale bake as deltas from the captured rest pose.
+/// Rotations bake as absolute local rotations and the job writes them straight to the bone, so a
+/// converted clip reproduces its authored pose exactly regardless of the avatar's rest pose.
 /// </summary>
 [CreateAssetMenu(fileName = "BasisMotionClip", menuName = "Basis/Authored Motion Clip")]
 public class BasisMotionClip : ScriptableObject
@@ -19,11 +20,14 @@ public class BasisMotionClip : ScriptableObject
     [Tooltip("Number of driven transforms this clip covers.")]
     public int transformCount;
 
+    [Tooltip("Transform path each row drives, relative to the sequence root. One per transform.")]
+    public string[] paths;
+
     // Flattened samples, laid out [transform0_frame0..frameN-1, transform1_...].
     // Index a (transform, frame) as transformIndex * frameCount + frame.
-    public Vector4[] rotationSamples;   // xyzw quaternion deltas from rest
-    public Vector3[] positionSamples;   // local position deltas from rest
-    public Vector3[] scaleSamples;      // local scale deltas from rest
+    public Vector4[] rotationSamples;   // absolute local rotation, xyzw
+    public Vector3[] positionSamples;   // reserved (unused in v1)
+    public Vector3[] scaleSamples;      // reserved (unused in v1)
 
     /// <summary>Clip length in seconds (<c>frameCount / frameRate</c>).</summary>
     public float Length => frameRate > 0f ? frameCount / frameRate : 0f;

From 0149e74bd6835356b4b8366514e30433d6a4b8a3 Mon Sep 17 00:00:00 2001
From: towneh <25694892+towneh@users.noreply.github.com>
Date: Mon, 25 May 2026 02:28:17 +0100
Subject: [PATCH 5/6] feat: add authored-motion inspector and clip baker

A custom BasisAuthoredMotion inspector shows only the fields each movement Kind uses, with localized labels and tooltips; the English strings are added to the SDK localization table and other languages fall back to English.

BasisMotionClipBaker (Basis > Authored Motion > Bake Clip) samples an AnimationClip's rotation curves onto an in-scene root and writes a shared BasisMotionClip for Sequence playback.
---
 .../Localization/Languages/en.json            |  69 ++++++++
 .../Editor/BasisAuthoredMotionEditor.cs       | 157 ++++++++++++++++++
 .../Editor/BasisAuthoredMotionEditor.cs.meta  |   2 +
 .../Scripts/Editor/BasisMotionClipBaker.cs    | 113 +++++++++++++
 .../Editor/BasisMotionClipBaker.cs.meta       |   2 +
 5 files changed, 343 insertions(+)
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs.meta
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs
 create mode 100644 Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs.meta

diff --git a/Basis/Packages/com.basis.sdk/Localization/Languages/en.json b/Basis/Packages/com.basis.sdk/Localization/Languages/en.json
index 4ff04a009..95aec86c7 100644
--- a/Basis/Packages/com.basis.sdk/Localization/Languages/en.json
+++ b/Basis/Packages/com.basis.sdk/Localization/Languages/en.json
@@ -193,6 +193,75 @@
     { "key": "sdk.parameterDriver.field.destMin", "value": "Dest Min" },
     { "key": "sdk.parameterDriver.field.destMax", "value": "Dest Max" },
 
+    { "key": "sdk.authoredMotion.movements.header", "value": "Movements  ({0})" },
+    { "key": "sdk.authoredMotion.movements.empty", "value": "No movements — click '+ Add Movement' below." },
+    { "key": "sdk.authoredMotion.movements.add", "value": "+ Add Movement" },
+    { "key": "sdk.authoredMotion.label.placeholder", "value": "<movement>" },
+    { "key": "sdk.authoredMotion.field.kind.label", "value": "Kind" },
+    { "key": "sdk.authoredMotion.field.kind.tooltip", "value": "Which authored-motion primitive this entry drives. The fields below change to match the kind." },
+    { "key": "sdk.authoredMotion.field.label.label", "value": "Label" },
+    { "key": "sdk.authoredMotion.field.label.tooltip", "value": "Author-facing identifier only; has no runtime effect." },
+    { "key": "sdk.authoredMotion.field.enabled.label", "value": "Enabled" },
+    { "key": "sdk.authoredMotion.field.enabled.tooltip", "value": "Author default for this movement. The runtime on/off toggle rides the component's own enabled state." },
+    { "key": "sdk.authoredMotion.field.axis.label", "value": "Axis" },
+    { "key": "sdk.authoredMotion.field.axis.tooltip", "value": "Local axis the movement acts about." },
+    { "key": "sdk.authoredMotion.field.channel.label", "value": "Channel" },
+    { "key": "sdk.authoredMotion.field.channel.tooltip", "value": "What the value drives — Rotation (degrees), Position (metres) or Scale (factor)." },
+    { "key": "sdk.authoredMotion.field.waveform.label", "value": "Waveform" },
+    { "key": "sdk.authoredMotion.field.waveform.tooltip", "value": "Oscillation shape: Sine, Triangle, Square or Pulse." },
+    { "key": "sdk.authoredMotion.field.pulseWidth.label", "value": "Pulse Width" },
+    { "key": "sdk.authoredMotion.field.pulseWidth.tooltip", "value": "Duty cycle (0–1) for the Square and Pulse waveforms." },
+    { "key": "sdk.authoredMotion.field.amplitude.label", "value": "Amplitude" },
+    { "key": "sdk.authoredMotion.field.amplitude.tooltip", "value": "Peak deviation from rest. Units follow Channel: degrees, metres or scale-factor." },
+    { "key": "sdk.authoredMotion.field.frequencyHz.label", "value": "Frequency (Hz)" },
+    { "key": "sdk.authoredMotion.field.frequencyHz.tooltip", "value": "Cycles per second." },
+    { "key": "sdk.authoredMotion.field.phase.label", "value": "Phase" },
+    { "key": "sdk.authoredMotion.field.phase.tooltip", "value": "Starting phase offset, in radians." },
+    { "key": "sdk.authoredMotion.field.chain.label", "value": "Chain" },
+    { "key": "sdk.authoredMotion.field.chain.tooltip", "value": "Transforms this movement drives. One entry is a simple sway on a single bone; multiple entries form a travelling wave down the chain. Oscillate and Noise are driven by this list — not by Target." },
+    { "key": "sdk.authoredMotion.field.chainPhaseStep.label", "value": "Chain Phase Step" },
+    { "key": "sdk.authoredMotion.field.chainPhaseStep.tooltip", "value": "Phase delay (radians) added per element down the chain — produces the travelling-wave look." },
+    { "key": "sdk.authoredMotion.field.chainFalloff.label", "value": "Chain Falloff" },
+    { "key": "sdk.authoredMotion.field.chainFalloff.tooltip", "value": "Amplitude multiplier applied per element down the chain (1 = no falloff)." },
+    { "key": "sdk.authoredMotion.field.target.label", "value": "Target" },
+    { "key": "sdk.authoredMotion.field.target.tooltip", "value": "Transform to drive. Used by Rotate and Orbit; Oscillate and Noise use Chain instead." },
+    { "key": "sdk.authoredMotion.field.speedDeg.label", "value": "Speed (deg/sec)" },
+    { "key": "sdk.authoredMotion.field.speedDeg.tooltip", "value": "Constant angular velocity about Axis, in degrees per second." },
+    { "key": "sdk.authoredMotion.field.pivot.label", "value": "Pivot" },
+    { "key": "sdk.authoredMotion.field.pivot.tooltip", "value": "Point the Target revolves around. Defaults to the Target's own position when unset." },
+    { "key": "sdk.authoredMotion.field.radius.label", "value": "Radius" },
+    { "key": "sdk.authoredMotion.field.radius.tooltip", "value": "Distance from the pivot, in metres." },
+    { "key": "sdk.authoredMotion.field.orbitSpeedDeg.label", "value": "Orbit Speed (deg/sec)" },
+    { "key": "sdk.authoredMotion.field.orbitSpeedDeg.tooltip", "value": "Revolution speed around the pivot, in degrees per second." },
+    { "key": "sdk.authoredMotion.field.selectTarget.label", "value": "Select Target" },
+    { "key": "sdk.authoredMotion.field.selectTarget.tooltip", "value": "Default target for options that don't set their own. Lets one component pose a single bone several ways, while options that name their own target can each drive a different bone." },
+    { "key": "sdk.authoredMotion.field.options.label", "value": "Options" },
+    { "key": "sdk.authoredMotion.field.options.tooltip", "value": "Weighted poses to pick between. Each option may target its own bone (falling back to Select Target) and is chosen in proportion to its weight." },
+    { "key": "sdk.authoredMotion.field.idleWeight.label", "value": "Idle Weight" },
+    { "key": "sdk.authoredMotion.field.idleWeight.tooltip", "value": "Relative weight of the 'pose nothing' outcome. Larger values make a rest cycle (all targets returning to rest) more likely than any single option." },
+    { "key": "sdk.authoredMotion.field.intervalRange.label", "value": "Interval Range" },
+    { "key": "sdk.authoredMotion.field.intervalRange.tooltip", "value": "Time between picks. The X value sets the fixed period in seconds; Y is reserved." },
+    { "key": "sdk.authoredMotion.field.attack.label", "value": "Attack" },
+    { "key": "sdk.authoredMotion.field.attack.tooltip", "value": "Ease-in time toward a newly chosen pose, in seconds." },
+    { "key": "sdk.authoredMotion.field.release.label", "value": "Release" },
+    { "key": "sdk.authoredMotion.field.release.tooltip", "value": "Ease-out time when a target returns to rest, in seconds." },
+    { "key": "sdk.authoredMotion.field.preventRepeats.label", "value": "Prevent Repeats" },
+    { "key": "sdk.authoredMotion.field.preventRepeats.tooltip", "value": "Avoid picking the same option twice in a row. Not yet honored by the deterministic picker." },
+    { "key": "sdk.authoredMotion.field.seed.label", "value": "Seed" },
+    { "key": "sdk.authoredMotion.field.seed.tooltip", "value": "Random seed for Noise and RandomSelect. 0 derives one from the registration index." },
+    { "key": "sdk.authoredMotion.field.noiseSpeed.label", "value": "Noise Speed" },
+    { "key": "sdk.authoredMotion.field.noiseSpeed.tooltip", "value": "How fast the simplex-noise field is sampled." },
+    { "key": "sdk.authoredMotion.field.sequenceTarget.label", "value": "Sequence Target" },
+    { "key": "sdk.authoredMotion.field.sequenceTarget.tooltip", "value": "Transform the timeline drives." },
+    { "key": "sdk.authoredMotion.field.sequenceRoot.label", "value": "Sequence Root" },
+    { "key": "sdk.authoredMotion.field.sequenceRoot.tooltip", "value": "The baked clip's transform paths resolve under this root (e.g. the avatar root the clip was authored against). Defaults to this component's transform when unset." },
+    { "key": "sdk.authoredMotion.field.bakedClip.label", "value": "Baked Clip" },
+    { "key": "sdk.authoredMotion.field.bakedClip.tooltip", "value": "Shared, read-only baked-curve asset produced by the clip baker. Drives every bone the source AnimationClip animated." },
+    { "key": "sdk.authoredMotion.field.keyframes.label", "value": "Keyframes" },
+    { "key": "sdk.authoredMotion.field.keyframes.tooltip", "value": "Inline pose-delta timeline for short motion. Ignored when a Baked Clip is assigned." },
+    { "key": "sdk.authoredMotion.field.loop.label", "value": "Loop" },
+    { "key": "sdk.authoredMotion.field.loop.tooltip", "value": "Loop the sequence, or play it once." },
+
     { "key": "sdk.buildReport.window.title", "value": "Basis Build Report Viewer" },
     { "key": "sdk.buildReport.window.tabTitle", "value": "Basis Bundle Report" },
     { "key": "sdk.buildReport.noDirectory", "value": "No build reports directory found." },
diff --git a/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs
new file mode 100644
index 000000000..6333c8cda
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs
@@ -0,0 +1,157 @@
+using System.Collections.Generic;
+using Basis.Editor.Localization;
+using UnityEditor;
+using UnityEngine;
+using static BasisAuthoredMotion.Movement;
+
+[CustomEditor(typeof(BasisAuthoredMotion))]
+public class BasisAuthoredMotionEditor : Editor
+{
+    private readonly List<bool> _foldouts = new List<bool>();
+
+    public override void OnInspectorGUI()
+    {
+        serializedObject.Update();
+        SerializedProperty movements = serializedObject.FindProperty("movements");
+
+        EditorGUILayout.LabelField(L("movements.header", movements.arraySize), EditorStyles.boldLabel);
+
+        while (_foldouts.Count < movements.arraySize) _foldouts.Add(true);
+        while (_foldouts.Count > movements.arraySize) _foldouts.RemoveAt(_foldouts.Count - 1);
+
+        if (movements.arraySize == 0)
+        {
+            GUIStyle emptyStyle = new GUIStyle(EditorStyles.miniLabel) { fontStyle = FontStyle.Bold, wordWrap = true };
+            emptyStyle.normal.textColor = new Color(0.6f, 0.6f, 0.6f);
+            GUILayout.Label(L("movements.empty"), emptyStyle);
+            GUILayout.Space(4);
+        }
+
+        int removeIndex = -1, swapA = -1, swapB = -1;
+        for (int i = 0; i < movements.arraySize; i++)
+            DrawMovementCard(movements, i, ref removeIndex, ref swapA, ref swapB);
+
+        if (swapA >= 0) movements.MoveArrayElement(swapA, swapB);
+        if (removeIndex >= 0) movements.DeleteArrayElementAtIndex(removeIndex);
+
+        GUILayout.Space(4);
+        if (GUILayout.Button(L("movements.add"), GUILayout.Height(30)))
+        {
+            movements.arraySize++;
+            _foldouts.Add(true);
+        }
+
+        serializedObject.ApplyModifiedProperties();
+    }
+
+    private void DrawMovementCard(SerializedProperty movements, int i,
+        ref int removeIndex, ref int swapA, ref int swapB)
+    {
+        SerializedProperty mv = movements.GetArrayElementAtIndex(i);
+        var kind = (Kind)mv.FindPropertyRelative("kind").enumValueIndex;
+        SerializedProperty label = mv.FindPropertyRelative("label");
+
+        EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+
+        EditorGUILayout.BeginHorizontal();
+        string title = string.IsNullOrEmpty(label.stringValue) ? L("label.placeholder") : label.stringValue;
+        _foldouts[i] = EditorGUILayout.Foldout(_foldouts[i], $" [{i}]  {title}", true);
+        GUILayout.Label(kind.ToString().ToUpper(), EditorStyles.miniLabel, GUILayout.Width(90));
+
+        GUI.enabled = i > 0;
+        if (GUILayout.Button("▲", GUILayout.Width(22), GUILayout.Height(18))) { swapA = i - 1; swapB = i; }
+        GUI.enabled = i < movements.arraySize - 1;
+        if (GUILayout.Button("▼", GUILayout.Width(22), GUILayout.Height(18))) { swapA = i; swapB = i + 1; }
+        GUI.enabled = true;
+        if (GUILayout.Button("✕", GUILayout.Width(22), GUILayout.Height(18))) removeIndex = i;
+        EditorGUILayout.EndHorizontal();
+
+        if (_foldouts[i])
+        {
+            GUILayout.Space(2);
+            EditorGUI.indentLevel++;
+
+            Field(mv, "kind", "kind");
+            Field(mv, "label", "label");
+            Field(mv, "enabled", "enabled");
+
+            switch (kind)
+            {
+                case Kind.Oscillate:
+                    Field(mv, "channel", "channel");
+                    Field(mv, "axis", "axis");
+                    Field(mv, "amplitude", "amplitude");
+                    Field(mv, "frequencyHz", "frequencyHz");
+                    Field(mv, "phase", "phase");
+                    Field(mv, "waveform", "waveform");
+                    var wf = (Waveform)mv.FindPropertyRelative("waveform").enumValueIndex;
+                    if (wf == Waveform.Square || wf == Waveform.Pulse)
+                        Field(mv, "pulseWidth", "pulseWidth");
+                    Field(mv, "chain", "chain");
+                    Field(mv, "chainPhaseStep", "chainPhaseStep");
+                    Field(mv, "chainFalloff", "chainFalloff");
+                    break;
+
+                case Kind.Noise:
+                    Field(mv, "channel", "channel");
+                    Field(mv, "axis", "axis");
+                    Field(mv, "amplitude", "amplitude");
+                    Field(mv, "noiseSpeed", "noiseSpeed");
+                    Field(mv, "seed", "seed");
+                    Field(mv, "chain", "chain");
+                    Field(mv, "chainFalloff", "chainFalloff");
+                    break;
+
+                case Kind.Rotate:
+                    Field(mv, "target", "target");
+                    Field(mv, "axis", "axis");
+                    Field(mv, "speedDeg", "speedDeg");
+                    break;
+
+                case Kind.Orbit:
+                    Field(mv, "target", "target");
+                    Field(mv, "pivot", "pivot");
+                    Field(mv, "axis", "axis");
+                    Field(mv, "radius", "radius");
+                    Field(mv, "orbitSpeedDeg", "orbitSpeedDeg");
+                    break;
+
+                case Kind.RandomSelect:
+                    Field(mv, "selectTarget", "selectTarget");
+                    Field(mv, "options", "options");
+                    Field(mv, "idleWeight", "idleWeight");
+                    Field(mv, "intervalRange", "intervalRange");
+                    Field(mv, "attack", "attack");
+                    Field(mv, "release", "release");
+                    Field(mv, "preventRepeats", "preventRepeats");
+                    Field(mv, "seed", "seed");
+                    break;
+
+                case Kind.Sequence:
+                    Field(mv, "bakedClip", "bakedClip");
+                    Field(mv, "sequenceRoot", "sequenceRoot");
+                    Field(mv, "loop", "loop");
+                    break;
+            }
+
+            EditorGUI.indentLevel--;
+            GUILayout.Space(5);
+        }
+        else
+        {
+            GUILayout.Space(3);
+        }
+
+        EditorGUILayout.EndVertical();
+        GUILayout.Space(3);
+    }
+
+    private static void Field(SerializedProperty parent, string relative, string key)
+    {
+        SerializedProperty p = parent.FindPropertyRelative(relative);
+        EditorGUILayout.PropertyField(p, new GUIContent(L($"field.{key}.label"), L($"field.{key}.tooltip")), true);
+    }
+
+    private static string L(string key) => BasisEditorLocalization.Get("sdk.authoredMotion." + key);
+    private static string L(string key, params object[] args) => BasisEditorLocalization.Get("sdk.authoredMotion." + key, args);
+}
diff --git a/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs.meta b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs.meta
new file mode 100644
index 000000000..c0d8d1c35
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisAuthoredMotionEditor.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a637f446b53f4580a3efd85adbea7f37
diff --git a/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs
new file mode 100644
index 000000000..19a4f0fa7
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs
@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+/// <summary>
+/// Bakes an <see cref="AnimationClip"/>'s rotation curves into a <see cref="BasisMotionClip"/> for a
+/// <c>Sequence</c> movement. Samples the clip at a fixed rate onto an in-scene root (via
+/// <see cref="AnimationMode"/>, which restores the pose afterwards) and records each animated bone's
+/// absolute local rotation. Paths are stored relative to the chosen root, so set the same root on the
+/// Sequence movement. Rotation only in v1 — position/scale curves are ignored.
+/// </summary>
+public class BasisMotionClipBaker : EditorWindow
+{
+    [SerializeField] private AnimationClip _clip;
+    [SerializeField] private GameObject _root;
+    [SerializeField] private float _frameRate = 60f;
+
+    [MenuItem("Basis/Authored Motion/Bake Clip")]
+    private static void Open() => GetWindow<BasisMotionClipBaker>(true, "Bake Authored Motion Clip");
+
+    private void OnGUI()
+    {
+        EditorGUILayout.HelpBox(
+            "Samples an AnimationClip's rotation curves into a BasisMotionClip. Paths are baked relative " +
+            "to Root (the avatar the clip was authored on) — set the same Root on the Sequence movement.",
+            MessageType.Info);
+
+        _clip = (AnimationClip)EditorGUILayout.ObjectField("Animation Clip", _clip, typeof(AnimationClip), false);
+        _root = (GameObject)EditorGUILayout.ObjectField("Root (in scene)", _root, typeof(GameObject), true);
+        _frameRate = EditorGUILayout.FloatField("Frame Rate", _frameRate);
+
+        using (new EditorGUI.DisabledScope(_clip == null || _root == null || _frameRate <= 0f))
+        {
+            if (GUILayout.Button("Bake", GUILayout.Height(28))) Bake();
+        }
+    }
+
+    private void Bake()
+    {
+        // Distinct rotation-animated paths, in binding order.
+        var paths = new List<string>();
+        var seen = new HashSet<string>();
+        foreach (EditorCurveBinding b in AnimationUtility.GetCurveBindings(_clip))
+        {
+            if (b.type != typeof(Transform)) continue;
+            if (!b.propertyName.StartsWith("m_LocalRotation") && !b.propertyName.StartsWith("localEulerAngles")) continue;
+            if (seen.Add(b.path)) paths.Add(b.path);
+        }
+        if (paths.Count == 0)
+        {
+            EditorUtility.DisplayDialog("Bake Authored Motion Clip", "The clip animates no transform rotations.", "OK");
+            return;
+        }
+
+        // Resolve each path under the root; drop any that aren't present.
+        var keepPaths = new List<string>();
+        var keepTransforms = new List<Transform>();
+        for (int i = 0; i < paths.Count; i++)
+        {
+            Transform tf = string.IsNullOrEmpty(paths[i]) ? _root.transform : _root.transform.Find(paths[i]);
+            if (tf == null) { BasisDebug.LogWarning($"[BasisMotionClipBaker] Path not under root, skipping: {paths[i]}", BasisDebug.LogTag.AuthoredMotion); continue; }
+            keepPaths.Add(paths[i]);
+            keepTransforms.Add(tf);
+        }
+        if (keepTransforms.Count == 0)
+        {
+            EditorUtility.DisplayDialog("Bake Authored Motion Clip",
+                "No animated paths resolved under Root. Is Root the avatar the clip was authored on?", "OK");
+            return;
+        }
+
+        int transformCount = keepTransforms.Count;
+        int frameCount = Mathf.Max(1, Mathf.CeilToInt(_clip.length * _frameRate));
+        var rotation = new Vector4[transformCount * frameCount];
+
+        AnimationMode.StartAnimationMode();
+        try
+        {
+            for (int f = 0; f < frameCount; f++)
+            {
+                float time = frameCount > 1 ? f / _frameRate : 0f;
+                AnimationMode.BeginSampling();
+                AnimationMode.SampleAnimationClip(_root, _clip, time);
+                AnimationMode.EndSampling();
+
+                for (int k = 0; k < transformCount; k++)
+                {
+                    Quaternion q = keepTransforms[k].localRotation;
+                    rotation[k * frameCount + f] = new Vector4(q.x, q.y, q.z, q.w);
+                }
+            }
+        }
+        finally
+        {
+            AnimationMode.StopAnimationMode();
+        }
+
+        string assetPath = EditorUtility.SaveFilePanelInProject(
+            "Save Motion Clip", _clip.name + " Motion", "asset", "Choose where to save the baked BasisMotionClip.");
+        if (string.IsNullOrEmpty(assetPath)) return;
+
+        var motion = CreateInstance<BasisMotionClip>();
+        motion.frameRate = _frameRate;
+        motion.frameCount = frameCount;
+        motion.transformCount = transformCount;
+        motion.paths = keepPaths.ToArray();
+        motion.rotationSamples = rotation;
+        AssetDatabase.CreateAsset(motion, assetPath);
+        AssetDatabase.SaveAssets();
+        EditorGUIUtility.PingObject(motion);
+        BasisDebug.Log($"[BasisMotionClipBaker] Baked {transformCount} transform(s) × {frameCount} frame(s) → {assetPath}", BasisDebug.LogTag.AuthoredMotion);
+    }
+}
diff --git a/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs.meta b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs.meta
new file mode 100644
index 000000000..6d4a4ae34
--- /dev/null
+++ b/Basis/Packages/com.basis.sdk/Scripts/Editor/BasisMotionClipBaker.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 255d2c608f1f4d7daa5bf25e36b93771

From cbb5e6928d4b4e57644c68b6461a1887c395ccc5 Mon Sep 17 00:00:00 2001
From: towneh <25694892+towneh@users.noreply.github.com>
Date: Mon, 25 May 2026 02:28:18 +0100
Subject: [PATCH 6/6] chore: stop tracking authored-motion design docs

The BasisAuthoredMotion design spec and the LeonaDynamics performance analysis are kept as local reference material rather than in-repo documentation.
---
 BasisAuthoredMotion-Design-Spec.md            | 240 ------------------
 ...-Dynamics-Animator-Performance-Analysis.md | 123 ---------
 2 files changed, 363 deletions(-)
 delete mode 100644 BasisAuthoredMotion-Design-Spec.md
 delete mode 100644 Leona-Dynamics-Animator-Performance-Analysis.md

diff --git a/BasisAuthoredMotion-Design-Spec.md b/BasisAuthoredMotion-Design-Spec.md
deleted file mode 100644
index 72a859aff..000000000
--- a/BasisAuthoredMotion-Design-Spec.md
+++ /dev/null
@@ -1,240 +0,0 @@
-# `BasisAuthoredMotion` — native authored-motion driver (design spec)
-
-**Problem.** Basis avatars commonly drive *cosmetic and secondary* motion — looping idles, tail and ear movement, spinning accessories — with a Unity Animator. Each Animator carries high *fixed* per-instance overhead (Playable-graph setup and evaluation, state-machine and transition processing, the per-Animator update pass) that is independent of how trivial the motion is, and it is paid on **every replicated copy of every avatar in the instance**. That overhead scales linearly with player count, so at high CCU it becomes a substantial share of frame time: a 1000-CCU load test measured a single avatar's cosmetic Animator at roughly **1/5 of scene frame time**. The motion itself is trivially simple — the cost is almost entirely Animator machinery, not animation. This doc proposes what to build instead. (Background measurement and the options weighed: see the analysis doc in the appendix.)
-
-**Names confirmed**: `BasisAuthoredMotion` (component) and `BasisAuthoredMotionSystem` (batched system).
-
-**Scope.** This is a general facility for **authored, deterministic dynamic movement on transforms the humanoid rig and IK don't drive** — non-humanoid *rigged* bones (tail and ear chains, extra bones) and standalone accessory objects. The boundary is the humanoid/IK-driven, networked skeleton — *not* bones in general, so rigged chains like tails are squarely in scope. It's a third category of avatar motion: the rigged skeleton is the primary networked/IK-driven pose, jiggle physics adds *emergent* physics-driven follow-through, and this is the *authored* motion the avatar (or prop) declares. The three **stack rather than compete** — authored motion supplies the animated base and **jiggle physics layers on top of it** (see *Jiggle physics ordering*). Cosmetic looping idle sequences or secondary animations (tail flicks, ears twitching, accessories spinning) are among the first use cases driving this, not the limit: any set-sequence or continuously-animated movement on those non-humanoid transforms belongs here.
-
----
-
-## What we're building
-
-**One deliverable**, in two co-shipped pieces:
-
-1. A whitelisted, **data-only** SDK component (`BasisAuthoredMotion`) the avatar carries — pure serialized configuration, no per-instance runtime `Update`.
-2. A **batched, Burst-compiled job system** (`BasisAuthoredMotionSystem`) that evaluates every registered avatar's movements in one parallel pass per frame and writes the target transforms directly — no Playable graph, no state machine, no per-instance dispatch.
-
-All runtime work happens in the shared job; the component just declares what to do. It mirrors the existing `RemoteBoneJobSystem` (`Packages/com.basis.framework/Drivers/Remote/BasisRemoteBoneDriver.cs`), which already proves the batched-transform pattern at thousand-avatar scale. Optimization is a hard requirement, not a later pass (see *Performance requirements*).
-
----
-
-## Authoring surface — the component
-
-A **data-only SDK MonoBehaviour** whose configuration model mirrors `BasisParameterDriver` (`Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`) — a serializable array of reusable, parameterised **movements**, the same `Operation[]`-style shape (an enum kind + per-kind fields). Only the *data model* is borrowed: `BasisParameterDriver` is a `StateMachineBehaviour`, not an avatar component, so it's a shape precedent, not a lifecycle or whitelist one. Allowing a component onto an avatar is the Content Police's job — add the type to `ContentPoliceSelector.selectedTypes` in `AvatarContentPoliceSelector.asset` (`Packages/com.basis.sdk/Scripts/Content Police/`). The movements are general primitives, not avatar-specific behaviours: the same set drives a tail, hair, antennae, ear, cloth strip, halo, orbiting gem, blink, or ambient micro-gesture. Any avatar declares whatever combination it needs.
-
-```csharp
-public class BasisAuthoredMotion : MonoBehaviour
-{
-    public Movement[] movements = Array.Empty<Movement>();
-
-    [Serializable]
-    public class Movement
-    {
-        // Open, extensible set — new kinds slot in without changing the
-        // registration / scheduling model (see "Extensibility").
-        public enum Kind { Oscillate, Rotate, Orbit, RandomSelect, Sequence, Noise }
-        public enum Channel  { Rotation, Position, Scale } // what Oscillate / Noise drive
-        public enum Waveform { Sine, Triangle, Square, Pulse } // Oscillate waveform
-
-        public Kind kind = Kind.Oscillate;
-        public string label;              // author-facing identifier only
-        public bool enabled = true;       // author default; runtime toggle rides the component's own enabled (any toggle system, e.g. HVR.Vixxy)
-        public Vector3 axis = Vector3.up; // local axis the movement acts about
-
-        // Oscillate — periodic motion on `channel`, optionally propagated down a
-        // chain to form a travelling wave (1 entry = simple sway). `waveform`
-        // selects sine (default) or triangle / square / pulse.
-        public Channel channel = Channel.Rotation; // amplitude unit: deg | metres | scale-factor
-        public Waveform waveform = Waveform.Sine;
-        public float pulseWidth = 0.5f;    // square/pulse duty cycle (0–1)
-        public Transform[] chain;
-        public float amplitude      = 15f;
-        public float frequencyHz    = 0.5f;
-        public float phase          = 0f;
-        public float chainPhaseStep = 0f; // phase delay per element down the chain
-        public float chainFalloff   = 1f; // amplitude scale per element down the chain
-
-        // Rotate — constant angular velocity about `axis`, in place.
-        public Transform target;
-        public float speedDeg = 36f;      // deg/sec
-
-        // Orbit — revolve `target` around `pivot` at `radius` (not a spin-in-place).
-        public Transform pivot;
-        public float radius = 0.1f;
-        public float orbitSpeedDeg = 90f; // deg/sec around the pivot
-
-        // RandomSelect — on a randomised interval pick one weighted option, ease in/out.
-        public Transform selectTarget;
-        public Option[] options = Array.Empty<Option>();
-        public Vector2 intervalRange = new Vector2(2f, 6f);  // seconds between picks
-        public float attack = 0.06f, release = 0.25f;        // ease in / out seconds
-        public bool preventRepeats = true;
-        public uint seed = 0;             // 0 = derive from registration index
-
-        // Sequence — authored timeline of pose deltas; loop or one-shot. Short
-        // motion uses inline keyframes; complex/converted clips reference a
-        // shared, read-only baked-curve asset instead (see Migration).
-        public Transform sequenceTarget;
-        public Keyframe[] keyframes = Array.Empty<Keyframe>();
-        public BasisMotionClip bakedClip; // shared baked curves; null when using inline keyframes
-        public bool loop = true;
-
-        // Noise — organic Perlin/simplex drift on `channel` about `axis`;
-        // smoother than RandomSelect, less repetitive than Oscillate. Reuses
-        // `amplitude`, `chain`, `chainFalloff`, and `seed`; `noiseSpeed` sets
-        // how fast the noise field is sampled.
-        public float noiseSpeed = 0.5f;
-    }
-
-    [Serializable]
-    public class Option   { public Vector3 axis; public float angleDeg; public float weight = 1f; }
-    [Serializable]
-    public class Keyframe { public float time; public Vector3 eulerDelta; public Vector3 positionDelta; public Vector3 scaleDelta; }
-}
-```
-
-As a concrete mapping, a common cosmetic Animator setup — a swaying tail, an orbiting accessory, and randomly twitching ears across three layers — reduces to three movements here: a tail bone chain → `Oscillate`, an accessory circling the body → `Orbit` (or `Rotate` if it spins in place), and each ear → a `RandomSelect` over a couple of pose options. The authored config is flattened into the job system's SoA at registration.
-
-### Supported motion types
-
-The initial supported set. Every type is a **delta from a captured rest pose** on its channel, evaluated in the batched job.
-
-| Type | What it does | Channel(s) | Key parameters | Example uses |
-|------|--------------|-----------|----------------|--------------|
-| **Oscillate** | periodic motion (sine / triangle / square / pulse), optionally a travelling wave down a chain | rotation / position / scale | `axis`, `amplitude`, `frequencyHz`, `phase`, `waveform`, `chainPhaseStep`, `chainFalloff` | tail / hair / ear sway, floating bob, breathing & glow pulse, mechanical ticks |
-| **Rotate** | constant angular velocity, spinning in place | rotation | `axis`, `speedDeg` | halos, fans, spinning gems/coins |
-| **Orbit** | revolve a transform around a pivot at a radius | position (+ optional facing) | `pivot`, `radius`, `orbitSpeedDeg`, `axis` | accessory circling the body/tail, orbiting orbs or particles |
-| **RandomSelect** | stochastic weighted pick among pose options on a randomised interval | rotation (pose deltas) | `options` (+`weight`), `intervalRange`, `attack`/`release`, `preventRepeats`, `seed` | ear flicks, blinks, idle micro-gestures |
-| **Sequence** | authored keyframed timeline of pose deltas, looping or one-shot; inline keys for short hand-authored motion, or a shared baked-curve asset for complex/converted clips | rotation + position + scale | `keyframes` (`time` + per-channel deltas) *or* baked-clip ref, `loop` | scripted flourishes, set-piece accessory animations, **any converted AnimationClip** (see Migration) |
-| **Noise** | organic Perlin/simplex drift, optionally down a chain | rotation / position / scale | `axis`, `amplitude`, `noiseSpeed`, `seed`, `chainFalloff` | idle wander, flame / cloth flutter, lifelike micro-sway |
-
-The math, per type:
-
-- **Oscillate** — `value = rest ⊕ (amplitude * w(t*frequencyHz*2π + phase))` on `axis`, where `w` is the selected `waveform` (sine, or triangle / square / pulse derived from the same phase — square/pulse using `pulseWidth` as the duty cycle) and `⊕` applies to the chosen channel (rotation = `AngleAxis`, position = offset along axis, scale = scalar along axis). For a chain, element *n* uses `phase + n*chainPhaseStep` and `amplitude * chainFalloffⁿ` → a wave travelling down the chain.
-- **Rotate** — `localRotation = rest * AngleAxis((t * speedDeg) mod 360, axis)`.
-- **Orbit** — `localPosition = pivotLocal + radius * (cos θ, sin θ)` in the plane normal to `axis`, `θ = t * orbitSpeedDeg`; optionally face the pivot.
-- **RandomSelect** — deterministic, no managed callback and no animator parameter. A per-movement `Unity.Mathematics.Random` (seeded by `seed`, or registration index) schedules the next pick from `intervalRange`, chooses a weighted `Option` (honouring `preventRepeats`), and eases its pose delta `0 → angleDeg → 0` over `attack`/`release`. This replaces the `BasisParameterDriver` state-machine-behaviour + RNG int + threshold-transition machinery entirely.
-- **Sequence** — sample the timeline at `t` (wrapping when `loop`), interpolate the per-channel deltas, apply over rest. A lightweight authored clip without an Animator/Playable graph. Short sequences use inline keyframes; complex/converted clips reference a shared, read-only baked curve buffer (see Migration).
-- **Noise** — `value = rest ⊕ (amplitude * noise.snoise(float2(t*noiseSpeed, seedOffset)))` on `axis` (simplex noise, range ≈ [-1, 1]); applies to the channel exactly as Oscillate does, and propagates down a chain via `chainFalloffⁿ` with a per-element `seedOffset`.
-
-All RNG, trig, and noise is `Unity.Mathematics`, so the routine is Burst-legal as written.
-
-### Extensibility
-
-The kind set is open. A new type = a new `Kind` enum value + a branch in the evaluation routine + its fields in the flattened struct; a kind with a very different data shape gets its own SoA array + sub-job. Registration, scheduling, culling, and toggles are all kind-agnostic, so adding a type never disturbs the system around it — which is what makes this a general avatar-motion facility rather than a fix for one avatar.
-
-The initial set already exercises the full range of shapes — clock-driven (**Oscillate**, **Rotate**, **Orbit**), stochastic (**RandomSelect**), baked (**Sequence**), and procedural-noise (**Noise**) — all self-contained, with no external input feeds. Further kinds slot in by the same mechanism whenever a real consumer needs one — none are committed speculatively here.
-
----
-
-## The runtime — batched Burst job system
-
-`BasisAuthoredMotionSystem`, a static orchestrator built as a sibling to `RemoteBoneJobSystem`:
-
-| Concern | Reuse from `RemoteBoneJobSystem` |
-|---|---|
-| Per-entry config | SoA `NativeList<MovementData>` (the `Movement` flattened to a blittable struct), one slot per driven transform |
-| Driven transforms | flat `TransformAccessArray` across all avatars |
-| RNG / select state | read-write `NativeArray` indexed by the flat slot, advanced in-job |
-| Registry | `Add`/`Remove` keyed by avatar id, dense swap-back, deferred adds committed at the frame sync |
-| Per-frame work | `Schedule()` → one Burst `IJobParallelForTransform` computing delta-from-rest and writing the target channel (`localRotation` / `localPosition` / `localScale`), with a uniform `time` field |
-| Cull / disable | `ValidMask`-style `NativeArray<byte>` — toggled movements and culled avatars become no-ops, no array churn |
-| Threading | adaptive `innerloopBatchCount = min(maxBatch, ceil(count / workerCount))` |
-
-**Registration** — co-locate with the bone system: `BasisRemoteAvatarDriver.RemoteCalibration` already calls `RemoteBoneJobSystem.AddRemotePlayer`; the local path (`BasisLocalAvatarDriver`) is the analogue. At calibration, walk the avatar's `BasisAuthoredMotion` components (`GetComponents` — an avatar may carry several, one per toggle group; see *Maintainer decisions* #3), flatten their movements + targets into the SoA and register; deregister on teardown/recalibration (the bone system's synchronous-remove rationale applies — drop the TAA entry while the transform is alive). Each component owns the `ValidMask` slice for its movements and toggles it in `OnEnable`/`OnDisable`, so any toggle-system-driven enable/disable is an event, not per-frame work. **Rest poses** are captured at registration and stored in the SoA; movements compose as deltas from rest, never baked absolutes. Registration is driven by the calibration hook — **no scene discovery** (`FindObjectsOfType` et al.).
-
-**Frame schedule** — schedule in the same phase as `RemoteBoneJobSystem`, after the avatar pose apply, completing before render.
-
-**A single compute-and-write job, deliberately simpler than the bone system.** `IJobParallelForTransform` serialises transforms per hierarchy root onto one worker — that's why the 51-bone skeleton needed a compute/apply split. A movement touches ~2–6 bones per avatar, so a single compute-and-write `IJobParallelForTransform` parallelises cleanly across avatars; no split needed.
-
-**Variable-length data** (`RandomSelect` options, `Oscillate` chains, baked `Sequence` curves) flattens into shared buffers with per-movement start/count indices (or a fixed cap), the same way the bone system holds all avatars' bones in one flat array.
-
-**Development practice** — build the job with Burst compilation *off* first (Jobs → Burst → Enable Compilation off). It then runs as plain managed C# — steppable, `Debug.Log` works — so the math is debugged directly. Validate it visually against the reference avatar's existing cosmetic Animator (the Animator is the correctness oracle), then enable Burst (the math is already Burst-legal: `Unity.Mathematics`, no managed types in the job).
-
-**Logging** — `BasisDebug.Log*` with a new `BasisDebug.LogTag`, never `UnityEngine.Debug`.
-
----
-
-## Performance requirements (the maintainer's bar)
-
-Maintainer feedback: an SDK driver component is acceptable, **but it must be heavily optimized.** Concrete targets this design commits to:
-
-- **Data-only component at runtime.** `BasisAuthoredMotion` holds serialized config and runs **no per-instance `Update`** — all runtime evaluation is the single batched Burst job. Editor preview rides the same runtime job during Test In Editor (see *Maintainer decisions*); there's no separate edit-mode evaluation path.
-- **One job set per frame for all avatars**, parallel across workers, cost scaling with total movement count — not a per-avatar dispatch. Mirrors `RemoteBoneJobSystem`.
-- **Zero per-frame GC** — persistent SoA `NativeArray`/`NativeList` + `TransformAccessArray`; no managed allocation in the frame loop.
-- **Burst with fast math** (`[BurstCompile(FloatMode = FloatMode.Fast, FloatPrecision = FloatPrecision.Low)]`, as `BasisRemoteBoneJob` uses).
-- **Shared read-only data** — config and baked `Sequence` curves shared per avatar/clip; per-instance state is minimal (playhead, RNG state, enabled mask) and cache-packed.
-- **Visibility + distance LOD.** Off-screen avatars skip via a `ValidMask` (no array churn). Because this motion is *cosmetic and non-critical*, distant avatars can update at a reduced rate (every N frames) — a temporal-LOD lever the skeletal bone system can't take, and a cheap way to cut the on-screen-crowd cost the culling stop-gap doesn't.
-- **Minimal writes** — only enabled movements write; driven-transform count kept modest; the `IJobParallelForTransform` write is the floor cost.
-- **Batched structural changes** — registration deferred and committed at the frame sync; removal swap-back — no mid-frame job stalls (the bone system's exact approach).
-
-**Acceptance bar:** at the 1000-CCU profile, the whole authored-motion pass is a small fraction of frame time and demonstrably far below the per-instance Animator it replaces (~1/5 of scene frame time at that scale). Profile against that baseline.
-
----
-
-## Cross-cutting design points
-
-- **Rest-pose capture** is the correctness linchpin — capture at registration, compose all motion as deltas, never bake absolute rotations.
-- **Jiggle physics ordering.** Avatars frequently run `JiggleRig` physics on the same chains authored motion drives (a tail, say), wired up in the remote driver. The authored-motion write must land **before** jiggle samples its input pose, so the two compose (authored movement = animated base, jiggle = secondary motion on top), matching how jiggle previously layered on the Animator output. Jiggle is advanced by `JigglePhysicsUpdater` in LateUpdate, so the authored write must be applied earlier in the frame (Update / early-LateUpdate) and **not** in `AfterSimulateOnRender` (which fires at `onBeforeRender`, after LateUpdate); confirm the execution order against the jiggle updater in implementation.
-- **Non-humanoid targets.** Driven bones (tail, ears, accessories) aren't in the networked bone set (`BasisBoneRotationCompression.SyncBoneCount` / `RemoteBoneJobSystem`) and aren't touched by local IK — the job owns them outright, so there's no write contention with the skeletal pipeline.
-
----
-
-## Migration & authoring journey
-
-If we're pitching this as a replacement for traditional Animator-driven cosmetic and secondary motion, the on-ramp from an *existing* animation has to be easy. Not all motion is parametric, so the system needs both a describable path and a faithful fallback — plus a tool that picks between them.
-
-**What moves here, and what doesn't.** This replaces *self-contained, continuously-running* dynamic motion — looping idles, ambient sway, spins, scripted flourishes — that runs independent of gameplay state. It does **not** replace parameter/gameplay-driven graphs (locomotion blend trees, gesture/expression layers, contact reactions); those stay in the Animator. This refines the Scope boundary: the motion must be on non-humanoid transforms *and* authored/self-contained — gameplay- or parameter-driven motion stays in the Animator even when it touches a non-humanoid bone.
-
-**Route 1 — parametric (describable motion).** A sine sway, a constant spin, an orbit: author directly as `Oscillate` / `Rotate` / `Orbit`. A few numbers, tiny data, infinitely tweakable (frequency / amplitude / phase), cheapest at runtime.
-
-**Route 2 — baked (arbitrary authored motion).** Complex hand-keyed motion a primitive can't describe — *e.g. a precise 15-second loop rotating a bone chain through a bespoke path* — is captured as a **`Sequence` backed by a baked clip asset**: the source curves sampled to a fixed-rate, blittable buffer (per driven transform, per channel). The baked data is a **shared, read-only asset** — every instance of the avatar references the same buffer; per-instance runtime state is just a playhead. The batched Burst job samples the shared curve at each instance's playhead and writes the channel. So even a faithful recording of a complex clip scales: the heavy data is shared once, per-instance cost is one interpolated sample per bone — none of the Animator's per-instance Playable-graph / state-machine / retarget overhead. (`AnimationCurve` isn't Burst-usable directly, hence the sampled buffer; rotations bake to quaternions and `nlerp`/`slerp` in-job.)
-
-**The converter tool — the actual on-ramp.** An editor utility takes an existing `AnimationClip` (+ its root) and emits a populated `BasisAuthoredMotion`:
-- **v1 is bake-only:** every animated curve is baked into a shared, read-only `Sequence` asset — a faithful recording, nothing silently approximated.
-- Primitives stay a *manual* authoring route (Route 1): an author who wants the tiny, tweakable `Oscillate` / `Rotate` / `Orbit` form sets it up by hand. The converter doesn't auto-detect them in v1.
-- Auto-fitting curves to primitives (near-constant-rate rotation → `Rotate`, near-single-frequency sinusoid → `Oscillate`) is a later enhancement layered on the same tool — an opt-in suggestion, never a silent substitution.
-- It's an editor-only tool independent of the runtime, so it can land alongside the core or immediately after.
-
-**Worked example — the 15s bone-chain loop.** The converter bakes each bone's rotation curve into one shared `Sequence` asset (sampled at the clip's framerate, looped) and plays it back in the same batched job as every other movement — reproducing the original exactly. Where a bone is actually a simple sway, an author can re-author it as a hand-tuned `Oscillate` afterward (lighter, tweakable); auto-detecting that case is the later converter enhancement.
-
-**Expectation-setting tradeoff:** parametric = tiny, tweakable, infinite variation; baked = faithful to any motion, larger (but shared) data, a fixed recording. Both shed the per-instance Animator overhead, which is the 1000-CCU win — so "we can always bake it" means *no* existing cosmetic or secondary animation is un-portable.
-
----
-
-## Maintainer decisions
-
-All resolved — nothing gating scaffolding.
-
-1. **Whitelist — ✅ RESOLVED.** An SDK driver component is acceptable, with a hard optimization bar (see *Performance requirements*).
-2. **Package home — ✅ RESOLVED (option A — split across existing packages).** Authoring component in `com.basis.sdk` (alongside `BasisParameterDriver` — the SDK avatar-config precedent; whitelisted for avatars via the Content Police, see *Authoring surface*); batched system in `com.basis.framework` (beside `RemoteBoneJobSystem`), with registration co-located at calibration. The feature spans two packages, matching both precedents, and relies on the existing direction where the framework runtime reads SDK-defined avatar components at calibration.
-3. **Runtime toggles — ✅ RESOLVED (component `enabled`, toggle-system-agnostic).** The component's toggle contract is its own `MonoBehaviour.enabled`: it flips its slice of the system's `ValidMask` in `OnEnable`/`OnDisable` — event-driven, not a per-frame `Update`, so the data-only guarantee holds. **Anything that can set a `Behaviour.enabled` drives it; `BasisAuthoredMotion` holds no reference to any toggle package**, so swapping the toggle system later leaves the component unchanged. HVR.Vixxy is the current consumer: a Vixxy *activation* sets the component's `enabled` (`SetToggleState` → `Behaviour.enabled`), which needs `BasisAuthoredMotion` added to Vixxy's `HVR_VixxyPermitted.PermittedTypeNames` — a by-name string entry on comms' side, so the dependency arrow points comms → SDK, never the reverse. This permitted-list entry is a **second, separate allowlist** from the Content Police entry that lets the component exist on an avatar at all (see *Authoring surface*) — shipping the toggle needs both. Authors group movements that toggle together into one component; an avatar can carry several. Per-*individual*-movement toggling (finer than grouping) would need the component to read an external parameter/variable address and map it to per-movement mask bits — revisit only if grouping proves insufficient.
-4. **Jiggle update ordering — ✅ RESOLVED (requirement); phase to lock in implementation.** The authored-motion write must land **before** `JiggleRig` physics samples its input pose (authored = animated base, jiggle = follow-through on top). Verified constraint: jiggle is advanced by `JigglePhysicsUpdater` in **LateUpdate**, so authored motion must be applied earlier in the frame (Update / early-LateUpdate, the way `RemoteBoneJobSystem` schedules from the network update) — **not** in `AfterSimulateOnRender`, which fires at `onBeforeRender`, after LateUpdate. Lock the execution order against the jiggle updater during implementation (see *Cross-cutting design points*).
-5. **Editor preview — ✅ RESOLVED.** Scope is: motion must at least be visible during **Test In Editor** (the SDK inspector's button, `BasisAvatarSDKInspector` → play mode). That path goes through normal calibration-time registration and runs the standard runtime job, so it's covered by the runtime with no extra work; a separate edit-mode (non-play) preview path is out of v1.
-6. **Converter scope — ✅ RESOLVED.** First pass is **bake-only** — every `AnimationClip` becomes a faithful baked `Sequence`. Primitive auto-fitting (`Rotate`/`Oscillate` where curves allow) is a later enhancement, not v1.
-
----
-
-## Build approach
-
-One reviewable deliverable, not a staged rollout. All maintainer decisions are settled (see above), so nothing gates the start:
-
-1. Place the pieces per the resolved package home (option A): the data-only `BasisAuthoredMotion` component in `com.basis.sdk`, the `BasisAuthoredMotionSystem` batched Burst job in `com.basis.framework`.
-2. Build the component, the batched Burst job, and the calibration-time registration **together**. Develop the job Burst-off for debuggability, validate against the reference avatar's current Animator, then enable Burst and load-test at 1000 CCU against the *Performance requirements* acceptance bar.
-3. The `AnimationClip` → component converter (Migration) lands with or immediately after the core — it's an editor-only tool, independent of the runtime. First pass is bake-only.
-
-The validation target is the Animator baseline this replaces: visually equivalent on the reference avatar, and measurably far cheaper at 1000 CCU.
-
----
-
-## Appendix — references
-
-- Analysis / rationale: `Leona-Dynamics-Animator-Performance-Analysis.md`
-- Burst batched-transform template: `Packages/com.basis.framework/Drivers/Remote/BasisRemoteBoneDriver.cs` (`RemoteBoneJobSystem`, the gather/compute/apply jobs)
-- Registration precedent (remote): `Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs` (`RemoteCalibration` → `RemoteBoneJobSystem.AddRemotePlayer`)
-- Registration seam (local): `Packages/com.basis.framework/Drivers/Local/BasisLocalAvatarDriver.cs` (`Calibration`, plus the static `CalibrationComplete` action)
-- Config data-model precedent (shape only — it's a `StateMachineBehaviour`, not an avatar component): `Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`
-- Avatar-component whitelist mechanism: `Packages/com.basis.sdk/Scripts/Content Police/ContentPoliceSelector.cs` + `Packages/com.basis.sdk/Settings/AvatarContentPoliceSelector.asset`
-- Toggle precedent (component `enabled` via Vixxy's separate allowlist): `Packages/dev.hai-vr.basis.comms/Scripts/Systems/Runtime/Vixxy/Internal/HVR_VixxyPermitted.cs` (`PermittedTypeNames`)
-- Already applied (stop-gap): cosmetic Animator `Culling Mode` set to `Cull Completely`.
diff --git a/Leona-Dynamics-Animator-Performance-Analysis.md b/Leona-Dynamics-Animator-Performance-Analysis.md
deleted file mode 100644
index a335790ae..000000000
--- a/Leona-Dynamics-Animator-Performance-Analysis.md
+++ /dev/null
@@ -1,123 +0,0 @@
-# LeonaDynamics cosmetic Animator — performance analysis
-
-**Context:** During a 1000-CCU load test, the `LeonaDynamics` Animator on the Leona avatar was measured at roughly **1/5 of the scene's frame time**. This document explains what that animator does, why it costs what it does at scale, and three routes to bring the cost down — in increasing order of effort and payoff.
-
----
-
-## TL;DR
-
-- `LeonaDynamics` is a **second, non-humanoid Animator** on the avatar's `Armature` GameObject, separate from the humanoid `BasisAvatar.Animator`. It runs three cosmetic idle layers: tail wag, tail-adornment orbit, and random ear twitch.
-- Basis's remote path **disables the humanoid animator** on every remote avatar and drives its bones via the networked job system (`BasisRemoteAvatarDriver.RemoteCalibration`, `Animator.enabled = false`). **It does not touch the secondary cosmetic animator.**
-- That secondary animator is set to **`Culling Mode = Always Animate`**, so it runs full state-machine evaluation *and* transform writes every frame on **all ~1000 remote instances, on-screen or not**. That is the cost.
-- **First pass (no code):** set its culling mode to *Cull Completely* and trim the layer/transition churn. Reclaims the cost of every off-screen instance immediately.
-- **Real fix at scale:** the per-instance Unity Animator is the wrong tool for trivial procedural motion replicated 1000×. A **native, data-oriented batched driver** (config on the avatar, one Burst/Jobs pass over all instances) collapses N heavyweight graphs into one tight pass.
-- **Cilbox was considered and rejected** for this: it's an interpreter, so a per-frame interpreted `Update` across 1000 avatars would likely be *worse* than the Animator, not better.
-
----
-
-## What the animator does
-
-`LeonaDynamics` is an `AnimatorController` with **3 layers, all weight 1, none masked** — so all three evaluate and blend every frame the animator ticks.
-
-**Parameters:** `Settings/Idles/Tail Wag` (bool), `Settings/Idles/Tail Orbit` (bool), `Settings/Idles/Tail Wag Speed` (float), `Settings/Idles/Ear Twitch` (bool), `Settings/Idles/Ear Twitch RNG` (int).
-
-| Layer | States | Behaviour |
-|---|---|---|
-| **Tail Wag** | `Wag On` / `Wag Off` | `Wag On` plays one clip with **both Speed and Time driven by `Tail Wag Speed`** — a looping back-and-forth. Toggled by the `Tail Wag` bool. |
-| **Tail Orbit** | `Orbit` (default) / `Orbit On` | Slow spin of the tail adornment (`Orbit On` at speed 0.1). Toggled by `Tail Orbit`. |
-| **Ear Twitch** | `Buffer` → `Interval` → `RNG` → `Twitch Left/Right` → `Reset` | The `RNG` state hosts a **`BasisParameterDriver`** StateMachineBehaviour (op type *Random*, `localOnly`) that writes a random `0–255` into `Ear Twitch RNG`. Int-threshold transitions then pick Left / Right / no-twitch. Most of the time it idles in `Buffer`/`Interval` playing a near-empty clip. |
-
-The motion these layers produce is *procedurally trivial*: a periodic wag, a constant slow rotation, and an occasional random pose.
-
-> Note: the `.controller` also carries **two orphaned `Locomotion` BlendTrees** not referenced by any layer — leftover sub-assets. They don't drive runtime cost but are dead weight in the asset and worth removing.
-
----
-
-## Why it costs what it does at 1000 CCU
-
-Unity's Animator is a fully-general evaluator with **high fixed per-instance overhead** — the Playable graph, `Animators.Update`, the parameter buffer, and per-frame transition evaluation (the Ear Twitch layer constantly re-checks several int thresholds). That fixed cost is paid **per Animator instance**, independent of how trivial the motion is.
-
-The decisive detail is **where this animator sits in the Basis avatar lifecycle**:
-
-- In `BasisRemoteAvatarDriver.RemoteCalibration` the **humanoid** animator is taken out of the loop on every remote avatar:
-  ```csharp
-  RemotePlayer.BasisAvatar.Animator.speed = 0;
-  RemotePlayer.BasisAvatar.Animator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
-  ...
-  RemotePlayer.BasisAvatar.Animator.enabled = false;   // bones driven by RemoteBoneJobSystem instead
-  ```
-  (`BasisRemoteAvatarDriver.cs`, lines ~109–112 and ~229.)
-
-- **`LeonaDynamics` is a different component** — a second Animator on the `Armature` child — and the remote path only ever references `BasisAvatar.Animator` (the root humanoid one). So the cosmetic animator is **never disabled, never throttled, never culled** by the framework. It keeps running normally on every client's copy of every remote Leona.
-
-- Its serialized culling mode is **`m_CullingMode: 0` = Always Animate** (verified in `LeonaDynamics.prefab` and in the avatar scene). Always Animate means the state machine evaluates **and** transforms are written **even when the avatar's renderers are off-screen**.
-
-So at 1000 CCU you have up to ~1000 of these graphs each doing full heavyweight evaluation for near-zero motion, regardless of visibility. The cost scales with instance count, which is exactly the regime the load test exercises.
-
-The tail and ear bones are **not** humanoid bones, so they are not part of the networked bone set — the cosmetic motion is produced *locally* on each client by this animator. That's why it has to run on remotes at all (otherwise everyone else's Leona has a frozen tail); it just shouldn't run the way it currently does.
-
----
-
-## Option A — First pass: tune the existing animator (no code)
-
-Lowest effort, immediate win, stays entirely in avatar content.
-
-1. **Culling Mode: `Always Animate` → `Cull Completely`.**
-   `Cull Completely` *fully* disables the animator when the avatar's renderers aren't visible (state machine included), versus `Cull Update Transforms`, which keeps the state machine running and only skips transform writes. For a purely cosmetic idle, `Cull Completely` is correct — off-screen instances stop costing anything, and motion resumes seamlessly when they come back on screen. In a 1000-CCU scene most instances are off-screen at any moment, so this reclaims the bulk of the cost on its own.
-
-2. **Collapse the three layers where possible.** The layers touch disjoint bones (ears, tail, adornment), so much of the three-state-machine evaluation is avoidable. Fewer always-on layers = less per-frame evaluation for the instances that *are* on screen.
-
-3. **Trim the Ear Twitch transition churn.** The RNG-threshold transitions are evaluated every frame while that layer is active; simplifying the graph reduces fixed per-frame work.
-
-4. **Remove the two orphaned `Locomotion` BlendTrees** from the controller asset.
-
-**Caveat:** culling only helps instances that are *off-screen*. A worst-case crowd test where everyone is visible at once still pays the on-screen cost — which is what Options B/C address.
-
----
-
-## Option B — Native, data-oriented batched driver (the real fix at scale)
-
-Replace the per-instance Animator graph with **one batched native system**.
-
-- The avatar carries a small **config component** (the same way `BasisParameterDriver` is a whitelisted SDK component today): "this bone wags at frequency/amplitude X, this bone orbits at rate Y, these ear bones twitch on interval Z."
-- A single Basis runtime system iterates a `NativeArray` of all registered cosmetic-idle avatars and computes every wag/orbit/twitch in **one Burst-compiled job**, writing the bone transforms in bulk — conceptually alongside the existing `RemoteBoneJobSystem` apply.
-- This turns "1000 heavyweight Playable graphs" into "one tight job over 1000 transform targets," which is the only thing that meaningfully changes the slope of the cost curve at high CCU.
-
-This is **SDK/engine-side** work, not avatar content. It's the largest effort of the three but the only one that scales to crowds. It also generalises: any avatar with simple procedural idles (tails, ears, floating accessories) could opt into the same batched path instead of shipping its own Animator.
-
----
-
-## Option C — Native per-avatar driver component (middle ground)
-
-A whitelisted **native** idle-driver MonoBehaviour doing the `sin`/rotate/interval math directly in `LateUpdate`.
-
-- Still per-instance (no batching), but native trivial math has a tiny fraction of the Animator's fixed overhead, so it's a large win over the current setup even before culling.
-- Whether avatars can carry a native whitelisted component for this depends on the avatar content whitelist — i.e. it would be an SDK-provided component the avatar references, not arbitrary user code.
-- Good stepping stone if the full batched system (Option B) is more than is wanted right now; the config surface designed here could later be fed into the batched job without changing the avatar-side authoring.
-
----
-
-## Why not a Cilbox avatar script
-
-Cilbox is the right mechanism for *untrusted custom logic on an avatar* — it sandboxes arbitrary scripts. But it executes by **interpreting CIL bytecode** op-by-op: `CilboxProxy.Update()` calls `box.InterpretIID(...)` every frame, and the interpreter carries per-instruction timeout accounting. Running an interpreted per-frame `Update` across ~1000 avatars would very plausibly cost *more* than the native Animator it's meant to replace — the work simply moves from `Animators.Update` to `InterpretIID`, at a higher per-unit price. (It also exposes only `Update`/`FixedUpdate`, not `LateUpdate`, which is where bone writes ideally land relative to the rig.)
-
-Cilbox is built for safety and flexibility of untrusted content, not for being a hot path replicated 1000×. It's the wrong tool for *this* goal.
-
----
-
-## Recommended staged plan
-
-1. **Now (Option A):** flip the cosmetic animator to `Cull Completely`, collapse layers, trim the Ear Twitch graph, drop the orphaned blend trees. Cheap, ships as avatar content, reclaims all off-screen cost.
-2. **Next (Option B or C):** decide whether to invest in the batched native driver (B, scales to on-screen crowds) or a native per-avatar component (C, simpler, still a large per-instance win). The Option C config surface is forward-compatible with the Option B job, so starting at C and graduating to B is viable.
-
-The framing worth landing with the maintainer: **the secondary cosmetic animator currently bypasses the same lifecycle management that already neutralises the humanoid animator on remotes.** Even just bringing it under that management (cull/disable when not needed) is most of the win; a batched driver is the principled long-term home for procedural avatar idles.
-
----
-
-## Appendix — file references
-
-- Animator controller: `Assets/_UserContent/Avatars/! E L I Z A/Leona/Controllers/Quest/LeonaDynamics.controller`
-- Animator component (culling mode): `.../Controllers/Quest/LeonaDynamics.prefab` (`m_CullingMode: 0`) and the avatar scene `! LEONA - OPEN ME.unity`
-- Remote lifecycle (humanoid animator disabled, bones job-driven): `Packages/com.basis.framework/Drivers/Remote/BasisRemoteAvatarDriver.cs` (~109–112, ~229)
-- Existing whitelisted SDK StateMachineBehaviour pattern: `Packages/com.basis.sdk/Scripts/BasisParameterDriver.cs`
-- Cilbox interpreter per-frame hook: `Packages/com.cnlohr.cilbox/CilboxProxy.cs` (`Update`/`FixedUpdate` → `box.InterpretIID`)