@adatechnology/game-characters-three 0.7.2 → 0.8.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
+import { T as Three, R as RichRig, B as BloodLook, F as FluidsBridge, C as CharacterSound, A as AvatarItemUsePose, a as AvatarViewMode, b as ReachView, P as PlayerAvatar } from './testing-DyQw8dCw.js';
+export { c as AVATAR_AREA_ID, d as AreaContext, e as AvatarEvent, f as AvatarTestOptions, g as AvatarUpdate, h as BODY_MATERIAL_DEF, i as BODY_SOUNDS, j as BloodAge, k as BloodLookOptions, l as BloodSink, m as BodySoundRule, n as CHARACTERS_AREA_ID, o as CharacterSoundOptions, p as CharacterSoundSink, q as CharacterSoundStyle, r as CharactersTestOptions, s as FilmSink, t as FluidsBridgeOptions, H as HIT_PRESETS, u as HitPreset, v as PERSON_ITEM_PREFIX, w as PLAYER_SOUNDS, x as PlayPoseOptions, y as PlayerAvatarColors, z as PlayerAvatarOptions, D as PlayerAvatarSpec, E as PoseTargets, G as ProfessionCard, I as RigAnimator, J as RigAnimatorOptions, U as UNDEAD_VOICES, K as UNDEAD_VOICE_SOURCES, L as UndeadCard, M as UndeadLike, N as UndeadVoice, V as VoiceMoment, O as VoiceStep, W as WoundSpray, Z as ZOMBIE_ITEM_PREFIX, Q as bloodLookOfAge, S as createAvatarTestModule, X as createCharacterSound, Y as createCharactersTestModule, _ as createFluidsBridge, $ as createPlayerAvatar, a0 as createRigAnimator, a1 as personSpecOf, a2 as registerBodyMaterial } from './testing-DyQw8dCw.js';
+import { BodySpec, SegmentId, PoseClip, PoseClipEvent, FirstPersonClip } from '@adatechnology/game-characters';
 import * as THREE_NS from 'three';
-import { BodySpec, CascadeJoint, RestPose as RestPose$1, StrideParams, GaitSample, lerpPose, GaitProfile, SegmentId, CharacterKit, CharacterPack, CharacterSpec, DamageCharacter, BodyHit, PoseClipEvent, PoseClip, PoseClipRegistry, FirstPersonClip } from '@adatechnology/game-characters';
-import { Vec3 as Vec3$1, DestructionEvent, SoundRequest, TestableModule, HandTargets } from '@adatechnology/game-contracts';
+import { LightBudget, SourceHandle } from '@adatechnology/game-render-three';
+import { DestructionEvent, HandTargets } from '@adatechnology/game-contracts';
 import { SoundRecipe, SoundBank } from '@adatechnology/game-audio';
 
-/** The three.js namespace the host passes in: the package never imports three itself, so one script tag works. */
-type Three = typeof THREE_NS;
-
 /**
  * The vertex-shader chunk of the instanced body, carried byte for byte from the game (G 65400 `bodyChunk`): the pose math of the 12 bones on the GPU.
  * Per-instance attributes: iA = (x, z, yaw, phase) · iB = (height, build, stride, pose + 16 × ground height in mm) · iC = (missing-parts mask, infection 0..1,
@@ -20,22 +20,22 @@ type BodyChunkOptions = {
 /** The chunk with the hip joint set (the only joint the shader holds as a constant); without options it is `BODY_CHUNK` itself. */
 declare const createBodyChunk: ({ hipHeight }?: BodyChunkOptions) => string;
 
-type Vec3 = readonly [number, number, number];
+type Vec3$1 = readonly [number, number, number];
 /**
  * The joints the instanced body hangs from, by the game's names. `E` is the side with the negative x (bones 2, 4, 7 and 9), `D` the positive one
  * (bones 3, 5, 8 and 10); the shader's `side` depends on it, so the sides are told apart by the sign of x, whatever a spec calls them.
  */
 type BodyJoints = {
-    readonly hip: Vec3;
-    readonly neck: Vec3;
-    readonly shoulderE: Vec3;
-    readonly shoulderD: Vec3;
-    readonly elbowE: Vec3;
-    readonly elbowD: Vec3;
-    readonly thighE: Vec3;
-    readonly thighD: Vec3;
-    readonly kneeE: Vec3;
-    readonly kneeD: Vec3;
+    readonly hip: Vec3$1;
+    readonly neck: Vec3$1;
+    readonly shoulderE: Vec3$1;
+    readonly shoulderD: Vec3$1;
+    readonly elbowE: Vec3$1;
+    readonly elbowD: Vec3$1;
+    readonly thighE: Vec3$1;
+    readonly thighD: Vec3$1;
+    readonly kneeE: Vec3$1;
+    readonly kneeD: Vec3$1;
 };
 declare const jointsOf: (body: BodySpec) => BodyJoints;
 type Geometry = THREE_NS.BufferGeometry;
@@ -51,6 +51,64 @@ type BuildInstancedBodyParams = {
  */
 declare const buildInstancedBody: (host: Three, { segments, body }: BuildInstancedBodyParams) => Geometry;
 
+/** Bones of the instanced body (`body-geometry.ts`) and texels per bone in the clip texture: a rotation and a displacement. */
+declare const CLIP_BONES = 12;
+declare const CLIP_TEXELS: number;
+/** Rows sampled per second of a clip (the bake rate of the D12 ladder). */
+declare const CLIP_RATE = 30;
+/** Clips a texture may hold: the index is four bits of `iD.z`. */
+declare const CLIP_LIMIT = 16;
+type ClipLimp = 'left' | 'right' | 'drag';
+/** A looping clip of the instanced body's walk, as numbers of the shader's own walk (`bodyAnim`) plus the gait styles of the identity extension. */
+type SegmentClipSpec = {
+    readonly id: string;
+    /** Rows of the clip: its cycles at 30 Hz. */
+    readonly frames: number;
+    /** Walk cycles the clip spans (a lurch is two). */
+    readonly cycles?: number;
+    /** 0 arms hanging as the wandering zombie, 1 raised toward the prey (blended per instance by the arms). */
+    readonly armRaise: number;
+    readonly sway?: number;
+    readonly bendPulse?: number;
+    readonly limp?: ClipLimp;
+    readonly stagger?: boolean;
+};
+type SegmentClipSet = {
+    readonly specs: readonly SegmentClipSpec[];
+    /** First row of each clip. */
+    readonly start: readonly number[];
+    readonly frames: readonly number[];
+    readonly cycles: readonly number[];
+    readonly rows: number;
+    /** RGBA32F, `CLIP_TEXELS` wide: per bone a quaternion (x, y, z, w) and a displacement (x, y, z, 0). */
+    readonly data: Float32Array;
+};
+declare const SEGMENT_CLIPS: readonly SegmentClipSpec[];
+/** Samples the clips at 30 Hz into one table (the rows of every clip one after the other): pure, no GPU. */
+declare const bakeSegmentClips: (specs?: readonly SegmentClipSpec[]) => SegmentClipSet;
+/** What a body material needs of the clips: the texture and the three tables, as shared uniforms. */
+type SegmentClipUniforms = {
+    readonly uClips: {
+        value: THREE_NS.DataTexture;
+    };
+    readonly uClipStart: {
+        value: number[];
+    };
+    readonly uClipFrames: {
+        value: number[];
+    };
+    readonly uClipCycles: {
+        value: number[];
+    };
+};
+/**
+ * The clip texture (economy ladder, step 3): RGBA32F, `CLIP_TEXELS` (24) wide, one row per sampled step, `NearestFilter` with no mipmaps: float texels are not
+ * filterable everywhere and a blend would mix neighbouring bones. The shader blends two rows itself.
+ */
+declare const createSegmentClipUniforms: (three: Three, set?: SegmentClipSet) => SegmentClipUniforms;
+/** The index of a clip by id (the crowd picks its family by name). */
+declare const clipIndexOf: (set: SegmentClipSet, id: string) => number;
+
 type BodyMaterialParams = {
     /** The depth material for shadows (true) or the lit body (false). */
     readonly depth?: boolean;
@@ -59,12 +117,23 @@ type BodyMaterialParams = {
         value: number;
     };
     readonly chunk?: BodyChunkOptions;
+    /** The distance material the point-light shadow pass reads (`customDistanceMaterial`); the vertices move the same way. */
+    readonly distance?: boolean;
+    /**
+     * Adds the identity extension (T4b.7): the `iD` attribute drives the gait style, the stagger, the lean of a shove, the trousers palette and the wound splashes.
+     * Off, the shader text is the game's, and the program key is three's own.
+     */
+    readonly identity?: boolean;
+    /** The material of an accessory batch: baked once at a reference pivot, moved and scaled per variant by `iAcc` (`vec4`: offset xyz, scale w). Implies `identity`. */
+    readonly accessory?: boolean;
+    /** The clip texture (`createSegmentClipUniforms`), shared by every material that reads it: a body flagged `clips` in its `iD` walks from the clips (T4b.7, step 3). */
+    readonly segmentClips?: SegmentClipUniforms;
 };
 /**
  * The instanced body's material: the pose chunk in the vertex shader and the per-instance tints (skin by tone and infection, shirt, pants, hair,
  * glowing eyes) in the fragment shader (G 65473 `bodyMaterial`).
  */
-declare const createBodyMaterial: (three: Three, { depth, time, chunk }: BodyMaterialParams) => THREE_NS.Material;
+declare const createBodyMaterial: (three: Three, { depth, distance, time, chunk, identity, accessory, segmentClips }: BodyMaterialParams) => THREE_NS.Material;
 
 type BodyBatchOptions = {
     /** Instances the batch can hold. */
@@ -73,6 +142,14 @@ type BodyBatchOptions = {
     readonly time: {
         value: number;
     };
+    /** Adds the `iD` identity attribute and the extension of the shader (T4b.7); off, the batch is the game's. */
+    readonly identity?: boolean;
+    /** A batch of an accessory (baked once, moved per variant by `iAcc`): implies `identity`. */
+    readonly accessory?: boolean;
+    /** Walk bodies from the clip texture (`createSegmentClipUniforms`): needs `identity` and a look with `clips`. */
+    readonly segmentClips?: SegmentClipUniforms;
+    /** Also makes a depth-only mesh over the same geometry, drawn first (`batch.prepass`), so the lit pass shades the nearest body of each pixel only (the room's lights make a fragment dear). */
+    readonly depthPrepass?: boolean;
 };
 /** One instance: the 12 numbers of the shader's `iA`, `iB` and `iC`, the shirt colour and the eye colour (G 65509 `push`). */
 type BodyInstance = {
@@ -91,9 +168,19 @@ type BodyInstance = {
     };
     /** Ground height (a pile of bodies, a jump); packed into `b[3]` next to the pose. */
     readonly y?: number;
+    /** The `iD` identity (with `identity`), see `packIdentity`. */
+    readonly d?: readonly [number, number, number, number];
+    /** The `iAcc` pivot offset and scale (with `accessory`). */
+    readonly acc?: readonly [number, number, number, number];
+};
+/** A plain `Mesh` over an `InstancedBufferGeometry` (no `instanceMatrix`: 4 vertex attribute slots less); `count` mirrors the geometry's `instanceCount`. */
+type BodyBatchMesh = THREE_NS.Mesh & {
+    count: number;
 };
 type BodyBatch = {
-    readonly mesh: THREE_NS.InstancedMesh;
+    readonly mesh: BodyBatchMesh;
+    /** The depth-only mesh drawn before `mesh` (with `depthPrepass`); add it to the scene next to `mesh`. */
+    readonly prepass?: THREE_NS.Mesh;
     readonly max: number;
     readonly count: number;
     begin(): void;
@@ -103,6 +190,86 @@ type BodyBatch = {
 /** A batch of bodies drawn in one call (zombies, survivors, corpses). `begin`, `push` per body each frame, then `end` (G 65509 `BodyBatch`). */
 declare const createBodyBatch: (three: Three, geometry: THREE_NS.BufferGeometry, options: BodyBatchOptions) => BodyBatch;
 
+/** How the body shader's `iD` (identity) and `iAcc` (accessory pivot) attributes are packed: whole numbers in floats, so every field survives the GPU. */
+declare const GAIT_STYLE: {
+    readonly NORMAL: 0;
+    readonly LIMP_LEFT: 1;
+    readonly LIMP_RIGHT: 2;
+    readonly DRAG: 3;
+    readonly LURCH: 4;
+    readonly SHAMBLE: 5;
+};
+type GaitStyle = (typeof GAIT_STYLE)[keyof typeof GAIT_STYLE];
+/** The accessory bits of `iD.y` bits 7 to 10: the batch of each accessory kind is fixed, a body carries any mix. */
+declare const ACCESSORY_BIT: {
+    readonly CAP: 1;
+    readonly HELMET: 2;
+    readonly BACKPACK: 4;
+    readonly EXTRA: 8;
+};
+/** Pose index of a body that is staggering (not in `INSTANCE_POSES`: the base chunk draws any unknown pose as the walk, the extension adds the stagger on top). */
+declare const STAGGER_POSE = 8;
+/** Trousers of the identity palette, 16 colours as hex (the shader and the impostor read the same table). */
+declare const TROUSER_PALETTE: readonly [2832981, 3821432, 1842208, 4868686, 7035452, 8022600, 4147764, 5913130, 2764600, 6120818, 6958890, 4864594, 9077872, 2372154, 3485738, 5660778];
+type IdentityLook = {
+    /** 2 bits per region (0 head, 1 torso, 2 left arm, 3 right arm, 4 left leg, 5 right leg): 0 none, 1 light, 2 severe. */
+    readonly wounds: number;
+    /** 0 old and dark to 15 fresh and bright. */
+    readonly freshness: number;
+    /** Index into `TROUSER_PALETTE`. */
+    readonly trousers: number;
+    readonly gaitStyle: number;
+    readonly accessories: number;
+    /** Clip indexes (4 bits each), the blend toward the second (0..1) and the clip speed step (0..15: 0.75 to 1.25). */
+    readonly clipA?: number;
+    readonly clipB?: number;
+    readonly clipBlend?: number;
+    readonly clipSpeed?: number;
+    /** Draw a walking body from the clip texture (needs the material's `segmentClips`); off, the shader's own walk. */
+    readonly clips?: boolean;
+    /** Lean toward a direction (radians) by an amount 0..1 (a shove, a thrown body's tumble). */
+    readonly leanAngle?: number;
+    readonly leanAmount?: number;
+};
+/** The bit of `iD.z` that turns the clip texture on for a body. */
+declare const CLIPS_BIT = 1048576;
+/** The four floats of `iD` for a look. */
+declare const packIdentity: (look: IdentityLook) => readonly [number, number, number, number];
+/** The look back from the four floats (tests and the impostor path). */
+declare const unpackIdentity: ([x, y, z, w]: readonly [number, number, number, number]) => Required<IdentityLook>;
+/** The speed factor of a clip speed step. */
+declare const clipSpeedOf: (step: number) => number;
+
+declare const createBodyChunkExt: ({ hipHeight, segmentClips }?: {
+    readonly hipHeight?: number;
+    readonly segmentClips?: boolean;
+}) => string;
+
+type AccessoryAttach = 'head' | 'torso';
+/** One accessory drawn by the kit's own survivor builder: a hat of `HATS` (`hat`) or a piece of gear of `EXTRAS` (`extra`), in one colour. */
+type KitAccessory = {
+    readonly id: string;
+    /** The bit of `iD.y` that says a body carries it (`ACCESSORY_BIT`). */
+    readonly bit: number;
+    readonly attach: AccessoryAttach;
+    readonly hat?: string;
+    readonly extra?: string;
+    readonly color: number;
+};
+/** The four accessory batches of the kit: a cap, a helmet, a backpack and a hood. */
+declare const KIT_ACCESSORIES: readonly KitAccessory[];
+/**
+ * The accessory geometry in a unit frame (the reference head or torso at the origin, one unit tall), tagged for the body shader: `bone`, `vcol` (own colour),
+ * `refPivot` and `ppivot`. A batch moves and scales it per variant with `iAcc` (`accessoryPlacement`): baked once, never per variant.
+ */
+declare const buildKitAccessory: (host: Three, accessory: KitAccessory) => THREE_NS.BufferGeometry;
+/**
+ * The `iAcc` of a baked body for an accessory: where the accessory goes (the centre of the head, or of the torso) and how big (its height), read from the variant's
+ * own geometry, so the same accessory sits right on every one of the 20 variants. The head is the bone-1 vertices without the eyes, the torso the bone-0 ones;
+ * a body without them gets a zero scale, so the accessory is not drawn instead of showing up unscaled at the feet.
+ */
+declare const accessoryPlacement: (body: THREE_NS.BufferGeometry, attach: AccessoryAttach) => readonly [number, number, number, number];
+
 /** Radial segments of the three instanced body geometries (G 65541 `BODY_LOD`): close, middle and far. */
 declare const LOD_SEGMENTS: readonly [16, 10, 5];
 /** Detail factors the rich builder bakes at for the same three levels (G ZVAR). */
@@ -188,10 +355,142 @@ declare const bakeVariants: (three: Three, builders: BakeBuilders, types: readon
     readonly variants: BodyVariant[];
     readonly byType: ReadonlyMap<string, readonly number[]>;
 };
+type VariantBatchesOptions = {
+    /** Identity on every batch (T4b.7). */
+    readonly identity?: boolean;
+    readonly segmentClips?: SegmentClipUniforms;
+    /** Which of the three levels cast a real shadow (default `LOD_CASTS_SHADOW`; `[true, false, false]` is the economy ladder's step 1). */
+    readonly castsShadow?: readonly [boolean, boolean, boolean];
+    /** Which of the three levels get a depth-only prepass (default none). */
+    readonly depthPrepass?: readonly [boolean, boolean, boolean];
+};
 /** The three batches of a variant (one per level of detail), sized for a horde. */
 declare const createVariantBatches: (three: Three, variant: BodyVariant, time: {
     value: number;
-}) => readonly BodyBatch[];
+}, options?: VariantBatchesOptions) => readonly BodyBatch[];
+
+/** Views around the body and steps of the walk the atlas holds for each silhouette. */
+declare const IMPOSTOR_ANGLES = 8;
+declare const IMPOSTOR_FRAMES = 8;
+type ImpostorBody = {
+    /** A far level of detail of a baked body (the 5-segment one). */
+    readonly geometry: THREE_NS.BufferGeometry;
+    /** The height of that body, which sets the cell the silhouette is drawn in (default the top of its bounding box). */
+    readonly height?: number;
+};
+type ImpostorAtlasOptions = {
+    /** Pixels of a cell (default 32 × 48). */
+    readonly cellWidth?: number;
+    readonly cellHeight?: number;
+    /** Cells in a row of the atlas (default 32). */
+    readonly columns?: number;
+};
+/** Where a silhouette's cell sits in the geometry units of its body: half the width, the bottom and the height. */
+type ImpostorBox = {
+    readonly halfWidth: number;
+    readonly bottom: number;
+    readonly height: number;
+};
+type ImpostorAtlas = {
+    /** Bone, material class, shade and coverage per texel. */
+    readonly texture: THREE_NS.DataTexture;
+    /** The colour the baked body gives the texel (square root of the linear colour), alongside `texture`. */
+    readonly colorTexture: THREE_NS.DataTexture;
+    readonly silhouettes: number;
+    readonly cellWidth: number;
+    readonly cellHeight: number;
+    readonly columns: number;
+    readonly rows: number;
+    readonly boxes: readonly ImpostorBox[];
+    /** The bytes of the texture (RGBA8): bone, material class, shade, coverage. */
+    readonly pixels: Uint8Array;
+    readonly colorPixels: Uint8Array;
+    dispose(): void;
+};
+/**
+ * The impostor atlas (economy ladder, step 2): each silhouette drawn on the CPU at 8 views and 8 steps of the walk from the far level of its baked body.
+ * A texel holds the bone (the group the shader tints and the missing limbs hide), the material class (skin, shirt, trousers...), the baked shade and the coverage;
+ * the colours are not in it, they come per instance. RGBA8 and `NearestFilter`: the bone is an index and must not be blended between texels.
+ */
+declare const bakeImpostorAtlas: (three: Three, bodies: readonly ImpostorBody[], options?: ImpostorAtlasOptions) => ImpostorAtlas;
+
+type ImpostorBatchOptions = {
+    /** Instances the batch holds. */
+    readonly max: number;
+    /** The light the baked shade is multiplied by (the impostor is not lit by the scene; default 0.85 grey). */
+    readonly light?: {
+        readonly r: number;
+        readonly g: number;
+        readonly b: number;
+    };
+};
+/** One far body: the same `iA`, `iC` and shirt as the near body, the scale of its variant, its silhouette (the atlas block) and the ground height. */
+type ImpostorInstance = {
+    readonly a: readonly [number, number, number, number];
+    /** Height and width scale (the near body's `b[0]` and `b[1]`). */
+    readonly scale: readonly [number, number];
+    readonly silhouette: number;
+    readonly y?: number;
+    readonly c: readonly [number, number, number, number];
+    readonly color: {
+        readonly r: number;
+        readonly g: number;
+        readonly b: number;
+    };
+    readonly d?: readonly [number, number, number, number];
+};
+type ImpostorBatch = {
+    readonly mesh: THREE_NS.Mesh & {
+        count: number;
+    };
+    readonly material: THREE_NS.ShaderMaterial;
+    readonly count: number;
+    begin(): void;
+    push(instance: ImpostorInstance): void;
+    end(): void;
+};
+/** The far bodies as one draw call: a standing quad per body that picks its cell of the atlas by the view angle and the walk phase, tinted per instance. */
+declare const createImpostorBatch: (three: Three, atlas: ImpostorAtlas, { max, light }: ImpostorBatchOptions) => ImpostorBatch;
+
+type Vec3 = readonly [number, number, number];
+type PosedVertex = {
+    readonly position: Vec3;
+    readonly normal: Vec3;
+};
+type JointBone = {
+    readonly bone: number;
+    readonly pivot: Vec3;
+    readonly parentPivot: Vec3;
+};
+/**
+ * The walk of the instanced shader (`bodyAnim`, pose 0) for one vertex on the CPU, at the cycle step `step` of `steps`, the arms half raised: the frames of the impostor atlas.
+ * It is the shader's own maths for the pose the impostor draws (the cascade of the joints, the knee bend, the arm swing and the lean), without the per-instance extras.
+ */
+declare const walkPoseVertex: (position: Vec3, normal: Vec3, { bone, pivot, parentPivot }: JointBone, step: number, steps: number) => PosedVertex;
+
+type BlobShadowOptions = {
+    /** Shadows the batch can hold. */
+    readonly max: number;
+    /** Radius in metres of a body of height 1 (default 0.55). */
+    readonly radius?: number;
+    /** The darkness at the centre (default 0.42). */
+    readonly opacity?: number;
+};
+type BlobShadowBatch = {
+    readonly mesh: THREE_NS.Mesh & {
+        count: number;
+    };
+    readonly count: number;
+    begin(): void;
+    /** One shadow under a body at `x`, `z` on the ground height `y`, for a body `height` metres tall. */
+    push(x: number, y: number, z: number, height: number): void;
+    end(): void;
+};
+/**
+ * The shadow of a body that is too far for a real one (economy ladder, step 1): one dark disc per body on the ground, a single draw call.
+ * No depth write and no shadow map: it costs a quad per body.
+ */
+declare const createBlobShadowBatch: (three: Three, { max, radius, opacity }: BlobShadowOptions) => BlobShadowBatch;
 
 /** Where a limb comes from: arms leave at chest height with the sleeve's colour, legs low and long with the trousers'. */
 type LimbLaunch = {
@@ -252,86 +551,6 @@ type FlyingLimbs = {
 /** Torn-off pieces that fly, bounce and stay on the ground, as one instanced mesh of capsules (G 67953 `fxLimb`, 68040 update). */
 declare const createFlyingLimbs: (host: Three, { max, random, effects }: FlyingLimbsOptions) => FlyingLimbs;
 
-type Euler3 = {
-    x: number;
-    y: number;
-    z: number;
-};
-type Node3 = {
-    rotation: Euler3;
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-};
-/** A limb of the rich body, as the Bestiário builds it: the group at the joint, the one below it (elbow, knee) and the rest angles. */
-type RigArm = {
-    g: Node3;
-    el: Node3 & {
-        userData: Record<string, unknown>;
-    };
-    base: number;
-    eBase: number;
-};
-type RigLeg = {
-    g: Node3;
-    kn: Node3;
-    base: number;
-    kBase: number;
-    lost?: boolean;
-};
-/** What `RichBodyBuilder.build` leaves in `root.userData.rig` (the page's `rig`). */
-type RichRig = {
-    readonly type: string;
-    readonly fig: Node3;
-    readonly upper: Node3;
-    readonly headG: Node3;
-    /** The neck cylinder, taken by identity; absent when the head is cut off. */
-    readonly neck?: Node3;
-    readonly arms: RigArm[];
-    readonly legs: RigLeg[];
-    readonly dangles: {
-        g: Node3;
-        el: Node3;
-    }[];
-    readonly flaps: (Node3 & {
-        userData: Record<string, unknown>;
-    })[];
-    readonly ph: number;
-    readonly dropBase: number;
-    readonly leanBase: number;
-    readonly hxBase: number;
-    /** Cascade state, made on the first call of `cascade`. */
-    cur?: Map<readonly [Node3 | Euler3, string, CascadeJoint], number>;
-    jl?: (readonly [Node3 | Euler3, string, CascadeJoint])[];
-};
-/** The names a pose may set (the Bestiário's `setPose`). All are optional: a joint a pose does not name keeps what it had. */
-type PoseTargets = Partial<Record<'lean' | 'twist' | 'side' | 'drop' | 'headX' | 'headY' | 'headZ' | 'armR' | 'armL' | 'elbR' | 'elbL' | 'armRz' | 'armLz' | 'legL' | 'legR' | 'kneeL' | 'kneeR', number>>;
-type RigAnimatorOptions = {
-    /** Gait profile by the type name the rig carries (`rig.type`); a type that is not here walks like the first type of the Bestiário (the slow one). */
-    readonly gaits?: Readonly<Record<string, GaitProfile>>;
-    /** Cascade rates per joint. Default: the engine's `CASCADE`. */
-    readonly cascade?: Readonly<Record<CascadeJoint, number>>;
-};
-type RigAnimator = {
-    /** The pose the gait swings around (legs `lost` stay out of the swing). */
-    restOf(rig: RichRig): RestPose$1;
-    /** The Bestiário's `animate0`: sets the joint rotations of one gait at `time`. `stride` ties cadence and swing to the ground speed. */
-    animate0(root: THREE_NS.Object3D, time: number, stride?: StrideParams): GaitSample | undefined;
-    /** `animate0` plus the bits that hang loose: the dangling forearm and the flaps of torn flesh. */
-    animate(root: THREE_NS.Object3D, time: number, stride?: StrideParams): void;
-    /** Moves every joint a fraction toward the value the animation left on it, from the hips to the head (the Bestiário's `cascade`). */
-    cascade(rig: RichRig, dt: number): void;
-    setPose(rig: RichRig, targets: PoseTargets): void;
-    lerpPose: typeof lerpPose;
-};
-/**
- * The rich body's animator: the Bestiário's `animate0`, `animate`, `cascade`, `setPose` and `lerpPose` over the rig the best builder leaves in
- * `root.userData.rig`. The gait maths is the engine's (`animateProfile`, pure CPU); this only reads the rest pose off the rig and writes the result back.
- */
-declare const createRigAnimator: (options?: RigAnimatorOptions) => RigAnimator;
-
 type BestTypeCard = {
     /** The name `spec.type` looks the type up by (the Bestiário's `nome`). */
     readonly name: string;
@@ -363,6 +582,8 @@ type PersonBuilderOptions = {
     readonly reducedMotion?: boolean;
     /** Eye colour of a zombified body by category (default the page's: lento, corredor, brutamonte). */
     readonly zombieEyes?: Readonly<Record<string, number>>;
+    /** The host's LightBudget: what a person holds that gives light (the flare) is a source of it instead of a PointLight. The sources a person took are in `lightSources` of what `build` returns: `remove()` them when the person leaves. */
+    readonly lights?: LightBudget;
 };
 type PersonBuilder = {
     build(spec: Record<string, any>, index?: number): any;
@@ -453,6 +674,10 @@ type HandItemContext = {
     metal: any;
     dark: any;
     woodM: any;
+    /** The host's LightBudget: the flare asks it for a light instead of creating a PointLight. */
+    lights?: LightBudget;
+    /** Where an item that took a source from `lights` leaves it, so the builder can hand it to whoever removes the person. */
+    sources?: SourceHandle[];
 };
 /** Items held in a hand by kind (`sp.hand`, `sp.lhand`); `g` is the group on the hand's mount. */
 declare const HAND_ITEMS: Record<string, (context: HandItemContext) => void>;
@@ -617,86 +842,6 @@ declare const gouge: (three: Three, materials: WoundMaterials, random: () => num
 /** Arsenal `explodeSeg`: 14 chunks the size of the part, thrown from its centre along the blow. */
 declare const explodeChunks: (three: Three, materials: WoundMaterials, random: () => number, box: THREE_NS.Box3, direction: THREE_NS.Vector3, fling: (chunk: THREE_NS.Object3D, velocity: THREE_NS.Vector3, spin: THREE_NS.Vector3) => void) => THREE_NS.Vector3;
 
-/** The part of a fluid world the bridge needs; `FluidWorld` from `@adatechnology/game-fluids` has it. The package does not import the fluids packages. */
-type BloodSink = {
-    splash(liquid: string, point: Vec3$1, liters: number, velocity?: Vec3$1): void;
-};
-/** Colours of one body's blood: the wet film and what it dries to (the infection age of a zombie: `ages.json`). */
-type BloodLook = {
-    /** Liquid of the blood in the fluid world and in the film (default: the bridge's `liquid`). An old body can bleed `old_blood`. */
-    readonly liquid?: string;
-    readonly tint?: {
-        readonly fresh: number;
-        readonly dry: number;
-    };
-    /** How much of the blood is left, 0 to 1 (the age's `blood` factor): it scales the drops thrown into the film, so a dried-out body throws none. Default 1. */
-    readonly amount?: number;
-};
-/** The part of an infection age the look needs (`UndeadAge` of `@adatechnology/game-characters-undead` has all of it). */
-type BloodAge = {
-    readonly id: string;
-    readonly blood: number;
-    readonly freshBloodColor: string;
-    readonly dryBloodColor: string;
-};
-type BloodLookOptions = {
-    /** Ages with a blood factor below this bleed `thinLiquid` (default 0.3: the old and the decrepit). */
-    readonly thinBelow?: number;
-    /** Liquid of the thin blood (default `old_blood`). */
-    readonly thinLiquid?: string;
-};
-/** The blood of an infection age: its fresh and dry colours (`ages.json`), its amount, and `old_blood` for the thin ones. */
-declare const bloodLookOfAge: (age: BloodAge, options?: BloodLookOptions) => BloodLook;
-/** A drop thrown into the running film of the liquids (`createFilmBridge(...)` of `@adatechnology/game-fluids-three` has it). The package does not import the fluids packages. */
-type FilmSink = {
-    splat(splat: {
-        fluid: string;
-        point: Vec3$1;
-        direction?: Vec3$1;
-        speed?: number;
-        radius?: number;
-        count?: number;
-        tint?: {
-            fresh: number;
-            dry: number;
-        };
-    }): number;
-};
-/** What a `wound` throws into the film: the drops, how fast and how big. Defaults 3 drops at 2.5 m/s of 3.2 mm. */
-type WoundSpray = {
-    readonly count?: number;
-    readonly speed?: number;
-    readonly radius?: number;
-};
-type FluidsBridgeOptions = {
-    readonly sink: BloodSink;
-    /** The running film: when given, a wound, a severed or destroyed segment and a split throw drops of blood into it, in the colours of the body's `BloodLook`. */
-    readonly film?: FilmSink;
-    /** Drops of a wound (`wound` change of a `body` event). */
-    readonly spray?: WoundSpray;
-    /** Drops thrown by a cut, a burst and a split (default 4, 7 and 10). */
-    readonly burstDrops?: Readonly<Record<'severed' | 'destroyed' | 'split', number>>;
-    /** Id of the blood in the fluid world. Default `blood`. */
-    readonly liquid?: string;
-    /** Metres per second a pressurised leak (a cut artery) throws its drops. Default 1.4. */
-    readonly spurtSpeed?: number;
-};
-type FluidsBridge = {
-    /** Reads a body's events: `leak` (bleeding) becomes blood on the surface below. Other events are ignored. */
-    handle(event: DestructionEvent): void;
-    /** The blood a cut, a burst or a split spills at once, at the world point the piece left from (and the drops it throws into the film, when there is one). */
-    burst(change: 'severed' | 'destroyed' | 'split', point: Vec3$1, look?: BloodLook, direction?: Vec3$1): void;
-    /** A wound that does not cut anything off (the `wound` change of the `body` event): drops of blood in the film, thrown along `direction` (default straight down). Returns how many found a grid. */
-    wound(point: Vec3$1, look?: BloodLook, direction?: Vec3$1): number;
-    /** Blood from the engine's own bleeders: `litersPerSecond` over `dt` seconds at `point`. */
-    bleed(point: Vec3$1, litersPerSecond: number, dt: number, direction?: Vec3$1, pressurized?: boolean): void;
-};
-/**
- * Connects the wounds to the fluids packages, with the fluid world injected: the body keeps its own bleeders (rate, duration, spurt) and this turns them
- * into blood, so the stains, pools and drying are the fluids' business and the character code draws none.
- */
-declare const createFluidsBridge: ({ sink, film, spray, burstDrops, liquid, spurtSpeed }: FluidsBridgeOptions) => FluidsBridge;
-
 /** The group that stands for one segment of the engine's tree on a drawn body, with what the wounds need to cut it off. */
 type WoundNode = {
     /** The group that leaves (its children go with it). */
@@ -725,83 +870,6 @@ type WoundBody = {
  */
 declare const woundBodyOf: (root: THREE_NS.Object3D) => WoundBody | undefined;
 
-/** One sound of a voice: the recipe and, for a sequence, the seconds after the first. */
-type VoiceStep = {
-    readonly sound: string;
-    readonly delay?: number;
-};
-/**
- * The voice of one undead type:
- * - `origin` says where it comes from: `team` (the page has a sound for this very type), `rule` (the page's class rule applied to the type: the Brutamonte,
- *   a chase speed above 3.4, or a walker) or `extra` (the nearest sound of the pages to the voice line of `types.json`, the kit's choice);
- * - `groan` / `gameGroan` is the groan of the art scene and of the game;
- * - `idle` (a body that wanders or chases) and `alert` (it noticed the player or woke up) default to the groan; `special` is what the type does at its
- *   ability (the screamer's call, the leaper's jump), and `gameSpecial` its game version (the game has no leap sound, so the art scene's is kept).
- */
-type UndeadVoice = {
-    readonly origin: 'team' | 'rule' | 'extra';
-    readonly groan: string;
-    readonly gameGroan: string;
-    readonly idle?: readonly VoiceStep[];
-    readonly alert?: readonly VoiceStep[];
-    readonly special?: readonly VoiceStep[];
-    readonly gameSpecial?: readonly VoiceStep[];
-};
-/** The voices of the 13 types of the Bestiario, by type id. */
-declare const UNDEAD_VOICES: Readonly<Record<string, UndeadVoice>>;
-declare const UNDEAD_VOICE_SOURCES: readonly string[];
-type VoiceMoment = 'idle' | 'alert' | 'special';
-type CharacterSoundStyle = 'art_scene' | 'game';
-/** What a change of a body sounds like, by the `change` of the `body` event. A head or a jaw hit is brighter (`flesh_head`). */
-type BodySoundRule = {
-    readonly sound: string;
-    readonly head?: string;
-};
-/** Art scene: bloodHit (cena L1084) is `flesh`, a cut is `sever` (L1127, L1143), a burst or an opened belly is `gore` (L1101, L1132). Game: the flesh class of `sfx`. */
-declare const BODY_SOUNDS: Readonly<Record<CharacterSoundStyle, Readonly<Record<string, BodySoundRule>>>>;
-/** What the player hears when a body grabs, bites or hurts him (cena L1350-L1352, at the listener). */
-declare const PLAYER_SOUNDS: {
-    readonly grab: "grab";
-    readonly bite: "bite";
-    readonly hurt: "hurt";
-};
-/** The part of the host's sound a body needs: `play`, and `register` to put the banks in its engine (`createAudioSink(...)` has both). */
-type CharacterSoundSink = {
-    play(request: SoundRequest): unknown;
-    register?(bank: unknown): void;
-};
-type CharacterSoundOptions = {
-    /** Which team answers (default `art_scene`, the kit mix). `game` plays the game's groans, scream and flesh, and the art scene for what the game lacks. */
-    readonly style?: CharacterSoundStyle;
-    /** Replaces a type's voice; `null` silences it. */
-    readonly voices?: Readonly<Record<string, UndeadVoice | null>>;
-    /** Replaces a `body` change's rule; `null` silences it. */
-    readonly body?: Readonly<Record<string, BodySoundRule | null>>;
-    /** The type used for an id that has no voice (default none: silent). */
-    readonly fallbackType?: string;
-};
-type CharacterSound = {
-    /** The steps a type plays at a moment. */
-    stepsOf(typeId: string, moment: VoiceMoment): readonly VoiceStep[];
-    /** Plays the voice of a type at a moment where the body is. Returns how many sounds were started or queued. */
-    voice(typeId: string, moment: VoiceMoment, position: Vec3$1, volume?: number): number;
-    /** Reads a `body` event of a body at `position`: a wound is flesh, a cut is `sever`, a burst or a split is `gore`. Other events are ignored. Returns true when a sound was asked for. */
-    body(event: DestructionEvent, position: Vec3$1, volume?: number): boolean;
-    /** The player is grabbed, bitten or hurt (heard at the listener). */
-    player(kind: keyof typeof PLAYER_SOUNDS, volume?: number): void;
-    /** Runs the sequences (the screamer's inhale, then the call): call it each frame. */
-    update(dt: number): void;
-    /** Sounds waiting for their time. */
-    readonly pending: () => number;
-    dispose(): void;
-};
-/**
- * Plays the sounds of the bodies on the host's sound: the voices of the undead types (the Bestiario's 13), what a wound sounds like and what the player
- * hears. The banks are registered in the host's engine, the sounds are positional, and the groans go through the engine's `undead_voice` limiter
- * (five at once, one every 0.25 s, nearer than 40 m). The team sounds are the recipes of `./recipes`; the table of who says what is data.
- */
-declare function createCharacterSound(sink: CharacterSoundSink, options?: CharacterSoundOptions): CharacterSound;
-
 type WoundsOptions = {
     readonly random: () => number;
     /** Where the flying pieces land. Default: the parent of the body. */
@@ -840,336 +908,12 @@ type Wounds = {
  */
 declare const createWounds: (three: Three, options: WoundsOptions) => Wounds;
 
-/** A crowd on the instanced path: variants baked on demand from the rich builder, one batch per variant and level of detail, members walking a field. */
-type Crowd = {
-    readonly group: THREE_NS.Group;
-    spawn(count: number): void;
-    clear(): void;
-    update(dt: number, camera: THREE_NS.Camera): void;
-    readonly count: number;
-    readonly bakeMs: number;
-    readonly drawCalls: number;
-    readonly triangles: number;
-    /** Triangles of one body at each level of detail (the budget the benchmark checks). */
-    trianglesPerLevel(typeId: string): readonly number[];
-};
-
-/** One undead type as the area needs it: the content pack's own record has all of these fields. */
-type UndeadCard = {
-    readonly id: string;
-    readonly name: Readonly<Record<string, string>>;
-    readonly eye: {
-        readonly color: string;
-    };
-    readonly gait: Readonly<Record<string, number | boolean>>;
-};
-/** A profession of the people pack (look, accessories, what it holds). */
-type ProfessionCard = {
-    readonly id: string;
-    readonly name: Readonly<Record<string, string>>;
-    readonly female?: boolean;
-    readonly look: {
-        readonly skin: string;
-        readonly hair: {
-            readonly style: string;
-            readonly color: string;
-        };
-        readonly hat?: {
-            readonly kind: string;
-            readonly color: string;
-        };
-        readonly face?: readonly string[];
-        readonly top: {
-            readonly color: string;
-            readonly sleeve: string;
-            readonly plaid?: string;
-        };
-        readonly pants: {
-            readonly color: string;
-        };
-        readonly shoes: string;
-    };
-    readonly accessories: readonly {
-        readonly id: string;
-        readonly color?: string;
-    }[];
-    readonly hand?: string;
-    readonly leftHand?: string;
-};
-/** The part of the undead engine the area uses (`createUndead(kit)` has all of it). */
-type UndeadLike = {
-    create(spec: Pick<CharacterSpec, 'seed'> & Partial<CharacterSpec>, options?: {
-        readonly type?: string;
-    }): DamageCharacter;
-    turn(person: DamageCharacter, options?: {
-        readonly type?: string;
-    }): DamageCharacter;
-    traitsOf(character: DamageCharacter): {
-        readonly type: string;
-        readonly age?: string;
-        readonly speeds: Readonly<Record<string, number>>;
-    } | undefined;
-    speedFor(traits: {
-        readonly type: string;
-        readonly speeds: Readonly<Record<string, number>>;
-    }, context: {
-        readonly moment: string;
-        readonly limp?: boolean;
-        readonly crawling?: boolean;
-    }): number;
-    onDeath?(character: DamageCharacter): readonly {
-        readonly kind: string;
-    }[];
-    infect?(wound: 'bite' | 'scratch' | 'laceration' | undefined, random: () => number): {
-        advance(seconds: number): unknown;
-        readonly reanimated: boolean;
-    } | undefined;
-};
-type CharactersTestOptions = {
-    /** `en` or `pt-BR` (default). */
-    readonly locale?: string;
-    /** Builds the kit the area uses; called again when the bench changes the penetration model or the death rule. Default `createCharacters` with `packs`. */
-    readonly createKit?: (options: {
-        readonly penetration: 'physical' | 'team-game';
-        readonly deathRule: 'vitality-or-head' | 'head-only';
-    }) => CharacterKit;
-    /** Packs for the default kit (people, uniformed, undead). */
-    readonly packs?: readonly CharacterPack[];
-    readonly undeadTypes?: readonly UndeadCard[];
-    readonly createUndead?: (kit: CharacterKit) => UndeadLike;
-    readonly professions?: readonly ProfessionCard[];
-    /** Where the blood of the wounds goes (the room's fluid world: `room.fluids`). Without it the wounds draw no blood on the ground. */
-    readonly fluids?: BloodSink;
-    /** The running film of the liquids (the room's `room.film`): wounds throw drops of blood into it, in the colours `bloodOf` gives. Without it only the fluid world gets blood. */
-    readonly film?: FilmSink;
-    /** The sounds of the bodies on the room's engine (`host.audio`): wounds, cuts and the voices of the bench. `false` leaves the area silent. */
-    readonly sound?: false | CharacterSoundOptions;
-    /** The blood of a body by its infection age (`bloodLookOfAge` over the content's ages). Bodies without an age, and games without this option, bleed the liquid's own colours. */
-    readonly bloodOf?: (age: string) => BloodLook | undefined;
-    /** Seed of the draws of the area (default 1). */
-    readonly seed?: number;
-    /** Crowd types to bake for the instanced field, by undead id (default walker and runner). */
-    readonly crowdTypes?: readonly string[];
-    /** Triangles a baked body may have at each level of detail (default 2500, 800, 250, the Bancada de Hordas budget). Given explicitly, every level is a hard check. */
-    readonly triangleBudget?: readonly number[];
-};
-
-/** What a scenario needs of the room: the pass/fail line and time. The test room's `ScenarioContext` has both. */
-type AreaContext = {
-    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
-    step(seconds: number): void;
-};
-
-declare const CHARACTERS_AREA_ID = "characters_area";
-declare const ZOMBIE_ITEM_PREFIX = "zombie_";
-declare const PERSON_ITEM_PREFIX = "person_";
-/**
- * The characters test area as a `TestableModule`: the undead types and the professions as bodies the room can shoot (each one a `DestructibleImpl` of the damage model, drawn with the
- * rich builders, wounds, eyes and gait), a shooting lane, a crowd on the instanced path, and a bench with the damage rules, the hits, the protection, the moment and the layers.
- * Everything comes in by option: the packs of content (people, undead) are the host page's, so this package knows no game.
- */
-declare function createCharactersTestModule(options?: CharactersTestOptions): TestableModule<AreaContext> & {
-    readonly entries: ReadonlyMap<string, unknown>;
-    readonly crowd: Crowd | null;
-};
-
-/**
- * What the "Hit" control of the bench does to the body: typical loads, in joules and millimetres, as the arsenal's calibre table gives them.
- * `caliberId` is used only when the kit's table knows it (the `team-game` model).
- */
-type HitPreset = {
-    readonly id: string;
-    readonly hit: Omit<BodyHit, 'point' | 'direction'>;
-    readonly range?: number;
-};
-declare const HIT_PRESETS: readonly HitPreset[];
-
-/**
- * The material the parts of a living body carry (`BODY_MATERIAL` of the engine), as a destruction world needs it declared: pass it in the world's material list
- * (`worldOptions.materials` of the test room) before loading the characters area. The body model owns the damage; the world only needs the density and thermal data
- * to raycast, blast and burn a body like any other object. Numbers are those of soft tissue (about 1050 kg/m3).
- */
-declare const BODY_MATERIAL_DEF: {
-    readonly id: "flesh";
-    readonly density: 1050;
-    readonly hpPerKg: 15;
-    readonly penetration: 1.2;
-    readonly ductility: 0.8;
-    readonly fracture: "tear";
-    readonly fragmentSize: readonly [0.03, 0.1];
-    readonly damageScale: {
-        readonly slash: 1.6;
-    };
-    readonly hitDebris: "drips";
-    readonly breakDebris: "drips";
-    readonly thermal: {
-        readonly ignitionC: 260;
-        readonly flameC: 700;
-        readonly fuelFraction: 0.25;
-        readonly burnRate: 0.004;
-        readonly conductivity: 0.5;
-        readonly heatCapacity: 3.5;
-        readonly smoke: "grey";
-    };
-    readonly tags: readonly ["organic", "body"];
-    readonly compressive: 1000;
-};
-/** Puts the body material in a destruction world that does not know it yet (`room.world`); a world that has it is left alone. Call it before `room.loadModule`. */
-declare const registerBodyMaterial: (world: {
-    readonly materials: Map<string, unknown>;
-}) => void;
-
-/** The person builder's spec for a profession of the people pack (look and gear as numbers; the builder draws the rest). */
-declare const personSpecOf: (profession: ProfessionCard) => Record<string, any>;
-
 /** The voice limiter group of the undead (`undead_voice`: five at once, one every 0.25 s, nearer than 40 m). */
 declare const UNDEAD_VOICE_GROUP = "undead_voice";
 /** The sounds of the game and of the art scene for the bodies, in one bank. */
 declare const CHARACTER_SOUNDS: readonly SoundRecipe[];
 declare const CHARACTER_SOUND_BANK: SoundBank;
 
-/**
- * The eye the hands are seen from, given per call to `apply` (null or none is the body seen from outside: nothing changes). `reachBend` keeps the elbow bent where a hand is out of reach, the hand stopping
- * short instead of the arm locking; `keepOutside` pulls a hand back so it stays in front of the surface `contact` finds along the camera's forward.
- */
-type ReachView = {
-    readonly camera: THREE_NS.Object3D;
-    /** The least interior bend of the elbow, radians, right then left. Default `ARM_REACH.viewBend`. */
-    readonly reachBend?: readonly [number, number];
-    readonly keepOutside?: {
-        /** The distance to the surface from `origin` along `direction` within `maxDistance`, or null. */
-        contact(origin: [number, number, number], direction: [number, number, number], maxDistance: number): number | null;
-        /** Default `ARM_REACH.contactMargin`. */
-        readonly margin?: number;
-        /** Default `ARM_REACH.contactNearest`. */
-        readonly nearest?: number;
-    };
-};
-
-type AvatarViewMode = 'first' | 'third';
-
-type PlayerAvatarSpec = Record<string, unknown>;
-type PlayerAvatarOptions = {
-    /** The body spec for the rich builder (`createBestBuilder.build`). Default: the team game's player (`player-avatar.json`). Merged over the default. */
-    readonly spec?: PlayerAvatarSpec;
-    /** Shirt colour, 0xRRGGBB. Default the team game's `PLAYER_COR`. */
-    readonly shirtColor?: number;
-    /** The clips `play(id)` finds. Default: a registry with `POSE_CLIPS`. */
-    readonly clips?: PoseClipRegistry;
-    /** Seconds to blend a clip in and out. Default 0.12. */
-    readonly blend?: number;
-    /** Seconds the body takes to go down (the shader's `fk` smoothstep). 0 is instant. Default 0.3. */
-    readonly fallSeconds?: number;
-    /** Smooth the joints with the Bestiário cascade (default true). */
-    readonly cascade?: boolean;
-    /**
-     * How many times faster the cascade follows while a clip that does not loop plays: a strike is over in a third of a second, and at the walk's pace the joints would
-     * still be on their way when it ends (a punch that never reaches the shoulder). 1 keeps the walk's pace. Default 5.
-     */
-    readonly clipCascade?: number;
-    /** Where the eye sits against the builder's eye point, in the head's frame (so it follows the head's scale and turn). Default [0, -0.068, 0]: about 1.70 m standing. */
-    readonly eyeOffset?: readonly [number, number, number];
-    /** How much of the walking and running bob of the body reaches the eye: 0 none, 1 all of it. Default 0.5. */
-    readonly eyeBob?: number;
-};
-type AvatarEvent = PoseClipEvent & {
-    clip: string;
-};
-type AvatarItemUsePose = {
-    readonly id: string;
-    readonly position: readonly [number, number, number];
-    readonly rotation: readonly [number, number, number];
-    /** How closed the other hand is (0 open to 1 closed) when it works on the item, as a hand turning a cap off opens between strokes; the room brings it there with `reach`. */
-    readonly gripL?: number;
-};
-type AvatarUpdate = {
-    /** Ground speed, m/s. Ties cadence and swing to the ground (the game's `walkCad` and `walkGait`). */
-    speed?: number;
-    /** Accepted for the game's state; the gait depends on the speed alone, as in the team game. */
-    running?: boolean;
-    crouch?: boolean;
-    down?: boolean;
-    /** Weapon in hand: both arms follow the aim (the game's arm code). Default false. */
-    armed?: boolean;
-    /** The camera pitch the game's `playerArmCode()` reads (`view.pitch`). */
-    pitch?: number;
-    /** Leg yaw toward the step while armed (the game's `P.hip`, radians). */
-    hip?: number;
-    /** Whether the player is carrying an item in the right hand. */
-    holding?: boolean;
-    /** Active scripted item use (`drink`, `sip`, `chug`, `pour`, `open`, `close`, `tilt`). */
-    itemUse?: AvatarItemUsePose | null;
-    /** Hands on a piece of furniture: `grip` closes on it with `progress`, `push` walks with it, `strain` strains against what does not give. */
-    push?: {
-        readonly phase: 'grip' | 'push' | 'strain';
-        readonly progress: number;
-    } | null;
-    /** On a seat: `sit` folds the legs under hips `hip` metres above the feet, `lie` lays the body face up with the pelvis there, the head behind the facing. */
-    seat?: {
-        readonly pose: 'sit' | 'lie';
-        readonly hip: number;
-    } | null;
-    /**
-     * A hand on a door, lid or drawer: `reach` to the handle, `swing` with it (`pull` toward the body or pushed away), `release` back, `rattle` on a locked one.
-     * `height` is the hand over the feet, metres (a fridge handle, a car door, a low drawer).
-     */
-    door?: {
-        readonly phase: 'reach' | 'swing' | 'release' | 'rattle';
-        readonly progress: number;
-        readonly height: number;
-        readonly pull: boolean;
-    } | null;
-};
-type PlayPoseOptions = {
-    onEvent?: (event: AvatarEvent) => void;
-    /** Overrides the avatar's blend for this clip. */
-    blend?: number;
-};
-/** The colours the body was drawn with, for whatever has to match it (the first-person arms): skin, shirt, trousers and shoes as 0xRRGGBB, and whether the sleeves cover the forearms. */
-type PlayerAvatarColors = {
-    skin: number;
-    shirt: number;
-    trousers: number;
-    shoes: number;
-    longSleeves: boolean;
-};
-type PlayerAvatar = {
-    root: THREE_NS.Object3D;
-    rig: RichRig;
-    /** What the body wears, read from the body itself. */
-    readonly colors: PlayerAvatarColors;
-    /** The three.js namespace the body was made with, so what is made to fit it (the first-person arms) uses the same one. */
-    readonly three: Three;
-    update(dt: number, state?: AvatarUpdate): void;
-    /**
-     * The world position of the eyes, as `update` left them: sampled at its end, before any `reach()` (which turns the chest and would swing the head), and kept in the
-     * body's own frame so it stays right when the host moves `root` afterwards. With `out` it fills that vector instead of making one.
-     */
-    eye(out?: THREE_NS.Vector3): THREE_NS.Vector3;
-    /** In 'first' with a camera, the head and neck are not drawn for that camera only (shadows, mirrors and every other camera still see them); 'third' draws them. */
-    setView(mode: AvatarViewMode, camera: THREE_NS.Object3D | null): void;
-    play(clip: string | PoseClip, options?: PlayPoseOptions): void;
-    stop(): void;
-    readonly playing: string | null;
-    /** A socket at the hand: 'R' is the weapon hand (the puppet's right, at -x), 'L' the other one. */
-    hand(side: 'R' | 'L'): THREE_NS.Object3D;
-    /** The joint of a shoulder ('R' the weapon side, at -x): where a long gun's stock rests, just inside it. */
-    shoulder(side: 'R' | 'L'): THREE_NS.Object3D;
-    /**
-     * Brings the hands to where the tool in them asks (`HandTargets`, world space) after `update`: shoulder, elbow and wrist each bend inside the human range, the chest turns and the shoulder
-     * blade slides toward a hand out of reach. Null, a strike playing or the body going down leave the arms as `update` posed them. Call it after the tool is placed and the root moved.
-     * `view` (given on each call, as the camera moves) is for the body seen from its own eyes: the elbows keep their bend and the hands stay out of walls; without it nothing changes.
-     */
-    reach(targets: HandTargets | null, view?: ReachView | null): void;
-    on(type: 'event', listener: (event: AvatarEvent) => void): () => void;
-    dispose(): void;
-};
-/**
- * The player's body: the rich human of the Bestiário/Elenco, built with the team game's player spec (data, overridable), walking with the engine's gait tied
- * to the ground speed, with the crouch and the knock-down of the game's GPU pose code (`BODY_CHUNK`) and a pose-clip overlay (`play`).
- */
-declare const createPlayerAvatar: (THREE: Three, options?: PlayerAvatarOptions) => PlayerAvatar;
-
 /** What `@adatechnology/game-test-room` calls a `RoomAvatar`, restated here so this package does not depend on the room. */
 type RoomAvatarLike = {
     root: THREE_NS.Object3D;
@@ -1210,11 +954,13 @@ type RoomAvatarLike = {
         leg?: 'left' | 'right';
         hand?: 'left' | 'right';
     }): number | null;
+    /** The foot the walk put down since the last call (`RoomAvatar.footfall`), or null. */
+    footfall(): 'left' | 'right' | null;
     /** The avatar it wraps. */
     readonly avatar: PlayerAvatar;
 };
 type ToRoomAvatarOptions = {
-    /** The third-person strike clips `strike` finds by id. Default `ATTACK_CLIPS` of game-characters-people. */
+    /** The third-person strike clips `strike` finds by id (`defaultCharacterClips()` of game-kit-defaults, or the game's own). Default `ATTACK_CLIPS` of game-characters-people, which is deprecated: pass them. */
     strikeClips?: readonly PoseClip[];
     /** The looping clip the body holds between punches (a clip of `strikeClips`), so a combo goes guard, punch, guard instead of dropping the hands each time; `false` for none. Default `'fight_guard'`. */
     guardClip?: string | false;
@@ -1231,43 +977,6 @@ type ToRoomAvatarOptions = {
  */
 declare const toRoomAvatar: (avatar: PlayerAvatar, options?: ToRoomAvatarOptions) => RoomAvatarLike;
 
-declare const AVATAR_AREA_ID = "avatar_area";
-type AvatarTestOptions = {
-    /** The body under test (the example makes it with `createPlayerAvatar(THREE)` and gives the same one to the room). */
-    avatar: PlayerAvatar;
-    /** The text language when the host does not ask for one. Default `pt-BR`. */
-    locale?: string;
-    /** The clips offered as buttons. Default `POSE_CLIPS` (the two of the Bestiário); a game adds its strikes, such as `ATTACK_CLIPS` of game-characters-people. */
-    clips?: readonly PoseClip[];
-    /** Texts of the `phase` labels of `clips` by locale, merged over `POSE_CLIP_LOCALES` (for example `ATTACK_CLIP_LOCALES`). */
-    clipLocales?: Readonly<Record<string, Readonly<Record<string, string>>>>;
-    /** The room's view: `mode()` reads it, `set` changes it (`room.cameraMode` and `room.setCameraMode`). Without it the camera buttons only log. */
-    camera?: {
-        mode(): 'first' | 'third';
-        set(mode: 'first' | 'third'): void;
-    };
-    /** The room's avatar state (`room.setAvatarState`): the module drives crouch, down and the armed arms through it. */
-    state?: {
-        set(state: {
-            crouch?: boolean;
-            down?: boolean;
-            armed?: boolean | null;
-        }): void;
-    };
-};
-/**
- * The player's body as a `TestableModule` for the area `avatar_area`: bench buttons for the view (1st and 3rd person), crouch, fall and get up, the armed arms and every registered
- * pose clip (grab, bite), and metrics for the camera, the clip, its last event and the joints. Every action goes to the room's
- * log as JSON. It uses only the contracts: the body, the camera and the state come in by option, so the module knows no room.
- */
-declare function createAvatarTestModule(options: AvatarTestOptions): TestableModule & {
-    readonly state: {
-        crouch: boolean;
-        down: boolean;
-        armed: boolean | null;
-    };
-};
-
 type Triple = [number, number, number];
 /**
  * A hand (or the foot) at rest, in the camera's space: x to the right, y up, the view looks down -z. `p` is the middle of the palm, `r` the Euler angles `[roll, yaw, pitch]` in the order YZX:
@@ -1446,4 +1155,4 @@ type TwoBone = {
  */
 declare const solveTwoBone: (root: THREE_NS.Vector3, target: THREE_NS.Vector3, upper: number, lower: number, pole: THREE_NS.Vector3, out: TwoBone) => TwoBone;
 
-export { AVATAR_AREA_ID, type AreaContext, type AvatarEvent, type AvatarItemUsePose, type AvatarTestOptions, type AvatarUpdate, type AvatarViewMode, BAKE_NEUTRAL_POSE, BODY_CHUNK, BODY_MATERIAL_DEF, BODY_SOUNDS, type BakeBuilders, type BakeSpec, type BakedBody, type BestBuilder, type BestBuilderOptions, type BestTypeCard, type BloodAge, type BloodLook, type BloodLookOptions, type BloodSink, type BodyBatch, type BodyBatchOptions, type BodyChunkOptions, type BodyInstance, type BodyJoints, type BodyMaterialParams, type BodySoundRule, type BodyVariant, type BuildInstancedBodyParams, CHARACTERS_AREA_ID, CHARACTER_SOUNDS, CHARACTER_SOUND_BANK, type CharacterSound, type CharacterSoundOptions, type CharacterSoundSink, type CharacterSoundStyle, type CharactersTestOptions, EXTRAS, type EyeOptions, type Eyes, FACE_FEATURES, FIRST_PERSON_BOB, FIRST_PERSON_COLORS, FIRST_PERSON_RIG, FIRST_PERSON_STANCES, type FilmSink, type FirstPersonArms, type FirstPersonArmsOptions, type FirstPersonArmsState, type FirstPersonBob, type FirstPersonColors, type FirstPersonEvent, type FirstPersonRig, type FluidsBridge, type FluidsBridgeOptions, type FlyingLimb, type FlyingLimbs, type FlyingLimbsOptions, type FlyingPiece, type FlyingPieces, type FlyingPiecesOptions, HAND_ITEMS, HATS, HIT_PRESETS, type HitPreset, LOD_BAKE, LOD_BATCH_CAPACITY, LOD_CASTS_SHADOW, LOD_DISTANCES, LOD_SEGMENTS, type LimbEffects, type LimbLaunch, PENDULUM, PERSON_ITEM_PREFIX, PLAYER_SOUNDS, type Pendulum, type PersonBuilder, type PersonBuilderOptions, type PlayPoseOptions, type PlayerAvatar, type PlayerAvatarColors, type PlayerAvatarOptions, type PlayerAvatarSpec, type PoseTargets, type ProfessionCard, type ReachView, type RestPose, type RichRig, type RigAnimator, type RigAnimatorOptions, type RoomAvatarLike, type StanceDef, type Three, type ToRoomAvatarOptions, type TwoBone, UNDEAD_VOICES, UNDEAD_VOICE_GROUP, UNDEAD_VOICE_SOURCES, type UndeadCard, type UndeadLike, type UndeadVoice, type VariantType, type VoiceMoment, type VoiceStep, type WoundBody, type WoundMaterials, type WoundNode, type WoundSpray, type Wounds, type WoundsOptions, ZOMBIE_ITEM_PREFIX, bakeBody, bakeVariants, blobGeometry, blobRadii, bloodLookOfAge, buildInstancedBody, createAvatarTestModule, createBestBuilder, createBodyBatch, createBodyChunk, createBodyMaterial, createCharacterSound, createCharactersTestModule, createEye, createFirstPersonArms, createFluidsBridge, createFlyingLimbs, createFlyingPieces, createGlowTexture, createPendulum, createPersonBuilder, createPlayerAvatar, createRigAnimator, createVariantBatches, createWoundMaterials, createWounds, exitWound, explodeChunks, findEyes, gouge, jointsOf, lodAt, makeCut, makeStump, personSpecOf, registerBodyMaterial, ringWound, solveTwoBone, starGeometry, stepPendulum, toRoomAvatar, woundBodyOf, woundDecal };
+export { ACCESSORY_BIT, type AccessoryAttach, AvatarItemUsePose, AvatarViewMode, BAKE_NEUTRAL_POSE, BODY_CHUNK, type BakeBuilders, type BakeSpec, type BakedBody, type BestBuilder, type BestBuilderOptions, type BestTypeCard, type BlobShadowBatch, type BlobShadowOptions, BloodLook, type BodyBatch, type BodyBatchMesh, type BodyBatchOptions, type BodyChunkOptions, type BodyInstance, type BodyJoints, type BodyMaterialParams, type BodyVariant, type BuildInstancedBodyParams, CHARACTER_SOUNDS, CHARACTER_SOUND_BANK, CLIPS_BIT, CLIP_BONES, CLIP_LIMIT, CLIP_RATE, CLIP_TEXELS, CharacterSound, type ClipLimp, EXTRAS, type EyeOptions, type Eyes, FACE_FEATURES, FIRST_PERSON_BOB, FIRST_PERSON_COLORS, FIRST_PERSON_RIG, FIRST_PERSON_STANCES, type FirstPersonArms, type FirstPersonArmsOptions, type FirstPersonArmsState, type FirstPersonBob, type FirstPersonColors, type FirstPersonEvent, type FirstPersonRig, FluidsBridge, type FlyingLimb, type FlyingLimbs, type FlyingLimbsOptions, type FlyingPiece, type FlyingPieces, type FlyingPiecesOptions, GAIT_STYLE, type GaitStyle, HAND_ITEMS, HATS, IMPOSTOR_ANGLES, IMPOSTOR_FRAMES, type IdentityLook, type ImpostorAtlas, type ImpostorAtlasOptions, type ImpostorBatch, type ImpostorBatchOptions, type ImpostorBody, type ImpostorBox, type ImpostorInstance, KIT_ACCESSORIES, type KitAccessory, LOD_BAKE, LOD_BATCH_CAPACITY, LOD_CASTS_SHADOW, LOD_DISTANCES, LOD_SEGMENTS, type LimbEffects, type LimbLaunch, PENDULUM, type Pendulum, type PersonBuilder, type PersonBuilderOptions, PlayerAvatar, ReachView, type RestPose, RichRig, type RoomAvatarLike, SEGMENT_CLIPS, STAGGER_POSE, type SegmentClipSet, type SegmentClipSpec, type SegmentClipUniforms, type StanceDef, TROUSER_PALETTE, Three, type ToRoomAvatarOptions, type TwoBone, UNDEAD_VOICE_GROUP, type VariantBatchesOptions, type VariantType, type WoundBody, type WoundMaterials, type WoundNode, type Wounds, type WoundsOptions, accessoryPlacement, bakeBody, bakeImpostorAtlas, bakeSegmentClips, bakeVariants, blobGeometry, blobRadii, buildInstancedBody, buildKitAccessory, clipIndexOf, clipSpeedOf, createBestBuilder, createBlobShadowBatch, createBodyBatch, createBodyChunk, createBodyChunkExt, createBodyMaterial, createEye, createFirstPersonArms, createFlyingLimbs, createFlyingPieces, createGlowTexture, createImpostorBatch, createPendulum, createPersonBuilder, createSegmentClipUniforms, createVariantBatches, createWoundMaterials, createWounds, exitWound, explodeChunks, findEyes, gouge, jointsOf, lodAt, makeCut, makeStump, packIdentity, ringWound, solveTwoBone, starGeometry, stepPendulum, toRoomAvatar, unpackIdentity, walkPoseVertex, woundBodyOf, woundDecal };