parseRig(rig: ?) → void

Normalize a `.rig` (table or JSON string) into the enriched form the math below reads: bones, name->index, role->bone, bone->role, FK globals, lengths. Idempotent: an already-parsed rig is returned unchanged.

vdot(a: ?, b: ?) → void

fkOrder(bones: ?) → void

Parent-before-child traversal order over a bone array (0-based parents).

symmetrizeBind(R: ?) → void

Absolute bind correction: force a perfectly symmetric canonical bind by mirroring each left/right bone's world position across x = 0 and rebuilding the local offsets from the symmetric positions. Orientation is already canonical (the caller ran the relative pass first), so only offsets change — this overrides the rig's authored left/right asymmetry and proportions, which is the whole point of absolute mode. `R` is a parsed, already-normalized rig.

computeBodyFrame(R: ?) → void

The rigid world rotation that aligns a rig's FACING to canonical: the horizontal hip-to-hip side onto +X, so the body faces +Z. Mesh-aware up: a humanoid mesh is modeled upright in model space, so +Y IS the body's up — a rig's bind SKELETON can sit at a tilt WITHIN that upright mesh (hips→neck leaning forward, say), and verticalizing to the skeleton's spine would rotate the upright mesh off vertical. So +Y up is left untouched and only the facing is aligned, a pure rotation about +Y that never tips the mesh. Read from joint POSITIONS, so it captures a baked facing an importer left in the bind regardless of bone rotations. `normalizeToTPose` applies it before aiming the limbs; the body's verticality stays as authored.

rolePos(roleName: ?) → void

computeUpAlign(R: ?) → void

Just the up-alignment of a rig's body frame: the rotation that stands the bind upright (hips→neck onto +Y), WITHOUT the yaw that would re-aim its facing. The retarget bake applies this to the source pose so a bind authored with a forward lean doesn't tilt the target, while leaving the source's heading intact — the character's world facing is the controller's job, and it drives source and target through the same convention, so re-aiming the clip's yaw would fight it (the character would face away from its travel — moonwalk).

rolePos(roleName: ?) → void

normalizeToTPose(rig: ?, opts: ?) →

Re-pose a rig's bind to the EXACT canonical T-pose, so a clip's source rig and the avatar it drives share one reference pose. Retarget transfers RELATIVE motion, so any residual bind mismatch (hands rolled the wrong way, feet pointing askew, an A-pose vs a T-pose) shows up as broken hands/feet in the result. Each bone is posed to a canonical world frame for its role — direction AND roll: arms horizontal palms-down, legs straight down, spine up. Only the limb bones whose bind direction differs between an A-pose and a T-pose are aimed; limb ENDPOINTS (hands, feet, toes) and bones with no role keep their authored orientation relative to the re-posed parent (their pose is mesh-defined, so aiming them twists the hand / tips the foot). The whole body is also rigidly de-rotated into an upright, forward-facing frame (handling a baked root rotation) and centered on its sagittal plane. Bind correction is RELATIVE by default — bone offsets/lengths/inverse-bind are untouched, so the rig keeps its own proportions and any authored left/right asymmetry. Pass `opts.symmetrize = true` for ABSOLUTE correction: left/right bones are mirrored across the sagittal plane for a perfectly symmetric bind, overriding the rig's authored asymmetry/proportions. correction (force symmetry); default/false = relative (preserve proportions).

qnlerp(a: ?, b: ?, s: ?) → void

Linear-blend two quaternions along the shortest arc, normalized.

sampleRotAt(ch: ?, t: ?) → void

The value quaternion of a Rotation channel at time `t`, interpolated by the channel's own mode (Step holds; Linear / CubicSpline blend the value samples — the CubicSpline tangents are skipped, so the value is exact at keyframes and a stable nlerp between them, which is all the cold rebake needs).

bindLocalRot(R: ?, i: ?) → void

A bone's local bind rotation (relative to its parent), from the parsed rig's FK globals.

validateScale(out: ?) → void

Scale is rig-independent; keep it, replacing non-finite / non-positive with 1.

copyArray(a: ?) → void

plan(srcRig: ?, tgtRig: ?) →

Report how a source rig's clips map onto a target rig: which canonical roles both rigs fill (`mapped`), which the source has but the target lacks (`unmappedSource` — those channels are dropped), and which the target has spare (`unmappedTarget`). Use it to see why a retarget is partial and which bone to hand-map in a rig's profile.

bake(clip: ?, srcRig: ?, tgtRig: ?, opts: ?) →

Retarget a decoded clip from its source rig onto a target rig, producing a clip in the TARGET's bone space (channels named for target bones). Per frame it forward-kinematics the source pose on the rig AS AUTHORED (the bind the clip's channel rotations are local to), measures each mapped role's world rotation as a deviation from the source's CANONICAL bind, re-applies that deviation to the target's CANONICAL bind, and converts back to a target-local rotation through the target's ANIMATED parent. The target chain is rebuilt top-down, so error never accumulates down a limb. Both rigs are re-posed to the geometry-derived canonical T-pose (`normalizeToTPose`) for that deviation, so the result depends only on the T-pose the two rigs share — never on whatever arbitrary pose either was authored in (an A-pose source idle lands the target's arms down, not splayed out at the A-pose offset). The apply path seeds that same canonical rest. Translation routes through the role and is size-scaled by the hip-height ratio; the apply path makes it relative to the target's bind. This is the cold step — bake once per (clip, target rig) and cache (see `bakeBytes`). (e.g. `json.decode(skeleton.clipDecode(bytes))`).

addBone(name: ?) → void

yExtent(rig: ?) → void

loadRig(ref: ?) →

Resolve a `.rig` asset and return its parsed, FK-enriched rig (ready for `plan` / `bake`). The rig payload is the asset's `rig.json`.

bakeBytes(clipBytes: ?, srcRig: ?, tgtRig: ?, cacheKey: ?, opts: ?) →

Bake from clip BYTES to retargeted clip BYTES — `clipDecode` -> `bake` -> `clipEncode` — with an in-memory cache. Retarget is cold: pass a stable `cacheKey` (e.g. clip identity + target rig identity) and the second call for the same pair returns the cached bytes. The hot path then just samples the result like any native clip. (absolute vs relative bind correction). Each mode caches separately.

bakeKey(cacheKey: string, opts: ?) → string

The key a bake is stored under, so a caller that derives something FROM a bake can hold it under the same key and have it dropped at the same time. Each correction mode bakes separately, which is what the suffix carries.

aux(bakeKey: string) →

Read what was cached beside the bake at `bakeKey`.

setAux(bakeKey: string, value: ?) → void

Cache a value beside the bake at `bakeKey`. It is dropped whenever that bake is, so it cannot outlive the bytes it was derived from.

clearCache(cacheKey: string?) → void

Drop every cached bake and everything derived from it (or just `cacheKey` when given). Call after editing a rig's profile so clips re-bake against the corrected mapping. the key passed to `bakeBytes` or an already-composed `bakeKey()`.