@adatechnology/game-weapons-three 0.11.3 → 0.13.0

package/dist/testing-BoxqhX_W.d.ts

@@ -0,0 +1,1698 @@
+import { HostTool, HandPose, EffectSink, HostEvent, HandTargets, TestableModule, AreaPlacement, DestructionEvent, Hit, Vec3 as Vec3$1, ModuleControl, ModuleLayer, ModuleMetric, ModuleHost } from '@adatechnology/game-contracts';
+import { CaseType, CaliberDef, ReloadStageId, WeaponEvent, MountKind, AttachmentDef, FittedAttachment, Arsenal, WeaponDef, ExplosiveDef } from '@adatechnology/game-weapons';
+import { SampleDefaults, SfxManifest, SoundBank, SfxManifestSound, AudioEngine } from '@adatechnology/game-audio';
+import * as THREE_NS from 'three';
+import { LightBudget, RenderPools } from '@adatechnology/game-render-three';
+
+interface FlybyInput {
+    /** Bullet speed where it passes the listener, m/s. */
+    readonly speed: number;
+    /** Closest distance from the bullet path to the listener's head, metres. Past `maxMiss` nothing is heard. */
+    readonly miss: number;
+    /** Pitch factor around 1. */
+    readonly pitch?: number;
+    /** Default 6 m. */
+    readonly maxMiss?: number;
+}
+interface FlybyVoice {
+    readonly kind: 'noise' | 'tone';
+    readonly filter?: 'highpass' | 'bandpass';
+    readonly frequency: number;
+    readonly to?: number;
+    readonly q?: number;
+    readonly gain: number;
+    readonly seconds: number;
+}
+interface FlybySound {
+    readonly supersonic: boolean;
+    readonly sample: 'bullet_crack_by' | 'bullet_whiz';
+    readonly voices: readonly FlybyVoice[];
+}
+declare function computeFlyby(input: FlybyInput): FlybySound | null;
+
+type CasingSurface = 'hard' | 'wood' | 'metal' | 'soft';
+type CasingKind = 'pistol' | 'rifle' | 'shell';
+interface CasingInput {
+    readonly caseType?: CaseType | string;
+    /** Floor material id (`concrete`, `wood_hard`, `soil`...). */
+    readonly surface?: string;
+    /** Vertical speed at the hit, m/s (the louder the faster). Default 1.5. */
+    readonly speed?: number;
+    /** 0 for the first hit, then 1, 2...: each bounce is softer and a little higher. */
+    readonly bounce?: number;
+    /** Pitch factor around 1 (the adapter draws ±6 %: no two cases ring the same). */
+    readonly pitch?: number;
+}
+interface CasingVoice {
+    readonly kind: 'tone' | 'noise';
+    readonly filter?: 'lowpass' | 'highpass' | 'bandpass';
+    readonly frequency: number;
+    readonly to?: number;
+    readonly q?: number;
+    readonly gain: number;
+    readonly seconds: number;
+}
+interface CasingSound {
+    readonly surface: CasingSurface;
+    readonly kind: CasingKind;
+    readonly sample: string;
+    readonly voices: readonly CasingVoice[];
+}
+declare function computeCasingSound(input: CasingInput): CasingSound;
+
+var profiles$1 = {
+	pistol_22lr: {
+		referenceJ: 160,
+		far: "pistol",
+		crack: {
+			frequency: 5200,
+			gain: 0.4,
+			seconds: 0.006
+		},
+		blast: {
+			cutoff: 3400,
+			gain: 0.517,
+			seconds: 0.05
+		},
+		body: {
+			from: 200,
+			to: 90,
+			gain: 0.045,
+			seconds: 0.04
+		},
+		far_layer: {
+			cutoff: 1300,
+			gain: 0.22,
+			seconds: 0.12
+		},
+		tail_out: {
+			cutoff: 1500,
+			gain: 0.08,
+			seconds: 0.5
+		},
+		tail_in: {
+			cutoff: 2400,
+			gain: 0.24,
+			seconds: 0.25
+		}
+	},
+	pistol_9mm: {
+		referenceJ: 500,
+		far: "pistol",
+		crack: {
+			frequency: 4200,
+			gain: 0.55,
+			seconds: 0.008
+		},
+		blast: {
+			cutoff: 2500,
+			gain: 0.92,
+			seconds: 0.09
+		},
+		body: {
+			from: 160,
+			to: 55,
+			gain: 0.189,
+			seconds: 0.1
+		},
+		far_layer: {
+			cutoff: 950,
+			gain: 0.35,
+			seconds: 0.2
+		},
+		tail_out: {
+			cutoff: 1150,
+			gain: 0.2,
+			seconds: 0.9
+		},
+		tail_in: {
+			cutoff: 2200,
+			gain: 0.45,
+			seconds: 0.4
+		}
+	},
+	pistol_45: {
+		referenceJ: 480,
+		far: "pistol",
+		crack: {
+			frequency: 3400,
+			gain: 0.42,
+			seconds: 0.009
+		},
+		blast: {
+			cutoff: 1650,
+			gain: 0.977,
+			seconds: 0.12
+		},
+		body: {
+			from: 120,
+			to: 42,
+			gain: 0.279,
+			seconds: 0.15
+		},
+		far_layer: {
+			cutoff: 760,
+			gain: 0.4,
+			seconds: 0.25
+		},
+		tail_out: {
+			cutoff: 1000,
+			gain: 0.22,
+			seconds: 1
+		},
+		tail_in: {
+			cutoff: 1900,
+			gain: 0.48,
+			seconds: 0.45
+		}
+	},
+	revolver_38_357: {
+		referenceJ: 800,
+		far: "pistol",
+		crack: {
+			frequency: 4000,
+			gain: 0.6,
+			seconds: 0.009
+		},
+		blast: {
+			cutoff: 2000,
+			gain: 1.035,
+			seconds: 0.13
+		},
+		body: {
+			from: 135,
+			to: 45,
+			gain: 0.248,
+			seconds: 0.15
+		},
+		far_layer: {
+			cutoff: 820,
+			gain: 0.42,
+			seconds: 0.28
+		},
+		tail_out: {
+			cutoff: 1100,
+			gain: 0.28,
+			seconds: 1.4
+		},
+		tail_in: {
+			cutoff: 2000,
+			gain: 0.54,
+			seconds: 0.5
+		}
+	},
+	revolver_44_50ae: {
+		referenceJ: 1800,
+		far: "pistol",
+		crack: {
+			frequency: 3100,
+			gain: 0.62,
+			seconds: 0.012
+		},
+		blast: {
+			cutoff: 1350,
+			gain: 1.15,
+			seconds: 0.18
+		},
+		body: {
+			from: 100,
+			to: 36,
+			gain: 0.369,
+			seconds: 0.21
+		},
+		far_layer: {
+			cutoff: 650,
+			gain: 0.5,
+			seconds: 0.33
+		},
+		tail_out: {
+			cutoff: 900,
+			gain: 0.34,
+			seconds: 1.7
+		},
+		tail_in: {
+			cutoff: 1700,
+			gain: 0.6,
+			seconds: 0.6
+		}
+	},
+	shotgun_12: {
+		referenceJ: 2700,
+		far: "shotgun",
+		crack: {
+			frequency: 2600,
+			gain: 0.36,
+			seconds: 0.012
+		},
+		blast: {
+			cutoff: 900,
+			gain: 1.15,
+			seconds: 0.26
+		},
+		body: {
+			from: 90,
+			to: 32,
+			gain: 0.405,
+			seconds: 0.3
+		},
+		far_layer: {
+			cutoff: 540,
+			gain: 0.55,
+			seconds: 0.42
+		},
+		tail_out: {
+			cutoff: 800,
+			gain: 0.38,
+			seconds: 1.9
+		},
+		tail_in: {
+			cutoff: 1500,
+			gain: 0.63,
+			seconds: 0.7
+		}
+	},
+	rifle_5_56: {
+		referenceJ: 1750,
+		far: "rifle",
+		crack: {
+			frequency: 5400,
+			gain: 0.78,
+			seconds: 0.007
+		},
+		blast: {
+			cutoff: 2700,
+			gain: 0.977,
+			seconds: 0.11
+		},
+		body: {
+			from: 145,
+			to: 50,
+			gain: 0.216,
+			seconds: 0.12
+		},
+		far_layer: {
+			cutoff: 900,
+			gain: 0.5,
+			seconds: 0.36
+		},
+		tail_out: {
+			cutoff: 1300,
+			gain: 0.4,
+			seconds: 2.1
+		},
+		tail_in: {
+			cutoff: 2300,
+			gain: 0.57,
+			seconds: 0.55
+		}
+	},
+	rifle_7_62x39: {
+		referenceJ: 2100,
+		far: "rifle",
+		crack: {
+			frequency: 4300,
+			gain: 0.72,
+			seconds: 0.01
+		},
+		blast: {
+			cutoff: 1850,
+			gain: 1.092,
+			seconds: 0.15
+		},
+		body: {
+			from: 115,
+			to: 40,
+			gain: 0.297,
+			seconds: 0.17
+		},
+		far_layer: {
+			cutoff: 780,
+			gain: 0.52,
+			seconds: 0.38
+		},
+		tail_out: {
+			cutoff: 1100,
+			gain: 0.42,
+			seconds: 2.2
+		},
+		tail_in: {
+			cutoff: 2000,
+			gain: 0.6,
+			seconds: 0.6
+		}
+	},
+	rifle_308_3006: {
+		referenceJ: 3500,
+		far: "rifle",
+		crack: {
+			frequency: 4500,
+			gain: 0.8,
+			seconds: 0.01
+		},
+		blast: {
+			cutoff: 1500,
+			gain: 1.15,
+			seconds: 0.19
+		},
+		body: {
+			from: 100,
+			to: 36,
+			gain: 0.36,
+			seconds: 0.21
+		},
+		far_layer: {
+			cutoff: 650,
+			gain: 0.6,
+			seconds: 0.46
+		},
+		tail_out: {
+			cutoff: 950,
+			gain: 0.5,
+			seconds: 2.7
+		},
+		tail_in: {
+			cutoff: 1800,
+			gain: 0.675,
+			seconds: 0.7
+		}
+	},
+	sniper_338_300wm: {
+		referenceJ: 6600,
+		far: "heavy",
+		crack: {
+			frequency: 4200,
+			gain: 0.86,
+			seconds: 0.012
+		},
+		blast: {
+			cutoff: 1250,
+			gain: 1.208,
+			seconds: 0.23
+		},
+		body: {
+			from: 85,
+			to: 32,
+			gain: 0.414,
+			seconds: 0.26
+		},
+		far_layer: {
+			cutoff: 580,
+			gain: 0.65,
+			seconds: 0.52
+		},
+		tail_out: {
+			cutoff: 850,
+			gain: 0.56,
+			seconds: 3.1
+		},
+		tail_in: {
+			cutoff: 1650,
+			gain: 0.72,
+			seconds: 0.8
+		}
+	},
+	antimateriel_50bmg: {
+		referenceJ: 18000,
+		far: "heavy",
+		crack: {
+			frequency: 3500,
+			gain: 0.9,
+			seconds: 0.015
+		},
+		blast: {
+			cutoff: 900,
+			gain: 1.265,
+			seconds: 0.3
+		},
+		body: {
+			from: 62,
+			to: 25,
+			gain: 0.495,
+			seconds: 0.36
+		},
+		far_layer: {
+			cutoff: 450,
+			gain: 0.7,
+			seconds: 0.62
+		},
+		tail_out: {
+			cutoff: 700,
+			gain: 0.6,
+			seconds: 3.6
+		},
+		tail_in: {
+			cutoff: 1400,
+			gain: 0.75,
+			seconds: 0.9
+		}
+	}
+};
+var data$1 = {
+	profiles: profiles$1};
+
+type GunshotProfileId = keyof typeof data$1.profiles;
+type GunshotFarClass = 'pistol' | 'rifle' | 'shotgun' | 'heavy';
+type Noise = {
+    readonly cutoff: number;
+    readonly gain: number;
+    readonly seconds: number;
+};
+interface GunshotProfile {
+    /** Muzzle energy (J) the numbers are written for: a lighter or heavier calibre of the family is scaled from it. */
+    readonly referenceJ: number;
+    readonly far: GunshotFarClass;
+    /** Supersonic N-wave or muzzle snap: highpass noise. */
+    readonly crack: {
+        readonly frequency: number;
+        readonly gain: number;
+        readonly seconds: number;
+    };
+    /** The mid "slap" of the muzzle blast: lowpass noise. */
+    readonly blast: Noise;
+    /** The low thump: a sine sweeping `from` → `to`. */
+    readonly body: {
+        readonly from: number;
+        readonly to: number;
+        readonly gain: number;
+        readonly seconds: number;
+    };
+    readonly far_layer: Noise;
+    readonly tail_out: Noise;
+    readonly tail_in: Noise;
+}
+declare const GUNSHOT_PROFILES: Readonly<Record<GunshotProfileId, GunshotProfile>>;
+type GunshotSpace = 'outdoor' | 'indoor';
+type GunshotGroup = 'close' | 'mech' | 'tail' | 'far';
+interface GunshotInput {
+    readonly caliber?: CaliberDef;
+    /** Muzzle energy (J), for a shot with no calibre; the calibre's energy (× pellets) otherwise. */
+    readonly energyJ?: number;
+    readonly category?: string;
+    /** Metres from the listener, default 0 (the player's own weapon). */
+    readonly distance?: number;
+    readonly suppressed?: boolean;
+    readonly space?: GunshotSpace;
+    /** 0..n−1: which take (`pickTake` gives one that is not the last). */
+    readonly take?: number;
+    /** Pitch factor of this shot, around 1 (the adapter draws ±4 %). */
+    readonly pitch?: number;
+    /** Master level, default 1. */
+    readonly volume?: number;
+    /** 0..1, a wall between the shot and the listener: −6 dB and the lowpass cutoffs at 40 % when fully behind it (as game-audio's occlusion). */
+    readonly occlusion?: number;
+}
+interface GunshotOptions {
+    /** Replaces or adds profiles. */
+    readonly profiles?: Readonly<Partial<Record<string, GunshotProfile>>>;
+    /** Replaces or adds calibre → profile links. */
+    readonly calibers?: Readonly<Record<string, string>>;
+    /** Level law `(reference / d)^exponent` beyond `reference` metres (default 4 m, 0.8: a little gentler than the 6 dB per doubling of the free field, as games do). */
+    readonly reference?: number;
+    readonly exponent?: number;
+    /** Below this the shot is not played (default 0.004, −48 dB). */
+    readonly minGain?: number;
+    /** The close sound fades to the far one between these distances, metres (default 25 and 80). */
+    readonly farFrom?: number;
+    readonly farTo?: number;
+}
+interface GunshotVoice {
+    readonly group: GunshotGroup;
+    /** Which part of the group: `crack`, `blast`, `body`, `action`, `tail`, `echo`, `reflection`, `boom`. */
+    readonly part: string;
+    /** Seconds after the trigger (the arrival delay included). */
+    readonly at: number;
+    readonly kind: 'noise' | 'tone';
+    readonly filter?: 'lowpass' | 'highpass' | 'bandpass';
+    /** Filter frequency (noise) or start frequency (tone). */
+    readonly frequency: number;
+    /** Tone end frequency. */
+    readonly to?: number;
+    readonly q?: number;
+    readonly gain: number;
+    readonly seconds: number;
+    /** Send to the reverb (a room). */
+    readonly wet?: number;
+}
+interface Gunshot {
+    readonly profile: string;
+    readonly energyJ: number;
+    readonly supersonic: boolean;
+    readonly take: number;
+    readonly pitch: number;
+    /** Distance / speed of sound. */
+    readonly delay: number;
+    /** 1 = all close, 0 = all far. */
+    readonly closeMix: number;
+    readonly audible: boolean;
+    /** The sample ids each group can be replaced by (checklist 5.1). */
+    readonly samples: Readonly<Record<GunshotGroup, string>>;
+    readonly voices: readonly GunshotVoice[];
+}
+/**
+ * The voices of one gunshot. Distance: every layer arrives `d / 343` s late; the level falls as `(reference / d)^exponent`, the highs go first (the
+ * crack fades over ~60 m, lowpass cutoffs fall with `1 + d / 250`) and the close sound fades into the far boom between `farFrom` and `farTo`. Space:
+ * outdoors the field answers with two late echoes and a long low tail; indoors the room answers at once (early reflections and a dense, short tail
+ * sent to the reverb). A suppressor takes the blast and the body down and leaves the action and a supersonic crack.
+ */
+declare function computeGunshot(input: GunshotInput, options?: GunshotOptions): Gunshot;
+
+/** 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;
+}
+
+/** Where the recorded files are: the manifest the converter wrote and how a file of it becomes a url. */
+interface WeaponSampleOptions {
+    readonly manifest: SfxManifest;
+    /** Prefix of every file (`/sfx/`), when `url` is not given. Default ''. */
+    readonly baseUrl?: string;
+    /** The url of a file of the manifest (`armas/pistol_9mm_close_01.ogg`): a served path or a `data:` url of the inlined bytes. */
+    readonly url?: (file: string) => string;
+    /** Replaces the numbers of a sound by id (gain, crossover, falloff...). */
+    readonly sounds?: Readonly<Record<string, Partial<SampleDefaults>>>;
+}
+/** The shot sounds: the calibre profiles and the suppressed ones. */
+declare const GUNSHOT_SAMPLE_IDS: readonly string[];
+/**
+ * A shot as recorded: the near take up to 20 m, the mid-distance one from 90 m, an equal-power crossfade between. The level falls gently (a
+ * gunshot carries: about −14 dB at 100 m, −36 dB at 800 m) and the highs go with the air (6.7 kHz at 50 m, 2.2 kHz at 200 m). Three plays ring at once at most, so a burst stays shot
+ * by shot.
+ */
+declare const GUNSHOT_SAMPLE: SampleDefaults;
+/** A reload step: heard at the hands, about a third of a shot's level after the converter's peak normalization. */
+declare const RELOAD_SAMPLE: SampleDefaults;
+/** Seconds from the start of each recorded reload step to its hit (`data/reload-sample-hits.json`, measured on the files). */
+declare const RELOAD_SAMPLE_HITS: Readonly<Record<string, number>>;
+/** The tier a weapon's weight plays (`SFX_TIERS`: light from 0, medium from 0.34, heavy from 0.67). */
+declare const WEIGHT_INTENSITY: Readonly<Record<SoundProfile['weight'], number>>;
+/**
+ * Reload cues the recordings of another cue already carry: the magazine release button is the start of the "detach magazine" take, the slide of
+ * the magazine into the well the start of the "insert magazine" one. When that sample plays, these cues stay silent.
+ */
+declare const CUES_IN_SAMPLE: Readonly<Record<string, string>>;
+/** The numbers of a sound of the manifest: a gunshot, a case landing or a reload step (`armas` only). */
+declare function weaponSampleDefaults(sound: SfxManifestSound, overrides?: WeaponSampleOptions['sounds']): SampleDefaults | undefined;
+/** The bank of the recorded weapon sounds, every url through `url` (or `baseUrl`). Gunshots choke at three voices. */
+declare function weaponSampleBank(options: WeaponSampleOptions): SoundBank;
+
+/** What a reload cue played: its recording, nothing (another cue's recording carries it), or the synthesized steps. */
+type CuePlayed = 'sample' | 'carried' | 'synth';
+/** What sounded for a shot: the recorded takes (`sample`, with the take of each layer) or the synthesized layers (`synth`). */
+type GunshotPlayed = {
+    readonly kind: 'synth';
+} | {
+    readonly kind: 'sample';
+    readonly id: string;
+    readonly layers: readonly {
+        readonly role: string;
+        readonly take: number;
+        readonly rate: number;
+    }[];
+};
+/** 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'> & {
+    /** Where the shot is, for the stereo side (the engine's listener is the other end). Left out, the shot is in front (the player's own weapon). */
+    readonly position?: readonly [number, number, number];
+    /** 0..1, a wall between the shot and the listener (the host's occlusion test): quieter and duller. */
+    readonly occlusion?: number;
+    /** Open field or a room; `indoors: true` means `'indoor'`. Default outdoor. */
+    readonly space?: GunshotSpace;
+};
+/** `gunshot` (default): the layered shot of `computeGunshot`. `game`: the game's single class burst (`computeShotSound`), kept for the golden traces. */
+type ShotModel = 'gunshot' | 'game';
+interface WeaponAudioOptions extends ShotSoundOptions {
+    /** How a shot is built; default `gunshot`. */
+    readonly shotModel?: ShotModel;
+    /** Tunes the layered gunshot (profiles, calibre links, distance law). */
+    readonly gunshot?: GunshotOptions;
+    /** Pitch spread of a shot, ± this fraction (default 0.04, C5). */
+    readonly pitchSpread?: number;
+    /** Told each gunshot played (profile, take, pitch, space, distance), so a host can log what sounded. */
+    readonly onGunshot?: (shot: Gunshot, input: GunshotInput, played: GunshotPlayed) => void;
+    /** Told each case that lands (floor, case type, sample id). */
+    readonly onCasing?: (sound: CasingSound, played: 'sample' | 'synth') => void;
+    /** 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;
+    /**
+     * The recorded shots and reload steps (game-audio's `assets/sfx/manifest.json` and where its files are served). A shot of a profile with files
+     * plays its takes, a reload cue the takes of the weapon's weight; until they are loaded, and for anything without files, the synthesized sound.
+     */
+    readonly samples?: WeaponSampleOptions;
+}
+/** Sounds the weapon presentation plays. */
+interface WeaponAudio {
+    /** A shot: the layered gunshot of its calibre (close, action, room or field, far) at its distance, or the game's class burst with `shotModel: 'game'`. */
+    shot(energyJ: number, category: string, extras?: ShotExtras): void;
+    /** The parameters `shot` would play with the `game` model (pure). */
+    shotSound(input: ShotSoundInput): ShotSound;
+    /** The voices `shot` plays with the `gunshot` model (pure; give `take` and `pitch` to fix them). */
+    gunshot(input: GunshotInput): Gunshot;
+    /** 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), where the clip says. `lead` is how early the clip started it (seconds before the part reaches its stop): a recording plays at once, its hit
+     * that much later; the synthesized steps, whose hit is at their start, wait `lead`.
+     */
+    cue(id: string, profile?: SoundProfile, lead?: number): CuePlayed;
+    /** Loads the recorded files now (they load on the first sound otherwise, and the synthesized sound plays meanwhile). */
+    loadSamples(): Promise<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 (the art scene's single ring; with the `gunshot` model, a pistol case on concrete). */
+    clink(): void;
+    /** A case hitting the floor: its type (pistol, rifle, shell), the floor material, the speed and which bounce. */
+    casing(input: CasingInput): void;
+    /** A bullet passing the listener (shot by someone else): crack when supersonic, whiz when not; `position` is where it passes, for the side. */
+    flyby(input: FlybyInput & {
+        readonly position?: readonly [number, number, number];
+    }): 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 host's light budget, when it has one: a light asks it for a slot instead of creating a `SpotLight`. */
+    readonly lights: LightBudget | 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>>;
+
+/** What a weapon or an explosive asks of an item model: the fields of `DrawableItem` of game-items-three that it fills in. */
+interface ItemModelRequest {
+    id: string;
+    category: string;
+    size: [number, number, number];
+    model?: string;
+}
+/**
+ * The item models of game-items-three, lent by the host as `items`; `itemModels` of game-items-three fits it, and the host that passes none gets it as the default.
+ * The default is deprecated and removed in the next major: pass `items`.
+ */
+interface ItemModels {
+    has(id: string): boolean;
+    /** `wear`: 0 new, 1 used, 2 spoiled. */
+    build(THREE: typeof THREE_NS, item: ItemModelRequest, options?: {
+        wear?: 0 | 1 | 2;
+    }): {
+        root: THREE_NS.Group;
+        kind: string;
+    };
+}
+
+interface WeaponFxOptions {
+    /** The item models of game-items-three (`itemModels` there) that draw the weapons the gallery did not model; default `itemModels` there (deprecated: pass it). */
+    items?: ItemModels;
+    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;
+    /** Whether shots are in a room or in the open (the gunshot tail). Default outdoor. */
+    soundSpace?: () => GunshotSpace;
+    /** The floor material under a point, for the sound of a case landing there. Default concrete. */
+    surfaceAt?: (x: number, z: number) => string | undefined;
+    /** 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;
+        played?: CuePlayed;
+    }) => 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 most casings and magazines alive at once (`host.particleLimit`), read at each spawn; without it the viewmodel keeps a cap of its own. */
+    particleLimit?: () => number | undefined;
+    /** The host's light budget (`host.lights`): the rocket in flight and the weapon light ask it for a light; without it they create lights of their own (deprecated, removed in the next major). */
+    lights?: LightBudget;
+    /** The host's pools (`host.pools`): the burning droplets and the ground flames of a flamethrower take their geometry and material from them; without them each makes its own (deprecated, removed in the next major). */
+    pools?: RenderPools;
+}
+
+/** 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;
+
+/** 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;
+}
+/** The weapons whose item model has another id or turns another way, with the draw that reads them: one set, with no other set sharing it. */
+interface WeaponProps {
+    /** 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). */
+    register(weaponId: string, model: WeaponItemModel | null): void;
+    /** The override of a weapon, if the set has one. */
+    get(weaponId: string): WeaponItemModel | undefined;
+    /** The item model of game-items-three that draws a weapon, or undefined when there is none. */
+    itemModelOf(weaponId: string, items?: ItemModels): string | undefined;
+    /** `buildItemWeaponModel` with this set's overrides. */
+    buildItemModel(THREE: typeof THREE_NS, def: Pick<WeaponDef, 'id'>, items?: ItemModels): THREE_NS.Group | undefined;
+    /** `buildWeaponModel` with this set's overrides. */
+    buildModel(THREE: typeof THREE_NS, def: Pick<WeaponDef, 'id' | 'category' | 'mass'>, items?: ItemModels): THREE_NS.Group;
+}
+/** The set behind `registerWeaponItemModel`, `itemModelOfWeapon`, `buildItemWeaponModel` and `buildWeaponModel`, created on first use. */
+declare const defaultWeaponProps: () => WeaponProps;
+/** @deprecated use `createWeaponProps(...).register`. */
+declare const 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. @deprecated use `createWeaponProps(...).itemModelOf`. */
+declare const itemModelOfWeapon: (weaponId: string, items?: ItemModels) => 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 `items` (the item models of game-items-three, lent by the host; default `itemModels` there) has none of it.
+ * @deprecated use `createWeaponProps(...).buildItemModel`.
+ */
+declare const buildItemWeaponModel: (THREE: typeof THREE_NS, def: Pick<WeaponDef, "id">, items?: ItemModels) => 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. @deprecated use `createWeaponProps(...).buildModel`. */
+declare const buildWeaponModel: (THREE: typeof THREE_NS, def: Pick<WeaponDef, "id" | "category" | "mass">, items?: ItemModels) => THREE_NS.Group;
+
+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;
+    /** The recorded shots and reload steps (game-audio's sfx manifest and where its files are); without it the synthesized sounds play. */
+    samples?: WeaponSampleOptions;
+    /** 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;
+    /** The item models of game-items-three (`itemModels` there): the weapons the gallery did not draw get the team's model instead of the low-poly prop; default `itemModels` there (deprecated: pass it). */
+    items?: ItemModels;
+    /** The weapon item model overrides to draw with (`createWeaponProps(...)`); default the shared set behind `registerWeaponItemModel`. */
+    props?: WeaponProps;
+}
+/** 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;
+};
+
+/** 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_sheltered: 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;
+        /** The share of a blast at `point` that reaches `target` through the cover between them (game-destruction `blastReach`). */
+        blastReach?(point: Vec3$1, target: Vec3$1, options?: {
+            readonly ignore?: readonly string[];
+        }): number;
+    };
+    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 items?: ItemModels;
+    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 item models of game-items-three (`itemModels` there): the P13 is drawn with the team's model (default `itemModels` there, deprecated: pass it). */
+    items?: ItemModels;
+}
+/**
+ * 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>;
+};
+
+export { type ShotSoundOptions as $, type AttachmentModelRegistry as A, type GunshotInput as B, CLASS_REFERENCE_ENERGY as C, DEFAULT_ENERGY_CURVE as D, EXPLOSIVES_AREA_ID as E, type FlybySound as F, GAME_DISTANCE_CURVE as G, type GunshotPlayed as H, type ItemModels as I, type ItemModelRequest as J, MECHANICAL_SOUNDS as K, type LaserRaycast as L, type ModelKit as M, MODEL_ENTRIES as N, MOUNTED_M134_ITEM_ID as O, type MechanicalSoundId as P, type ModelEntry as Q, type ModelMaterials as R, type ModelOptions as S, type MountFrame as T, RELOAD_SAMPLE as U, RELOAD_SAMPLE_HITS as V, type WeaponProps as W, type ShotExtras as X, type ShotSound as Y, type ShotSoundClass as Z, type ShotSoundInput as _, type WeaponItemModel as a, type SoundClassDef as a0, type SoundStep as a1, WEAPON_ITEM_PREFIX as a2, WEIGHT_INTENSITY as a3, type WeaponAudio as a4, type WeaponAudioOptions as a5, type WeaponFx as a6, type WeaponFxOptions as a7, type WeaponSampleOptions as a8, type WeaponsTestModuleOptions as a9, buildItemWeaponModel as aa, buildWeaponModel as ab, buildWeaponModelById as ac, computeCasingSound as ad, computeFlyby as ae, computeGunshot as af, computeShotSound as ag, createExplosivesTestModule as ah, createWeaponAudio as ai, createWeaponFx as aj, createWeaponsTestModule as ak, defaultWeaponProps as al, deriveFrames as am, explosivesTextOf as an, hasWeaponModel as ao, itemModelOfWeapon as ap, mechanicalSoundOf as aq, modelKit as ar, mountFrame as as, registerWeaponItemModel as at, weaponSampleBank as au, weaponSampleDefaults as av, weaponsLayout as aw, type WeaponModel as b, type ModelParts as c, type ModelFamily as d, ARCHETYPE_MODELS as e, type AttachmentBuildContext as f, type AttachmentModel as g, type AttachmentModelBuilder as h, COUNTER_ITEM_ID as i, CUES_IN_SAMPLE as j, type CasingSound as k, type CuePlayed as l, DEFAULT_EXPLOSIVES_SCENE as m, type DistanceCurve as n, EXPLOSIVES_TEXT as o, type EnergyCurve as p, type ExplosivesRoom as q, type ExplosivesScene as r, type ExplosivesTestModuleOptions as s, type ExplosivesText as t, type FxLayers as u, GAME_SOUND_CLASSES as v, GUNSHOT_PROFILES as w, GUNSHOT_SAMPLE as x, GUNSHOT_SAMPLE_IDS as y, type Gunshot as z };