@adatechnology/game-characters-three 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,876 @@
+import * as THREE_NS from 'three';
+import { BodySpec, CascadeJoint, RestPose, StrideParams, GaitSample, lerpPose, GaitProfile, SegmentId, CharacterKit, CharacterPack, CharacterSpec, DamageCharacter, BodyHit } from '@adatechnology/game-characters';
+import { Vec3 as Vec3$1, DestructionEvent, TestableModule } from '@adatechnology/game-contracts';
+
+/** 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,
+ * arms 0 human / 1 zombie / 2+ armed, skin tone) · iCol = shirt colour · iEye = eye colour (0 = human). The mask bits are `MISSING_BITS`.
+ * A test compares its sha-256 with the one recorded from the game.
+ */
+declare const BODY_CHUNK = "\n  attribute float bone; attribute vec4 vcol; attribute vec3 pivot; attribute vec3 ppivot;\n  attribute vec4 iA; attribute vec4 iB; attribute vec4 iC; attribute vec3 iCol; attribute vec3 iEye;\n  uniform float uTime;\n  varying vec3 vTint; varying float vGlow;\n  mat3 rX(float a){ float c=cos(a), s=sin(a); return mat3(1.,0.,0., 0.,c,s, 0.,-s,c); }\n  mat3 rY(float a){ float c=cos(a), s=sin(a); return mat3(c,0.,-s, 0.,1.,0., s,0.,c); }\n  mat3 rZ(float a){ float c=cos(a), s=sin(a); return mat3(c,s,0., -s,c,0., 0.,0.,1.); }\n  bool miss(float bit){ if (iC.z > 1.5) return false; return mod(floor(iC.x / bit), 2.) > 0.5; }\n  vec3 bodyAnim(vec3 p, inout vec3 nrm){\n    float ph = iA.w*6.2831, gait = iB.z, pose = iB.w - floor(iB.w/16.)*16., zomb = iC.z;\n    float side = (bone==2.||bone==4.||bone==7.||bone==9.) ? -1. : 1.;\n    // cascata: cada junta atrasa em rela\u00E7\u00E3o ao quadril (Besti\u00E1rio 12.3)\n    float lag = bone==1.||bone==6.||bone==11. ? 0.55 : (bone>=7.&&bone<=8. ? 0.35 : (bone==2.||bone==3. ? 0.2 : 0.));\n    float sw = sin(ph - lag);\n    mat3 Rp = mat3(1.), Rc = mat3(1.);\n    bool isArm = bone==2.||bone==3., isFore = bone==7.||bone==8., isThigh = bone==4.||bone==5., isShin = bone==9.||bone==10.;\n    float legS = (bone==4.||bone==9.) ? 1. : -1.;\n    float walkS = sin(ph) * legS;\n    if (isThigh || isShin) Rp = rX(-walkS*0.5*gait);\n    if (isShin) Rc = rX(max(0., cos(ph + (legS>0.?0.:3.1416)))*0.85*gait);\n    if (pose==6.) { if (isThigh) Rp = rX(-1.1); if (isShin) Rc = rX(1.4); }\n    if (pose==5.) { if (isThigh) Rp = rX(-0.95 - walkS*0.3*gait); if (isShin) Rc = rX(1.9); } // agachado: joelho dobra, o p\u00E9 fica no ch\u00E3o\n    if (pose==7.) { if (isThigh) Rp = rX(-1.15); if (isShin) Rc = rX(2.3); } // ajoelhado comendo\n    if (pose==2. && isShin && fract(iA.w*3.)*legS > 0.3) Rc = rX(fract(iA.w*3.)*1.3); // corpo com um joelho dobrado\n    float armS = sin(ph) * (side>0. ? 1. : -1.);\n    if (isArm || isFore) {\n      // zumbi: bra\u00E7os ca\u00EDdos vagando; levanta (iC.z = 1 + 0,4 \u00D7 alcance) quando percebe algu\u00E9m ou vai agarrar\n      float raise = clamp((zomb - 1.)/0.4, 0., 1.);\n      float fwd = zomb > 0.5 && zomb < 1.5 ? mix(-0.12 + armS*0.3*gait + 0.05*sin(uTime*1.3+iA.w), -1.35 + armS*0.18 + 0.1*sin(uTime*2.+iA.w), raise) : armS*0.45*gait;\n      if (pose==3.) fwd = -1.55 + 0.35*sin(uTime*9.+iA.w);\n      if (pose==4.) fwd = -2.6;\n      if (pose==6.) fwd = -2.0;\n      if (pose==2.) fwd = (fract(iA.w*5.) > 0.5 && side > 0.) ? -2.8 : -0.35 + 0.3*sin(iA.w*5. + side);\n      if (pose==1.) fwd = -2.6 + 0.5*sin(ph)*side; // puxa o corpo com os bra\u00E7os\n      if (pose==7.) fwd = -0.9 + 0.3*sin(uTime*6.+iA.w);\n      Rp = rX(fwd) * rZ(side*(pose==2. ? 0.5 + 0.3*sin(iA.w*3.) : 0.08));\n      // armado (iC.z = 2 + pitch codificado): as duas m\u00E3os na arma, bra\u00E7os seguem a mira\n      if (zomb > 1.5 && pose != 2.) { float aim = (zomb - 2.)*3. - 1.; Rp = rX(-1.42 + aim*0.85 + 0.02*sin(ph)*gait) * rZ(side < 0. ? 0.36 : -0.54); } // arma na m\u00E3o direita de verdade (o osso 'D' fica em +x, que \u00E9 a esquerda do boneco virado para +z); a esquerda encontra na empunhadura\n    }\n    if (isFore) Rc = rX(zomb > 1.5 && pose != 2. ? (side < 0. ? -0.12 : -0.04) : zomb > 0.5 ? mix(-0.3 - max(0., armS)*0.3*gait, -0.15, clamp((zomb - 1.)/0.4, 0., 1.)) : -0.35 - max(0., armS)*0.4*gait);\n    if (bone==11.) Rc = rX(pose==3.||pose==4. ? 0.35 + 0.2*sin(uTime*14.) : 0.05);\n    vec3 q = p; vec3 n = nrm;\n    if (isFore || isShin) { q = Rc*(q - pivot) + pivot; n = Rc*n; q = Rp*(q - ppivot) + ppivot; n = Rp*n; }\n    else if (isArm || isThigh || bone==11.) { q = Rp*(q - pivot) + pivot; n = Rp*n; q = Rc*(q - pivot) + pivot; n = Rc*n; }\n    // humano armado andando de lado: quadril e pernas giram para a dire\u00E7\u00E3o do passo (iC.x leva o \u00E2ngulo)\n    if (zomb > 1.5 && (isThigh || isShin)) { mat3 hy = rY((iC.x - 0.5)*10.); q = hy*(q - vec3(0.,0.9,0.)) + vec3(0.,0.9,0.); n = hy*n; }\n    // partes faltando: colapsa no piv\u00F4\n    if ((bone==1.||bone==6.||bone==11.) && miss(1.)) q = pivot;\n    if (bone==11. && miss(512.)) q = pivot;\n    if ((bone==2.||bone==7.) && miss(2.)) q = pivot; if ((bone==3.||bone==8.) && miss(4.)) q = pivot;\n    if ((bone==4.||bone==9.) && miss(8.)) q = pivot; if ((bone==5.||bone==10.) && miss(16.)) q = pivot;\n    if (bone==7. && miss(32.)) q = pivot; if (bone==8. && miss(64.)) q = pivot;\n    if (bone==9. && miss(128.)) q = pivot; if (bone==10. && miss(256.)) q = pivot;\n    // corpo: inclina\u00E7\u00E3o, balan\u00E7o, agachar, rastejar, ca\u00EDdo\n    bool upper = !(isThigh || isShin);\n    float zz = zomb > 0.5 && zomb < 1.5 ? 1. : 0.;\n    float lean = zz > 0.5 ? 0.12 + 0.3*min(1., gait) : 0.04*gait;\n    if (pose==3.) lean += 0.15;\n    if (pose==5.) lean += 0.25;\n    if (pose==7.) lean += 0.8;\n    if (upper) { q -= vec3(0.,0.95,0.); q = rX(lean)*q; n = rX(lean)*n; q += vec3(0.,0.95,0.); }\n    vec3 hp = rX(lean)*(pivot - vec3(0.,0.95,0.)) + vec3(0.,0.95,0.); // pesco\u00E7o j\u00E1 inclinado: a cabe\u00E7a n\u00E3o descola\n    if (bone==1.||bone==6.||bone==11.) { q -= hp; mat3 h = rY(sin(uTime*0.7+iA.w)*0.25*zz) * rZ(0.18*zz*sin(iA.w*3.)); q = h*q; n = h*n; q += hp; }\n    q.y += abs(sin(ph))*0.035*gait - (pose==5. ? 0.35 : pose==7. ? 0.5 : 0.);\n    if (pose==1. && (bone==1.||bone==6.||bone==11.)) { mat3 hc = rX(-1.25); q = hc*(q - hp) + hp; n = hc*n; } // rastejante levanta a cabe\u00E7a\n    if (pose==1.) { mat3 c = rX(1.42); q = c*(q - vec3(0.,0.95,0.)) + vec3(0.,0.2,0.); n = c*n; }\n    if (pose==2.) { float flip = step(0.5, fract(iA.w*1.7)); float fk = clamp(gait, 0., 1.); fk = fk*fk*(3.-2.*fk); /* queda animada: passada leva o progresso */ mat3 c = rX((-1.5 + flip*3.0)*fk) * rZ(sin(iA.w*7.)*0.3*fk); /* de costas ou de bru\u00E7os */ q = c*(q - vec3(0.,0.95,0.)) + mix(vec3(0.,0.95,0.), vec3(0.,0.16,-0.6 + flip*1.2), fk); n = c*n; }\n    nrm = n;\n    return q;\n  }\n";
+type BodyChunkOptions = {
+    /** Height of the hip joint (the trunk's pivot), metres. The game's 0.95 is the default. */
+    readonly hipHeight?: number;
+};
+/** 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];
+/**
+ * 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;
+};
+declare const jointsOf: (body: BodySpec) => BodyJoints;
+type Geometry = THREE_NS.BufferGeometry;
+type BuildInstancedBodyParams = {
+    /** Radial segments of the torso: 16, 10 or 5 for the three levels of detail. */
+    readonly segments: number;
+    /** Proportions (default `TEAM_GAME`, the joints the game's body was drawn with). */
+    readonly body?: BodySpec;
+};
+/**
+ * The crowd body as one merged geometry, torso, head, hair, jaw, eyes, arms and legs tagged with the bone, pivot and material the shader reads
+ * (G 65367 `buildBody`). The joints come from the spec, so a different `body` moves the limbs; the parts' own sizes follow the segment lengths.
+ */
+declare const buildInstancedBody: (three: Three, { segments, body }: BuildInstancedBodyParams) => Geometry;
+
+type BodyMaterialParams = {
+    /** The depth material for shadows (true) or the lit body (false). */
+    readonly depth?: boolean;
+    /** The shared clock the shader reads (`uTime`): `{ value }` the host advances once per frame. */
+    readonly time: {
+        value: number;
+    };
+    readonly chunk?: BodyChunkOptions;
+};
+/**
+ * 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;
+
+type BodyBatchOptions = {
+    /** Instances the batch can hold. */
+    readonly max: number;
+    readonly castShadow?: boolean;
+    readonly time: {
+        value: number;
+    };
+};
+/** 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 = {
+    readonly a: readonly [number, number, number, number];
+    readonly b: readonly [number, number, number, number];
+    readonly c: readonly [number, number, number, number];
+    readonly color: {
+        readonly r: number;
+        readonly g: number;
+        readonly b: number;
+    };
+    readonly eye?: {
+        readonly r: number;
+        readonly g: number;
+        readonly b: number;
+    };
+    /** Ground height (a pile of bodies, a jump); packed into `b[3]` next to the pose. */
+    readonly y?: number;
+};
+type BodyBatch = {
+    readonly mesh: THREE_NS.InstancedMesh;
+    readonly max: number;
+    readonly count: number;
+    begin(): void;
+    push(instance: BodyInstance): void;
+    end(): void;
+};
+/** 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;
+
+/** 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). */
+declare const LOD_BAKE: readonly [1, 0.5, 0.28];
+/** Distances in metres where the middle and the far level start (G `LOD_D`). */
+declare const LOD_DISTANCES: readonly [18, 55];
+/** Instances each level's batch holds for baked variants (G ZVAR). */
+declare const LOD_BATCH_CAPACITY: readonly [160, 700, 2600];
+/** The far level casts no shadow. */
+declare const LOD_CASTS_SHADOW: readonly [true, true, false];
+/** 0, 1 or 2 for a body `distance` metres from the camera. */
+declare const lodAt: (distance: number, distances?: readonly [number, number]) => 0 | 1 | 2;
+
+/** The pose a body is baked in: every joint at rest, so the shader's animation starts from a neutral body (G 66017 `BAKE_NEUTRO`). */
+declare const BAKE_NEUTRAL_POSE: {
+    readonly lean: 0;
+    readonly armL: 0;
+    readonly armR: 0;
+    readonly elbL: 0;
+    readonly elbR: 0;
+    readonly legL: 0;
+    readonly legR: 0;
+    readonly kneeL: 0;
+    readonly kneeR: 0;
+    readonly headX: 0;
+    readonly headZ: 0;
+    readonly drop: 0;
+    readonly armOut: 0;
+    readonly neck: 0;
+    readonly headFwd: 0;
+};
+type BakeSpec = {
+    readonly type?: string;
+    readonly decay?: number;
+    readonly seed?: number;
+    readonly pose?: Readonly<Record<string, number>>;
+    /** A detailed survivor to bake instead of a zombie body. */
+    readonly retrato?: unknown;
+    readonly [key: string]: unknown;
+};
+/** The rich builders the bake reads, injected: the Bestiário v17 builder and (optionally) the survivor builder. */
+type BakeBuilders = {
+    /** Builds a body at the level of detail `lod` (1, 0.5, 0.28); `spec.pose` already carries the neutral pose. */
+    buildBest(spec: BakeSpec, lod: number): THREE_NS.Object3D;
+    buildPortrait?(portrait: unknown, lod: number): THREE_NS.Object3D;
+    /** The material of the shirt, which the baked parts mark as material 1. */
+    topMaterial(): THREE_NS.Material | null;
+};
+type BakedBody = {
+    readonly geo: THREE_NS.BufferGeometry;
+    readonly s: number;
+    readonly bulk: number;
+    readonly verts: number;
+};
+/**
+ * Bakes a rich body into one indexable geometry, each vertex with its bone, pivot, parent pivot and colour, so the instanced shader can animate it
+ * (G 66019 `bakeBody`). Blood stays a vivid wine red at any decay; eyes are enlarged far away so they read.
+ */
+declare const bakeBody: (three: Three, builders: BakeBuilders, spec: BakeSpec, lod: number) => BakedBody;
+
+type VariantType = {
+    readonly id: string;
+    /** The name the rich builder looks the type up by (the Bestiário's `nome`). */
+    readonly name: string;
+    readonly index: number;
+};
+type BodyVariant = {
+    readonly typeId: string;
+    readonly variant: number;
+    readonly seed: number;
+    readonly decay: number;
+    readonly s: number;
+    readonly bulk: number;
+    /** Vertex count per level of detail. */
+    readonly verts: readonly number[];
+    readonly geometries: readonly THREE_NS.BufferGeometry[];
+};
+/**
+ * The baked variants of each type (G ZVAR): `variantCountFor(type)` bodies per type, each at decay 1, 2, 1, 2 and the seed `7000 + c·101 + v·13`,
+ * baked at the three levels of detail so a horde is a few draw calls.
+ */
+declare const bakeVariants: (three: Three, builders: BakeBuilders, types: readonly VariantType[]) => {
+    readonly variants: BodyVariant[];
+    readonly byType: ReadonlyMap<string, readonly number[]>;
+};
+/** 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[];
+
+/** Where a limb comes from: arms leave at chest height with the sleeve's colour, legs low and long with the trousers'. */
+type LimbLaunch = {
+    readonly x: number;
+    readonly z: number;
+    readonly kind: 'arm' | 'leg';
+    /** The sleeve colour of the owner (arms). */
+    readonly color: number;
+    /** The blood of the owner's age: colour, dried colour and whether it bleeds at all (the oldest dead do not: they spill dust). */
+    readonly blood: {
+        readonly color: number;
+        readonly dried: number;
+        readonly bleeds: boolean;
+    };
+};
+type FlyingLimb = {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    rx: number;
+    rz: number;
+    w: number;
+    t: number;
+    rest: boolean;
+    len: number;
+    col: number;
+    cor: number;
+    seco: number;
+    splat: boolean;
+};
+/** The fluids bridge: where a limb bleeds when it leaves and where it splats when it lands. The host decides what that draws. */
+type LimbEffects = {
+    onLaunch?(limb: FlyingLimb, kind: 'arm' | 'leg'): void;
+    onSplat?(splat: {
+        readonly x: number;
+        readonly z: number;
+        readonly radius: number;
+        readonly rotation: number;
+        readonly color: number;
+        readonly dried: number;
+    }): void;
+};
+type FlyingLimbsOptions = {
+    /** Pieces alive at once (the game's 40 per player); the oldest is reused. */
+    readonly max?: number;
+    readonly random: () => number;
+    readonly effects?: LimbEffects;
+};
+type FlyingLimbs = {
+    readonly mesh: THREE_NS.InstancedMesh;
+    readonly limbs: readonly FlyingLimb[];
+    launch(launch: LimbLaunch): FlyingLimb;
+    update(dt: number): void;
+};
+/** 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: (three: 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;
+    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;
+    /** 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;
+    /** Eye colour as a number (0xRRGGBB). */
+    readonly eye: number;
+};
+type BestBuilderOptions = {
+    readonly types: readonly BestTypeCard[];
+    /** Draws a phase or a seed when the spec has none. Default `Math.random`. */
+    readonly random?: () => number;
+};
+type BestBuilder = {
+    build(spec: Record<string, any>): any;
+    TYPES: Record<string, Record<string, number | boolean>>;
+    /** Level of detail: 1 full, 0.5, 0.28 (segments and sphere resolution scale with it). */
+    setLOD(factor: number): void;
+    /** The shirt material of the last body built (the bake marks it as material 1). */
+    topM(): any;
+};
+declare const createBestBuilder: (THREE: Three, { types, random }: BestBuilderOptions) => BestBuilder;
+
+type PersonBuilderOptions = {
+    /** The stream for stains and phases. The page shared one `rng(77)` across the cast, built in order; default the same. */
+    readonly random?: () => number;
+    readonly createCanvas?: () => HTMLCanvasElement;
+    /** 0 is the highest level of detail (fingers drawn); anything above skips the fingers. Default 0. */
+    readonly detail?: number;
+    /** `prefers-reduced-motion`: no idle motion in `pose`. */
+    readonly reducedMotion?: boolean;
+    /** Eye colour of a zombified body by category (default the page's: lento, corredor, brutamonte). */
+    readonly zombieEyes?: Readonly<Record<string, number>>;
+};
+type PersonBuilder = {
+    build(spec: Record<string, any>, index?: number): any;
+    pose(character: any, zombie: boolean, walk: number, time: number): void;
+    zombify(character: any, category?: string): void;
+    buildPerson(person: Record<string, any>, zombie: boolean): {
+        root: any;
+        chars: any[];
+    };
+};
+declare const createPersonBuilder: (THREE: Three, options?: PersonBuilderOptions) => PersonBuilder;
+
+type ExtraContext = {
+    THREE: any;
+    PI: number;
+    U: any;
+    Hd: any;
+    root: any;
+    add: any;
+    Bx: any;
+    cmat: any;
+    ring: any;
+    torsoGeo: any;
+    legs: any[];
+    arms: any[];
+    fem: boolean;
+    topM: any;
+    m: any;
+    e: any[];
+    k: string;
+    sp: any;
+    splat: any;
+    R: () => number;
+    ball: any;
+    cap: any;
+    hc: any;
+    headG: any;
+    fig: any;
+    upper: any;
+    skinM: any;
+};
+/** Clothing and gear by id (`sp.ex` entries `[id, colour?]`), each drawn onto the body parts it names. */
+declare const EXTRAS: Record<string, (context: ExtraContext) => void>;
+
+type FaceContext = {
+    THREE: any;
+    PI: number;
+    Hd: any;
+    add: any;
+    Bx: any;
+    cmat: any;
+    hc: any;
+    sp: any;
+    f: string[];
+    scaleHex: (hex: number, factor: number) => number;
+};
+/** Face features in the order the page draws them (the order is part of the scene hash): `ids` are the `sp.face` entries that switch one on. */
+declare const FACE_FEATURES: {
+    ids: string[];
+    apply: ({ Bx, Hd, THREE, add, cmat, f }: FaceContext) => void;
+}[];
+
+type HatContext = {
+    THREE: any;
+    PI: number;
+    Hd: any;
+    add: any;
+    Bx: any;
+    cmat: any;
+    cap: any;
+    c: any;
+    k: string;
+    sp: any;
+};
+/** Hats by kind (`sp.hat.k`); `c` is the hat's material. */
+declare const HATS: {
+    kinds: string[];
+    apply: ({ Bx, Hd, PI, add, c, cap, k }: HatContext) => void;
+}[];
+
+type HandItemContext = {
+    THREE: any;
+    PI: number;
+    add: any;
+    Bx: any;
+    cmat: any;
+    g: any;
+    metal: any;
+    dark: any;
+    woodM: any;
+};
+/** 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>;
+
+/** A soft round spot, white in the middle and clear at the edge: the sprite of an eye that glows. Needs a canvas; without one, returns no texture. */
+declare const createGlowTexture: (three: Three, createCanvas?: () => {
+    width: number;
+    height: number;
+    getContext(kind: "2d"): unknown;
+}) => THREE_NS.Texture | null;
+type EyeOptions = {
+    readonly color: number;
+    /** Radius of the eyeball. */
+    readonly radius?: number;
+    /** Size of the additive glow sprite; 0 draws no glow. Default five times the radius, as the Bestiário does. */
+    readonly glow?: number;
+    readonly glowOpacity?: number;
+    readonly texture?: THREE_NS.Texture | null;
+};
+/** One glowing eye: an unlit ball (emissive by itself) and an additive sprite on top. Add it to the head group at the socket. */
+declare const createEye: (three: Three, { color, radius, glow, glowOpacity, texture }: EyeOptions) => THREE_NS.Group;
+type Eyes = {
+    /** The eyeballs: the meshes the builder marked `userData.eye`. They are what a test layer can ask for with `isolate`. */
+    readonly markable: readonly THREE_NS.Mesh[];
+    /** The additive sprites next to them. */
+    readonly glows: readonly THREE_NS.Sprite[];
+    /** Brightness 0..1 of both the ball colour and the glow. */
+    setBrightness(level: number): void;
+    /** A quarter of the light: a zombie that has not noticed anyone. */
+    dim(): void;
+    /** Dark: the eyes of a dead body. */
+    off(): void;
+    /** Back to the colour the body was built with. */
+    on(): void;
+    /** Hides everything that is not an eye (the test area's "eyes only" layer); `false` shows it again. */
+    isolate(only: boolean): void;
+};
+/** Finds the eyes of a body (a built zombie or a person with `zombify`) and gives them a dimmer: ball colour and additive glow move together. */
+declare const findEyes: (three: Three, root: THREE_NS.Object3D) => Eyes;
+
+/** The numbers of the Elenco's swinging arm (`pends`, line 593). */
+declare const PENDULUM: {
+    /** Spring toward the pose of the body: `-26 (angle + base)`. */
+    readonly spring: 26;
+    /** Damping: `-1.8 v`. */
+    readonly damping: 1.8;
+    /** Angular speed the blow gives the arm. */
+    readonly kick: 6;
+    /** Sway added while the body walks: `sin(2 phase) * 9`. */
+    readonly walkSway: 9;
+    /** Sideways swing of the node: `sin(3 angle) * 0.12`; a shoulder also keeps its side * 0.12. */
+    readonly sideSwing: 0.12;
+    /** The forearm of a broken shoulder hangs at this angle. */
+    readonly forearmHang: -0.05;
+};
+type Pendulum = {
+    /** The group that swings (the upper arm of a broken shoulder, the forearm of a broken elbow). */
+    readonly node: {
+        rotation: {
+            x: number;
+            z: number;
+        };
+    };
+    readonly kind: 'shoulder' | 'elbow';
+    /** The side of the arm, +1 or -1. */
+    readonly side: number;
+    /** The forearm of a broken shoulder, pulled to `forearmHang`. */
+    readonly forearm?: {
+        rotation: {
+            x: number;
+        };
+    };
+    a: number;
+    v: number;
+};
+declare const createPendulum: (node: Pendulum["node"] & {
+    rotation: {
+        x: number;
+    };
+}, kind: Pendulum["kind"], side: number, forearm?: Pendulum["forearm"]) => Pendulum;
+/** One step: `base` is the angle the body carries the arm at (the spine and figure lean, plus the shoulder for an elbow); `walkPhase` sways it while walking. */
+declare const stepPendulum: (pendulum: Pendulum, base: number, dt: number, walkPhase?: number) => void;
+
+/** The Elenco's `blobR`: the radii of a ragged round outline (`n` points), from a seeded rough shape. `random` is the stream the page called `R`. */
+declare const blobRadii: (n: number, rough: number, seed: number, random: () => number) => number[];
+/** The Elenco's `blobGeo`: a flat shape from those radii, stretched by `rx` and `ry`. */
+declare const blobGeometry: (three: Three, radii: readonly number[], rx: number, ry: number) => THREE_NS.ShapeGeometry;
+type WoundMaterials = {
+    readonly wound: THREE_NS.MeshStandardMaterial;
+    readonly bone: THREE_NS.MeshStandardMaterial;
+    readonly meat: THREE_NS.MeshStandardMaterial;
+    readonly fat: THREE_NS.MeshStandardMaterial;
+    readonly rim: THREE_NS.MeshStandardMaterial;
+    /** Arsenal `M.hole`, `M.bruise` and `M.flesh`: the dark entry hole, the bruise around it and torn flesh. */
+    readonly hole: THREE_NS.MeshStandardMaterial;
+    readonly bruise: THREE_NS.MeshStandardMaterial;
+    readonly flesh: THREE_NS.MeshStandardMaterial;
+    readonly dispose: () => void;
+};
+/** The Elenco's wound materials (`woundM`, `boneM`, `meatM`, `fatM`, `rimM`). */
+declare const createWoundMaterials: (three: Three) => WoundMaterials;
+/**
+ * The cut face of a limb (Elenco `makeCut`): a ragged rim, the meat, a ring of fat, the bone with a splintered tip, torn flaps and two strands. `up` faces
+ * the cut upward (the flying piece), otherwise downward (the stump). Returns the strands' tips, where the stump drips.
+ */
+declare const makeCut: (three: Three, materials: WoundMaterials, random: () => number, group: THREE_NS.Object3D, radius: number, up: boolean) => THREE_NS.Object3D[];
+/** Elenco `makeStump`: the cut face left on the body where the piece left (`flip` turns it over for a head). */
+declare const makeStump: (three: Three, materials: WoundMaterials, random: () => number, parent: THREE_NS.Object3D, position: THREE_NS.Vector3, radius: number, flip?: boolean) => {
+    group: THREE_NS.Group;
+    strands: THREE_NS.Object3D[];
+};
+/** Elenco `ringWound`: the dark ring and three torn strips of a broken bone that stays in the limb. */
+declare const ringWound: (three: Three, materials: WoundMaterials, parent: THREE_NS.Object3D, radius: number, y?: number) => THREE_NS.Group;
+
+type FlyingPiece = {
+    readonly object: THREE_NS.Object3D;
+    readonly velocity: THREE_NS.Vector3;
+    readonly spin: THREE_NS.Vector3;
+    rest: boolean;
+    /** Whatever the caller attached (the segment id the piece came from). */
+    readonly tag?: string;
+};
+type FlyingPiecesOptions = {
+    readonly random: () => number;
+    /** Height of the ground under a point. Default 0. */
+    readonly groundAt?: (x: number, z: number) => number;
+    /** Called once when a piece comes to rest: where a pool should start. */
+    readonly onRest?: (piece: FlyingPiece, point: THREE_NS.Vector3) => void;
+    /** Pieces kept; the oldest is removed beyond it. Default 40 (the game's number). */
+    readonly max?: number;
+};
+type FlyingPieces = {
+    readonly pieces: readonly FlyingPiece[];
+    /** Throws a copy of `source` (in world space, from where it is now) away from the body (Elenco `fly`). `direction` is the side or the blow, in world space. */
+    launch(source: THREE_NS.Object3D, scene: THREE_NS.Object3D, direction: THREE_NS.Vector3, dress?: (clone: THREE_NS.Object3D) => void, tag?: string): FlyingPiece;
+    /** Adds an already-built object to the simulation with a given velocity (Arsenal `particle`). */
+    throwObject(object: THREE_NS.Object3D, velocity: THREE_NS.Vector3, spin: THREE_NS.Vector3, tag?: string): FlyingPiece;
+    update(dt: number): void;
+    clear(): void;
+};
+/** The torn-off pieces of the rich bodies: they fly, spin, bounce and lie on the ground (Elenco `fly` and the `FLY` step of `updateFx`). */
+declare const createFlyingPieces: (three: Three, { random, groundAt, onRest, max }: FlyingPiecesOptions) => FlyingPieces;
+
+/** Arsenal `starGeo`: the ragged star of an exit wound, `points` spikes. */
+declare const starGeometry: (three: Three, random: () => number, radius: number, points: number) => THREE_NS.ShapeGeometry;
+/** Arsenal `woundDecal`: a bruise with a rim and a dark hole, laid on a segment at a world point with the surface normal. */
+declare const woundDecal: (three: Three, materials: WoundMaterials, segment: THREE_NS.Object3D, point: THREE_NS.Vector3, normal: THREE_NS.Vector3, radius: number) => THREE_NS.Mesh;
+/**
+ * Arsenal `exitWound`: finds where the bullet left the segment (a ray back along the shot from 0.6 m beyond) and lays a torn star there. Returns the
+ * world point and the surface normal, or undefined when the ray missed (the part was too small).
+ */
+declare const exitWound: (three: Three, materials: WoundMaterials, random: () => number, segment: THREE_NS.Object3D, point: THREE_NS.Vector3, direction: THREE_NS.Vector3, damage: number) => {
+    point: THREE_NS.Vector3;
+    normal: THREE_NS.Vector3;
+    radius: number;
+} | undefined;
+/**
+ * Arsenal `gouge`: a blow of 55 or more tears chunks out (7 from 150, 4 from 55, 2 below), leaves a crater with a flesh rim and, on a limb, a splinter
+ * of bone. `fling` receives each chunk with its velocity and spin. Returns the crater.
+ */
+declare const gouge: (three: Three, materials: WoundMaterials, random: () => number, segment: THREE_NS.Object3D, segmentKind: string, point: THREE_NS.Vector3, normal: THREE_NS.Vector3, direction: THREE_NS.Vector3, damage: number, fling: (chunk: THREE_NS.Object3D, velocity: THREE_NS.Vector3, spin: THREE_NS.Vector3) => void) => THREE_NS.Mesh;
+/** 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 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). */
+    readonly node: THREE_NS.Object3D;
+    /** Radius of the cut face. */
+    readonly radius: number;
+    /** For an arm: which one in `rig.arms`, and the joint that swings when the bone breaks. */
+    readonly arm?: {
+        readonly index: number;
+        readonly joint: 'shoulder' | 'elbow';
+    };
+    readonly leg?: number;
+    /** The cut face of a head faces the other way. */
+    readonly flip?: boolean;
+};
+type WoundBody = {
+    readonly root: THREE_NS.Object3D;
+    readonly rig: RichRig;
+    readonly nodes: Partial<Record<SegmentId, WoundNode>>;
+};
+/**
+ * Maps the rich body the best builder makes onto the engine's segments. The left side is +x, as the engine has it. The drawn body has no hand or foot
+ * group of its own: they ride with the forearm and the shin, so a hand or foot that is lost takes its parent's node only when the parent is lost too.
+ */
+declare const woundBodyOf: (root: THREE_NS.Object3D) => WoundBody | undefined;
+
+/** 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;
+};
+type FluidsBridgeOptions = {
+    readonly sink: BloodSink;
+    /** 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. */
+    burst(change: 'severed' | 'destroyed' | 'split', point: Vec3$1): void;
+    /** 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, liquid, spurtSpeed }: FluidsBridgeOptions) => FluidsBridge;
+
+type WoundsOptions = {
+    readonly random: () => number;
+    /** Where the flying pieces land. Default: the parent of the body. */
+    readonly scene: THREE_NS.Object3D;
+    readonly groundAt?: (x: number, z: number) => number;
+    /** The fluids bridge, when the game has the fluids packages. Without it the wounds draw no blood on the ground. */
+    readonly bridge?: FluidsBridge;
+    readonly materials?: WoundMaterials;
+    /** Pieces alive at once. Default 40. */
+    readonly maxPieces?: number;
+};
+type Wounds = {
+    readonly materials: WoundMaterials;
+    readonly flying: FlyingPieces;
+    /** Starts watching a body. Returns the same body for chaining. */
+    track(body: WoundBody): WoundBody;
+    untrack(body: WoundBody): void;
+    /** Reads an event of the body (a `body`, `hole` or `leak` event of the engine) and draws what it says. Events of other objects are the caller's to filter. */
+    handle(body: WoundBody, event: DestructionEvent): void;
+    /** Sets the walk phase the swinging arms sway to; `undefined` when the body stands. */
+    setWalkPhase(body: WoundBody, phase: number | undefined): void;
+    /** Which segments are gone from the drawn body. */
+    goneOf(body: WoundBody): ReadonlySet<SegmentId>;
+    /** Steps the swinging arms and the flying pieces. Call it after the animation of the frame; `applyLimp` then bends the legs that are hurt. */
+    update(dt: number): void;
+    applyLimp(body: WoundBody): void;
+    dispose(): void;
+};
+/**
+ * Wounds of the rich body (`near` level of the damage model): a cut leaves a stump and a piece that flies, a broken bone leaves a ring wound and a
+ * swinging arm or a limping leg, a part destroyed bursts into chunks, a torso hit hard splits in two, and a bullet leaves an entry decal and, when it
+ * went through, a torn exit. The rule (what is cut, when) is the engine's; this draws the Elenco and Arsenal dynamics for it, with the random stream
+ * injected so a scene can be repeated.
+ */
+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 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;
+    /** 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;
+
+export { type AreaContext, BAKE_NEUTRAL_POSE, BODY_CHUNK, BODY_MATERIAL_DEF, type BakeBuilders, type BakeSpec, type BakedBody, type BestBuilder, type BestBuilderOptions, type BestTypeCard, type BloodSink, type BodyBatch, type BodyBatchOptions, type BodyChunkOptions, type BodyInstance, type BodyJoints, type BodyMaterialParams, type BodyVariant, type BuildInstancedBodyParams, CHARACTERS_AREA_ID, type CharactersTestOptions, EXTRAS, type EyeOptions, type Eyes, FACE_FEATURES, 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, type Pendulum, type PersonBuilder, type PersonBuilderOptions, type PoseTargets, type ProfessionCard, type RichRig, type RigAnimator, type RigAnimatorOptions, type Three, type UndeadCard, type UndeadLike, type VariantType, type WoundBody, type WoundMaterials, type WoundNode, type Wounds, type WoundsOptions, ZOMBIE_ITEM_PREFIX, bakeBody, bakeVariants, blobGeometry, blobRadii, buildInstancedBody, createBestBuilder, createBodyBatch, createBodyChunk, createBodyMaterial, createCharactersTestModule, createEye, createFluidsBridge, createFlyingLimbs, createFlyingPieces, createGlowTexture, createPendulum, createPersonBuilder, createRigAnimator, createVariantBatches, createWoundMaterials, createWounds, exitWound, explodeChunks, findEyes, gouge, jointsOf, lodAt, makeCut, makeStump, registerBodyMaterial, ringWound, starGeometry, stepPendulum, woundBodyOf, woundDecal };