@adatechnology/game-test-room 0.18.0 → 0.19.1

package/README.md

@@ -130,6 +130,12 @@ Anything slow shows a spinner or a bar with a line of text over the room, so the
 
 A module declares what is slow and the room does the rest: `ModuleControl.slow` (an action or a control that takes a third of a second or more) and `TestableItem.slow` (a vehicle) make the room's own panel and catalogue run the press or the spawn behind the indicator (`bench().act/set` and `spawn` stay synchronous for scenarios). A module with a job of its own (a house rebuilt after a seed change) calls `host.loading.busy(...)`. `LOADING_CSS` and `loadingMarkup` are the same card as static HTML, for a page that must show it before its scripts run (the default test room's first frame does).
 
+## How long debris stays on screen
+
+`debris: { fragmentLife, maxFragments, particles }` sets it for the whole room. `fragmentLife` is in seconds (default 12, `0` = forever) or a rule per fragment
+(`(fragment, objectId) => seconds`, from its material, size and object). `maxFragments` is the live budget (default 160). `particles` tunes the sprites by kind, for
+example `{ dust: { life: [10, 30] }, chips: { life: [60, 120] } }`. Loose pieces stay in the map with collision.
+
 ## Blasts shove what is around them
 
 An `explosion` moves the loose items, the heavy furniture that is not fixed, and the bodies of the modules that answer it. One rule, `blastShove` of `@adatechnology/game-contracts`: `min(maxSpeed, sqrt(2 * energy * coupling / mass)) * (1 - d / r)^2` away from the centre with some lift, and nothing under `minSpeed`. The room's `blastShove` option sets the numbers (`coupling` 0.02, `maxSpeed` 20 m/s, `lift` 0.3, `minSpeed` 0.3, `falloffPower` 2) for the renderer's pieces and, as `host.blastShove`, for modules such as the characters area, which slide and knock their people down.
@@ -205,7 +211,9 @@ Every frame the room puts `root` at the player's feet turned to where the player
 
 **Pushing furniture.** Against a piece that stands on the floor, with bare hands, a tap on E grabs as ever and holding E fills a ring around the crosshair (longer the heavier). Then W pushes, S pulls, slower with the mass; letting go ends it. Before each step the volume of the piece is swept (`world.sweepBox`) against everything and the arena: at an obstacle the piece and the player stop and the player strains, and a piece too heavy for the player (`RoomOptions.push`, `FurniturePushRules` of game-player) never moves. A piece lower than a table is pushed from above, bent over it. Scripted: `room.push`. Try it: `?scene=push` in the example.
 
-**First-person arms and strikes.** An avatar may carry `firstPerson` (arms drawn in the camera's space; the room shows them only in the first person, updates them every frame after the modules' frame hooks and hands them where the tool in the hands asks the hands to be) and `strike(clipId)`. The hand targets come from the module that places the tool (`host.setHandTargets(source)`, `HandTargets` of `@adatechnology/game-contracts`: world-space poses of the right and left hand plus the grip closure and the size of the hands), else from the carried item, else null; the stance is `hold` when there are targets, else `handStances[toolId]` (default `{ fists: 'fists' }`) or `relaxed`. A melee strike (`fists`, `shove`, Shift+V kick) no longer lands at the click: the room calls `avatar.strike(strikeClips[toolId])` (default `{ fists: 'punch_right', shove: 'shove_two_hands', kick: 'front_kick' }`), which plays the clip on the arms and on the body and answers the seconds to its impact, writes a `strike` line to the log, and calls the existing `meleeUse` at that second with the aim read again. The left click with bare hands (`hand`, the default tool) punches too (E or the right button grab). Punches alternate hands, right first (`punchHand`: `alternate`, `left`, `right`; `punchTools`, default `['hand', 'fists']`): the room calls `strike(clip, { hand })` and logs the hand, as the kick does with `kickLeg` and `{ leg }`. A **strike combo** is an ability the page gives (`strikeCombo`, such as `PUNCH_COMBO` of `game-characters-people`: jab, cross, hook, uppercut): while it is on (N, its button, `setStrikeCombo(true)`, `strikeComboOn`) each blow of its tools plays its next step (`{ clip, hand }`) and a pause longer than its `reset` starts it over; off, the tools strike as usual. The strike line carries `combo` and `step`. A tool without a clip, or an avatar that answers null, keeps the instant blow; a strike pending blocks the same tool. `toRoomAvatar(createPlayerAvatar(THREE))` already gives all of it (`firstPerson: false` for no arms).
+**Opening by hand.** A tap of E on a leaf (a part an `open_*` clip of the item moves: furniture doors, drawers and lids, vehicle doors, hood and trunk) opens it, and E again closes it; looking into what an open leaf opened, E closes that leaf. The player steps up to the handle, the body's hand goes to the free edge of the leaf (a drawer by its front) through the same `reach` as a held tool, in both views, and follows it, pulling (the arm bends, the body leans back) or pushing; a door that swings into the player makes the player step back. The leaf swings along the item's own clip at a speed set by its mass, its sweep tested against the world (`world.sweepBox`) and the arena: it stops at what is in its way with a knock. A locked leaf (`room.lockLeaf`) only rattles. Latch, hinge creak, the leaf meeting the frame and the rattle play by material. Holding E still pushes the piece. Scripted: `room.useLeaf`, `room.leafOpening`, `room.leaves`, `room.door`; the numbers are `RoomOptions.doors` (`DoorUseRules` of game-player). A module that moves its own leaves (the doors of a house) asks for the same hand and body with `host.reachFor`. Try it: `?scene=doors` in the example.
+
+**Hands and strikes.** The body is the only set of arms, in both views: the room hands its hands where the tool in them asks them to be (`reach`, every frame after the modules' frame hooks) and an avatar may answer `strike(clipId)`. The hand targets come from the module that places the tool (`host.setHandTargets(source)`, `HandTargets` of `@adatechnology/game-contracts`: world-space poses of the right and left hand plus the grip closure and the size of the hands), else from the carried item, else null; the stance is `hold` when there are targets, else `handStances[toolId]` (default `{ fists: 'fists' }`) or `relaxed`. A melee strike (`fists`, `shove`, Shift+V kick) no longer lands at the click: the room calls `avatar.strike(strikeClips[toolId])` (default `{ fists: 'punch_right', shove: 'shove_two_hands', kick: 'front_kick' }`), which plays the clip on the body (in both views) and answers the seconds to its impact, writes a `strike` line to the log, and calls the existing `meleeUse` at that second with the aim read again. The left click with bare hands (`hand`, the default tool) punches too (E or the right button grab). Punches alternate hands, right first (`punchHand`: `alternate`, `left`, `right`; `punchTools`, default `['hand', 'fists']`): the room calls `strike(clip, { hand })` and logs the hand, as the kick does with `kickLeg` and `{ leg }`. A **strike combo** is an ability the page gives (`strikeCombo`, such as `PUNCH_COMBO` of `game-characters-people`: jab, cross, hook, uppercut): while it is on (N, its button, `setStrikeCombo(true)`, `strikeComboOn`) each blow of its tools plays its next step (`{ clip, hand }`) and a pause longer than its `reset` starts it over; off, the tools strike as usual. The strike line carries `combo` and `step`. A tool without a clip, or an avatar that answers null, keeps the instant blow; a strike pending blocks the same tool. `toRoomAvatar(createPlayerAvatar(THREE))` already gives all of it .
 
 `room.setCameraMode('first' | 'third')` (option `cameraMode`, property `cameraMode`, event `room.on('camera', fn)`; every change is a `camera` action in the log). V toggles it when a body is set. In `first` the body is hidden; in `third` it is shown, the camera stands over the shoulder, and a carried item rides `avatar.hand('R')` instead of the camera frame. Option `thirdPerson` changes the view; the defaults are the team game's shoulder camera (`zombiada-modo-livre.html`, `cameraUpdate`, line 76546): `back` 3.8 m, `side` 0.9 m to the right, `up` 1.95 m (`crouchUp` 1.4 m), `lift` 0.1 m, three probe rays (`probes` 0 and +-0.2 m) that pull the camera in `margin` 0.3 m short of a wall (never closer than `minDistance` 0.2 m) and let it out at `recover` 4 per second.
 

package/dist/index.d.ts

@@ -2,16 +2,41 @@ import * as THREE_NS from 'three';
 import { AudioEngine } from '@adatechnology/game-audio';
 import { Vec3 as Vec3$1, DestructionWorld, BlastOptions, DestructibleSpec, DestructionOptions, DestructionEvent } from '@adatechnology/game-destruction';
 export { DestructionEvent, Vec3 } from '@adatechnology/game-destruction';
-import { FurniturePushPhase, FurniturePushBlock, FurniturePushRules } from '@adatechnology/game-player';
-import { BusySink, Vec3, HandTargets, ModuleControl, ControlValue, ModuleLayer, EnvironmentBus, BusyTask, BusyOptions, TestableModule, DestructibleImpl, AnimationClipSpec, GroundLayout, BlastShoveOptions } from '@adatechnology/game-contracts';
+import { DoorUsePhase, FurniturePushPhase, FurniturePushBlock, FurniturePushRules, DoorUseRules } from '@adatechnology/game-player';
+import { BusySink, ItemSeat, Vec3, HandTargets, ModuleControl, ControlValue, ModuleLayer, EnvironmentBus, BusyTask, BusyOptions, TestableModule, ModuleItemSeal, DestructibleImpl, AnimationClipSpec, GroundLayout, BlastShoveOptions } from '@adatechnology/game-contracts';
 export { AnimationClipSpec, DestructibleImpl, ItemAnimationContract, ModuleScenario, TestableItem, TestableModule } from '@adatechnology/game-contracts';
-import { DestructionRenderer, SpecFromObjectOptions, Quality } from '@adatechnology/game-destruction-three';
+import { DestructionRenderer, SpecFromObjectOptions, Quality, FragmentLifeRule } from '@adatechnology/game-destruction-three';
 import { Arsenal, WeaponState, WeaponDef } from '@adatechnology/game-weapons';
-import { VfxWorld } from '@adatechnology/game-vfx';
+import { VfxWorld, SpriteKindDef } from '@adatechnology/game-vfx';
 import { Terrain, TerrainBudget } from '@adatechnology/game-terrain';
 import { FilmBridge, FluidRenderer } from '@adatechnology/game-fluids-three';
 import { FluidWorld, ContainerSpec, LiquidDef, ItemUseDef, SurfaceSpec } from '@adatechnology/game-fluids';
 
+/**
+ * The room's side of opening and closing by hand: finds the leaf the eye rests on (a door, a lid, a drawer of furniture or of a vehicle: a part an `open_*` clip of the item moves),
+ * asks `createDoorUse` (game-player) how far it goes, tests the sweep of the leaf against what is around before each step and puts the hand on the handle.
+ * The leaf is posed along its item's own open clip, so the same opening the item's animation shows is the one the hand drives.
+ */
+
+type RoomDoorEventType = 'reach' | 'opened' | 'closed' | 'blocked' | 'locked' | 'stepped_back';
+type RoomDoorEvent = {
+    readonly type: RoomDoorEventType;
+    readonly objectId: string;
+    readonly part: string;
+    readonly name: string;
+    /** How open the leaf is, 0 to 1. */
+    readonly opening: number;
+    /** What stopped it (`blocked`): another object, the wall of the room, the player. */
+    readonly by?: string;
+};
+type RoomDoorState = {
+    readonly objectId: string;
+    readonly part: string;
+    readonly phase: DoorUsePhase;
+    readonly opening: number;
+    readonly goal: 0 | 1;
+};
+
 /**
  * The room's side of pushing furniture: finds what the player leans on, asks `createFurniturePush` (game-player) how it goes, tests the volume of the piece before each
  * step (the world, the walls of the arena, the blockers of the modules) and moves it with the player. The animations read `avatarState` and `handTargets`.
@@ -76,6 +101,20 @@ interface LoadingOptions {
 declare const nextPaint: () => Promise<void>;
 declare function createLoading(options: LoadingOptions): RoomLoading;
 
+/**
+ * The room's seats: puts the player on a seat an item brings (`TestRoomItem.seats`, the shape of a `game-interactables` seat) and back on its feet at the seat's exit.
+ * Seated, the keys do not walk and the view stays within reach of the seat's facing; a walk key or a jump gets up, and so does losing the seat (the item is gone).
+ */
+
+/** The seat the player is on. */
+type RoomSeat = {
+    readonly objectId: string;
+    readonly seatId: string;
+    readonly pose: ItemSeat['pose'];
+    /** Where the hips (sit) or the pelvis (lie) are, in the world. */
+    readonly hips: Vec3;
+};
+
 type NewEntry = NewLogEntry;
 /** The log the room writes to (a `TestRoomLog` plus the write side). */
 interface WritableLog extends TestRoomLog {
@@ -322,6 +361,8 @@ interface RoomAvatarItemUse {
     readonly id: string;
     readonly position: readonly [number, number, number];
     readonly rotation: readonly [number, number, number];
+    /** How closed the other hand is when it works on the item (turning a cap off); the room brings it there with `reach`. */
+    readonly gripL?: number;
 }
 /** What the room tells the avatar every frame. */
 interface RoomAvatarState {
@@ -344,6 +385,18 @@ interface RoomAvatarState {
         readonly phase: 'grip' | 'push' | 'strain';
         readonly progress: number;
     } | null;
+    /** On a seat: the pose and how high the hips (or the pelvis) are above the feet. */
+    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`, `rattle` on a locked one; `height` of the hand over the feet, metres. */
+    door?: {
+        readonly phase: 'reach' | 'swing' | 'release' | 'rattle';
+        readonly progress: number;
+        readonly height: number;
+        readonly pull: boolean;
+    } | null;
 }
 /** What the room tells the first-person arms every frame, after the modules have placed the tool in the hands. */
 interface RoomFirstPersonState {
@@ -367,16 +420,17 @@ interface RoomAvatar {
     update(dt: number, state: RoomAvatarState): void;
     /** A socket at a hand: the carried item follows `hand('R')` in third person. */
     hand?(side: 'R' | 'L'): THREE_NS.Object3D;
+    /** The joint of a shoulder: in third person the room rests a long gun's stock in the pocket just inside the right one (`ModuleHost.holdFrame`). */
+    shoulder?(side: 'R' | 'L'): THREE_NS.Object3D;
     /**
-     * The arms of the first-person view. The room shows `root` only in first person (the body only in third), updates it every frame after the modules'
-     * frame hooks (so the tool in the hands is already placed) and before the render.
+     * Where the body's eyes are after its pose (world space), sampled before `reach`: with it the room draws the body in both views, puts the first-person camera there (pulled back out of
+     * walls) and shoots, aims and reaches from there in both views. Without it the room keeps the player's own eye.
      */
-    firstPerson?: {
-        root: THREE_NS.Object3D;
-        update(dt: number, state: RoomFirstPersonState): void;
-    };
+    eye?(out?: THREE_NS.Vector3): THREE_NS.Vector3;
+    /** Hides the head and neck from `camera` while the view is `first` (shadows, mirrors and other cameras keep seeing them). */
+    setView?(mode: CameraMode, camera: THREE_NS.Object3D | null): void;
     /**
-     * Plays the strike `clipId` (on the body and on the arms) and answers the seconds until its impact, or null when this avatar has no such clip. The room then waits that long
+     * Plays the strike `clipId` (on the body, in both views) and answers the seconds until its impact, or null when this avatar has no such clip. The room then waits that long
      * before the blow lands (`strikeClips`); an avatar without `strike`, or one that answers null, gets the blow at the click.
      */
     strike?(clipId: string, options?: {
@@ -384,10 +438,17 @@ interface RoomAvatar {
         hand?: 'left' | 'right';
     }): number | null;
     /**
-     * Brings the body's hands to the tool in them (`HandTargets`, world space: the module's, as the first-person arms get them). The room calls it in third person every frame, after the
-     * modules have placed the tool and before the render; an avatar without it keeps the hands where its own pose puts them.
+     * Brings the body's hands to the tool in them (`HandTargets`, world space: the module's). The room calls it in both views every frame, after the modules have placed the tool and
+     * before the render, with `view` (the eye's camera, and `contact` to keep the hands out of walls) in both views. An avatar without it keeps the hands where its own pose puts them.
      */
-    reach?(targets: HandTargets | null): void;
+    reach?(targets: HandTargets | null, view?: RoomReachView): void;
+}
+/** The first-person view the body's hands keep to: the camera, and the room's ray (`contact`) so a hand stops before a wall. */
+interface RoomReachView {
+    camera: THREE_NS.Object3D;
+    keepOutside?: {
+        contact(origin: [number, number, number], direction: [number, number, number], maxDistance: number): number | null;
+    };
 }
 /** Which leg a kick uses: `alternate` swaps at each kick (right first). */
 type KickLeg = 'alternate' | 'left' | 'right';
@@ -464,6 +525,8 @@ interface TestRoomItem {
     specOptions?: SpecFromObjectOptions;
     /** Can be grabbed and thrown (default: total mass <= `maxCarryKg`). Vehicles and trees are usually `false`. */
     movable?: boolean;
+    /** A big piece that stands on the floor (a sofa, a wardrobe, a fridge) and can be pushed by leaning on it (`TestableItem.pushable`). Default false. */
+    pushable?: boolean;
     /** Short note shown in the inspector. */
     note?: string;
     /** Building it takes a noticeable time (a vehicle): the catalogue shows the loading indicator while it spawns one. `true`, or the text to show. */
@@ -478,6 +541,11 @@ interface TestRoomItem {
         uses?: string[];
         offset?: Vec3$1;
     };
+    /**
+     * The item is a sealed container (`ModuleItemSeal`): a use that empties it (`eat`, `drink`, `pour`) opens it first, by hand or with one of `openWith` (an item
+     * within reach or a weapon of the loadout), and refuses while it needs a tool there is not; a hole through it or a leak spoils it for eating and drinking.
+     */
+    seal?: ModuleItemSeal;
     /** The item is also a weapon the player can equip from the catalogue (e.g. a crowbar, a knife, a pistol on the table). */
     weapon?: string;
     /**
@@ -487,6 +555,8 @@ interface TestRoomItem {
     impl?: (root: THREE_NS.Object3D, id: string) => DestructibleImpl;
     /** Use animations the item brings (see `TestRoom.playAnimation`). Part poses move the child of the built object named after the part id. */
     animations?: AnimationClipSpec[];
+    /** Where the player can sit or lie on it (see `TestRoom.sit`). */
+    seats?: readonly ItemSeat[];
     /** Picture for the catalogue, the search results and the aimed-item label: an image URL or inline `<svg…>` markup (see `TestableItem.thumbnail`). */
     thumbnail?: string;
     /** Author and licence of the thumbnail, shown as the tooltip of the picture in the inspector. */
@@ -513,11 +583,12 @@ interface SceneryObject {
     /**
      * Lets the drawing follow the object in the destruction world, for what the room's destruction renderer cannot draw on it (a house wall redraws its
      * courses without the bricks that shots knock out). Called once the object is in the world as `objectId`; the room calls `restore` when it resets the
-     * object and `dispose` when it removes it.
+     * object and `dispose` when it removes it. `update` (optional) is called every frame, after the renderer's: where the follower paints what it deferred.
      */
     follow?: (root: THREE_NS.Object3D, world: DestructionWorld, objectId: string) => {
         restore?(): void;
         dispose?(): void;
+        update?(): void;
     } | null | void;
     /** Name shown in the inspector and the log (default the translated name of a default id, else the id). */
     label?: string;
@@ -539,6 +610,8 @@ interface SceneryObject {
      * not a pistol), make it a piece and shove it. Default false: the scenery stays put.
      */
     free?: boolean;
+    /** Can also be pushed by leaning on it (needs `free`). Default false. */
+    pushable?: boolean;
 }
 /** What the room asks when something thrown or set down needs a model: the tool in the hand, the explosive it carries (an id of the arsenal) and how it is used. */
 interface ProjectileQuery {
@@ -641,6 +714,8 @@ interface TestRoomOptions {
     strikeClips?: Readonly<Record<string, string>>;
     /** The numbers of pushing furniture (`FurniturePushRules` of game-player): the player's force, the friction by material, the hold time, the speed. */
     push?: Partial<FurniturePushRules>;
+    /** The numbers of opening by hand (`DoorUseRules` of game-player): how long the hand takes to the handle, how fast a leaf of each mass swings. */
+    doors?: Partial<DoorUseRules>;
     /** Which leg the kick uses: `alternate` (default) swaps at each kick starting with the right, or always `left` or `right`. */
     kickLeg?: KickLeg;
     /** Metres above the feet the kick looks for a target from (level, the way the player faces; the nearest hit wins), so it finds what stands low in front; default every 10 cm from 0.25 to 0.85 m (shin to hip). */
@@ -666,6 +741,19 @@ interface TestRoomOptions {
     thirdPerson?: ThirdPersonOptions;
     /** Room counters the bench panel shows and `TestRoom.metrics()` returns (default all); `false` for none. */
     metrics?: readonly RoomMetricId[] | false;
+    /**
+     * How long what breaks off stays on screen. `fragmentLife`: seconds a resting fragment (a chip, a shard, a chunk) stays before it fades, 0 = forever, or a rule per
+     * fragment from its material, size and object (default 12 s); `maxFragments`: how many live at once, the oldest fades first (default 160). `particles` tunes the
+     * sprites (dust, smoke, chips, sparks...) by kind, e.g. `{ dust: { life: [10, 30] } }` (seconds, min and max). Loose pieces (what breaks off whole: a door, a leg,
+     * a slab) stay as part of the map, with collision.
+     */
+    debris?: {
+        fragmentLife?: number | FragmentLifeRule;
+        maxFragments?: number;
+        particles?: Readonly<Record<string, Partial<SpriteKindDef> | null>>;
+        /** Milliseconds of destruction events the renderer applies per frame; the rest wait for the next frames (default 8). `Infinity` applies every event in the frame it happens, which a test comparing counts needs. */
+        eventBudgetMs?: number;
+    };
     /** Blast options every explosion of the room starts with (`shelter`, `fragmentHits`, `confinement`; default all off). The HUD toggles them and `TestRoom.setBlast` changes them. */
     blast?: BlastOptions;
     /**
@@ -753,6 +841,15 @@ interface TestRoom {
     readonly playerPosition: Vec3$1;
     /** Grab what the camera looks at (or drop what is held). */
     grab(): boolean;
+    /**
+     * Sits the player on a seat an item brings (`TestRoomItem.seats`): on `objectId` (default: what the camera looks at, within 3.2 m), on `seatId` (default: the seat nearest the
+     * player). Seated, the keys do not walk and the view stays near the seat's facing; a walk key or a jump gets up. Null when there is no seat there.
+     */
+    sit(objectId?: string, seatId?: string): RoomSeat | null;
+    /** Gets up at the seat's exit; false when not seated or something stands on the exit. */
+    stand(): boolean;
+    /** The seat the player is on, or null. */
+    readonly seat: RoomSeat | null;
     /**
      * Pushing furniture, as holding E against it does: `begin` leans on what the camera looks at (false: nothing within reach to lean on), `setWalk` walks by script (world `[x, z]`, unit; null: the keys), `end`
      * lets go, and `state` says the phase (`grip` while the hold timer fills, `push`, `strain`), the timer and what stops it (`too_heavy`, `obstacle`).
@@ -856,6 +953,19 @@ interface TestRoom {
      * offsets from the rest pose, interpolated linearly; the item keeps the last pose. Events are logged (and `sound` events reach `onSound`).
      */
     playAnimation(clipId: string, objectId?: string): boolean;
+    /**
+     * Opens or closes a leaf (a door, a lid, a drawer: a part an `open_*` clip of the item moves) as the hand does with E: the hand goes to the handle, the leaf swings at the speed of
+     * its mass and stops at what is in its way; a locked leaf only rattles. Default part: the first leaf of the object. Answers false when the object has no such leaf.
+     */
+    useLeaf(objectId: string, part?: string): boolean;
+    /** How open a leaf is, 0 closed to 1 open (default part: the first leaf). */
+    leafOpening(objectId: string, part?: string): number;
+    /** The parts of an object that open by hand. */
+    leaves(objectId: string): string[];
+    /** Locks (or unlocks) a leaf, or every leaf of the object when `part` is left out: E then only rattles it. */
+    lockLeaf(objectId: string, locked?: boolean, part?: string): void;
+    /** The leaf being worked by hand now, or null. */
+    readonly door: RoomDoorState | null;
     /** The bench of a loaded module (default the active one: the module of the last `openArea`, else the last loaded with a bench), or null. */
     bench(moduleId?: string): BenchHandle | null;
     /**
@@ -1062,4 +1172,4 @@ declare function encodeBenchState(controls: readonly BenchControl[], layers: rea
 /** Reads an encoded state as hostile input: unknown ids, NaN, options not offered and malformed pairs are dropped; numbers are clamped. */
 declare function decodeBenchState(encoded: string, controls: readonly ModuleControl[], layers: readonly ModuleLayer[]): Map<string, ControlValue>;
 
-export { type AnimationInfo, type BenchControl, type BenchHandle, type BenchLayer, type BuildFromSpecOptions, type CameraMode, DEFAULT_HAND_STANCES, DEFAULT_STRIKE_CLIPS, DEFAULT_TRIALS, type HudState, type InspectInfo, type KickLeg, LOADING_CLASS, LOADING_CSS, type LoadingOptions, type LoadingState, type LogEntry, MATERIAL_COLORS, type ModuleReport, type NewEntry, type NewLogEntry, type ProjectileModel, type ProjectileQuery, type PunchHand, type RoomAvatar, type RoomAvatarState, type RoomFirstPersonState, type RoomLoading, type RoomMetricId, type RoomPushEvent, type RoomPushState, type RoomStrings, type ScenarioContext, type ScenarioReport, type SceneryObject, type SceneryTap, type SpawnedObject, type StrikeComboOption, TRIAL_KINDS, type TestRoom, type TestRoomItem, type TestRoomLocale, type TestRoomLog, type TestRoomOptions, type TestRoomScenario, type TestTable, type TestTableContext, type TestTableObject, type TestTableOptions, type TestTablePage, type ThirdPersonOptions, type ThreeNamespace, type TrialKind, type TrialTool, type WritableLog, brickWallSpec, buildFromSpec, createLoading, createLog, createTestRoom, createTestTable, decodeBenchState, encodeBenchState, fitRow, loadingMarkup, locales, nextPaint, resolveStrings, rowCentres, trialView };
+export { type AnimationInfo, type BenchControl, type BenchHandle, type BenchLayer, type BuildFromSpecOptions, type CameraMode, DEFAULT_HAND_STANCES, DEFAULT_STRIKE_CLIPS, DEFAULT_TRIALS, type HudState, type InspectInfo, type KickLeg, LOADING_CLASS, LOADING_CSS, type LoadingOptions, type LoadingState, type LogEntry, MATERIAL_COLORS, type ModuleReport, type NewEntry, type NewLogEntry, type ProjectileModel, type ProjectileQuery, type PunchHand, type RoomAvatar, type RoomAvatarState, type RoomDoorEvent, type RoomDoorState, type RoomFirstPersonState, type RoomLoading, type RoomMetricId, type RoomPushEvent, type RoomPushState, type RoomReachView, type RoomSeat, type RoomStrings, type ScenarioContext, type ScenarioReport, type SceneryObject, type SceneryTap, type SpawnedObject, type StrikeComboOption, TRIAL_KINDS, type TestRoom, type TestRoomItem, type TestRoomLocale, type TestRoomLog, type TestRoomOptions, type TestRoomScenario, type TestTable, type TestTableContext, type TestTableObject, type TestTableOptions, type TestTablePage, type ThirdPersonOptions, type ThreeNamespace, type TrialKind, type TrialTool, type WritableLog, brickWallSpec, buildFromSpec, createLoading, createLog, createTestRoom, createTestTable, decodeBenchState, encodeBenchState, fitRow, loadingMarkup, locales, nextPaint, resolveStrings, rowCentres, trialView };