@voqalize/avatar 0.4.1 → 0.4.3

package/dist/supports.d.ts

@@ -1,13 +1,12 @@
 /**
- * `supports` for every avatar this package ships — the SVG faces and the six
- * canvas identities alike.
+ * `supports` for every avatar this package ships.
  *
- * It is one constant and one file because they are one renderer: the canvas
- * avatars mount the same mixer with the same clip library, so a second list
- * would be the same list with a second chance to be wrong. It is not in
+ * It is one constant and one file because they are one renderer: every avatar
+ * mounts the same mixer with the same clip library, so a second list would be
+ * the same list with a second chance to be wrong. It is not in
  * `createAvatar.ts`, where the type is documented, because a value is imported
- * for real — reading it from there would pull `peep`'s drawing into a canvas
- * avatar's bundle.
+ * for real — reading it from there would pull `peep`'s drawing into every
+ * consumer's bundle.
  *
  * The two required ids first, then this renderer's own catalogue. `ACTION_IDS`
  * already carries `RESPONSE_INTERRUPTED` as this renderer's shape for it, so

package/dist/supports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supports.d.ts","sourceRoot":"","sources":["../client/supports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,eAAO,MAAM,QAAQ,EAAE,aAKrB,CAAC"}
+{"version":3,"file":"supports.d.ts","sourceRoot":"","sources":["../client/supports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,eAAO,MAAM,QAAQ,EAAE,aAKrB,CAAC"}

package/dist/supports.js

@@ -1,13 +1,12 @@
 /**
- * `supports` for every avatar this package ships — the SVG faces and the six
- * canvas identities alike.
+ * `supports` for every avatar this package ships.
  *
- * It is one constant and one file because they are one renderer: the canvas
- * avatars mount the same mixer with the same clip library, so a second list
- * would be the same list with a second chance to be wrong. It is not in
+ * It is one constant and one file because they are one renderer: every avatar
+ * mounts the same mixer with the same clip library, so a second list would be
+ * the same list with a second chance to be wrong. It is not in
  * `createAvatar.ts`, where the type is documented, because a value is imported
- * for real — reading it from there would pull `peep`'s drawing into a canvas
- * avatar's bundle.
+ * for real — reading it from there would pull `peep`'s drawing into every
+ * consumer's bundle.
  *
  * The two required ids first, then this renderer's own catalogue. `ACTION_IDS`
  * already carries `RESPONSE_INTERRUPTED` as this renderer's shape for it, so

package/dist/supports.js.map

@@ -1 +1 @@
-{"version":3,"file":"supports.js","sourceRoot":"","sources":["../client/supports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,CAAC,MAAM,QAAQ,GAAkB,MAAM,CAAC,MAAM,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC;QACrB,GAAG,eAAe;QAClB,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,eAAqC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;KACnF,CAAC;CACH,CAAC,CAAC"}
+{"version":3,"file":"supports.js","sourceRoot":"","sources":["../client/supports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,CAAC,MAAM,QAAQ,GAAkB,MAAM,CAAC,MAAM,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC;QACrB,GAAG,eAAe;QAClB,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,eAAqC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;KACnF,CAAC;CACH,CAAC,CAAC"}

package/dist/three/assets.d.ts

@@ -2,6 +2,8 @@ export declare const ASSETS: Readonly<{
     tara: string;
     tushar: string;
     tanya: string;
+    tess: string;
+    tanvi: string;
 }>;
 /** Every compiled character, in build order. */
 export type CharacterName = keyof typeof ASSETS;

package/dist/three/assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../client/three/assets.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,MAAM;;;;EAIjB,CAAC;AAEH,gDAAgD;AAChD,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,MAAM,CAAC"}
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../client/three/assets.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,MAAM;;;;;;EAMjB,CAAC;AAEH,gDAAgD;AAChD,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,MAAM,CAAC"}

package/dist/three/assets.js

@@ -1,19 +1,23 @@
 /**
- * The three compiled characters as one table — for a page that enumerates them.
+ * Every compiled character as one table — for a page that enumerates them.
  *
  * Each URL lives in its own module (`tara-asset.ts` and its siblings) and this
  * file only gathers them, because a bundler emits assets per module: anything
- * importing *this* ships all three GLBs, which is right for a rig instrument
- * that switches between characters and wrong for a consumer who mounted one.
+ * importing *this* ships every GLB, which is right for a rig instrument that
+ * switches between characters and wrong for a consumer who mounted one.
  * So the character modules never import this — they import their own — and the
  * only reader is `/internal/three`, a separate entry point that ships nothing.
  */
 import { TANYA_GLB } from "./tanya-asset.js";
+import { TANVI_GLB } from "./tanvi-asset.js";
+import { TESS_GLB } from "./tess-asset.js";
 import { TARA_GLB } from "./tara-asset.js";
 import { TUSHAR_GLB } from "./tushar-asset.js";
 export const ASSETS = Object.freeze({
     tara: TARA_GLB,
     tushar: TUSHAR_GLB,
     tanya: TANYA_GLB,
+    tess: TESS_GLB,
+    tanvi: TANVI_GLB,
 });
 //# sourceMappingURL=assets.js.map

package/dist/three/assets.js.map

@@ -1 +1 @@
-{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../client/three/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClC,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,SAAS;CACjB,CAAC,CAAC"}
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../client/three/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClC,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,SAAS;IAChB,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,SAAS;CACjB,CAAC,CAAC"}

package/dist/three/budgets.d.ts

@@ -12,6 +12,6 @@ export declare const HARD_BUDGET: Readonly<{
     triangles: 60000;
     drawCalls: 30;
     bones: 40;
-    morphTargets: 40;
+    morphTargets: 45;
 }>;
 //# sourceMappingURL=budgets.d.ts.map

package/dist/three/budgets.js

@@ -16,6 +16,6 @@ export const HARD_BUDGET = Object.freeze({
     triangles: 60_000,
     drawCalls: 30,
     bones: 40,
-    morphTargets: 40,
+    morphTargets: 45,
 });
 //# sourceMappingURL=budgets.js.map

package/dist/three/character-rig.d.ts

@@ -0,0 +1,366 @@
+/**
+ * The Blender characters' renderer: the `AvatarRig` contract (`apply(frame)` /
+ * `destroy()`) over a Blender-authored GLB. One of these drives every compiled
+ * character, and `createCharacter.ts` is what hands it one.
+ *
+ * The whole file is one idea — **the pose channel is the interface, and every
+ * mapping here is a translation of one channel into the one control that
+ * renders it.** `scripts/morphs.py` authored the shape keys under the library's
+ * own channel names precisely so this file never has to interpret a viseme, a
+ * state or an emotion; it receives a fully mixed pose and moves geometry.
+ */
+import type { AvatarRig } from "../internal.js";
+import * as THREE from "three";
+/**
+ * Head motion, in degrees at the channel's own clamp, so the envelope is
+ * unreachable by construction rather than by a second clamp nobody runs.
+ *
+ * Yaw is the tight axis: the albedo is a front-orthographic projection of a
+ * shallow shell, and a large turn is where that reads as a cardboard cutout
+ * rather than a head. A ladder rendered at 9/12/15/18/21/25/30 and read at crop
+ * is clean to 21° on tara and to 18° on the tightest of the others, so 15°
+ * keeps headroom; pitch and roll opened once `NECK_QUAD` made the neck's follow
+ * exact. How far a pose may be *held* is a stricter question, measured per
+ * character (`motion-limits.json`, applied through `holds.ts`).
+ *
+ * The yaw twist's two fields are an expansion in the angle, so their error
+ * grows as θ²/6 — 0.85 % at 15°, on a displacement that is itself a fraction of
+ * the neck's radius (`morphs.neck_twist`).
+ *
+ * TARA-SPECIFIC: reach before an artefact; see 3d-avatar-tara-specific.md.
+ */
+export declare const HEAD_CLAMP = 1.4;
+export declare const HEAD_DEG: {
+    yaw: number;
+    pitch: number;
+    roll: number;
+};
+/**
+ * Where the head turns about. v 0.36 is the jaw angle and the earlobe, and it
+ * sits a fifth of a face height *behind* the face plane — a pivot on the
+ * surface spins the face in place, where a real yaw swings the chin across as
+ * well as around, which is most of what makes a small turn read.
+ *
+ * The asset carries this (`stamp_abi`, as `head_pivot`); this is the fallback
+ * for a GLB built before the stamp.
+ */
+export declare const PIVOT: THREE.Vector3;
+/**
+ * Where the head *tilts* about, from `morphs.ROLL_PIVOT`: the midline just
+ * above the chin. A roll is a bend of the whole neck, so its centre is far
+ * below the ear, and a drawn head sells it by holding the chin and swinging
+ * the crown — Live2D's sample rigs tilt about this same point. About PIVOT
+ * instead, the chin swung 7 px the other way at 8° and the head read as a
+ * pendulum hung from the ears.
+ *
+ * It sits inside the yaw and pitch, so a turned head still tilts about its own
+ * chin. The asset carries it (`stamp_abi`, as `roll_pivot`); this is the
+ * fallback for a GLB built before the stamp, and `morphs.ROLL_PIVOT` has what
+ * sets the height.
+ */
+export declare const ROLL_PIVOT: THREE.Vector3;
+/**
+ * What the head takes with it, from `build_character.HEAD_PARTS`. `Body` stays
+ * behind, and so does `Neck` — but the neck is not *static*: it follows the
+ * skull through morph targets of its own (`NECK_QUAD` below).
+ *
+ * Without that follow a turn dragged the skull's jaw rim across a throat that
+ * had not moved, and the rim landed mid-neck as a second jawline — invisible at
+ * the 400 × 300 tile, obvious at a 3× crop.
+ *
+ * The asset carries its own list (`stamp_abi`, as `head_parts`); this is the
+ * fallback for a GLB built before the stamp.
+ */
+export declare const HEAD_PARTS: string[];
+/** Degrees per pose unit: the globe turns `pupil * GAZE_TRAVEL / GLOBE_RADIUS`
+ *  radians, and the head reaches `HEAD_DEG` at the clamp.
+ *
+ *  Exported through `internal.ts` for the same reason as the head envelope. */
+export declare const EYE_DEG: {
+    x: number;
+    y: number;
+};
+/**
+ * The mixer's per-rig calibration, passed by the character's entry point and by
+ * the motion audit so both measure the same face. A pose unit is an angle here
+ * and a pixel count on an SVG face, so the speech layer's amplitudes are tuned
+ * per rig rather than in the library.
+ *
+ * The shared look table is drawn for a line face, whose pupils cross most of an
+ * eye, so it put every look in the eyes: a thinking look away was the iris
+ * parked in the corner of the socket for two thirds of the state, which is
+ * side-eye, not thought. Here the head carries about 60 % of a look and the
+ * eyes land a third of the way off centre, where a real eye-head shift leaves
+ * them (Freedman & Sparks; Pejsa & Andrist). The comment on each target is its
+ * world angle, x right and y down.
+ *
+ *   vor        Real gain in the light is close to 1. A little under leaves the
+ *              head some say, so a nod carries the eyes a touch with it rather
+ *              than pinning them to the lens. Vertically it is well under:
+ *              her pitch is a shell tipping on a photograph and
+ *              reads as a fraction of what it is, so the eyes' full answer to
+ *              it read as the eyes moving on their own — at 0.8, THINKING's
+ *              up-look rolled the iris to the lid with white beneath it, and
+ *              the reply that followed dropped it into a downcast look with the
+ *              lid riding down, while the head was still coming back. At 0.35
+ *              the eyes mostly go where the head takes them.
+ *   range      How far the reflex may carry the eye in the socket. Unlimited,
+ *              an up-look's onset put the whole 8° in the eye before the neck
+ *              moved — the iris pinned under the lid, white beneath it, which
+ *              on this photograph reads as an eye-roll. Up 0.45 is 2.8° and
+ *              down 0.5 is 3.1°; the head covers the rest, as it does once the
+ *              eye nears its effective range. Both were looser (0.55, 0.85)
+ *              and a gap between turns hit both ends of them every time.
+ *   lidFollow  Down 0.38 keeps the upper lid on the iris: the lid travels
+ *              0.068 face units per lid unit and the iris 0.026 per pupil unit.
+ *              Up a little less, so an upward look opens the eye a hair instead
+ *              of dragging the lid along with it.
+ *   avert      A conversational look away keeps under half its size in the
+ *              eyes and gives the neck 0.6 of it — on this face the eyes alone
+ *              could only make it a glance sideways.
+ *   head       The follow's launch and cruise, in head units. A real head
+ *              reaches a 7-8° shift in about 0.4 s, its speed scaling with the
+ *              size of the shift; the shared amble took a thinking look 1.2 s,
+ *              and the reflex, doing its job, held the eyes in the corner of
+ *              the socket the whole way.
+ *
+ * `trunkFollow` is 0.3, under the line faces' 0.45. Live2D's face-tracking
+ * sample gives the body a third of the head's yaw (BodyAngleX 10 against
+ * AngleX 30; docs/research-head-rotation.md § 5 item 6), and that is the
+ * benchmark to sit at, not above. Here it matters for a reason a line face
+ * does not have: the neck's outline holds under a twist by construction
+ * (`morphs.neck_twist`), so the trunk's sway is what is left moving it — a
+ * quarter to a third of it at the yaw peak in the recorded call, read as the
+ * neck sliding.
+ */
+export declare const CHARACTER_TUNING: {
+    readonly prosodyHeadGain: 1;
+    readonly prosodyFaceGain: 1;
+    readonly saccadeGain: 2.4;
+    readonly aversionGain: 1.8;
+    readonly trunkFollow: 0.3;
+    readonly brows: {
+        readonly range: readonly [-0.28, 0.24];
+        readonly floor: 0.11;
+        readonly forms: readonly [{
+            readonly p: 0.38;
+            readonly inner: 0;
+            readonly angle: 0;
+        }, {
+            readonly p: 0.34;
+            readonly inner: 0.26;
+            readonly angle: 0;
+        }, {
+            readonly p: 0.28;
+            readonly inner: 0;
+            readonly angle: 0.3;
+        }];
+    };
+    readonly states: {
+        readonly WORKING: {
+            readonly pose: {
+                readonly headPitch: 0.04;
+                readonly lidL: -0.08;
+                readonly lidR: -0.08;
+                readonly shoulderL: 0.06;
+                readonly shoulderR: 0.06;
+            };
+        };
+        readonly CANT_HEAR: {
+            readonly pose: {
+                readonly torsoLean: 0.22;
+                readonly headPitch: 0.1;
+                readonly browRaiseL: -0.14;
+                readonly browRaiseR: -0.14;
+                readonly browInnerL: 0.22;
+                readonly browInnerR: 0.18;
+                readonly mouthPress: 0.4;
+                readonly mouthCornerL: -0.1;
+                readonly mouthCornerR: -0.1;
+            };
+        };
+        readonly SEARCHING_SCREEN: {
+            readonly pose: {
+                readonly mouthPress: 0.4;
+                readonly mouthCornerL: -0.08;
+                readonly mouthCornerR: -0.08;
+                readonly browRaiseL: -0.1;
+                readonly browRaiseR: -0.06;
+            };
+        };
+    };
+    readonly oculomotor: {
+        readonly angles: {
+            readonly eye: {
+                x: number;
+                y: number;
+            };
+            readonly head: {
+                x: number;
+                y: number;
+            };
+        };
+        readonly vor: {
+            readonly x: 0.8;
+            readonly y: 0.35;
+        };
+        readonly range: {
+            readonly x: 0.8;
+            readonly up: 0.45;
+            readonly down: 0.5;
+        };
+        readonly lidFollow: {
+            readonly down: 0.38;
+            readonly up: 0.3;
+        };
+        readonly avert: {
+            readonly eye: 0.45;
+            readonly head: 0.6;
+        };
+        readonly head: {
+            readonly accel: 16;
+            readonly speed: 3.5;
+        };
+        readonly targets: {
+            readonly OWN_SCREEN: {
+                readonly px: 0.14;
+                readonly py: 0.24;
+                readonly hx: 0.1;
+                readonly hy: 0.06;
+            };
+            readonly USER_EAR: {
+                readonly px: -0.2;
+                readonly py: 0.05;
+                readonly hx: 0.4;
+                readonly hy: 0.02;
+                readonly roll: 0.55;
+            };
+            readonly SCREEN_CENTER: {
+                readonly px: 0;
+                readonly py: -0.06;
+                readonly hx: 0;
+                readonly hy: -0.14;
+            };
+            readonly SCREEN_LEFT: {
+                readonly px: -0.42;
+                readonly py: -0.1;
+                readonly hx: -0.8;
+                readonly hy: -0.05;
+            };
+            readonly SCREEN_RIGHT: {
+                readonly px: 0.42;
+                readonly py: -0.1;
+                readonly hx: 0.8;
+                readonly hy: -0.05;
+            };
+            readonly SCREEN_TOP: {
+                readonly px: 0;
+                readonly py: -0.26;
+                readonly hx: 0;
+                readonly hy: -0.28;
+            };
+            readonly SCREEN_WORK: {
+                readonly px: -0.35;
+                readonly py: 0.18;
+                readonly hx: -0.55;
+                readonly hy: 0.12;
+            };
+            readonly AWAY_THINKING: {
+                readonly px: -0.3;
+                readonly py: -0.4;
+                readonly hx: -0.75;
+                readonly hy: -0.33;
+                readonly roll: 0.08;
+            };
+            readonly AWAY_RIGHT: {
+                readonly px: 0.3;
+                readonly py: -0.36;
+                readonly hx: 0.72;
+                readonly hy: -0.3;
+                readonly roll: -0.06;
+            };
+            readonly AWAY_DOWN: {
+                readonly px: -0.28;
+                readonly py: 0.45;
+                readonly hx: -0.62;
+                readonly hy: 0.16;
+                readonly roll: 0.04;
+            };
+            readonly AWAY_SIDE: {
+                readonly px: 0.32;
+                readonly py: 0.08;
+                readonly hx: 0.72;
+                readonly hy: 0.02;
+                readonly roll: -0.03;
+            };
+        };
+    };
+};
+export interface CharacterRigOptions {
+    /** Called once the GLB is in the scene, for a capture tool that must wait. */
+    readonly onReady?: () => void;
+    /** The character's GLB. Every build fact the rig reads (jaw-shadow tile, rim
+     *  depth, morph names) travels in the GLB's own extras, so a character built
+     *  by the same scripts needs nothing else.
+     *
+     *  Required, and deliberately not defaulted: a default would make this module
+     *  import one character's URL, and a bundler emits assets per module — so
+     *  every consumer of *any* character would ship that one's GLB whether or not
+     *  they mounted it. The caller knows which character it is building; this
+     *  file must not ([tara-asset.ts](./tara-asset.ts)). */
+    readonly url: string;
+    /** `false` leaves an asset's expression maps unread, for a capture tool
+     *  comparing the face with and without them. */
+    readonly expression?: boolean;
+    /** Keeps the drawing buffer readable after the browser has composited it, so
+     *  a caller can copy the canvas out at any moment rather than only from
+     *  inside the frame that drew it.
+     *
+     *  A pose sheet reuses one context, holding a pose still and copying the
+     *  canvas into a tile; copy outside the drawing frame without this and the
+     *  buffer has already been cleared, which is a blank tile and not an error.
+     *  A consumer must not have it: the buffer can no longer be discarded, which
+     *  on some drivers means a second copy of every frame. */
+    readonly readback?: boolean;
+}
+/**
+ * The hair's roll, which is the one thing in this rig that is not a function of
+ * the pose alone. `hold` is the share of the head's roll the hanging hair
+ * declines to take, and `hz`/`damping` are how it gets there.
+ *
+ * A hank that hangs past the jaw is lying on a shoulder, and a shoulder does
+ * not tilt when the head does: rolled rigidly with the skull it lifts off the
+ * collar and the page shows through behind it, so the shell gives up `hold` of
+ * the roll at its lowest rows and none at the crown (`morphs.hair_hold`).
+ *
+ * The other half is why roll read as a hinge at all. A rigid rotation about a
+ * fixed point *is* a hinge, and what a real tilt has that this lacked is hair
+ * that arrives late and settles (`docs/research-head-rotation.md` § 3.1:
+ * mobility ~0.95, delay 0.8-0.9, one clear overshoot). At 0.65 that is a single
+ * visible overshoot, inside 5% of the hold in 450 ms — faster reads as a flick,
+ * slower as wet hair.
+ *
+ * It is on the hair and not on `headRoll` on purpose: every clip in the library
+ * is authored pre-compensated for the mixer's per-channel time constants, so a
+ * spring on the channel would silently re-time every nod ever authored.
+ */
+export declare const HAIR_ROLL: {
+    hold: number;
+    hz: number;
+    damping: number;
+};
+/**
+ * One step of `HAIR_ROLL`'s spring: semi-implicit, the rate taking the frame's
+ * acceleration before the angle takes the rate. Explicit Euler rings at this
+ * stiffness and 30 fps; this does not, which is the only reason the order of
+ * those two lines is worth a sentence.
+ *
+ * Exported for `test/nods.test.ts`: settle time and overshoot are numbers, not
+ * something a still frame can show.
+ */
+export declare const hairRollStep: (angle: number, rate: number, target: number, dt: number) => {
+    angle: number;
+    rate: number;
+};
+export declare function createCharacterRig(mount: HTMLElement, options?: unknown): AvatarRig;
+//# sourceMappingURL=character-rig.d.ts.map

package/dist/three/character-rig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-rig.d.ts","sourceRoot":"","sources":["../../client/three/character-rig.ts"],"names":[],"mappings":"AACA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAe,SAAS,EAAW,MAAM,gBAAgB,CAAC;AACtE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAiB/B;;;;;;;;;;;;;;;;;GAiBG;AAKH,eAAO,MAAM,UAAU,MAAM,CAAC;AAC9B,eAAO,MAAM,QAAQ;;;;CAAkC,CAAC;AAExD;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,eAAsC,CAAC;AAEzD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,eAAsC,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,UAC+B,CAAC;AAqFvD;;;+EAG+E;AAC/E,eAAO,MAAM,OAAO;;;CAA2G,CAAC;AAGhI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HnB,CAAC;AAymBX,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B;;;;;;;;4DAQwD;IACxD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;oDACgD;IAChD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;8DAQ0D;IAC1D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AA4HD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;;;;CAAyC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,MAAM,MAAM,EAAE,QAAQ,MAAM,EAAE,IAAI,MAAM;;;CAInF,CAAC;AA0CF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAmfnF"}