@adatechnology/game-weather 0.2.7 → 0.3.0

package/dist/testing-B4pjKlOJ.d.ts

@@ -0,0 +1,453 @@
+import { Vec3, AudioSink, EnvironmentBus, EnvironmentState, TestableModule, ModuleLayer, ModuleHost } from '@adatechnology/game-contracts';
+
+/** Every number of a weather state; these are the values that blend between two states. */
+type StateValues = {
+    /** Rain in mm/h. */
+    readonly rain: number;
+    /** Drops the renderer keeps in the air. */
+    readonly drops: number;
+    /** 0..1: rain sheets (curtains of water) passing. */
+    readonly sheets: number;
+    /** Wind in m/s along x and z (the rain slants by windX). */
+    readonly windX: number;
+    readonly windZ: number;
+    /** Strongest gust in m/s. */
+    readonly gust: number;
+    /** Linear fog far distance in metres (render). */
+    readonly fogFar: number;
+    /** Exponential-squared fog density; 0 means linear fog. */
+    readonly fogDensity: number;
+    /** Multiplies the sky colour. */
+    readonly skyScale: number;
+    /** How far one sees for gameplay, in metres (not the render fog). */
+    readonly visibility: number;
+    /** Relative humidity, 0..1, before the climate offset. */
+    readonly humidity: number;
+    /** Added to the climate's temperature of the moment. */
+    readonly temperatureDeltaC: number;
+    /** Ground wetness this state wets up to, 0..1. */
+    readonly wetness: number;
+    /** Multiplies the radius at which listeners hear (rain masks). */
+    readonly hearingScale: number;
+    /** Multiplies the noise footsteps make. */
+    readonly footstepScale: number;
+    /** Multiplies how fast wet ground dries. */
+    readonly dryingScale: number;
+    /** Acceleration in m/s² that wind puts on loose debris. */
+    readonly debrisPush: number;
+    /** 0..1: heat haze. */
+    readonly haze: number;
+    readonly mistPerSecond: number;
+    readonly ashPerSecond: number;
+};
+type StateValueKey = keyof StateValues;
+/** Strikes of a state: seconds between them, seconds to the first one, how far they land and how long a flash reveals the scene. */
+type LightningConfig = {
+    readonly interval: readonly [min: number, max: number];
+    readonly first: readonly [min: number, max: number];
+    readonly distance: readonly [min: number, max: number];
+    readonly reveal: number;
+};
+type WeatherState = StateValues & {
+    readonly id: string;
+    /** Where each number comes from: a team source and line, or the design decision that set it. */
+    readonly sources: readonly string[];
+    readonly lightning?: LightningConfig;
+};
+type Climate = {
+    readonly id: string;
+    readonly sources: readonly string[];
+    readonly start: string;
+    /** Game hours a state lasts, drawn uniformly. */
+    readonly dwellHours: readonly [min: number, max: number];
+    /** Game minutes a change takes to blend. */
+    readonly blendMinutes: number;
+    /** Where fronts travel to: [1, 0] is toward +x, so they arrive from the west. */
+    readonly frontDirection: readonly [x: number, z: number];
+    readonly temperatureC: {
+        readonly mean: number;
+        readonly swing: number;
+    };
+    readonly humidityOffset: number;
+    /** From state to the weights of the next one. A state that is not here, or has nothing reachable, stays. */
+    readonly transitions: Readonly<Record<string, Readonly<Record<string, number>>>>;
+};
+type DeepPartial<TValue> = {
+    readonly [Key in keyof TValue]?: NonNullable<TValue[Key]> extends readonly unknown[] ? TValue[Key] : NonNullable<TValue[Key]> extends object ? DeepPartial<NonNullable<TValue[Key]>> : TValue[Key];
+};
+type WeatherEffects = {
+    /** Gameplay visibility in metres. */
+    readonly visibility: number;
+    /** Multiplies how far something sees (`perc[0]` of the game): weather times `1 - 0.4 × nightFactor`. */
+    readonly sightScale: number;
+    /** Multiplies how far something hears (rain masks sound). */
+    readonly hearingScale: number;
+    /** Multiplies the noise a footstep makes. */
+    readonly footstepScale: number;
+    readonly heatIndexC: number;
+    /** 0..1 on the NOAA bands 27, 32, 41 and 54 °C. */
+    readonly heatStress: number;
+    /** Seconds a flash lights the scene (0 where there is no lightning). */
+    readonly lightningReveal: number;
+    readonly dryingScale: number;
+    readonly debrisPush: number;
+};
+type Strike = {
+    readonly id: number;
+    /** Simulation seconds since the weather started. */
+    readonly time: number;
+    /** Game seconds since the weather started. */
+    readonly gameSeconds: number;
+    /** Metres from the listener. */
+    readonly distance: number;
+    /** Degrees clockwise from north. */
+    readonly bearing: number;
+    /** Seconds from the flash to the thunder: distance / 343. */
+    readonly thunderDelay: number;
+};
+type WeatherSample = StateValues & {
+    readonly gameSeconds: number;
+    /** 0 is midnight, 0.5 is noon. */
+    readonly dayFraction: number;
+    readonly hour: number;
+    readonly nightFactor: number;
+    /** 0..1 sun height (the game's `s`). */
+    readonly sun: number;
+    /** The state being blended to (or settled in), and the one it is leaving while the blend runs. */
+    readonly state: string;
+    readonly previous: string | undefined;
+    /** 0..1: how far the blend has come; 1 is settled. */
+    readonly blend: number;
+    readonly front: {
+        readonly direction: readonly [x: number, z: number];
+        readonly progress: number;
+    };
+    readonly windSpeed: number;
+    readonly temperatureC: number;
+    /** Relative humidity in percent, with the climate offset. */
+    readonly humidityPercent: number;
+    /** Ground wetness now, 0..1 (rises with rain, dries 180 s after it stops). */
+    readonly groundWetness: number;
+    /** 0..1 flash of the latest strike (the Workshop's double flash). */
+    readonly flash: number;
+    readonly effects: WeatherEffects;
+};
+type WeatherEventMap = {
+    readonly transition: {
+        readonly from: string;
+        readonly to: string;
+        readonly gameSeconds: number;
+    };
+    readonly strike: Strike;
+    readonly thunder: Strike;
+};
+
+declare const WEATHER_STATES: readonly WeatherState[];
+declare const CLIMATES: readonly Climate[];
+type RegistryOptions = {
+    /** Added to the shipped states or, when the id exists, replacing it. */
+    readonly states?: readonly WeatherState[];
+    readonly climates?: readonly Climate[];
+    /** Merged into a shipped or added entry by id; a patch for an id that does not exist is ignored. */
+    readonly patch?: {
+        readonly states?: Readonly<Record<string, DeepPartial<WeatherState>>>;
+        readonly climates?: Readonly<Record<string, DeepPartial<Climate>>>;
+    };
+    readonly remove?: {
+        readonly states?: readonly string[];
+        readonly climates?: readonly string[];
+    };
+};
+type WeatherRegistry = {
+    state(id: string): WeatherState | undefined;
+    climate(id: string): Climate | undefined;
+    stateIds(): string[];
+    climateIds(): string[];
+    registerState(state: WeatherState): void;
+    registerClimate(climate: Climate): void;
+    patchState(id: string, patch: DeepPartial<WeatherState>): void;
+    patchClimate(id: string, patch: DeepPartial<Climate>): void;
+    removeState(id: string): void;
+    removeClimate(id: string): void;
+};
+/** The shipped states and climates with yours added, patched or removed; change it later with the same verbs. */
+declare function createWeatherRegistry(options?: RegistryOptions): WeatherRegistry;
+
+declare const DEFAULT_WET_RISE_SECONDS = 120;
+/** The Workshop sheet: the water goes back to the colour of the ground 3 minutes after the rain stops. */
+declare const DEFAULT_DRY_OUT_SECONDS = 180;
+type WetnessOptions = {
+    /** Seconds of rain to wet the ground fully. */
+    readonly riseSeconds?: number;
+    /** Seconds from the end of the rain until the ground is dry. */
+    readonly dryOutSeconds?: number;
+};
+type Wetness = {
+    value(): number;
+    /** Moves `seconds` toward `target` (the wetness the weather asks for); `dryingScale` speeds the dry-out up. Returns the new value. */
+    update(seconds: number, target: number, dryingScale?: number): number;
+    reset(value?: number): void;
+};
+/** Ground wetness: rises while the weather asks for more, then falls in a straight line that ends `dryOutSeconds` after the start of the fall. */
+declare function createWetness(options?: WetnessOptions): Wetness;
+
+declare const DEFAULT_START_HOUR = 8;
+type WeatherOptions = RegistryOptions & {
+    /** Seed of the schedule and of the lightning (each has its own stream). Default 1. */
+    readonly seed?: number;
+    /** Climate id. Default `temperate`. */
+    readonly climate?: string;
+    /** First state; default the climate's `start`, which is `clear`: the normal world comes first. */
+    readonly start?: string;
+    /** Game seconds per real second. Default 72 (the 20-minute day). */
+    readonly timeScale?: number;
+    /** Hour of the day the world starts at. Default 8. */
+    readonly startHour?: number;
+    /** `false` keeps the state until `force` changes it. Default true. */
+    readonly autoSchedule?: boolean;
+    readonly wetness?: WetnessOptions;
+    /** An existing registry, instead of building one from the registry options. */
+    readonly registry?: WeatherRegistry;
+};
+type WeatherTimeline = {
+    readonly seed: number;
+    readonly climate: string;
+    readonly start: string;
+    readonly hours: number;
+    readonly sampleMinutes: number;
+    readonly transitions: ReadonlyArray<{
+        readonly gameSeconds: number;
+        readonly from: string;
+        readonly to: string;
+    }>;
+    readonly strikes: readonly Strike[];
+    readonly samples: ReadonlyArray<Readonly<Record<string, number | string>>>;
+};
+type Weather = {
+    readonly registry: WeatherRegistry;
+    /** Moves the world forward by `dt` real seconds (game time moves `timeScale` times as fast). Events fire in order as they are crossed. */
+    advance(dt: number): void;
+    sample(): WeatherSample;
+    /** The state being blended to, or settled in. */
+    state(): string;
+    /** Changes state now, blending over `blendSeconds` real seconds (0 is at once); the new state then lasts a normal dwell. */
+    force(id: string, blendSeconds?: number): void;
+    setTimeScale(timeScale: number): void;
+    setAutoSchedule(isOn: boolean): void;
+    /** What a fresh world with these options does over `hours` game hours; the live world is not touched. */
+    timeline(hours: number, sampleMinutes?: number): WeatherTimeline;
+    on<TEvent extends keyof WeatherEventMap>(event: TEvent, listener: (payload: WeatherEventMap[TEvent]) => void): () => void;
+};
+declare function createWeather(options?: WeatherOptions): Weather;
+type TimelineOptions = WeatherOptions & {
+    readonly hours: number;
+    /** Game minutes between samples. Default 10. */
+    readonly sampleMinutes?: number;
+};
+/**
+ * What a fresh world does over `hours` game hours, stepping one game minute at a time: the state changes, the strikes (time, distance, bearing) and
+ * a sample every `sampleMinutes`. Plain JSON, rounded to 6 decimals, so it can be a golden.
+ */
+declare function createTimeline(options: TimelineOptions): WeatherTimeline;
+
+type WeatherSoundStyle = 'art_scene' | 'game';
+type WeatherSoundOptions = {
+    /** Which team's rain: `art_scene` (default, the kit mix) or `game` (a highpass hiss). The wind and the thunder are the same. */
+    readonly style?: WeatherSoundStyle;
+    /**
+     * Level of the rain loop. It is `light` at `lightAt` mm/h (the game's rain, 0.035) and `heavy` from `heavyAt` mm/h (the art scene's, 0.06), a straight
+     * line between, and 0 when it does not rain.
+     */
+    readonly rain?: {
+        readonly light?: number;
+        readonly heavy?: number;
+        readonly lightAt?: number;
+        readonly heavyAt?: number;
+    };
+    /** Level of the wind loop: `base` (the art scene's 0.05) at `referenceSpeed` m/s, in proportion to the speed, at most `max`. */
+    readonly wind?: {
+        readonly base?: number;
+        readonly referenceSpeed?: number;
+        readonly max?: number;
+    };
+    /** Where the listener is, to place the thunder around it (default the origin). */
+    readonly listener?: () => Vec3;
+    /** Level of the thunder (default 1). */
+    readonly thunderVolume?: number;
+    /** `false` keeps the sink's bank as it is (the host registered `WEATHER_BANK` itself). */
+    readonly register?: boolean;
+};
+declare const DEFAULT_RAIN_SOUND: {
+    readonly light: 0.035;
+    readonly heavy: 0.06;
+    readonly lightAt: 2.5;
+    readonly heavyAt: 15;
+};
+/** The art scene opens its wind at 0.05 with the breeze of its day (3.8 m/s, the `clear` state's wind): the level follows the speed from there. */
+declare const DEFAULT_WIND_SOUND: {
+    readonly base: 0.05;
+    readonly referenceSpeed: 3.8;
+    readonly max: 0.12;
+};
+/** The level of the rain loop for `rain` mm/h. */
+declare function rainVolume(rain: number, options?: WeatherSoundOptions['rain']): number;
+/** The level of the wind loop for a wind of `speed` m/s. */
+declare function windVolume(speed: number, options?: WeatherSoundOptions['wind']): number;
+/** Where a strike is, around `origin`: `bearing` is degrees clockwise from north, and north is -z. */
+declare function strikePosition(strike: Pick<Strike, 'distance' | 'bearing'>, origin?: Vec3): Vec3;
+type WeatherSound = {
+    /** Sets the level of the loops from the weather of now (opens a loop the first time it is above 0). */
+    update(sample: Pick<WeatherSample, 'rain' | 'windSpeed'>): void;
+    /** Plays a clap of thunder at the strike (call it when the thunder arrives: the weather delays it by `distance / 343`). */
+    thunder(strike: Pick<Strike, 'distance' | 'bearing'>): void;
+    dispose(): void;
+};
+/** The sound of the weather on the host's `audio`: the rain loop, the wind loop and the thunder. Without a sink (or one without loops) it does nothing. */
+declare function createWeatherSound(sink: AudioSink | undefined, options?: WeatherSoundOptions): WeatherSound;
+
+/** The shape of the film of `game-fluids-three` (`FilmBridge`) this needs: no import, so the weather does not depend on it. */
+type FilmTarget = {
+    setWeather(weather: {
+        rain: number;
+        drying?: number;
+    }): void;
+    wash?(maxDryness?: number): number;
+};
+/** The interactables world (`game-interactables`): its water takes the rain, the soft volumes the wind. */
+type InteractablesTarget = {
+    water: {
+        setRain(mmPerHour: number): void;
+    };
+    setWind(x: number, z: number): void;
+};
+/** The vegetation renderer (`game-vegetation`). `direction` is normalised by the renderer, `strength` and `gust` are 0..1. */
+type VegetationTarget = {
+    setWind(wind: {
+        direction?: [number, number];
+        strength?: number;
+        gust?: number;
+    }): void;
+};
+/** The effects world (`game-vfx`'s `VfxWorld`): smoke and dust drift with its wind. */
+type VfxTarget = {
+    setWind(wind: readonly [number, number, number]): void;
+};
+type WeatherTargets = {
+    readonly film?: FilmTarget;
+    readonly interactables?: InteractablesTarget;
+    readonly vegetation?: VegetationTarget;
+    readonly vfx?: VfxTarget;
+    /** The host's environment bus (`ModuleHost.environment`). */
+    readonly environment?: Pick<EnvironmentBus, 'set'>;
+    /** The host's sound (`ModuleHost.audio`): the rain and wind loops, and the thunder. */
+    readonly audio?: AudioSink;
+};
+/** The rules the bridges apply; every number can be replaced. */
+type WeatherBridgeRules = {
+    /** Rain in mm/h at which the film counts as fully rained on (it stops drying, spreads 1.5 times faster). Default 2.5, the light rain. */
+    readonly filmRainFullAt?: number;
+    /** Rain in mm/h from which the rain washes the fresh stain (Workshop and visor: heavy rain and stronger). Default 15; light rain does not wash. */
+    readonly washFrom?: number;
+    /** Stains less dry than this are washed (visor L13494). Default 0.5. */
+    readonly washBelow?: number;
+    /** Seconds between two washes while it pours. Default 1. */
+    readonly washEvery?: number;
+    /** Wind speed in m/s that is 1 for the vegetation (`strength = min(1, speed / this)`). Default 20. */
+    readonly windFull?: number;
+};
+type WeatherBridgeOptions = WeatherBridgeRules & {
+    readonly sound?: WeatherSoundOptions | false;
+};
+declare const DEFAULT_BRIDGE_RULES: {
+    readonly filmRainFullAt: 2.5;
+    readonly washFrom: 15;
+    readonly washBelow: 0.5;
+    readonly washEvery: 1;
+    readonly windFull: 20;
+};
+/** The weather as the environment bus holds it. */
+declare function environmentOf(sample: WeatherSample): Partial<EnvironmentState>;
+type WeatherBridges = {
+    /** Follows this weather (the one before is let go) and pushes its values at once. */
+    bind(weather: Weather): void;
+    /** Pushes the weather of now to every target; call it each frame after `weather.advance(dt)`. */
+    update(dt: number): void;
+    dispose(): void;
+};
+/**
+ * Pushes one weather to the packages that react to it, each through a small interface of its own, so the weather depends on none of them and every
+ * target is optional:
+ * - fluids film: `setWeather({ rain: min(1, rain / filmRainFullAt), drying: dryingScale })`, and `wash()` every `washEvery` seconds while the rain is at
+ *   `washFrom` or stronger (light rain stops the drying and does not wash);
+ * - interactables: `water.setRain(mm/h)` and `setWind(x, z)`;
+ * - vegetation: `setWind({ direction: [x, z], strength: min(1, speed / windFull), gust: min(1, gust / windFull) })`;
+ * - vfx: `setWind([x, 0, z])`;
+ * - the environment bus: every value of `environmentOf`;
+ * - sound: the rain and wind loops follow the weather, and each thunder that arrives plays at its bearing.
+ */
+declare function createWeatherBridges(targets: WeatherTargets, options?: WeatherBridgeOptions): WeatherBridges;
+
+/** What a renderer of the weather (game-weather-three) gives the bench: its layers, a step per frame and the switch of each layer. */
+type WeatherVisual = {
+    update(dt: number): void;
+    setLayer(id: string, on: boolean): void;
+    dispose(): void;
+};
+/** The bench hands a visual the weather it shows (always the live one, even after the bench restarts it) and what the room lends. */
+type WeatherVisualContext = {
+    readonly host: ModuleHost;
+    readonly locale: string;
+    readonly weather: {
+        sample(): WeatherSample;
+    };
+};
+/** The bench declares its layers before the room lends anything, so the factory tells them first (`fog` is the bench's own layer and reaches the visual through `setLayer` too). */
+type WeatherVisualFactory = {
+    layers(locale: string): readonly ModuleLayer[];
+    create(context: WeatherVisualContext): WeatherVisual;
+};
+type WeatherTestModuleOptions = WeatherOptions & {
+    locale?: string;
+    /** Text of a state id in the game's words; without it the bench uses its own names, then the id. */
+    translate?: (key: string, locale: string) => string | undefined;
+    /** The weather to test (default a new one built from the other options). */
+    weather?: Weather;
+    /** Whether the scene fog follows the weather at first (default true; the layer can be switched either way). A room that is not about weather starts it off. */
+    fog?: boolean;
+    /** The packages the weather drives besides the host's environment bus and sound (fluids film, interactables, vegetation, vfx), from the example. */
+    targets?: Omit<WeatherTargets, 'environment' | 'audio'>;
+    /** The rain, wind and thunder on the host's `audio`; `false` keeps the area silent. */
+    sound?: WeatherSoundOptions | false;
+    /** The picture of the weather (rain, fog, sky, lightning, headlights, haze), from `@adatechnology/game-weather-three`. With it the bench leaves the scene fog to the visual. */
+    visual?: WeatherVisualFactory;
+};
+/** What the scenarios use of the context the test room passes. */
+interface WeatherScenarioLike {
+    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
+}
+type WeatherTestModule = TestableModule<WeatherScenarioLike> & {
+    /** The weather in use (replaced when the bench changes the seed or the hour). */
+    readonly weather: Weather;
+};
+/**
+ * The weather area of a test room, written against the generic contracts only: it drives a `createWeather` world, writes the result into the host's
+ * environment bus (`host.environment`) every frame and shows the numbers a game reads from it. It also sets the scene fog from the weather's render fog.
+ * Pure: no three.js beyond the host's own `Fog`, and the sky, rain, lightning and sound wait for the packages that draw and play them.
+ */
+declare function createWeatherTestModule(options?: WeatherTestModuleOptions): WeatherTestModule;
+
+type WeatherBenchText = {
+    readonly group: string;
+    readonly name: string;
+    readonly controls: Readonly<Record<'state' | 'transition' | 'time_of_day' | 'auto_schedule' | 'seed', string>>;
+    readonly hints: Readonly<Record<'transition' | 'time_of_day' | 'auto_schedule' | 'seed', string>>;
+    readonly options: Readonly<Record<'instant' | 'ten_seconds', string>>;
+    readonly layers: Readonly<Record<'environment' | 'fog', string>>;
+    readonly metrics: Readonly<Record<'state' | 'hour' | 'rain' | 'visibility' | 'sight' | 'hearing' | 'wind' | 'heat_index' | 'wetness' | 'strikes' | 'blend' | 'temperature', string>>;
+    readonly scenarios: Readonly<Record<'storm' | 'blend' | 'determinism' | 'dry_ground', string>>;
+    /** Names of the states and climates by id; the bench falls back to the id. */
+    readonly states: Readonly<Record<string, string>>;
+};
+declare const weatherBenchTextOf: (locale: string) => WeatherBenchText;
+
+export { strikePosition as $, type WeatherTestModule as A, type WeatherTestModuleOptions as B, type Climate as C, DEFAULT_BRIDGE_RULES as D, type WeatherTimeline as E, type FilmTarget as F, type WeatherVisual as G, type WeatherVisualContext as H, type InteractablesTarget as I, type WeatherVisualFactory as J, type Wetness as K, type LightningConfig as L, type WetnessOptions as M, createTimeline as N, createWeather as O, createWeatherBridges as P, createWeatherRegistry as Q, type RegistryOptions as R, type StateValueKey as S, type TimelineOptions as T, createWeatherSound as U, type VegetationTarget as V, type WeatherState as W, createWeatherTestModule as X, createWetness as Y, environmentOf as Z, rainVolume as _, type StateValues as a, weatherBenchTextOf as a0, windVolume as a1, type WeatherEffects as b, CLIMATES as c, DEFAULT_DRY_OUT_SECONDS as d, DEFAULT_RAIN_SOUND as e, DEFAULT_START_HOUR as f, DEFAULT_WET_RISE_SECONDS as g, DEFAULT_WIND_SOUND as h, type DeepPartial as i, type Strike as j, type VfxTarget as k, WEATHER_STATES as l, type Weather as m, type WeatherBenchText as n, type WeatherBridgeOptions as o, type WeatherBridgeRules as p, type WeatherBridges as q, type WeatherEventMap as r, type WeatherOptions as s, type WeatherRegistry as t, type WeatherSample as u, type WeatherScenarioLike as v, type WeatherSound as w, type WeatherSoundOptions as x, type WeatherSoundStyle as y, type WeatherTargets as z };

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+export { n as WeatherBenchText, v as WeatherScenarioLike, A as WeatherTestModule, B as WeatherTestModuleOptions, G as WeatherVisual, H as WeatherVisualContext, J as WeatherVisualFactory, X as createWeatherTestModule, a0 as weatherBenchTextOf } from './testing-B4pjKlOJ.js';
+import '@adatechnology/game-contracts';

package/dist/testing.js

@@ -0,0 +1,9 @@
+import {
+  createWeatherTestModule,
+  weatherBenchTextOf
+} from "./chunk-EODWEOJG.js";
+export {
+  createWeatherTestModule,
+  weatherBenchTextOf
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/game-weather",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "license": "MIT",
   "description": "Pure, seeded weather for games: states (clear to typhoon), climates with a Markov scheduler in game time, fronts from the west, lightning with thunder delay, ground wetness, gameplay effects, heat index and the day-night formula. Knows nothing about any game.",
   "keywords": [
@@ -32,14 +32,18 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    },
     "./global": "./dist/index.global.js"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@adatechnology/game-audio": "^0.3.5",
-    "@adatechnology/game-contracts": "^0.20.0"
+    "@adatechnology/game-audio": "^0.4.0",
+    "@adatechnology/game-contracts": "^0.22.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.7",