@adatechnology/game-audio 0.3.6 → 0.5.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { Vec3, AudioSink, TestableModule } from '@adatechnology/game-contracts';
+import { S as SampleSound, a as SampleLoader, B as BusId, b as SampleCrossover, F as Falloff, c as SoundBank, L as LoopRecipe, d as SoundRecipe, P as ParamRef, R as Range, e as Layer, f as SoundSet, g as SoundPlan, h as SamplePlan, A as AudioLoopHandle, i as LoopEntry, M as MixProfile, j as AudioEngine } from './locale-BugSe8dA.js';
+export { k as ActionCheck, l as AudioBenchText, m as AudioChannel, n as AudioEngineOptions, o as AudioScenarioLike, p as AudioStats, q as AudioTestModule, r as AudioTestModuleOptions, s as Automation, t as BENCH_BANK, u as BUILD_ORDERS, v as BUS_IDS, w as BUS_PRIORITY, x as BuildOrder, y as BusSetting, C as CRITERIA, z as CRITERIA_TARGETS, D as CriterionId, E as CriterionResult, G as Curve, H as DEFAULT_CROSSOVER, I as DEFAULT_LISTENER, J as DEFAULT_MAX_VOICES, K as DEFAULT_MIX, N as DEFAULT_SAMPLE_CUTOFF_K, O as DEFAULT_SAMPLE_FALLOFF, Q as DEFAULT_SAMPLE_PITCH, T as DEFAULT_TAIL_GAIN, U as DeepPartial, V as DistanceMode, W as Envelope, X as EnvelopePoint, Y as FilterBank, Z as FilterSpec, _ as FormantVoiceSource, $ as LAYER_FLOOR, a0 as LayerSource, a1 as Listener, a2 as LoopOrder, a3 as LoopSet, a4 as MIX_PROFILES, a5 as MeasureOptions, a6 as Modulator, a7 as NoiseSource, a8 as OPEN_CUTOFF, a9 as OscSource, aa as PAN_LIMIT, ab as PAN_MIN_DISTANCE, ac as PlanInput, ad as PlannedAutomation, ae as PlannedEnvelopePoint, af as PlannedFilter, ag as PlannedLayer, ah as PlannedModulator, ai as PlannedSampleLayer, aj as PlannedSource, ak as PlayOptions, al as SAMPLE_ENVIRONMENTS, am as SFX_BLOWS, an as SFX_CATALOG, ao as SFX_CATEGORIES, ap as SFX_IMPACTS, aq as SFX_MATERIALS, ar as SampleEnvironment, as as SampleLayerRole, at as SampleLoadReport, au as SampleMemory, av as SampleOptions, aw as SamplePlanInput, ax as SampleRef, ay as SampleStatus, az as SampleStore, aA as SampleTail, aB as SampleTier, aC as SfxBlow, aD as SfxCategory, aE as SfxEntry, aF as SfxMaterial, aG as SfxPriority, aH as SfxState, aI as SoundRegistry, aJ as StartQueueOptions, aK as Time, aL as VOICE_GROUPS, aM as VoiceDecision, aN as VoiceGroup, aO as VoiceHandle, aP as VoiceManager, aQ as VoiceManagerOptions, aR as VoiceRefusal, aS as VoiceRequest, aT as VoiceStartEvent, aU as VoiceStats, aV as audioBenchTextOf, aW as busGain, aX as busPriority, aY as createAudioEngine, aZ as createAudioTestModule, a_ as createSampleStore, a$ as createSoundRegistry, b0 as createVoiceManager, b1 as crossGains, b2 as farMixAt, b3 as fetchLoader, b4 as impactSoundId, b5 as inlineLoader, b6 as limiterCurve, b7 as listenerDistance, b8 as measureCriteria, b9 as panFor, ba as pickTake, bb as planSample, bc as planSound, bd as recordOutput, be as resolveMix, bf as sampleCutoff, bg as sampleUrls, bh as sfxState, bi as tierFor } from './locale-BugSe8dA.js';
+import { AudioSink } from '@adatechnology/game-contracts';
 
 /** Deterministic mulberry32 generator; floats in [0, 1). The same generator the golden tool seeds `Math.random` with, so a team routine and its recipe draw the same numbers. */
 declare function createRng(seed: number): () => number;
@@ -8,355 +10,159 @@ declare function streamFor(seed: number, name: string | number): () => number;
 /** `min + random × (max − min)`: the form every team routine uses (`95 + Math.random() * 40`). */
 declare function drawBetween(random: () => number, min: number, max: number): number;
 
+declare const CALIBRATION_ID = "calibration_shot";
+/** 16-bit PCM mono WAV bytes of the samples (clamped to ±1). */
+declare function encodeWav(samples: Float32Array, sampleRate?: number): ArrayBuffer;
+/** The calibration sound (weapons bus, every layer, fallback to the game's pistol noise class). */
+declare const CALIBRATION_SOUND: SampleSound;
+declare const CALIBRATION_LOOP_ID = "calibration_loop";
+/** A steady hiss in three 0.6 s takes, crossed in 0.15 s: the loop the harness checks for seams (no dip, no gap where two takes meet). */
+declare const CALIBRATION_LOOP_SOUND: SampleSound;
+/** Whether a url is one of the calibration takes. */
+declare const isCalibrationUrl: (url: string) => boolean;
+/** Bytes of the calibration takes (made on demand, the same for the same name). Falls through to `next` for any other url. */
+declare function calibrationLoader(next?: SampleLoader): SampleLoader;
+
 /**
- * Sound recipes are data. A recipe says which nodes a sound has and which numbers drive them; ranges are drawn when the sound is planned, in
- * the order the fields are written (see `planSound`), so a recipe ported from a team routine draws its random numbers in the routine's order.
- */
-declare const BUS_IDS: readonly ["weapons", "voices", "world", "ambience", "weather", "ui"];
-type BusId = (typeof BUS_IDS)[number];
-/** A named number: from `PlayOptions.params` or the recipe's `vars`, times `scale`, plus `add`. */
-type ParamRef = {
-    readonly param: string;
-    readonly scale?: number;
-    readonly add?: number;
-};
-/** A number, a `[min, max]` drawn uniformly (`min + random × (max − min)`), or a named number. */
-type Range = number | readonly [min: number, max: number] | ParamRef;
-/** Seconds from the layer start: a range, the layer `'duration'`, or `'0.6d'` (0.6 × the layer duration). */
-type Time = Range | 'duration' | `${number}d`;
-type Curve = 'linear' | 'exp';
-/**
- * How an AudioParam moves:
- * - `{ set }` assigns `.value`;
- * - `{ set, to, curve, over }` assigns `.value`, then ramps to `to` at `over`;
- * - `{ from }` calls `setValueAtTime(from)` at the start; with `to`, `curve` and `over` it then ramps to `to` (`'from'` is the value drawn for `from`: the art scene ramps a tone back to its own start when it gives no end).
+ * Measurements of rendered sound (pure, on plain sample arrays), for the criteria C1–C9: when it starts, how loud and how bright it is, which side
+ * it is on, how long it rings and how many separate hits a burst has.
  */
-type Automation = {
-    readonly set: Range;
-    readonly to?: Range | 'from';
-    readonly curve?: Curve;
-    readonly over?: Time;
-} | {
-    readonly from: Range;
-    readonly to?: Range | 'from';
-    readonly curve?: Curve;
-    readonly over?: Time;
-};
+type Channels = readonly Float32Array[];
+/** Linear amplitude to dBFS (−Infinity for 0). */
+declare const dbOf: (amplitude: number) => number;
+/** The loudest sample of every channel between two sample indexes (linear). */
+declare function peakOf(channels: Channels, start?: number, end?: number): number;
+/** Index of the loudest sample (any channel) between two indexes. */
+declare function peakIndex(channels: Channels, start?: number, end?: number): number;
+/** First sample index at or after `start` whose amplitude (any channel) reaches `threshold`, or −1. */
+declare function onsetIndex(channels: Channels, start?: number, threshold?: number): number;
+/** RMS of all channels between two indexes, dBFS. */
+declare function rmsDb(channels: Channels, start: number, end: number): number;
+/** Spectral centroid (Hz) of `size` samples from `start` (channels summed, Hann window, plain DFT): the brightness of the sound. */
+declare function centroidHz(channels: Channels, sampleRate: number, start: number, size?: number): number;
+/** Energy balance from −1 (all left) to 1 (all right) between two indexes. */
+declare function balanceOf(left: Float32Array, right: Float32Array, start: number, end: number): number;
+/** Seconds from `start` to the last 10 ms window louder than `floorDb` (how long the sound rings, tail included). */
+declare function ringSeconds(channels: Channels, sampleRate: number, start: number, floorDb?: number): number;
 /**
- * One gain point: time (seconds, or `'0.6d'`), value and how it is reached (`set` = `setValueAtTime`, or a ramp). The value is multiplied by the
- * layer level (volume, distance and layer gain) except when the fourth item is `'fixed'` (the floor a ramp falls to, such as 0.001).
+ * Separate hits in a burst: attacks of the 2 ms envelope, where it jumps to twice the mean of the 20 ms before it and reaches `threshold`, at least
+ * 30 ms apart (so a rapid fire over a long tail still counts every shot).
  */
-type EnvelopePoint = readonly [time: number | `${number}d`, value: number, curve: 'set' | Curve] | readonly [time: number | `${number}d`, value: number, curve: 'set' | Curve, fixed: 'fixed'];
-type Envelope = readonly EnvelopePoint[];
-type FilterSpec = {
-    readonly type: BiquadFilterType;
-    readonly frequency: Automation;
-    readonly q?: Range;
-    /** The BiquadFilter gain (shelf and peaking types). */
-    readonly gain?: Range;
-    /** A gain node after the filter, for a parallel bank where each band has its own level (the game's scream formants). */
-    readonly level?: Range;
-};
-type FilterBank = {
-    readonly mode: 'serial' | 'parallel';
-    readonly bank: readonly FilterSpec[];
-};
-/** An LFO. `depth` is absolute, or a factor of the source start frequency. With `base`, gain modulation goes through its own gain stage (the game rotor). */
-type Modulator = {
-    readonly target: 'gain' | 'frequency';
-    /** Left out, the oscillator keeps its default (sine) and no type is set. */
-    readonly wave?: OscillatorType;
-    readonly rate: Range;
-    readonly depth: Range | {
-        readonly scaleOf: 'frequency';
-        readonly factor: number;
-    };
-    readonly base?: number;
-};
+declare function countHits(channels: Channels, sampleRate: number, threshold: number): number;
+/** Peak of the last `seconds` of a file against its own peak, dB (≤ −40: it fades out, it does not end on a cut). */
+declare function endDropDb(channels: Channels, sampleRate: number, seconds?: number): number;
+
 /**
- * Noise from the engine's seeded buffer. `offset` is where playback starts in it: `'random'` (random × `offsetScale`, default 1), `'fit'`
- * (random × (buffer length − duration)) or seconds. `loop` sets the source to loop (the art scene sets it on every noise source).
+ * The manifest the converter (`scripts/sfx-convert.mjs`) writes next to the converted files: every sound id with its takes per layer, the file
+ * facts the criteria check (rate, channels, peak, length) and where each file came from. `sampleBankFromManifest` turns it into a `SoundBank`
+ * of `SampleSound`s, with the bus and the numbers of each sound given by the caller.
  */
-type NoiseSource = {
-    readonly kind: 'noise';
-    readonly offset?: 'random' | 'fit' | number;
-    readonly offsetScale?: number;
-    readonly loop?: boolean;
-};
-type OscSource = {
-    readonly kind: 'osc';
-    readonly wave: OscillatorType;
-    readonly frequency: Automation;
-};
-/** The art scene's `voice`: an oscillator with vibrato through formant bands, plus a band of breath noise, summed and boosted. */
-type FormantVoiceSource = {
-    readonly kind: 'formant_voice';
-    readonly wave: OscillatorType;
-    readonly frequency: Automation;
-    /** Vibrato rate, and depth as a factor of the start frequency. */
-    readonly vibrato: {
-        readonly rate: Range;
-        readonly depth: number;
-    };
-    readonly formants: readonly {
-        readonly frequency: Range;
-        readonly q: number;
-    }[];
-    readonly breath: {
-        readonly frequency: Range;
-        readonly q: number;
-        readonly gain: Range;
-    };
-    readonly mix: number;
-};
-type LayerSource = NoiseSource | OscSource | FormantVoiceSource;
-type Layer = {
-    /** Start, seconds after the sound starts. */
-    readonly at?: Range;
-    /** Overrides the recipe duration for this layer. */
-    readonly duration?: Range;
-    /** Seconds the source keeps running after the duration (the `+ 0.05` of the team routines). Default: the recipe's, else 0.05. */
-    readonly tail?: number;
-    /** The layer played `count` times, `spacing` seconds apart (the game's animal calls). */
-    readonly repeat?: {
-        readonly count: number;
-        readonly spacing: number;
+
+/** Licences the SDK accepts (the files are redistributed on npm): public domain or attribution only. */
+declare const SDK_LICENSES: readonly ["CC0", "CC-BY"];
+type SdkLicense = (typeof SDK_LICENSES)[number];
+type SfxFileEntry = {
+    /** Path from the manifest's folder: `armas/pistol_9mm_close_01.ogg`. */
+    readonly file: string;
+    readonly sampleRate: number;
+    readonly channels: number;
+    /** dBFS. */
+    readonly peak: number;
+    readonly seconds: number;
+    readonly source: string;
+    readonly author: string;
+    readonly license: SdkLicense;
+};
+/** The layers a file name can end in: `<id>_<layer>_<nn>` (`pistol_9mm_close_01`); a name without one is a `close` take. */
+declare const SFX_LAYERS: readonly ["close", "far", "tail_in", "tail_out"];
+type SfxLayer = (typeof SFX_LAYERS)[number];
+type SfxManifestSound = {
+    readonly id: string;
+    readonly category: string;
+    readonly layers: Partial<Readonly<Record<SfxLayer, readonly SfxFileEntry[]>>>;
+};
+type SfxManifest = {
+    readonly version: 1;
+    readonly format: {
+        readonly codec: 'vorbis';
+        readonly sampleRate: number;
+        readonly channels: number;
+        readonly peakDb: number;
     };
-    /** Layer level before distance. Default 1. */
-    readonly gain?: Range;
-    /** Send to the reverb, 0..1 or more (the art scene uses up to 1.2). */
-    readonly wet?: number;
-    readonly source: LayerSource;
-    readonly filters?: FilterBank;
-    readonly modulators?: readonly Modulator[];
-    readonly envelope: Envelope;
-};
-/**
- * Distance falloff of a sound's level:
- * - `inverse_square`: `volume / (1 + d² × k)`; `cutoffK` also divides every lowpass cutoff by `1 + d × cutoffK` (the game's muffling);
- * - `linear`: `max(0, 1 − d / range)`, silent at or below `minGain`;
- * - `none`: no distance.
- * `scale` multiplies the level (the game's boom is 1.4 at the source), and below `minGain` the sound is not played.
- */
-type Falloff = {
-    readonly model: 'inverse_square';
-    readonly k: number;
-    readonly minGain?: number;
-    readonly cutoffK?: number;
-    readonly scale?: number;
-} | {
-    readonly model: 'linear';
-    readonly range: number;
-    readonly minGain?: number;
-    readonly scale?: number;
-} | {
-    readonly model: 'none';
+    readonly sounds: readonly SfxManifestSound[];
 };
-/**
- * The order the realizer creates and wires the nodes in. Each one is the order of the team routine it reproduces, so the trace of the SDK
- * matches the trace of the team code node for node:
- * - `layered` (default): the art scene's `sNoise`, `sTone` and `voice`; every layer has its own output stage (distance gain, pan, reverb send);
- * - `burst`: the game's `sfx` (jogo L62089);
- * - `scream`: the game's `grito` (L62128);
- * - `groan`: the game's `voz` (L62143);
- * - `boom`: the game's `boom` (L68278);
- * - `static`: the game's `chiado` (L69998);
- * - `chord`: the game's `buzina` (L70272);
- * - `calls`: the game's `bichoSom` (L66625);
- * - `siren`: the art scene's `siren` (L1369);
- * - `weapon`: the weapon audio of the kit (`weapons-three`): per layer a filtered noise burst or an oscillator, then its own gain, chained to the bus.
- * Every order but `layered` puts the level into the envelope and connects straight to the bus.
- */
-declare const BUILD_ORDERS: readonly ["layered", "burst", "scream", "groan", "boom", "static", "chord", "calls", "siren", "weapon"];
-type BuildOrder = (typeof BUILD_ORDERS)[number];
-type SoundRecipe = {
-    readonly id: string;
+/** The numbers of one sound that the files do not say (bus, curve, pitch...). */
+type SampleDefaults = {
     readonly bus: BusId;
-    readonly order?: BuildOrder;
-    /** Named numbers drawn first, in the order written; layers read them with `{ param }`. */
-    readonly vars?: Readonly<Record<string, Range>>;
-    readonly duration?: Range;
-    readonly tail?: number;
-    readonly layers: readonly Layer[];
+    readonly gain?: number;
+    readonly pitch?: number;
+    readonly crossover?: SampleCrossover;
+    readonly tailGain?: number;
     readonly falloff?: Falloff;
-    /** Stereo pan from the listener (the art scene's `panFor`). Only the `layered` order has an output stage to pan. */
-    readonly pan?: boolean;
-    /** Voice group for the limiter (`undead_voice`...). */
+    readonly cutoffK?: number;
     readonly group?: string;
-    /** Limiter priority; default from the bus (weapons > voices > world > ambience). */
     readonly priority?: number;
-    /**
-     * The team routine creates nodes before it checks the level (the game's `bichoSom` creates its gain and filter first): a silent sound is kept as
-     * a plan with `silent: true` so the realizer repeats those nodes. Off by default.
-     */
-    readonly keepSilent?: boolean;
-    /** Where the numbers come from: `"jogo:L62128"`, `"cena:L1342"`, or `"sdk"` for values the kit chose. */
-    readonly sources: readonly string[];
+    readonly fallback?: string;
 };
-/**
- * The order the loop realizer creates the nodes in:
- * - `game_loop`: the game's `loopSet` (L62109): gain and filter first, nodes created the first time the volume passes `startAbove`, gain from 0;
- * - `chain_loop`: the art scene's loops in `initAudio` (L1314–1316): source, filters, gain at its starting volume, created when the loop opens.
- */
-type LoopOrder = 'game_loop' | 'chain_loop';
-type LoopRecipe = {
+type SampleBankOptions = {
     readonly id: string;
-    readonly bus: BusId;
-    readonly order?: LoopOrder;
-    /** An oscillator loop may leave the frequency out: it starts at the default and `set({ frequency })` glides it (the game's motor). */
-    readonly source: (NoiseSource & {
-        readonly loop: true;
-    }) | {
-        readonly kind: 'osc';
-        readonly wave: OscillatorType;
-        readonly frequency?: Automation;
-        readonly loop: true;
-    };
-    readonly filters?: FilterBank;
-    readonly modulators?: readonly Modulator[];
-    /** `setTargetAtTime` time constants (jogo L62125–62126: 0.15 for the volume, 0.08 for the frequency). */
-    readonly smoothing?: {
-        readonly volume: number;
-        readonly frequency: number;
-    };
-    /** Nodes are created the first time the volume reaches this (jogo L62112: 0.002). */
-    readonly startAbove?: number;
-    /** Volume the gain starts at when the loop opens (`chain_loop`). */
-    readonly volume?: number;
-    readonly sources: readonly string[];
-};
-type SoundBank = {
+    /** Prefix of every url (where the manifest's folder is served: `/sfx/`). Default ''. */
+    readonly baseUrl?: string;
+    /** Numbers per sound id, or one function; a sound with neither is left out (it has no bus). */
+    readonly sounds?: Readonly<Record<string, SampleDefaults>>;
+    readonly defaults?: (sound: SfxManifestSound) => SampleDefaults | undefined;
+};
+/** The strength suffixes of a sound id (`kick_hit_heavy`): takes of the tiers of `kick_hit`, from these intensities. */
+declare const SFX_TIERS: Readonly<Record<string, number>>;
+/** Splits a file name (no extension) into its sound id, layer and take number. */
+declare function parseSfxName(name: string): {
     readonly id: string;
-    readonly sounds?: readonly SoundRecipe[];
-    readonly loops?: readonly LoopRecipe[];
+    readonly layer: SfxLayer;
+    readonly take: number;
 };
-
-/** Where the ears are. `yaw` turns around y like a three.js camera: the right ear points at `(cos yaw, 0, −sin yaw)`. */
-type Listener = {
-    readonly position: Vec3;
-    readonly yaw: number;
+/** The base id and tier of a sound id: `kick_hit_heavy` → `kick_hit`, `heavy`. */
+declare function splitTier(id: string): {
+    readonly base: string;
+    readonly tier?: string;
 };
-type DistanceMode = 'xz' | '3d';
-declare const DEFAULT_LISTENER: Listener;
-/** The art scene clamps the pan to ±0.85 and never divides by less than 2 m (cena L1319). */
-declare const PAN_LIMIT = 0.85;
-declare const PAN_MIN_DISTANCE = 2;
-/** Distance from the listener: on the ground (`xz`, the teams' choice) or in 3D. */
-declare function listenerDistance(listener: Listener, position: Vec3, mode?: DistanceMode): number;
-/** The art scene's `panFor`: the side the sound is on, −0.85 (left) to 0.85 (right). No HRTF, for cost. */
-declare function panFor(listener: Listener, position: Vec3): number;
+/** A bank of sample sounds from a manifest. */
+declare function sampleBankFromManifest(manifest: SfxManifest, options: SampleBankOptions): SoundBank;
 
-/** How an AudioParam moves, with every number resolved and every time in seconds from the layer start. */
-type PlannedAutomation = {
-    /** Assigned to `.value`. */
-    readonly value?: number;
-    /** `setValueAtTime(from)` at the layer start. */
-    readonly from?: number;
-    /** Ramp target, reached `at` seconds after the layer start. */
-    readonly to?: number;
-    readonly curve?: Curve;
-    readonly at?: number;
-};
-type PlannedFilter = {
-    readonly type: BiquadFilterType;
-    readonly frequency: PlannedAutomation;
-    readonly q?: number;
-    readonly gain?: number;
-    readonly level?: number;
-};
-type PlannedModulator = {
-    readonly target: 'gain' | 'frequency';
-    readonly wave?: OscillatorType;
-    readonly rate: number;
-    readonly depth: number;
-    readonly base?: number;
-};
-type PlannedSource = {
-    readonly kind: 'noise';
-    readonly offset: number;
-    readonly loop: boolean;
-} | {
-    readonly kind: 'osc';
-    readonly wave: OscillatorType;
-    readonly frequency: PlannedAutomation;
-} | {
-    readonly kind: 'formant_voice';
-    readonly wave: OscillatorType;
-    readonly frequency: PlannedAutomation;
-    readonly vibrato: {
-        readonly rate: number;
-        readonly depth: number;
-    };
-    readonly formants: readonly {
-        readonly frequency: number;
-        readonly q: number;
-    }[];
-    readonly breath: {
-        readonly frequency: number;
-        readonly q: number;
-        readonly gain: number;
-        readonly offset: number;
-    };
-    readonly mix: number;
-};
-type PlannedEnvelopePoint = {
-    readonly time: number;
-    readonly value: number;
-    readonly curve: 'set' | Curve;
-};
-type PlannedLayer = {
-    readonly at: number;
-    readonly duration: number;
-    readonly tail: number;
-    /** Layer gain × the sound's level: in the envelope for every order but `layered`, in the output stage for `layered`. */
-    readonly level: number;
-    readonly wet?: number;
-    readonly source: PlannedSource;
-    readonly filters?: {
-        readonly mode: 'serial' | 'parallel';
-        readonly bank: readonly PlannedFilter[];
-    };
-    readonly modulators: readonly PlannedModulator[];
-    readonly envelope: readonly PlannedEnvelopePoint[];
-};
-/** A sound with every number decided: what the realizer builds, what goldens compare and what the bench sheet prints. */
-type SoundPlan = {
-    readonly id: string;
-    readonly bus: BusId;
-    readonly order: BuildOrder;
-    readonly group?: string;
-    readonly priority: number;
-    /** The level from volume and distance, before layer gains. */
-    readonly level: number;
-    readonly distance: number;
-    readonly pan?: number;
-    /** Too quiet to hear, kept only for a recipe with `keepSilent`. */
-    readonly silent: boolean;
-    /** Seconds until the last source stops. */
-    readonly length: number;
-    readonly layers: readonly PlannedLayer[];
-};
-type PlanInput = {
-    /** Where the numbers are drawn from. Default: a fresh stream with seed 1. */
-    readonly random?: () => number;
-    readonly volume?: number;
-    /** Distance in meters; overrides `position`. */
-    readonly distance?: number;
-    readonly position?: Vec3;
-    readonly listener?: Listener;
-    readonly distanceMode?: DistanceMode;
-    readonly params?: Readonly<Record<string, number>>;
-    /** 0..1 from the host's occlusion callback: gain × (1 − 0.5 × o), lowpass cutoffs × (1 − 0.6 × o). */
-    readonly occlusion?: number;
-    /** Length of the noise buffer, for `offset: 'fit'`. Default 1.5. */
-    readonly noiseSeconds?: number;
+/** The bus of a manifest category (the folder the file sits in). */
+declare const KIT_CATEGORY_BUS: Readonly<Record<string, BusId>>;
+/**
+ * Recipe id → file id. The recipe keeps playing until the takes of the file id load. Hand-worked leaves (doors, drawers) of `game-destruction-three`
+ * and the hand sounds of items.
+ */
+declare const KIT_SAMPLE_ALIASES: Readonly<Record<string, string>>;
+/** The numbers of a sound the files do not say: the bus of its folder, a little pitch spread. */
+declare function kitSampleDefaults(sound: SfxManifestSound): SampleDefaults | undefined;
+type KitSampleBankOptions = {
+    /** Where the `assets/sfx/` folder is served (`./sfx/`). */
+    readonly baseUrl?: string;
+    /** Recipe id → file id (default `KIT_SAMPLE_ALIASES`); `{}` adds none. */
+    readonly aliases?: Readonly<Record<string, string>>;
+    readonly id?: string;
+};
+/** The manifest with each alias as one more sound, holding the takes of its file id. */
+declare function withAliases(manifest: SfxManifest, aliases: Readonly<Record<string, string>>): SfxManifest;
+/** The bank of the kit's files. */
+declare function kitSampleBank(manifest: SfxManifest, options?: KitSampleBankOptions): SoundBank;
+type LoadKitSamplesOptions = KitSampleBankOptions & {
+    /** Gets the manifest (default `fetch` of `<baseUrl>manifest.json`). */
+    readonly fetchManifest?: (url: string) => Promise<SfxManifest>;
+    /** Ids to load right away instead of on their first play (the sounds of the first seconds, so they are not the recipe). */
+    readonly preload?: readonly string[];
+};
+type Registers = {
+    register(bank: SoundBank): void;
+    loadSamples?(ids?: readonly string[]): Promise<unknown>;
 };
 /**
- * Turns a recipe into a plan: pure, Node-safe, the same plan for the same `random`. Numbers are drawn in this order: `vars` (in the order written),
- * `duration`, then each layer in the order its fields are written, the noise start point last in its layer. A sound below its falloff's `minGain`
- * gives `null` (or a silent plan with `keepSilent`) before any number is drawn.
+ * Fetches the manifest and registers the bank on the engine. Resolves to the bank, or `null` when the manifest cannot be had (a page opened from
+ * `file://`, the folder not served): the recipes keep playing, so that is not an error.
  */
-declare function planSound(recipe: SoundRecipe, input?: PlanInput): SoundPlan | null;
+declare function loadKitSamples(engine: Registers, options?: LoadKitSamplesOptions): Promise<SoundBank | null>;
 
 /** The distance curves of the team routines, by name. Each recipe carries its own; these are the values to copy. */
 declare const DISTANCE_CURVES: {
@@ -406,68 +212,6 @@ declare function isSilent(falloff: Falloff | undefined, gain: number): boolean;
 /** What every lowpass cutoff is divided by at `distance` (1 when the curve has no muffling). */
 declare function cutoffDivisor(falloff: Falloff | undefined, distance: number): number;
 
-/**
- * Rules for a group of voices (`undead_voice`...). A request passes when every rule passes:
- * - `maxConcurrent`: at most this many of the group play at once (`steal` replaces the group's oldest instead of refusing);
- * - `cooldown`: seconds after an accepted voice before the next one (the game's `groanBudget`, jogo L66986 and L70472);
- * - `maxDistance`: only voices nearer than this (the game's `d < 40`).
- */
-type VoiceGroup = {
-    readonly maxConcurrent?: number;
-    readonly cooldown?: number;
-    readonly maxDistance?: number;
-    readonly steal?: boolean;
-    readonly sources?: readonly string[];
-};
-/** `undead_voice`: the art scene's five at once with the game's 0.25 s cooldown and 40 m. */
-declare const VOICE_GROUPS: Readonly<Record<string, VoiceGroup>>;
-/** Q7: weapons > voices > world > ambience; the interface above all, weather with the ambience. */
-declare const BUS_PRIORITY: Readonly<Record<BusId, number>>;
-declare const DEFAULT_MAX_VOICES = 32;
-declare function busPriority(bus: BusId): number;
-type VoiceRequest = {
-    readonly group?: string;
-    readonly priority: number;
-    /** Planned level; the global cap drops the lowest `priority × gain`. */
-    readonly gain: number;
-    readonly distance?: number;
-    /** Seconds the voice lasts. */
-    readonly length: number;
-};
-type VoiceRefusal = 'cooldown' | 'distance' | 'group_full' | 'global_full';
-type VoiceDecision = {
-    readonly accepted: true;
-    readonly id: number;
-    readonly evicted: readonly number[];
-} | {
-    readonly accepted: false;
-    readonly reason: VoiceRefusal;
-};
-type VoiceStats = {
-    readonly active: number;
-    readonly peak: number;
-    readonly dropped: number;
-    readonly maxVoices: number;
-};
-type VoiceManager = {
-    request(request: VoiceRequest): VoiceDecision;
-    /** Ends a voice early (stopped by the host). */
-    release(id: number): void;
-    /** Sets how long an accepted voice lasts (the engine admits a voice before its random length is drawn). */
-    setLength(id: number, seconds: number): void;
-    /** Moves time on: cooldowns count down and finished voices leave. Returns the ids that ended. */
-    advance(dt: number): number[];
-    setGroup(id: string, group: VoiceGroup | undefined): void;
-    stats(): VoiceStats;
-};
-type VoiceManagerOptions = {
-    /** Default `VOICE_GROUPS`. */
-    readonly groups?: Readonly<Record<string, VoiceGroup>>;
-    readonly maxVoices?: number;
-};
-/** The voice limiter: per-group rules, a global cap and priority dropping. Pure and time-driven (`advance`), so goldens script it frame by frame. */
-declare function createVoiceManager(options?: VoiceManagerOptions): VoiceManager;
-
 /** jogo L62112: a loop's nodes exist only once its volume reaches 0.002. */
 declare const LOOP_START_ABOVE = 0.002;
 /** jogo L62125–62126: `setTargetAtTime` time constants. */
@@ -498,64 +242,6 @@ type LoopState = {
  */
 declare function createLoopState(recipe: LoopRecipe, open?: boolean): LoopState;
 
-type BusSetting = {
-    readonly gain?: number;
-    readonly muted?: boolean;
-};
-/**
- * A mixing chain. `master` → (compressor) → output; with `reverb`, a wet bus → convolver (an impulse from the engine's seed) → master. `noise` is
- * the shared noise buffer: its length, and whether it is made with the chain (`eager`, the art scene) or by the first sound that needs it (`lazy`,
- * the game). Buses sit under the master and have no node until one is changed.
- */
-type MixProfile = {
-    readonly id: string;
-    readonly master: number;
-    readonly compressor?: {
-        readonly threshold: number;
-        readonly ratio: number;
-        readonly knee?: number;
-        readonly attack?: number;
-        readonly release?: number;
-    };
-    readonly reverb?: {
-        readonly seconds: number;
-        readonly decay: number;
-        readonly wet: number;
-    };
-    readonly noise: {
-        readonly seconds: number;
-        readonly create: 'lazy' | 'eager';
-    };
-    readonly buses?: Readonly<Partial<Record<BusId, BusSetting>>>;
-    readonly sources: readonly string[];
-};
-/** The two team chains: `game` (master 0.5, jogo L62080) and `art_scene` (compressor and reverb, cena L1305–1313). */
-declare const MIX_PROFILES: Readonly<Record<string, MixProfile>>;
-/** Q1: the kit plays through the art scene chain (compressor and reverb); `mix: 'game'` reverts. */
-declare const DEFAULT_MIX = "art_scene";
-/** A profile by id from `profiles`, or the profile itself. */
-declare function resolveMix(mix: string | MixProfile, profiles?: Readonly<Record<string, MixProfile>>): MixProfile;
-/** The gain a bus plays at: 0 when muted, its gain (default 1) otherwise. */
-declare function busGain(setting: BusSetting | undefined): number;
-
-type DeepPartial<TValue> = TValue extends readonly unknown[] ? TValue : TValue extends object ? {
-    readonly [Key in keyof TValue]?: DeepPartial<TValue[Key]>;
-} : TValue;
-/** Every sound and loop the engine knows, by id. Banks register in order; a later bank replaces an earlier recipe with the same id. */
-type SoundRegistry = {
-    register(bank: SoundBank): void;
-    /** Merged into the recipe by id (objects merge, arrays such as `layers` are replaced); an unknown id is ignored. */
-    patch(id: string, patch: DeepPartial<SoundRecipe> | DeepPartial<LoopRecipe>): void;
-    remove(id: string): void;
-    sound(id: string): SoundRecipe | undefined;
-    loop(id: string): LoopRecipe | undefined;
-    soundIds(): string[];
-    loopIds(): string[];
-    /** Which bank each id came from. */
-    bankOf(id: string): string | undefined;
-};
-declare function createSoundRegistry(banks?: readonly SoundBank[]): SoundRegistry;
-
 /** One row of the game's `sfx` table (jogo L62096–62100): lowpass cutoff, peak gain and seconds of a noise burst. */
 type NoiseClass = {
     readonly id: string;
@@ -640,106 +326,58 @@ declare const LIBRARY_SOUNDS: readonly SoundRecipe[];
 declare const LIBRARY_LOOPS: readonly LoopRecipe[];
 declare const LIBRARY_BANK: SoundBank;
 
-/** A continuous sound: `set` glides the volume and, for an oscillator, the frequency; `stop` tears the nodes down. */
-type AudioLoopHandle = {
-    set(state: {
-        readonly volume?: number;
-        readonly frequency?: number;
-    }): void;
-    stop(): void;
-};
+/** Small sounds of the hand: `vol / (1 + d² × 0.02)`, lowpass cutoffs `/ (1 + d × 0.04)`, silent below 0.004 (a latch at 10 m is a third, at 50 m gone). */
+declare const FOLEY_FALLOFF: Falloff;
+/** The doors and lids of furniture and vehicles, by what the leaf is (the room picks one from the item, else from the leaf's material). */
+declare const LEAF_FOLEY: readonly SoundRecipe[];
+/** What the hand does with an item: picking it up by what it is made of, throwing it, and the uses (opening, drinking, eating, first aid). */
+declare const ITEM_FOLEY: readonly SoundRecipe[];
+/** The foley bank: register it in the engine (`engine.register(FOLEY_BANK)`). */
+declare const FOLEY_BANK: SoundBank;
+/** What a picked-up item sounds like, by its heaviest material class. */
+declare const PICKUP_CLASSES: readonly ["metal", "plastic", "glass", "paper", "fabric", "wood", "food"];
+type PickupClass = (typeof PICKUP_CLASSES)[number];
+/** The sound set of a leaf worked by hand: the ids it plays at the latch, while it turns, and as it meets the frame (gently, and slammed). */
+type LeafFoley = {
+    readonly open: string;
+    readonly turn?: string;
+    readonly close: string;
+    readonly slam?: string;
+    readonly locked: string;
+};
+/** The leaf sound sets the kit ships, by name; an item names one (`TestableItem.sounds.leaves`), else the room picks `wood_door` or `metal_door` by the leaf's material. */
+declare const LEAF_FOLEY_SETS: Readonly<Record<string, LeafFoley>>;
 
-type StartQueueOptions = {
-    /** Most milliseconds of main-thread work one task spends building voices (at least one voice is always built). Default 2. */
-    readonly budgetMs?: number;
-    /** A voice still waiting after this many milliseconds is dropped instead of starting late. Default 250. */
-    readonly maxLatencyMs?: number;
-};
+/** Takes per id. */
+declare const BODY_FOLEY_TAKES = 4;
+/** Footsteps fade fast with distance and lose their top: a step 10 m away is a quarter of the level, 30 m a few percent, and duller. */
+declare const FOOTSTEP_FALLOFF: Falloff;
+/** Blows and body sounds carry further than a step. */
+declare const BODY_FALLOFF: Falloff;
+/**
+ * Every body sound of `game-contracts`' `BODY_FOLEY_IDS` as a set of four takes (`footstep_concrete_walk` plays `footstep_concrete_walk_01`..`_04`,
+ * never the same twice in a row, at ±4% of rate). Register it in the engine the body plays on.
+ */
+declare const BODY_FOLEY_BANK: SoundBank;
+/** The ids the bank answers (the sets), in the contract's order. */
+declare const BODY_FOLEY_SET_IDS: readonly string[];
 
-type PlayOptions = {
-    readonly position?: Vec3;
-    /** Meters; overrides `position` for the distance (not for the pan). */
-    readonly distance?: number;
-    readonly volume?: number;
-    readonly params?: Readonly<Record<string, number>>;
-    /** This sound's own stream: same seed, same sound. */
-    readonly seed?: number;
-    /** Seconds from now. */
-    readonly delay?: number;
-    /** A named stream of the engine (`streamFor(seed, name)`), so one subject never shifts another's sounds. */
-    readonly channel?: string;
-};
-type VoiceHandle = {
-    readonly id: number;
-    readonly plan: SoundPlan;
-    stop(): void;
-};
-/** A subject's own random stream; `ownNoise` also gives it its own noise buffer, filled from that stream (the order `createWeaponAudio` uses). */
-type AudioChannel = {
-    readonly random: () => number;
-    play(id: string, options?: PlayOptions): VoiceHandle | null;
-    plan(id: string, options?: PlayOptions): SoundPlan | null;
-};
-type AudioStats = {
-    readonly context: 'none' | AudioContextState;
-    readonly voices: number;
-    readonly peak: number;
-    readonly dropped: number;
-    readonly maxVoices: number;
-    readonly loops: number;
-};
-type AudioEngineOptions = {
-    /** Seeds the engine stream: the noise, the reverb impulse and every sound played without its own seed or channel. Default 1. */
-    readonly seed?: number;
-    /** Default `art_scene` (Q1). */
-    readonly mix?: string | MixProfile;
-    readonly profiles?: Readonly<Record<string, MixProfile>>;
-    readonly banks?: readonly SoundBank[];
-    readonly maxVoices?: number;
-    readonly groups?: Readonly<Record<string, VoiceGroup>>;
-    readonly distance?: DistanceMode;
-    /** 0 (clear) to 1 (behind a wall) for a sound at a point; without it there is no occlusion (Q8). */
-    readonly occlusion?: (point: Vec3) => number;
-    readonly createContext?: () => AudioContext | null;
-    /** Build voices in timed slices between frames instead of inside `play` (a sound starts a few ms late; a burst never costs a frame). Off by default. */
-    readonly deferredStart?: StartQueueOptions;
-};
-type AudioEngine = {
-    readonly registry: SoundRegistry;
-    register(bank: SoundBank): void;
-    /** Pure: the plan a sound would play with, from `options.seed` or the engine seed; draws nothing from the live streams. */
-    plan(id: string, options?: PlayOptions): SoundPlan | null;
-    play(id: string, options?: PlayOptions): VoiceHandle | null;
-    playPlan(plan: SoundPlan, options?: {
-        readonly delay?: number;
-    }): VoiceHandle | null;
-    loop(id: string, options?: {
-        readonly volume?: number;
-    }): AudioLoopHandle;
-    channel(options: {
-        readonly seed?: number;
-        readonly random?: () => number;
-        readonly ownNoise?: boolean;
-    }): AudioChannel;
-    setListener(listener: Listener): void;
-    setBus(id: BusId, setting: BusSetting): void;
-    setMix(mix: string | MixProfile): void;
-    /** The master volume of the current chain and of any later one (0 to 1). */
-    setMaster(gain: number): void;
-    /** Creates the context and the mixing chain if needed and resumes it; call from a click or a key. */
-    unlock(): void;
-    /** Creates the context, the mixing chain (reverb impulse included) and the shared noise buffer now, so the first sound does not pay for them inside a frame. Returns false without a context. */
-    warmUp(): boolean;
-    stats(): AudioStats;
-    /** RMS (0 to 1) of what a bus carries now, read from an analyser the first time you ask; sounds started before that do not reach it. 0 without a context. */
-    level(bus: BusId): number;
-    dispose(): void;
-};
 /**
- * The sound engine: plans recipes and builds them on a lazily created AudioContext through one of the team mixing chains. Without an AudioContext
- * (Node, workers) every call except `plan` does nothing.
+ * A plan played faster or slower, as a tape would: every frequency (tones, filters, formants, LFOs) times `rate`, every time divided by it. Noise
+ * has no pitch of its own, so its colour moves with its filters. `rate` 1 gives the plan back.
  */
-declare function createAudioEngine(options?: AudioEngineOptions): AudioEngine;
+declare function retunePlan(plan: SoundPlan, rate: number): SoundPlan;
+/** Remembers the last variant of each set, so the next draw never repeats it. */
+type SetPicker = {
+    /** The variant to play and its rate, drawn from `random` (two numbers: the variant, then the rate). */
+    pick(set: SoundSet, random: () => number): {
+        readonly id: string;
+        readonly rate: number;
+    };
+    /** Forget the last variants (a fresh scene). */
+    reset(): void;
+};
+declare function createSetPicker(): SetPicker;
 
 /** Where a plan is built: the context, the bus it plays into, the reverb send (if the mix has one), the shared noise and the start time. */
 type RealizeTarget = {
@@ -756,6 +394,50 @@ type RealizedVoice = {
     stop(): void;
 };
 
+type SampleTarget = {
+    readonly context: BaseAudioContext;
+    readonly output: AudioNode;
+    readonly buffer: (url: string) => AudioBuffer | undefined;
+    readonly time: number;
+};
+/** A sample voice can also be faded out (the choke of its sound). */
+type RealizedSampleVoice = RealizedVoice & {
+    fade(at: number, seconds: number): void;
+};
+/**
+ * Builds a sample plan: each layer is a buffer source at the planned rate with its own gain, the layers meet in one voice gain (the choke fades it),
+ * one lowpass (left out when open) and one stereo panner (when the plan has a pan), then the bus. A layer whose buffer is not loaded is skipped.
+ */
+declare function realizeSample(plan: SamplePlan, target: SampleTarget): RealizedSampleVoice;
+/** Seconds a sample plan lasts with its buffers (the longest layer, at its rate). */
+declare function sampleLength(plan: SamplePlan, seconds: (url: string) => number | undefined): number;
+
+/** The crossfade between two takes of a loop, in seconds, when `loop: true` gives none. */
+declare const DEFAULT_LOOP_CROSSFADE = 0.25;
+/** The crossfade of a looping sample sound, or `undefined` when it does not loop. */
+declare function loopCrossfade(sound: SampleSound): number | undefined;
+/** Steps of the equal-power ramps (straight lines between points of the sine and cosine quarter). */
+declare const CROSSFADE_STEPS = 8;
+/** The gain of an equal-power crossfade at `t` (0..1) for the take coming in; the take going out has the gain at `1 − t`. */
+declare const equalPowerIn: (t: number) => number;
+/** What a sample loop needs from its engine. */
+type SampleLoopHost = {
+    ready(): AudioContext | null;
+    /** The node sample voices of a bus go to (the limiter of the bus). */
+    output(bus: BusId): AudioNode;
+    buffer(url: string): AudioBuffer | undefined;
+    isReady(sound: SampleSound): boolean;
+    /** Loads the files of the sound (resolves when they are decoded or failed). */
+    load(sound: SampleSound): Promise<unknown>;
+    /** The recipe loop that plays while the files are not ready. */
+    fallback(volume: number): AudioLoopHandle;
+    random(): number;
+    register(loop: LoopEntry): void;
+    unregister(loop: LoopEntry): void;
+    /** Whether a bus is muted now. */
+    muted(bus: BusId): boolean;
+};
+
 /** Builds a plan's nodes on `target`, in the node order of the team routine its `order` names. */
 declare function realize(plan: SoundPlan, target: RealizeTarget): RealizedVoice;
 
@@ -797,61 +479,4 @@ type EngineSink = AudioSink & {
 /** Lends an engine as the host's `audio`: sounds by key, loops, the listener, and banks registered into the same engine. */
 declare function createAudioSink(engine: AudioEngine): EngineSink;
 
-/**
- * Two probe sounds of the bench itself (a ping and a hiss), so panning, distance and the seed can be heard on something that has no subject. They are
- * made by the kit, not delivered by any team (`sdk` in the sources).
- */
-declare const BENCH_BANK: SoundBank;
-type AudioTestModuleOptions = {
-    /** The engine to test (default: the one the host lends in `host.audio`, else a new one of the module's own). */
-    engine?: AudioEngine;
-    /** Banks registered in the engine besides the bench's probes (default the game's noise classes and the library). */
-    banks?: readonly SoundBank[];
-    locale?: string;
-    /** Text of a sound or loop id (`sound.glass`) in the game's words; without it the bench shows the bank and the id. */
-    translate?: (key: string, locale: string) => string | undefined;
-    seed?: number;
-    /** First sound chosen (default `bench_ping`). */
-    sound?: string;
-    /**
-     * Draws the thing the probe stands for, where the sound comes from with the `probe` source (for example a portable radio of `game-items-three`). The module
-     * draws nothing of its own: without it the area has no probe and the sounds come from the bench settings.
-     */
-    probe?: (THREE: unknown) => unknown;
-};
-/** What the scenarios use of the context the test room passes. */
-interface AudioScenarioLike {
-    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
-}
-type AudioTestModule = TestableModule<AudioScenarioLike> & {
-    /** The engine in use: the host's when it lent one, the module's own otherwise. */
-    readonly engine: AudioEngine;
-    /** The resolved plan of the chosen sound as text (the S3 view: every number decided). */
-    sheet(): string;
-    /** Plays the chosen sound as the bench is set. */
-    play(): VoiceHandle | null;
-};
-/**
- * The sound area of a test room, written against the generic contracts only: it plays any sound of an engine at a distance and bearing from the listener
- * (or from a probe standing in the area), runs loops, throws a storm of voices at the limiter, switches the mixing chain and its parts, reads the
- * level of each bus and prints the resolved plan. The engine is the host's (`host.audio`) when lent, else the module's own.
- */
-declare function createAudioTestModule(options?: AudioTestModuleOptions): AudioTestModule;
-
-type AudioBenchText = {
-    readonly group: string;
-    readonly name: string;
-    readonly probe: string;
-    readonly controls: Readonly<Record<'sound' | 'distance' | 'bearing' | 'volume' | 'mix' | 'seed' | 'play' | 'voice_storm' | 'loop' | 'loop_level' | 'loop_pitch' | 'source', string>>;
-    readonly hints: Readonly<Record<'distance' | 'bearing' | 'mix' | 'seed' | 'voice_storm' | 'loop_pitch' | 'source', string>>;
-    readonly options: Readonly<Record<'none' | 'bench' | 'probe', string>>;
-    readonly layers: Readonly<Record<'reverb' | 'compressor' | 'panning' | 'muffling', string>>;
-    readonly metrics: Readonly<Record<'voices' | 'peak' | 'dropped' | 'loops' | 'context' | 'plan_length' | 'plan_level' | 'plan_pan' | 'level_weapons' | 'level_voices' | 'level_world' | 'level_ambience' | 'level_weather' | 'level_ui', string>>;
-    readonly scenarios: Readonly<Record<'panning' | 'distance' | 'determinism' | 'limiter', string>>;
-    readonly mixes: Readonly<Record<string, string>>;
-    /** Text of a sound or loop id when the game has one; the bench falls back to the id. */
-    readonly sheet: Readonly<Record<'title' | 'level' | 'distance' | 'pan' | 'length' | 'silent' | 'layer' | 'none', string>>;
-};
-declare const audioBenchTextOf: (locale: string) => AudioBenchText;
-
-export { type AudioBenchText, type AudioChannel, type AudioEngine, type AudioEngineOptions, type AudioLoopHandle, type AudioScenarioLike, type AudioStats, type AudioTestModule, type AudioTestModuleOptions, type Automation, BENCH_BANK, BUILD_ORDERS, BUS_IDS, BUS_PRIORITY, type BuildOrder, type BusId, type BusSetting, type Curve, DEFAULT_LISTENER, DEFAULT_MAX_VOICES, DEFAULT_MIX, DISTANCE_CURVES, type DeepPartial, type DistanceCurveName, type DistanceMode, type EngineSink, type Envelope, type EnvelopePoint, type Falloff, type FilterBank, type FilterSpec, type FormantVoiceSource, GAME_SFX_BANK, GAME_SFX_CLASSES, GAME_SFX_FALLBACK, LIBRARY_BANK, LIBRARY_LOOPS, LIBRARY_SOUNDS, LOOP_SMOOTHING, LOOP_START_ABOVE, type Layer, type LayerSource, type Listener, type LoopAction, type LoopOrder, type LoopRecipe, type LoopState, MIX_PROFILES, type MixChain, type MixProfile, type Modulator, type NoiseClass, type NoiseSource, type OscSource, PAN_LIMIT, PAN_MIN_DISTANCE, type ParamRef, type PlanInput, type PlannedAutomation, type PlannedEnvelopePoint, type PlannedFilter, type PlannedLayer, type PlannedModulator, type PlannedSource, type PlayOptions, type Range, type RealizeTarget, type RealizedVoice, type SceneLength, type SceneNoise, type SceneRecipeOptions, type SceneTone, type SceneVoice, type SoundBank, type SoundPlan, type SoundRecipe, type SoundRegistry, type StartQueueOptions, type Time, VOICE_GROUPS, type VoiceDecision, type VoiceGroup, type VoiceHandle, type VoiceManager, type VoiceManagerOptions, type VoiceRefusal, type VoiceRequest, type VoiceStats, audioBenchTextOf, bufferOf, buildChain, busGain, busPriority, createAudioEngine, createAudioSink, createAudioTestModule, createLoopState, createRng, createSoundRegistry, createVoiceManager, cutoffDivisor, drawBetween, falloffGain, fillImpulse, fillNoise, globalContext, isSilent, listenerDistance, noiseClassRecipe, panFor, planSound, realize, resolveMix, sceneMany, sceneNoise, sceneRecipe, sceneTone, sceneVoice, streamFor, streamSeed, unlockContext };
+export { AudioEngine, AudioLoopHandle, BODY_FALLOFF, BODY_FOLEY_BANK, BODY_FOLEY_SET_IDS, BODY_FOLEY_TAKES, BusId, CALIBRATION_ID, CALIBRATION_LOOP_ID, CALIBRATION_LOOP_SOUND, CALIBRATION_SOUND, CROSSFADE_STEPS, DEFAULT_LOOP_CROSSFADE, DISTANCE_CURVES, type DistanceCurveName, type EngineSink, FOLEY_BANK, FOLEY_FALLOFF, FOOTSTEP_FALLOFF, Falloff, GAME_SFX_BANK, GAME_SFX_CLASSES, GAME_SFX_FALLBACK, ITEM_FOLEY, KIT_CATEGORY_BUS, KIT_SAMPLE_ALIASES, type KitSampleBankOptions, LEAF_FOLEY, LEAF_FOLEY_SETS, LIBRARY_BANK, LIBRARY_LOOPS, LIBRARY_SOUNDS, LOOP_SMOOTHING, LOOP_START_ABOVE, Layer, type LeafFoley, type LoadKitSamplesOptions, type LoopAction, LoopRecipe, type LoopState, type MixChain, MixProfile, type NoiseClass, PICKUP_CLASSES, ParamRef, type PickupClass, Range, type RealizeTarget, type RealizedSampleVoice, type RealizedVoice, SDK_LICENSES, SFX_LAYERS, SFX_TIERS, type SampleBankOptions, SampleCrossover, type SampleDefaults, SampleLoader, type SampleLoopHost, SamplePlan, SampleSound, type SampleTarget, type SceneLength, type SceneNoise, type SceneRecipeOptions, type SceneTone, type SceneVoice, type SdkLicense, type SetPicker, type SfxFileEntry, type SfxLayer, type SfxManifest, type SfxManifestSound, SoundBank, SoundPlan, SoundRecipe, SoundSet, balanceOf, bufferOf, buildChain, calibrationLoader, centroidHz, countHits, createAudioSink, createLoopState, createRng, createSetPicker, cutoffDivisor, dbOf, drawBetween, encodeWav, endDropDb, equalPowerIn, falloffGain, fillImpulse, fillNoise, globalContext, isCalibrationUrl, isSilent, kitSampleBank, kitSampleDefaults, loadKitSamples, loopCrossfade, noiseClassRecipe, onsetIndex, parseSfxName, peakIndex, peakOf, realize, realizeSample, retunePlan, ringSeconds, rmsDb, sampleBankFromManifest, sampleLength, sceneMany, sceneNoise, sceneRecipe, sceneTone, sceneVoice, splitTier, streamFor, streamSeed, unlockContext, withAliases };