@adatechnology/game-weapons-three 0.11.2 → 0.12.0

package/dist/index.d.ts

@@ -1,681 +1,10 @@
-import { HostTool, HandPose, EffectSink, HostEvent, HandTargets, TestableModule, AreaPlacement, DestructionEvent, Hit, Vec3 as Vec3$1, ModuleControl, ModuleLayer, ModuleMetric, ModuleHost, TestableItem, DestructibleSpec, ToolClipSet } from '@adatechnology/game-contracts';
-import { CaliberDef, ReloadStageId, WeaponEvent, MountKind, AttachmentDef, FittedAttachment, Arsenal, ExplosiveDef, WeaponDef, CartridgeDims, CaseType, ReloadFamily } from '@adatechnology/game-weapons';
-import { AudioEngine } from '@adatechnology/game-audio';
+import { I as ItemModels, W as WeaponProps, a as WeaponItemModel, M as ModelKit, b as WeaponModel, c as ModelParts, d as ModelFamily, A as AttachmentModelRegistry, L as LaserRaycast } from './testing-BlaMwqMW.js';
+export { e as ARCHETYPE_MODELS, f as AttachmentBuildContext, g as AttachmentModel, h as AttachmentModelBuilder, C as CLASS_REFERENCE_ENERGY, i as COUNTER_ITEM_ID, D as DEFAULT_ENERGY_CURVE, j as DEFAULT_EXPLOSIVES_SCENE, k as DistanceCurve, E as EXPLOSIVES_AREA_ID, l as EXPLOSIVES_TEXT, m as EnergyCurve, n as ExplosivesRoom, o as ExplosivesScene, p as ExplosivesTestModuleOptions, q as ExplosivesText, F as FxLayers, G as GAME_DISTANCE_CURVE, r as GAME_SOUND_CLASSES, s as ItemModelRequest, t as MECHANICAL_SOUNDS, u as MODEL_ENTRIES, v as MOUNTED_M134_ITEM_ID, w as MechanicalSoundId, x as ModelEntry, y as ModelMaterials, z as ModelOptions, B as MountFrame, S as ShotExtras, H as ShotSound, J as ShotSoundClass, K as ShotSoundInput, N as ShotSoundOptions, O as SoundClassDef, P as SoundStep, Q as WEAPON_ITEM_PREFIX, R as WeaponAudio, T as WeaponAudioOptions, U as WeaponFx, V as WeaponFxOptions, X as WeaponsTestModuleOptions, Y as buildItemWeaponModel, Z as buildWeaponModel, _ as buildWeaponModelById, $ as computeShotSound, a0 as createExplosivesTestModule, a1 as createWeaponAudio, a2 as createWeaponFx, a3 as createWeaponsTestModule, a4 as defaultWeaponProps, a5 as deriveFrames, a6 as explosivesTextOf, a7 as hasWeaponModel, a8 as itemModelOfWeapon, a9 as mechanicalSoundOf, aa as modelKit, ab as mountFrame, ac as registerWeaponItemModel, ad as weaponsLayout } from './testing-BlaMwqMW.js';
 import * as THREE_NS from 'three';
-
-/** One sound of the game: [lowpass cutoff Hz, gain, seconds]. Literal from the `P` table of `sfx` in the game (jogo.js L62101-L62104). */
-type SoundClassDef = readonly [cutoff: number, gain: number, seconds: number];
-/** The game names are pistola, escopeta, fuzil, rifle, impacto, carne, passo, vidro, madeira, recarga, vazio and explosao. */
-declare const GAME_SOUND_CLASSES: {
-    readonly pistol: readonly [1800, 0.9, 0.18];
-    readonly shotgun: readonly [900, 1.2, 0.35];
-    readonly rifle: readonly [1400, 1.1, 0.28];
-    readonly long_rifle: readonly [1100, 1.3, 0.45];
-    readonly impact: readonly [2500, 0.25, 0.05];
-    readonly flesh: readonly [600, 0.35, 0.08];
-    readonly step: readonly [400, 0.08, 0.05];
-    readonly glass: readonly [5000, 0.5, 0.3];
-    readonly wood: readonly [700, 0.5, 0.2];
-    readonly reload: readonly [3000, 0.15, 0.06];
-    readonly empty: readonly [4000, 0.12, 0.03];
-    readonly explosion: readonly [200, 1.6, 1.4];
-};
-/** The four classes a shot can have: the game picks one by calibre (jogo.js L68697). */
-type ShotSoundClass = 'pistol' | 'shotgun' | 'rifle' | 'long_rifle';
-/** Distance muffling of the game (jogo.js L62092, L62105): `gain / (1 + d² × gainFalloff)`, `cutoff / (1 + d × cutoffFalloff)`, silent under `minGain`. */
-type DistanceCurve = {
-    readonly gainFalloff: number;
-    readonly cutoffFalloff: number;
-    readonly minGain: number;
-};
-declare const GAME_DISTANCE_CURVE: DistanceCurve;
-/**
- * The calibre energy (joules) scales loudness, length and brightness around the class: each factor is `base + span × k`, where k goes from 0 (50 J)
- * to 1 (50 J × 10^spanDecades) on a log scale, divided by the same factor at the class reference energy. So the game calibres sound exactly as in
- * the game, and a lighter or heavier calibre of the same class is quieter and brighter, or louder and duller.
- */
-type EnergyCurve = {
-    readonly floorJ: number;
-    readonly spanDecades: number;
-    readonly gain: readonly [base: number, span: number];
-    readonly duration: readonly [base: number, span: number];
-    readonly cutoff: readonly [base: number, span: number];
-    /** The muzzle crack (high noise) and the body (low thump) follow the energy alone. */
-    readonly crackGain: readonly [base: number, span: number];
-    readonly bodyGain: readonly [base: number, span: number];
-    readonly bodyDuration: readonly [base: number, span: number];
-    readonly bodyFrequency: readonly [base: number, span: number];
-};
-declare const DEFAULT_ENERGY_CURVE: EnergyCurve;
-/** Muzzle energy of the game calibres in the SDK (9x19, 12ga_00buck × pellets, 7_62x39, 7_62x51): where a class sounds exactly as in the game. */
-declare const CLASS_REFERENCE_ENERGY: Readonly<Record<ShotSoundClass, number>>;
-type ShotSoundOptions = {
-    /** Replaces or adds sound classes (the game table is the default). */
-    readonly classes?: Readonly<Record<string, SoundClassDef>>;
-    readonly distance?: Partial<DistanceCurve>;
-    readonly energy?: Partial<EnergyCurve>;
-    readonly referenceEnergy?: Partial<Record<ShotSoundClass, number>>;
-    /** Picks the class of a shot; the default follows the game (shotgun by shell, handguns by category, then by energy). */
-    readonly classOf?: (input: ShotSoundInput, energyJ: number) => ShotSoundClass;
-    /** Class bands by energy (J): below `handgunBelowJ` a pistol, below `rifleBelowJ` a rifle, above that a long rifle. */
-    readonly bands?: {
-        readonly handgunBelowJ: number;
-        readonly rifleBelowJ: number;
-    };
-    readonly suppressor?: {
-        readonly gain: number;
-        readonly cutoff: number;
-        readonly crack: number;
-        readonly body: number;
-    };
-    readonly indoors?: {
-        readonly duration: number;
-        readonly cutoff: number;
-    };
-};
-type ShotSoundInput = {
-    /** The calibre; its energy (× pellets) is used unless `energyJ` is given. */
-    readonly caliber?: CaliberDef;
-    readonly energyJ?: number;
-    readonly category?: string;
-    /** Metres from the listener, default 0. */
-    readonly distance?: number;
-    /** Master gain of the game `sfx` (its `vol`), default 1. */
-    readonly volume?: number;
-    readonly suppressed?: boolean;
-    readonly indoors?: boolean;
-};
-type ShotSound = {
-    readonly soundClass: ShotSoundClass;
-    readonly energyJ: number;
-    /** False when the shot is under the game's `minGain` at this distance: nothing is played. */
-    readonly audible: boolean;
-    /** The main noise burst: lowpass cutoff Hz, starting gain and the seconds of the exponential tail (to 0.001). */
-    readonly cutoff: number;
-    readonly gain: number;
-    readonly duration: number;
-    /** High noise burst of the muzzle. */
-    readonly crack: {
-        readonly gain: number;
-        readonly cutoff: number;
-        readonly duration: number;
-    };
-    /** Low thump that sweeps from `frequency` to `to`. */
-    readonly body: {
-        readonly gain: number;
-        readonly frequency: number;
-        readonly to: number;
-        readonly duration: number;
-    };
-};
-/**
- * The parameters of a gunshot, without WebAudio: the sound class and the distance muffling of the game (S2) with the calibre energy of the SDK.
- * Pure and deterministic; the playback layer only turns it into nodes.
- */
-declare const computeShotSound: (input: ShotSoundInput, options?: ShotSoundOptions) => ShotSound;
-
-/** One layer of a mechanical sound; `at` is seconds after the start. */
-type SoundStep = 
-/** Metal click: a short high noise plus a square tone at 0.6 × the frequency (the SDK synth, as before). */
-{
-    readonly layer: 'metal';
-    readonly at: number;
-    readonly frequency: number;
-    readonly gain: number;
-}
-/** A sound class of the game (`recarga`, `vazio`...) played at a volume. */
- | {
-    readonly layer: 'class';
-    readonly at: number;
-    readonly soundClass: keyof typeof GAME_SOUND_CLASSES;
-    readonly volume: number;
-}
-/** Dull landing: lowpass noise. */
- | {
-    readonly layer: 'thud';
-    readonly at: number;
-    readonly gain: number;
-    readonly frequency: number;
-}
-/** The art scene's `sTone` (cena L1324): a tone sliding from `f` to `f2` (default `f`) in `d` seconds, at `vol`, `at` seconds after the start. */
- | {
-    readonly layer: 'scene_tone';
-    readonly at: number;
-    readonly wave: 'sine' | 'square';
-    readonly f: number;
-    readonly f2?: number;
-    readonly d: number;
-    readonly vol: number;
-}
-/** The art scene's `sNoise` (cena L1323): filtered noise, the filter sliding to `f2` when given, `d` seconds, at `vol`. */
- | {
-    readonly layer: 'scene_noise';
-    readonly at: number;
-    readonly type: 'lowpass' | 'highpass' | 'bandpass';
-    readonly f: number;
-    readonly f2?: number;
-    readonly q: number;
-    readonly d: number;
-    readonly vol: number;
-};
-type MechanicalSoundId = ReloadStageId | 'dry_fire' | 'misfire' | 'feed' | 'cycle' | 'mode' | 'safety_on' | 'safety_off' | 'jam' | 'clear_start' | 'clear_end' | 'stock_fold' | 'light_click' | 'attach';
-/**
- * Sounds keyed by the rule: the `reload_stage` ids of `RELOAD_STAGES`, plus the other weapon events. The click of an empty weapon and the generic
- * reload tick are the game's `vazio` and `recarga` classes (jogo.js L62101-L62104; played at L68644-L68662). The Cena de Arte delivered the reload sounds
- * (`empty` -> dry_fire, `magOut` -> magazine_out, `magIn` -> magazine_in, `bolt` -> charge, `shell` -> round_in; cena L1339-L1343), so those use them; the gallery
- * (sources/armas-itens__galeria-3d-arsenal.js) has no sound, and the other metal layers are the SDK synth (the same `metal` used since the first version).
- */
-declare const MECHANICAL_SOUNDS: Readonly<Record<MechanicalSoundId, readonly SoundStep[]>>;
-/** Which mechanical sound a weapon event asks for, if any (`shot`, `draw` and `reload` start/end have their own handling). */
-declare const mechanicalSoundOf: (event: WeaponEvent) => MechanicalSoundId | undefined;
-
-var profiles = {
-	weight: {
-		light: {
-			pitch: 1.3,
-			gain: 0.85
-		},
-		medium: {
-			pitch: 1,
-			gain: 1
-		},
-		heavy: {
-			pitch: 0.78,
-			gain: 1.2
-		}
-	},
-	material: {
-		steel: {
-			pitch: 1,
-			gain: 1
-		},
-		polymer: {
-			pitch: 0.82,
-			gain: 0.8
-		}
-	}
-};
-var data = {
-	profiles: profiles};
-
-/** How a weapon sounds: the weight of its metal (pitch and level) and what it is made of. */
-interface SoundProfile {
-    readonly weight: keyof typeof data.profiles.weight;
-    readonly material: keyof typeof data.profiles.material;
-}
-
-/** What a shot adds to the energy and the category: where the listener is and how the weapon is set. */
-type ShotExtras = Pick<ShotSoundInput, 'caliber' | 'distance' | 'volume' | 'suppressed' | 'indoors'>;
-interface WeaponAudioOptions extends ShotSoundOptions {
-    /** Seed of the noise buffer, of the start point in it and of the casing pitch: same seed, same sound. Default 1. */
-    readonly seed?: number;
-    /** Replaces or adds mechanical sounds by id. */
-    readonly mechanical?: Readonly<Partial<Record<MechanicalSoundId, readonly SoundStep[]>>>;
-    /** Replaces or adds the sounds of the reload clip cues by id (`reload-sounds.json` has the ones the kit ships). */
-    readonly reloadCues?: Readonly<Record<string, readonly SoundStep[]>>;
-    /** Where the AudioContext comes from (default: the global one); lets a host or a test lend its own. Not used with `engine`. */
-    readonly createContext?: () => AudioContext;
-    /**
-     * A sound engine the host already has (one shared engine mixes, limits and pans every module the same way). The weapon sounds are registered in it
-     * and play on its `weapons` bus; `seed` gives them their own random stream, the master volume and the context stay the engine's. Without it the
-     * weapon audio makes its own engine with the game mix, no voice limit, and the master at `volume`.
-     */
-    readonly engine?: AudioEngine;
-}
-/** Sounds the weapon presentation plays. */
-interface WeaponAudio {
-    /** A shot: class and distance muffling of the game, loudness and body from the muzzle energy (joules). */
-    shot(energyJ: number, category: string, extras?: ShotExtras): void;
-    /** The parameters `shot` would play (pure). */
-    shotSound(input: ShotSoundInput): ShotSound;
-    /** Dry click of an empty weapon. */
-    click(): void;
-    /** A mechanical sound by id: a reload stage, `dry_fire`, `jam`, `safety_on`... */
-    mechanical(id: MechanicalSoundId): void;
-    /** A cue of a reload clip (`mag_seat`, `charging_handle_pull`, `pump_back`...) for a weapon's profile (the weight of its metal and what it is made of): played now, where the clip says. */
-    cue(id: string, profile?: SoundProfile): void;
-    /** The mechanical sound of a weapon event, if it has one (reload stages, empty, misfire, fault, clear, safety, mode, feed). */
-    event(event: WeaponEvent): void;
-    /** A sound class of the game by name (`impact`, `flesh`, `glass`...), with the game's distance muffling. */
-    play(soundClass: string, volume?: number, distance?: number): void;
-    /** Magazine out, or the first shell in. */
-    reloadStart(category: string): void;
-    /** Magazine seated and the action racked. */
-    reloadEnd(category: string): void;
-    /** The pump or lever cycling after a shot. */
-    cycle(): void;
-    /** A casing bouncing on the floor. */
-    clink(): void;
-    /** A magazine landing on the floor. */
-    thud(): void;
-    /** Master volume, 0 to 1. */
-    setVolume(volume: number): void;
-    dispose(): void;
-}
-declare function createWeaponAudio(volume?: number, options?: WeaponAudioOptions): WeaponAudio;
-
-/** What the bench turns on or off in the presentation of the weapon: the ejected casings, the dropped magazines, the muzzle flash, the accessory models and the light and laser beams. */
-interface FxLayers {
-    casings: boolean;
-    magazines: boolean;
-    muzzleFlash: boolean;
-    attachments: boolean;
-    beams: boolean;
-}
-
-/** How the gallery builders describe a weapon: the short keys of `data/models.json` (the page's own option names), all optional. */
-interface ModelOptions {
-    /** Total length and barrel length in mm, and the calibre text, as the weapons table gives them. */
-    L?: number;
-    B?: number;
-    cal?: string;
-    /** Pistol style (`glock`, `taurus`, `g2c`, `beretta`, `pt100`, `sig`, `cz`, `m1911`, `makarov`, `fiveseven`, `deagle`), slide height, grip length. */
-    st?: string;
-    h?: number;
-    gl?: number;
-    deagle?: number;
-    /** Metal and furniture finish. */
-    steel?: number;
-    stain?: number;
-    wood?: number;
-    olive?: number;
-    tan?: number;
-    /** Selector or safety mark, cyclic rate (rpm), rounds in a burst, how unreliable (`rel`). */
-    sel?: number;
-    rpm?: number;
-    burst?: number;
-    rel?: number;
-    /** Rifle layout. */
-    stock?: string;
-    stockLen?: number;
-    hg?: string;
-    hgFrac?: number;
-    hR?: number;
-    wR?: number;
-    br?: number;
-    grip?: string;
-    gripAt?: number;
-    mag?: string;
-    magLen?: number;
-    magAt?: number;
-    magMat?: string;
-    curve?: number;
-    fore?: number;
-    tubeLen?: number;
-    scope?: number;
-    brake?: number;
-    ejectBack?: number;
-    round?: number;
-    ar?: number;
-    ak?: number;
-    g3?: number;
-    charge?: number;
-    rail?: number;
-    jacket?: number;
-    gas?: number;
-    noFH?: number;
-    carry?: number;
-    bipod?: number;
-    bolt?: number;
-    lever?: number;
-    tube?: number;
-    pump?: number;
-    heat?: number;
-    /** Chambers of the revolver cylinder (default 6): the capacity of the weapon. */
-    chambers?: number;
-    bayo?: number;
-    rod?: number;
-    bands?: number;
-    shot?: number;
-    /** Launcher type: `rpg`, `m72`, `at4`, `carl`, `flame`, `flameDIY`. */
-    lt?: string;
-}
-/**
- * Numbers the builders write down while they draw, in the space of `inner` (metres along the barrel, before `fitLength` stretches it): where the accessories go.
- * Written by the rifle and the M134 builders; the others get theirs measured from the model (`deriveFrames`).
- */
-interface ModelFrames {
-    length: number;
-    barrelY: number;
-    barrelRadius: number;
-    receiverStart: number;
-    receiverEnd: number;
-    receiverHeight: number;
-    receiverWidth: number;
-    handguardEnd: number;
-    magazineX: number;
-    gripX: number;
-    /** The top rail is drawn (an optic sits on it without an adapter). */
-    hasRail: boolean;
-    /** Where the gun joins what is under the barrel (x, y), when the model has a place for it that the rule does not derive from the handguard. */
-    underbarrel?: readonly [number, number];
-}
-/** The moving mechanism of a model, which picks its fire, reload and clear motion. */
-type ModelFamily = 'pistol' | 'revolver' | 'rifle' | 'semiint' | 'semi12' | 'p90' | 'belt' | 'pump' | 'lever' | 'bolt' | 'boltmag' | 'break' | 'rocket' | 'flame';
-/** The named parts a model exposes to the animation: pivots and marks inside the model, never copies. */
-interface ModelParts {
-    family: ModelFamily;
-    /** Recoil strength of the model (the page's `kick`). */
-    kick?: number;
-    /** How far the slide or bolt travels back, in metres. */
-    stroke?: number;
-    slide?: THREE_NS.Object3D;
-    bolt?: THREE_NS.Object3D;
-    boltHandle?: THREE_NS.Object3D;
-    boltHandleRest?: number;
-    mag?: THREE_NS.Object3D | null;
-    /** How far a magazine drops, and `1` for one that goes up. */
-    magDrop?: number;
-    magDir?: number;
-    trigger?: THREE_NS.Object3D;
-    hammer?: THREE_NS.Object3D;
-    lever?: THREE_NS.Object3D;
-    pump?: THREE_NS.Object3D;
-    belt?: THREE_NS.Object3D;
-    cover?: THREE_NS.Object3D;
-    crane?: THREE_NS.Object3D;
-    cylinder?: THREE_NS.Object3D;
-    chambers?: THREE_NS.Object3D[];
-    barrels?: THREE_NS.Object3D;
-    breech?: THREE_NS.Object3D[];
-    /** The pivot of the pistol grip (its y runs along the grip, tilted as the grip is): the right hand holds here. Models without a drawn grip leave it out and the hand is placed from `frames`. */
-    grip?: THREE_NS.Object3D;
-    /** The existing selector or safety mesh; the gallery draws it but does not move it. */
-    safety?: THREE_NS.Object3D;
-    muzzle?: THREE_NS.Object3D;
-    eject?: THREE_NS.Object3D;
-    loadPort?: THREE_NS.Object3D;
-    topLoad?: THREE_NS.Object3D;
-    /** Parts that glow with barrel heat; each owns a clone of its material. */
-    glow: THREE_NS.Mesh[];
-    /** Launchers. */
-    launcherType?: string;
-    disposable?: boolean;
-    rear?: THREE_NS.Object3D;
-    round?: THREE_NS.Object3D;
-    roundRest?: number;
-    makeRound?: () => THREE_NS.Object3D;
-    gauge?: THREE_NS.Object3D;
-    /** Where the accessories go (see `ModelFrames`). */
-    frames?: ModelFrames;
-    /** The meshes of the stock the builder drew, in the order it drew them: `rigStock` moves them into one pivot. */
-    stockMeshes?: THREE_NS.Object3D[];
-    /** The stock pivot `rigStock` made, and how it moves. */
-    stock?: THREE_NS.Object3D;
-    stockMove?: StockMove;
-    /** The meshes of each part that ships on the weapon, by accessory id (`red_dot`, `bipod`, `muzzle_brake`): taking the accessory off hides them. */
-    fittings?: Record<string, THREE_NS.Object3D[]>;
-    /** The pivot a launcher under the barrel sits in (made by `rigUnderbarrel`), and its muzzle mark once one is fitted. */
-    ugl?: THREE_NS.Object3D;
-    uglMuzzle?: THREE_NS.Object3D;
-}
-/** How the stock moves when it collapses: a slide of `travel` metres along the weapon (in `inner` units), or a half turn about `axis` (`foldAxis` of the rule). */
-interface StockMove {
-    kind: 'fold' | 'retract';
-    axis: 'x' | 'y' | 'z';
-    travel: number;
-}
-
-/** One weapon of the gallery as `data/models.json` keeps it: the builder, the measures in mm and the builder's options. */
-interface ModelEntry {
-    readonly builder: 'pistol' | 'revolver' | 'rifle' | 'bullpup' | 'p90' | 'break' | 'm2' | 'm134' | 'launcher';
-    readonly caliber: string;
-    readonly length: number;
-    readonly barrel: number;
-    readonly options: ModelOptions;
-    readonly variantOf?: string;
-}
-declare const MODEL_ENTRIES: Readonly<Record<string, ModelEntry>>;
-/**
- * The model each generic archetype wears: the one of the first brand weapon (lowest id) that points to it with `archetype` and fires the same way (a rocket launcher that points to
- * `shotgun_pump_12` does not lend its tube to the shotgun). An archetype nothing points to, the melee weapons and the bow keep their simple prop.
- */
-declare const ARCHETYPE_MODELS: Readonly<Record<string, string>>;
-/** A weapon model: `root` (the page's `wr`) holds `inner` (what the builder made, fitted to the real length); `parts` are pivots and marks inside `inner`. */
-interface WeaponModel {
-    readonly id: string;
-    readonly root: THREE_NS.Group;
-    readonly inner: THREE_NS.Group;
-    readonly parts: ModelParts;
-}
-declare const hasWeaponModel: (id: string) => boolean;
-/** The gallery model of a weapon (or of the brand weapon an archetype wears, see `ARCHETYPE_MODELS`), long axis along +x, rear at the origin; undefined for melee, throwables and what nothing drew. */
-declare function buildWeaponModelById(THREE: typeof THREE_NS, id: string): WeaponModel | undefined;
-
-type Three = typeof THREE_NS;
-type Material = THREE_NS.Material;
-type Parent = THREE_NS.Object3D;
-declare const createMaterials: (THREE: Three) => {
-    metal: THREE_NS.MeshStandardMaterial;
-    steel: THREE_NS.MeshStandardMaterial;
-    steelL: THREE_NS.MeshStandardMaterial;
-    dark: THREE_NS.MeshStandardMaterial;
-    poly: THREE_NS.MeshStandardMaterial;
-    olive: THREE_NS.MeshStandardMaterial;
-    tan: THREE_NS.MeshStandardMaterial;
-    wood: THREE_NS.MeshStandardMaterial;
-    woodL: THREE_NS.MeshStandardMaterial;
-    brass: THREE_NS.MeshStandardMaterial;
-    copper: THREE_NS.MeshStandardMaterial;
-    lead: THREE_NS.MeshStandardMaterial;
-    shell: THREE_NS.MeshStandardMaterial;
-    glass: THREE_NS.MeshStandardMaterial;
-    lens: THREE_NS.MeshStandardMaterial;
-    rubber: THREE_NS.MeshStandardMaterial;
-    white: THREE_NS.MeshStandardMaterial;
-    hole: THREE_NS.MeshStandardMaterial;
-    bake: THREE_NS.MeshStandardMaterial;
-    rust: THREE_NS.MeshStandardMaterial;
-    rustD: THREE_NS.MeshStandardMaterial;
-    worn: THREE_NS.MeshStandardMaterial;
-    fire: THREE_NS.MeshBasicMaterial;
-    fire2: THREE_NS.MeshBasicMaterial;
-    flashA: THREE_NS.MeshBasicMaterial;
-    flashB: THREE_NS.MeshBasicMaterial;
-    smokeP: THREE_NS.MeshStandardMaterial;
-    /** Launcher paints. */
-    yellow: THREE_NS.MeshStandardMaterial;
-    red: THREE_NS.MeshStandardMaterial;
-    redPaint: THREE_NS.MeshStandardMaterial;
-    tape: THREE_NS.MeshStandardMaterial;
-    pipe: THREE_NS.MeshStandardMaterial;
-    green: THREE_NS.MeshStandardMaterial;
-    /** Magazine finishes named by the options. */
-    bakelite: THREE_NS.MeshStandardMaterial;
-    polyMag: THREE_NS.MeshStandardMaterial;
-};
-type ModelMaterials = ReturnType<typeof createMaterials>;
-/**
- * The gallery's primitives on the host's three.js. Each takes the parent first and the position last as the page does (`box(parent, w, h, d, material, x, y, z, rz, ry, rx)`),
- * so that the builders read like the originals. `roundness` is the page's `RF`: how round the next boxes are, `null` for the default.
- */
-interface ModelKit {
-    readonly THREE: Three;
-    readonly M: ModelMaterials;
-    roundness: number | null;
-    group(): THREE_NS.Group;
-    box(parent: Parent, w: number, h: number, d: number, material: Material, x: number, y: number, z: number, rz?: number, ry?: number, rx?: number): THREE_NS.Mesh;
-    /** Cylinders along x, y and z. `radiusEnd` makes a cone. */
-    cylinderX(parent: Parent, radius: number, length: number, material: Material, x: number, y: number, z: number, segments?: number, radiusEnd?: number): THREE_NS.Mesh;
-    cylinderY(parent: Parent, radius: number, height: number, material: Material, x: number, y: number, z: number, segments?: number, radiusEnd?: number): THREE_NS.Mesh;
-    cylinderZ(parent: Parent, radius: number, length: number, material: Material, x: number, y: number, z: number, segments?: number): THREE_NS.Mesh;
-    sphere(parent: Parent, radius: number, material: Material, x: number, y: number, z: number, detail?: number): THREE_NS.Mesh;
-    torus(parent: Parent, geometry: THREE_NS.TorusGeometry, material: Material, x: number, y: number, z: number): THREE_NS.Mesh;
-    mark(parent: Parent, x: number, y: number, z: number): THREE_NS.Object3D;
-    pivot(parent: Parent, x?: number, y?: number, z?: number): THREE_NS.Group;
-}
-/**
- * One kit per three.js namespace: the materials and the geometry cache are shared by every model built with it. The kit's `THREE` is
- * `shapeGeometries(host)`: box, cylinder, cone, sphere and torus come from game-shapes (the same bytes, the same classes); the rest is the host's.
- */
-declare function modelKit(host: Three): ModelKit;
-
-type Vec3 = [number, number, number];
-/** The shape of a model that carries its `inner` and `root` as `buildWeaponModelById` makes them. */
-interface FramedModel {
-    readonly root: THREE_NS.Group;
-    readonly inner: THREE_NS.Group;
-    readonly parts: ModelParts;
-}
-/** Where an accessory of one kind of mount goes, in the space of the wrapper (`root`): the origin of its own frame and the sizes it needs from the weapon. */
-interface MountFrame {
-    readonly mount: MountKind;
-    readonly position: Vec3;
-    /** The other end, for what stretches between two points (a sling between its swivels). */
-    readonly secondary?: Vec3;
-    readonly barrelRadius: number;
-    readonly receiverWidth: number;
-    readonly receiverHeight: number;
-    /** The top rail is drawn: an optic needs no adapter. */
-    readonly hasRail: boolean;
-    /** The sign of z for a side rail: left is negative, right is positive (z is to the right of the weapon). */
-    readonly side: -1 | 0 | 1;
-}
-/**
- * Frames for a model whose builder wrote none (pistols, revolvers, bullpups, launchers...): measured from the model as it is built, with `root` still at the origin.
- * The numbers are in the space of `inner`, like the ones the rifle builder writes.
- */
-declare function deriveFrames(THREE: typeof THREE_NS, model: FramedModel): ModelFrames;
-/** The frame of a mount of the model, or undefined for the mounts nothing is drawn on (`stock`, `barrel`). */
-declare function mountFrame(model: FramedModel, mount: MountKind): MountFrame | undefined;
-
-/** Distance in metres to what the ray hits, or null when it hits nothing within `maxDistance`: the host's raycast, which the laser asks every frame. */
-type LaserRaycast = (origin: THREE_NS.Vector3, direction: THREE_NS.Vector3, maxDistance: number) => number | null;
-/** What a builder is given: the accessory, where it sits on the weapon (`frame`, in the space of the wrapper) and the pieces of the model it may hang from or hide. */
-interface AttachmentBuildContext {
-    readonly kit: ModelKit;
-    readonly model: WeaponModel;
-    readonly attachment: AttachmentDef;
-    readonly fitted: FittedAttachment;
-    readonly frame: MountFrame;
-    readonly raycast: LaserRaycast | undefined;
-    /** The meshes the magazine pivot had before any accessory (a drum or an extension replaces or extends them). */
-    readonly factoryMagazine: readonly THREE_NS.Object3D[];
-    /** The pivot of the launcher under the barrel, which the reload clip slides (only on a weapon with a place for one). */
-    readonly slide: THREE_NS.Object3D | undefined;
-}
-/** What a builder makes: the object (its origin on the frame), and what the rig needs to know about it. */
-interface AttachmentModel {
-    readonly object: THREE_NS.Object3D;
-    /** Where the object hangs: the wrapper (default), the magazine pivot (it moves with the magazine) or the sliding pivot of the launcher. */
-    readonly hangsFrom?: 'root' | 'magazine';
-    /** Parts of the weapon that are not drawn while this one is on (a drum hides the magazine it replaces). */
-    readonly hides?: readonly THREE_NS.Object3D[];
-    /** How far forward the muzzle moves (a suppressor): the flash and the smoke come out of its end. */
-    readonly muzzleOffset?: number;
-    /** A launcher's muzzle mark, which the shot clip flashes. */
-    readonly muzzle?: THREE_NS.Object3D;
-    /** A light or laser turned on or off. */
-    setOn?(on: boolean): void;
-    /** Every frame, while the weapon is in the hands (the laser measures how far its beam goes). */
-    update?(): void;
-    dispose?(): void;
-}
-type AttachmentModelBuilder = (context: AttachmentBuildContext) => AttachmentModel | THREE_NS.Object3D | null;
-/** Builders by the `model` id of the accessory (`AttachmentDef.model`). A game replaces or adds one with `attachmentModels` of the weapons module. */
-type AttachmentModelRegistry = Readonly<Record<string, AttachmentModelBuilder>>;
-
-interface WeaponFxOptions {
-    THREE: typeof THREE_NS;
-    scene: THREE_NS.Scene;
-    camera: THREE_NS.Camera;
-    arsenal: Arsenal;
-    /** Height things rest on at (x, z): casings and magazines land there. */
-    groundAt: (x: number, z: number) => number;
-    /** Sounds (`createWeaponAudio`); null or absent: silent. */
-    audio?: WeaponAudio | null;
-    /** Seed of the scatter of the effects of the gallery models. */
-    seed?: number;
-    /** The rocket of a launcher flies out of the viewmodel along the barrel (default true). A host that draws the projectile itself (the test room does) sets it to false, so one round flies, not two. */
-    flyRocket?: boolean;
-    /** The tool as it is now (barrel heat, fuel burning). */
-    tool?: () => HostTool;
-    /** Wear of the weapon: `new`, `used`, `worn` or `rusty`. */
-    condition?: string;
-    /** What is drawn: read at the moment of each event, so the bench can change it live. */
-    layers?: FxLayers;
-    /** Metres between the shooter and the listener, for the distance muffling of the shot sound (default 0). */
-    soundDistance?: () => number;
-    /** Told at every sound cue of a reload clip, at the moment the clip says it (also with no audio): the weapon, the cue id and the profile it sounds with. */
-    onSound?: (cue: {
-        weapon: string;
-        cue: string;
-        profile: SoundProfile;
-    }) => void;
-    /** Builders of accessory models that replace or add to the ones the kit ships (by the `model` of the accessory). */
-    attachmentModels?: AttachmentModelRegistry;
-    /** How far a laser beam goes from a point along a direction (metres), or null when it hits nothing: the dot lands where it ends. */
-    raycast?: LaserRaycast;
-    /** Where the world is (distance from a point along a direction to the first surface, or null): the weapon in the hands comes back from a wall it would go through. */
-    contact?: LaserRaycast;
-    /** Where the body holds the tool (`ModuleHost.holdFrame`): third person draws it there at its real size. */
-    bodyHold?: () => HandPose | null;
-    /** The host's effects: the muzzle flash, smoke, backblast and flame jet of the gallery models are recipes it plays; without it the viewmodel makes a world of its own for them. */
-    effects?: EffectSink;
-}
-
-/** The weapon in the hands, its fire and reload motion, ejected casings and dropped magazines, and their sounds. */
-interface WeaponFx {
-    /** Feed every tool event of the host, with the tool as it is after the event. */
-    handle(event: HostEvent, tool: HostTool): void;
-    update(dt: number): void;
-    /** Dresses the weapon for its wear (`new`, `used`, `worn`, `rusty`); the gallery models show it in their metal. */
-    setCondition(condition: string): void;
-    /** Where the hands take the weapon (world space, read every frame after `update`): the grip and the forend of the model, or the handle of the generic prop; null with nothing in the hands. */
-    handTargets(): HandTargets | null;
-    /** What is drawn (casings, magazines, muzzle flash): change a field and the next event follows it. */
-    readonly layers: FxLayers;
-    /** Weapon shown in the hands, or null. */
-    readonly inHand: string | null;
-    /** The clips of the model playing now with the seconds each lasts (scaled to the rule's duration): which reload variant went (`reload` or `reload_empty`...). */
-    readonly clips: ReadonlyArray<{
-        name: string;
-        seconds: number;
-    }>;
-    /** Casings and magazines currently on the floor or in the air. */
-    readonly casings: number;
-    readonly magazines: number;
-    dispose(): void;
-}
-/**
- * The presentation of the tool in the hands. The weapons the gallery drew (`MODEL_ENTRIES`) get their model and the clips the rule's events call for
- * (fire, cycle, jam, clear, safety, the seven reloads); the generic archetypes keep their low-poly prop.
- */
-declare function createWeaponFx(options: WeaponFxOptions): WeaponFx;
-
-interface WeaponsTestModuleOptions {
-    /** `en` or `pt-BR` (default). */
-    locale?: string;
-    /** The arsenal to lay out (default `createArsenal` with the locale). */
-    arsenal?: Arsenal;
-    /** Play sounds (default true; silent anyway where there is no AudioContext). */
-    sound?: boolean;
-    /** Wear of the weapon in the hands, which the gallery models show in their metal: `new` (default), `used`, `worn` or `rusty`. */
-    condition?: string;
-    /** Seed of the scatter of casings and smoke (default 1). */
-    seed?: number;
-    /** Builders of accessory models that replace or add to the ones the kit ships (by the `model` of the accessory). */
-    attachmentModels?: AttachmentModelRegistry;
-    /** Folder (ending with a slash) the weapon thumbnails are served from, relative to the page (default `weapon-svg/`); `false` leaves the items without a thumbnail. */
-    thumbnailBase?: string | false;
-    /** The rocket of a launcher flies out of the weapon in the hands (default true). A host that draws the projectile (the test room's `projectileModel`) passes false: one round flies. */
-    flyRocket?: boolean;
-}
-/** Prefix of the item ids of the weapon props (`weapon_pistol_9mm`). */
-declare const WEAPON_ITEM_PREFIX = "weapon_";
-declare const COUNTER_ITEM_ID = "counter_weapons";
-declare const MOUNTED_M134_ITEM_ID = "m134_tripod";
-/** Where the counters go and where each weapon lies on them: weapons side by side across the counters in order, each taking its strip, until the counter is full. */
-declare function weaponsLayout(weaponItemIds: string[], pitchOf?: (itemId: string) => number): AreaPlacement[];
-/**
- * The weapons test area as a `TestableModule` of @adatechnology/game-contracts: every weapon of the arsenal on counters, the real model of each one the gallery drew (aim at one and
- * press H to equip it), targets at shooting distance, and, through `attach`, the weapon in the hands with its fire and reload motion,
- * ejected casings, dropped magazines and sounds, driven by the host's tool events.
- */
-declare function createWeaponsTestModule(options?: WeaponsTestModuleOptions): TestableModule & {
-    readonly audio: WeaponAudio | null;
-    readonly fx: WeaponFx | null;
-};
+import { TestableItem, Vec3, HostEvent, EffectSink, DestructibleSpec, DeepPartial, ToolClipSet } from '@adatechnology/game-contracts';
+import { ExplosiveDef, Arsenal, WeaponDef, CartridgeDims, CaliberDef, CaseType, ReloadFamily, FittedAttachment, AttachmentDef } from '@adatechnology/game-weapons';
+import { LightBudget } from '@adatechnology/game-render-three';
+import '@adatechnology/game-audio';
 
 /** Where a thumbnail came from: the model of the kit (`generated`) or a freely licensed drawing of the real weapon (`commons`, with its author and licence). */
 interface WeaponThumbnailEntry {
@@ -696,296 +25,6 @@ declare const DEFAULT_THUMBNAIL_BASE = "weapon-svg/";
 /** The URL of a weapon's thumbnail under `base` (which ends with a slash), or undefined when it has none. */
 declare function weaponThumbnailUrl(id: string, base?: string): string | undefined;
 
-/** The words of the explosives area (the P13 cylinder bench and its narration), by locale (`en` and `pt-BR`). `{name}` marks a value the module fills in. */
-interface ExplosivesText {
-    group: string;
-    name: string;
-    cylinder: string;
-    actions: Record<'shoot' | 'valve' | 'light' | 'fire' | 'reset', {
-        name: string;
-        hint: string;
-    }>;
-    blastScale: {
-        name: string;
-        hint: string;
-    };
-    layers: Record<'rings', string>;
-    metrics: Record<'gas' | 'clock' | 'phase', string>;
-    phases: Record<'rest' | 'leaking' | 'torch' | 'primed' | 'exploded', string>;
-    rings: {
-        lethal: string;
-        injury: string;
-    };
-    triggers: Record<'shot' | 'fire' | 'explosion', string>;
-    things: Record<string, string>;
-    verdicts: {
-        wall_pieces: string;
-        lost_parts: string;
-        dead: string;
-        hurt: string;
-        unhurt: string;
-        wall_broken: string;
-        wall_cracked: string;
-        wall_intact: string;
-        burning: string;
-        standing: string;
-    };
-    log: {
-        leak_shot: string;
-        leak_valve: string;
-        valve_closed: string;
-        valve_closed_late: string;
-        primed: string;
-        jet_lit: string;
-        jet_lit_by: string;
-        lighter_none: string;
-        lighter_lit: string;
-        fire_set: string;
-        heating: string;
-        explode: string;
-        shell: string;
-        shell_landed: string;
-        residual: string;
-        aftermath_person: string;
-        aftermath_wall: string;
-        aftermath_object: string;
-        reset: string;
-        scale: string;
-        no_room: string;
-        shoot: string;
-        no_vessel: string;
-    };
-    sheet: {
-        kicker: string;
-        title: string;
-        body: string;
-        facts: Record<'energy' | 'lethal' | 'injury' | 'gas' | 'mass' | 'torch' | 'shot_chain' | 'fire_chain', string>;
-        steps: Array<{
-            at: string;
-            text: string;
-        }>;
-        segments: Record<'jet' | 'torch' | 'blast', string>;
-        note: string;
-    };
-    scenarios: {
-        shot: string;
-        shot_leak: string;
-        shot_ignite: string;
-        shot_explode: string;
-        shot_zombie: string;
-        shot_survivor: string;
-        shot_wall: string;
-        valve: string;
-        valve_leak: string;
-        valve_quiet: string;
-        valve_lit: string;
-        valve_explode: string;
-        fire: string;
-        fire_explode: string;
-        chain: string;
-        chain_explode: string;
-        push_p13: string;
-        push_grenade: string;
-        push_found: string;
-        push_told: string;
-        push_outward: string;
-        push_falloff: string;
-        push_person: string;
-        push_heavy: string;
-    };
-}
-declare const EXPLOSIVES_TEXT: Record<string, ExplosivesText>;
-declare const explosivesTextOf: (locale: string) => ExplosivesText;
-
-/** Id of the explosives module (`?area=explosives_area` opens it). */
-declare const EXPLOSIVES_AREA_ID = "explosives_area";
-/** The parts of a part state the bench reads (structural: `PartState` of the destruction world fits). */
-interface PartView {
-    readonly liters?: number;
-    readonly temperature: number;
-    readonly status: string;
-    readonly holes: ReadonlyArray<{
-        readonly diameter: number;
-        readonly through: boolean;
-    }>;
-    readonly cracks: readonly unknown[];
-    readonly burning: boolean;
-}
-/** What the explosives module needs from the room it drives (structural: the `TestRoom` of game-test-room fits). */
-interface ExplosivesRoom {
-    readonly world: {
-        readonly time: number;
-        ids(): string[];
-        on(type: '*', fn: (event: DestructionEvent) => void): () => void;
-        hit(objectId: string, hit: Hit): unknown;
-        vent(objectId: string, partId: string, opening?: {
-            point?: Vec3$1;
-            normal?: Vec3$1;
-            diameter?: number;
-        }): boolean;
-        seal(objectId: string, partId: string): number;
-        part(objectId: string, partId: string): PartView | null;
-        state(objectId: string): {
-            readonly parts: readonly (PartView & {
-                readonly id: string;
-                readonly hp: number;
-                readonly maxHp: number;
-            })[];
-        } | null;
-    };
-    readonly renderer: {
-        impulse(objectId: string, impulse: Vec3$1, point?: Vec3$1): void;
-    };
-    readonly vfx: {
-        spawn(kind: string, point: Vec3$1, velocity: Vec3$1, options?: {
-            color?: number;
-            size?: number;
-            life?: number;
-            alpha?: number;
-        }): void;
-        burst(kind: string, point: Vec3$1, normal: Vec3$1, count: number, speed?: number): void;
-        fire(options: {
-            point: Vec3$1;
-            radius: number;
-            life: number;
-        }): number;
-        stop(handle: number): void;
-    };
-    spawned(): ReadonlyArray<{
-        readonly objectId: string;
-        readonly itemId: string;
-        readonly root: unknown;
-    }>;
-    openArea(group: string): unknown;
-    clear(): void;
-    spawn(itemId: string, position?: Vec3$1, rotationY?: number): {
-        readonly objectId: string;
-        readonly itemId: string;
-        readonly root: unknown;
-    };
-    setTool(weaponId: string): void;
-    waitUntilReady(maxSeconds?: number): number;
-    look(position: Vec3$1, target: Vec3$1): void;
-    use(hold?: number): void;
-    on(type: 'spawn', fn: (data: unknown) => void): () => void;
-}
-/** The bench of the explosives area as the module and its scenarios see it. */
-interface ExplosivesBench {
-    readonly room: ExplosivesRoom | undefined;
-    readonly def: ExplosiveDef;
-    /** The strength multiplier now (the next cylinder laid takes it). */
-    blastScale(): number;
-    /** Called by the module's `area`: the cylinders spawned from now on belong to the area (they get their rings). */
-    areaOpened(): void;
-    controls(): ModuleControl[];
-    layers(): ModuleLayer[];
-    metrics(): ModuleMetric[];
-    attach(host: ModuleHost): () => void;
-    /** The actions of the bench, by the id of their button. Each answers whether it did something. */
-    readonly actions: Readonly<Record<'shoot' | 'valve' | 'light' | 'fire' | 'reset', () => boolean>>;
-    /** The cylinder of the scene (the first one alive), with what the bench knows about it. */
-    vessel(): VesselView | undefined;
-    /** The wall of the scene, the zombie and the survivor, as the aftermath reads them. */
-    /** The last explosion the host told (a part of the world or a thrown explosive): where, how strong and how far; undefined before the first, and after the area is cleared. */
-    lastBlast(): {
-        readonly point: Vec3$1;
-        readonly energy: number;
-        readonly radius: number;
-        readonly cause: string;
-        readonly explosive?: string;
-    } | undefined;
-    witnesses(): Array<{
-        kind: 'person' | 'wall' | 'object';
-        id: string;
-        itemId: string;
-        distance: number;
-        alive?: boolean;
-        vitality?: number;
-        broken?: number;
-        marks?: number;
-        pieces?: number;
-    }>;
-}
-interface VesselView {
-    readonly objectId: string;
-    /** World time of the first leak, of the jet catching fire and of the blast (seconds); undefined until they happen. */
-    readonly leakAt: number | undefined;
-    readonly litAt: number | undefined;
-    readonly explodedAt: number | undefined;
-    readonly cause: 'shot' | 'valve' | undefined;
-    readonly valveOpen: boolean;
-    readonly lit: boolean;
-    readonly exploded: boolean;
-    readonly point: Vec3$1 | undefined;
-}
-interface ExplosivesBenchOptions {
-    readonly locale: string;
-    readonly text: ExplosivesText;
-    readonly def: ExplosiveDef;
-    readonly scene: {
-        readonly cylinder: Vec3$1;
-    };
-    readonly room: ExplosivesRoom | undefined;
-    readonly blastScale: number;
-    readonly profile: {
-        readonly visualRadius?: number;
-        readonly residualFires?: ReadonlyArray<{
-            readonly radius: number;
-            readonly life: number;
-        }>;
-    } | undefined;
-}
-/**
- * The state and the actions of the explosives area: it follows the world's events of the cylinder (leak, primed, explode), tells each phase in the room's log, plays the torch and the flight
- * of the shell (the Laboratório de Explosões, `SC.p13`) and drives the destruction world for the bench actions. The module wraps it in a `TestableModule`.
- */
-declare function createExplosivesBench(options: ExplosivesBenchOptions): ExplosivesBench;
-
-/** Where the things of the scene stand (metres, in the room's world; the brick wall is the room's own at z = -11). The kitchen corner is against the wall; the player looks at it from about 6 m. */
-interface ExplosivesScene {
-    /** Item ids and positions of the kitchen furniture (items of the household module); one that the room does not know is left out. */
-    readonly furniture: ReadonlyArray<{
-        readonly item: string;
-        readonly at: Vec3$1;
-        readonly rotationY?: number;
-    }>;
-    /** The cylinder. */
-    readonly cylinder: Vec3$1;
-    /** The zombie (about 3 m from the cylinder) and the survivor (about 8 m): item ids of the characters module. */
-    readonly zombie: {
-        readonly item: string;
-        readonly at: Vec3$1;
-    };
-    readonly survivor: {
-        readonly item: string;
-        readonly at: Vec3$1;
-    };
-    /** The player's eye (about 6 m from the cylinder: outside the 5 m lethal ring, the lamp rig of the weather module is behind it). */
-    readonly eye: Vec3$1;
-}
-/** The kitchen corner of the default scene: fridge, cabinet, the cylinder and the stove side by side against the wall, a table 2 m away. */
-declare const DEFAULT_EXPLOSIVES_SCENE: ExplosivesScene;
-interface ExplosivesTestModuleOptions {
-    /** `en` or `pt-BR` (default). */
-    locale?: string;
-    /** The arsenal to read the P13 from (default `createArsenal` with the locale). */
-    arsenal?: Arsenal;
-    /** The room the module drives: its destruction world, effects and tools. Without it the module still lays the area and the bench shows, but the actions only say they need the room. */
-    room?: ExplosivesRoom;
-    /** Overrides of the default scene (see `ExplosivesScene`). */
-    scene?: Partial<ExplosivesScene>;
-    /** Strength multiplier the bench starts at (default 1: the arsenal's numbers; a game value, see the README). */
-    blastScale?: number;
-}
-/**
- * The explosives test area as a `TestableModule`: the P13 cooking gas cylinder in a kitchen corner against a brick wall, with furniture, a zombie at 3 m, a survivor at 8 m and rings on the floor at the
- * lethal and injury radii. The bench shoots it, opens its valve, lights it with a lighter, throws it in a fire or restarts the scene; every phase is told in the room's log in the locale of the room.
- * The module reads the sequence (the torch delay, the gas, the flight of the shell) from the arsenal def of `propane_p13` and the blast from its `chain`, so a game changes them with `ArsenalOptions.patch.explosives`.
- */
-declare function createExplosivesTestModule(options?: ExplosivesTestModuleOptions): TestableModule & {
-    readonly bench: ReturnType<typeof createExplosivesBench>;
-};
-
 /** Prefix of the item ids of the explosives that sit in the world (`world_fuel_barrel`). */
 declare const WORLD_EXPLOSIVE_PREFIX = "world_";
 /** Name of the mesh of the brass valve on the P13 model (the team's `botijao`: the 0xb8913a cylinder on the neck). */
@@ -996,14 +35,16 @@ declare const WORLD_EXPLOSIVE_IDS: readonly string[];
 interface WorldExplosiveOptions {
     /** Multiplies `energy`, `lethalRadius` and `injuryRadius` of the explosive (default 1: the arsenal's numbers). It is a game value, not a physical table; the arsenal's own place for it is `ArsenalOptions.patch.explosives`. */
     readonly scale?: () => number;
+    /** The item models of game-items-three (`itemModels` there): the P13 is drawn with the team's model; default `itemModels` there (deprecated: pass it). */
+    readonly items?: ItemModels;
 }
 /** Where the valve is on a spawned cylinder, in the world (the centre of the brass mesh), or undefined when the object has none. */
-declare const worldExplosiveValve: (THREE: typeof THREE_NS, root: THREE_NS.Object3D) => Vec3$1 | undefined;
+declare const worldExplosiveValve: (THREE: typeof THREE_NS, root: THREE_NS.Object3D) => Vec3 | undefined;
 /**
  * What is left of a world explosive after the blast, as an object to fly: the same model, worn and darkened (the torn shell of the P13 in the Laboratório de Explosões, `SC.p13`),
  * with no part mapped. Undefined for the explosives that have no model of the team.
  */
-declare const worldExplosiveShell: (THREE: typeof THREE_NS, defId: string) => THREE_NS.Group | undefined;
+declare const worldExplosiveShell: (THREE: typeof THREE_NS, defId: string, items?: ItemModels) => THREE_NS.Group | undefined;
 /** An explosive of the arsenal standing in the world: it goes off by a bullet, fire or another blast, after the delay its `chain` gives. */
 declare const worldExplosiveItem: (def: ExplosiveDef, name: string, options?: WorldExplosiveOptions) => TestableItem | undefined;
 
@@ -1057,27 +98,28 @@ declare const BODY_ACTIONS: ReadonlySet<string>;
 declare function weaponProp(def: Pick<WeaponDef, 'id' | 'category' | 'mass'>, name?: string): WeaponProp;
 /** One mesh per box part, named after the part (what destruction renderers bind to), in a group with its origin on the floor. */
 declare function buildProp(THREE: typeof THREE_NS, prop: WeaponProp): THREE_NS.Group;
-/** How a weapon is drawn from an item model of game-items-three: the item (default the weapon id), and the turns the laying-down rule gets wrong. */
-interface WeaponItemModel {
-    /** Catalog id of the item model; the weapon id when absent. */
-    readonly item?: string;
-    /** Quarter turns about y after the long axis is laid along x (a crossbow's stock is shorter than its limbs). */
-    readonly turn?: number;
-    /** Turn it end for end after the head is found (the head is the narrow end: a knife's blade, a screwdriver's tip, an extinguisher's nozzle). */
-    readonly flip?: boolean;
-}
-/** Draws a weapon the gallery did not model with an item model of game-items-three (a game adds its own or corrects one; `null` keeps the low-poly prop). */
-declare function registerWeaponItemModel(weaponId: string, model: WeaponItemModel | null): void;
-/** The item model of game-items-three that draws a weapon (`baseball_bat`, `axe`, `fire_extinguisher`...), or undefined when there is none. */
-declare function itemModelOfWeapon(weaponId: string): string | undefined;
+
 /**
- * A weapon the gallery did not draw, with the team's item model (Itens do Vale Cinzento: the bat, the axe, the machete, the extinguisher...): its long axis turned
- * along +x and laid flat, the wider end (the head) at +x unless `registerWeaponItemModel` says otherwise, the origin at the bottom centre, an empty `handle` at the narrow end where the hand closes. Undefined
- * when game-items-three has no model of it.
+ * The prop of a weapon the gallery drew (or that an item model draws, `buildItemWeaponModel`), for a counter or the floor: its model lying on the side, centred on the footprint with its underside on the floor, joined into one mesh per
+ * material (the hands keep the model with its pivots, `buildWeaponModelById`), every mesh naming the one rigid part (`body`) that moves it. The size of that part is left in
+ * `userData.footprint` for `modeledPropSpec`.
  */
-declare function buildItemWeaponModel(THREE: typeof THREE_NS, def: Pick<WeaponDef, 'id'>): THREE_NS.Group | undefined;
-/** The model of a weapon for the hands or a shelf: the team's item model when the kit has one (`buildItemWeaponModel`), the low-poly prop the counters show otherwise. */
-declare function buildWeaponModel(THREE: typeof THREE_NS, def: Pick<WeaponDef, 'id' | 'category' | 'mass'>): THREE_NS.Group;
+declare function buildModeledProp(THREE: typeof THREE_NS, def: Pick<WeaponDef, 'id'>, name: string, decorate?: (root: THREE_NS.Object3D) => void, items?: ItemModels, props?: WeaponProps): THREE_NS.Group | undefined;
+/** A modeled weapon on a tripod of three steel legs under its middle (the same legs the `tripod` accessory draws in the hands). */
+declare function buildTripodMountedProp(THREE: typeof THREE_NS, def: Pick<WeaponDef, 'id'>, name: string, items?: ItemModels, props?: WeaponProps): THREE_NS.Group | undefined;
+/** The destruction spec of a modeled prop: one steel box of its measures, with the real mass of the weapon. */
+declare function modeledPropSpec(root: unknown, def: Pick<WeaponDef, 'mass'>, name: string): DestructibleSpec;
+
+interface WeaponPropsOptions {
+    /** Item model overrides by weapon id, added to the shipped ones (`null` keeps the low-poly prop); later packs replace earlier ones. */
+    readonly packs?: readonly Readonly<Record<string, WeaponItemModel | null>>[];
+    /** Changes to an override by weapon id, merged field by field. */
+    readonly patch?: Readonly<Record<string, DeepPartial<WeaponItemModel>>>;
+    /** Weapon ids whose override is taken out (the weapon id itself is then the item model id). */
+    readonly remove?: readonly string[];
+}
+/** A set of weapon prop overrides of its own: the shipped ones plus `packs`, `patch` and `remove`. Nothing is shared with any other set on the page. */
+declare function createWeaponProps(options?: WeaponPropsOptions): WeaponProps;
 
 /** The shapes the gallery draws: rimfire, straight rimless (`p`), straight rimmed (`rimp`), bottleneck rimless (`r`), bottleneck rimmed (`rr`) and shotgun shell. */
 type CartridgeShape = 'shell' | 'rim' | 'p' | 'rimp' | 'r' | 'rr';
@@ -1125,6 +167,8 @@ interface FitAttachmentOptions {
     readonly isDrawn?: () => boolean;
     /** Asked every frame: false puts the light and laser out whatever they are set to (the bench layer for the beams). */
     readonly areBeamsOn?: () => boolean;
+    /** The host's light budget: the weapon light is a source of it. Without it the light is a `SpotLight` of its own (deprecated, removed in the next major). */
+    readonly lights?: LightBudget;
 }
 /** The accessories drawn on one model: it follows the list of fitted parts. */
 interface AttachmentRig {
@@ -1160,4 +204,4 @@ declare function rigUnderbarrel(THREE: typeof THREE_NS, model: WeaponModel, def:
  */
 declare function rigStock(THREE: typeof THREE_NS, model: WeaponModel, def: Pick<WeaponDef, 'stock' | 'dimensions'>): void;
 
-export { ARCHETYPE_MODELS, ATTACHMENT_MODELS, type AttachmentBuildContext, type AttachmentModel, type AttachmentModelBuilder, type AttachmentModelRegistry, type AttachmentRig, BODY_ACTIONS, CLASS_REFERENCE_ENERGY, COUNTER_ITEM_ID, type CartridgeShape, type ClipContext, DEFAULT_ENERGY_CURVE, DEFAULT_EXPLOSIVES_SCENE, DEFAULT_THUMBNAIL_BASE, type DistanceCurve, EXPLOSIVES_AREA_ID, EXPLOSIVES_TEXT, type EnergyCurve, type ExplosivesRoom, type ExplosivesScene, type ExplosivesTestModuleOptions, type ExplosivesText, type FitAttachmentOptions, type FxLayers, GAME_DISTANCE_CURVE, GAME_SOUND_CLASSES, type LaserRaycast, MECHANICAL_SOUNDS, MODEL_ENTRIES, MOUNTED_M134_ITEM_ID, type MechanicalSoundId, type ModelEntry, type ModelFamily, type ModelKit, type ModelMaterials, type ModelOptions, type ModelParts, type MountFrame, P13_VALVE_MESH, type ProjectileModel, type ProjectileQuery, type ShotExtras, type ShotSound, type ShotSoundClass, type ShotSoundInput, type ShotSoundOptions, type SoundClassDef, type SoundStep, WEAPON_ITEM_PREFIX, WEAPON_THUMBNAILS, WORLD_EFFECTS, WORLD_EXPLOSIVE_IDS, WORLD_EXPLOSIVE_PREFIX, type WeaponAudio, type WeaponAudioOptions, type WeaponFx, type WeaponFxOptions, type WeaponItemModel, type WeaponModel, type WeaponProp, type WeaponThumbnailEntry, type WeaponsTestModuleOptions, type WorldEffectIds, type WorldEffectsOptions, type WorldExplosiveOptions, applyCondition, buildCartridge, buildCasing, buildItemWeaponModel, buildProp, buildRound, buildToolClips, buildWeaponModel, buildWeaponModelById, cartridgeShape, computeShotSound, createExplosivesTestModule, createWeaponAudio, createWeaponFx, createWeaponsTestModule, createWorldEffects, deriveFrames, explosivesTextOf, fitAttachmentModels, hasWeaponModel, itemModelOfWeapon, mechanicalSoundOf, modelKit, mountFrame, partRegistry, projectileModel, registerWeaponItemModel, rigStock, rigUnderbarrel, weaponProp, weaponThumbnailCredit, weaponThumbnailUrl, weaponsLayout, worldExplosiveItem, worldExplosiveShell, worldExplosiveValve };
+export { ATTACHMENT_MODELS, AttachmentModelRegistry, type AttachmentRig, BODY_ACTIONS, type CartridgeShape, type ClipContext, DEFAULT_THUMBNAIL_BASE, type FitAttachmentOptions, ItemModels, LaserRaycast, ModelFamily, ModelKit, ModelParts, P13_VALVE_MESH, type ProjectileModel, type ProjectileQuery, WEAPON_THUMBNAILS, WORLD_EFFECTS, WORLD_EXPLOSIVE_IDS, WORLD_EXPLOSIVE_PREFIX, WeaponItemModel, WeaponModel, type WeaponProp, WeaponProps, type WeaponPropsOptions, type WeaponThumbnailEntry, type WorldEffectIds, type WorldEffectsOptions, type WorldExplosiveOptions, applyCondition, buildCartridge, buildCasing, buildModeledProp, buildProp, buildRound, buildToolClips, buildTripodMountedProp, cartridgeShape, createWeaponProps, createWorldEffects, fitAttachmentModels, modeledPropSpec, partRegistry, projectileModel, rigStock, rigUnderbarrel, weaponProp, weaponThumbnailCredit, weaponThumbnailUrl, worldExplosiveItem, worldExplosiveShell, worldExplosiveValve };