@adatechnology/game-weather 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anderson Fernandes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,95 @@
-# Temporary Holding Version
+# @adatechnology/game-weather
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Pure, seeded weather for games: states from clear to typhoon, climates that move between them in game time, lightning with the thunder delay,
+ground wetness, what the weather means for sight, hearing and footsteps, the heat index and the day-night formula. No three.js, no audio, no
+game content; renderers and sound engines read it. Zero runtime dependencies; works in the browser and in Node.
+
+The numbers come from the teams' pages (each state lists its `sources`): the rain, fog and lightning of the VFX Workshop, the dry and wet fog and
+the day of the game, the wind and fog of the Art Scene, the rain rules of the Vale Cinzento gallery. Cyclone, typhoon and extreme heat have no team
+source and are physics presets (and off in the `temperate` climate).
+
+- **The normal world comes first.** Every climate starts `clear`; nothing is tied to an outbreak.
+- **States** (`WEATHER_STATES`): `clear`, `overcast`, `light_rain`, `heavy_rain`, `storm`, `fog`, `windy`, `cyclone`, `typhoon`, `extreme_heat`.
+- **Climates** (`CLIMATES`): `temperate` (mostly clear and overcast, no extremes, the default) and `tropical` (extremes rare and enabled).
+  A seeded Markov chain in game time: each state lasts 2 to 6 game hours, a change blends over 10 game minutes and the front arrives from the west.
+- **Lightning** has its own seeded stream (the server sends the seed, every client sees the same strikes): the first strike 2 to 4 s after a storm
+  begins, then every 3.5 to 6 s, the Workshop's double flash, thunder `distance / 343` seconds later.
+- **Wetness** rises with the rain and is dry 180 s after it stops (faster in extreme heat).
+- **Effects**: `visibility`, `sightScale` (weather times the game's `1 - 0.4 × night`), `hearingScale`, `footstepScale`, `heatIndexC` (NOAA
+  Rothfusz), `heatStress` (0..1 on the 27, 32, 41 and 54 °C bands), `lightningReveal`, `dryingScale`, `debrisPush`.
+- **Day and night**: the game's formula (`daylight`), a 20-minute day by default (`timeScale` 72).
+
+## Install
+
+```sh
+pnpm add @adatechnology/game-weather
+```
+
+Browser without a bundler (the global is `GameWeather`):
+
+```html
+<script src="https://unpkg.com/@adatechnology/game-weather/dist/index.global.js"></script>
+<script>
+  const weather = GameWeather.createWeather({ seed: 7 })
+</script>
+```
+
+## Usage
+
+```ts
+import { createWeather } from '@adatechnology/game-weather'
+
+const weather = createWeather({ seed: 7, climate: 'tropical' }) // starts clear, 8:00, a 20-minute day
+weather.on('strike', (strike) => flash(strike.bearing))
+weather.on('thunder', (strike) => playThunder(strike.distance))
+weather.on('transition', ({ from, to }) => log(`${from} -> ${to}`))
+
+// every frame, with real seconds
+weather.advance(dt)
+const sample = weather.sample()
+sample.rain // mm/h, blended between states
+sample.windX // m/s
+sample.nightFactor // 0 day, 1 night
+sample.groundWetness // 0..1
+sample.effects.hearingScale // multiply a listener's radius by this
+sample.front // { direction: [1, 0], progress } — the curtain moves along +x
+
+weather.force('storm', 10) // blend to a storm over 10 real seconds
+weather.timeline(72) // what a fresh world does in 72 game hours (plain JSON, a golden)
+```
+
+### Registry: add, patch, remove
+
+```ts
+import { createWeather, WEATHER_STATES } from '@adatechnology/game-weather'
+
+const weather = createWeather({
+  states: [{ ...WEATHER_STATES[2]!, id: 'drizzle', sources: ['my game'], rain: 0.5, drops: 300 }],
+  patch: { states: { storm: { rain: 90, lightning: { interval: [2, 4] } } }, climates: { temperate: { dwellHours: [1, 3] } } },
+  remove: { states: ['fog'] }, // nothing schedules it any more
+})
+weather.registry.patchState('heavy_rain', { visibility: 100 }) // later, with the same verbs
+```
+
+## Determinism
+
+The schedule and the lightning draw from separate seeded streams (`streamSeed(seed, 'schedule' | 'lightning')`), so strikes never move the
+schedule and the result does not depend on the size of the steps `advance` is called with. `createTimeline` steps one game minute at a time and is
+checked against goldens on Node 22 and 24.
+
+## API
+
+Everything is exported from the package root; see `src/*.ts` for the doc comments. Units: metres, seconds, mm/h, degrees Celsius; wind in m/s.
+
+## Português
+
+Clima puro e determinístico por semente: estados de céu limpo a tufão, climas que passam de um estado a outro em tempo de jogo, relâmpago com o
+atraso do trovão, solo molhado, o que o tempo muda para visão, audição e passos, índice de calor e a fórmula de dia e noite do jogo. Sem three.js,
+sem som, sem conteúdo de jogo: quem desenha e quem toca lê daqui. Cada estado traz `sources` com a origem dos números (Oficina de VFX, jogo, Cena de
+Arte, Galeria do Vale Cinzento); ciclone, tufão e calor intenso não têm fonte de time e são predefinições físicas, desligadas no clima `temperate`.
+
+- O mundo normal vem primeiro: todo clima começa em `clear`.
+- O estado dura de 2 a 6 horas de jogo, a mudança se mistura em 10 minutos de jogo e a frente chega de oeste.
+- Relâmpago com fluxo próprio de semente (o servidor manda a semente e todos veem o mesmo clarão); trovão `distância / 343` s depois.
+- O solo seca 180 s depois que a chuva para; `effects` entrega `sightScale`, `hearingScale`, `footstepScale`, índice de calor e estresse de calor.
+- Catálogo por registro: acrescente, troque (`patch`) ou tire estados e climas sem mexer no núcleo.

package/dist/index.d.ts

@@ -0,0 +1,376 @@
+import { TestableModule } 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;
+
+declare const STATE_VALUE_KEYS: readonly StateValueKey[];
+declare function valuesOf(state: WeatherState): StateValues;
+/** Every number between two states: `progress` 0 is `from`, 1 is `to`. */
+declare function blendValues(from: StateValues, to: StateValues, progress: number): StateValues;
+
+type Scheduler = {
+    /** Game seconds at which the current state ends. */
+    nextChangeAt(): number;
+    /** Picks the state after `current`, then draws how long it lasts from `at`. Returns the new state's id. */
+    next(current: string, at: number): string;
+    /** Draws a new duration from `at` (after a forced change). */
+    restart(at: number): void;
+};
+/**
+ * A seeded Markov chain in game time. Draw order, fixed so the timeline repeats: at start one dwell; at each change the next state first
+ * (one draw, over the weights in the climate's order), then its dwell. States `isKnown` rejects are left out of the weights.
+ */
+declare function createScheduler(climate: Climate, seed: number, isKnown: (id: string) => boolean): Scheduler;
+
+/** Speed of sound in air, m/s: a physical constant, so it is not configurable. */
+declare const SPEED_OF_SOUND = 343;
+/** Seconds a flash goes on after a strike before the scene is back to normal (Workshop W1068: `k > .4`). */
+declare const FLASH_END_SECONDS = 0.4;
+/** Seconds from the flash to the thunder for a strike `distance` metres away. */
+declare function thunderDelay(distance: number): number;
+/** The Workshop double flash (W1068): full for 0.08 s, 0.2 until 0.16 s, 0.8 until 0.26 s, then dark. `elapsed` is seconds since the strike. */
+declare function flashIntensity(elapsed: number): number;
+type LightningStream = {
+    /** Seconds from entering a state with lightning to its first strike. */
+    first(config: LightningConfig): number;
+    /** Seconds from a strike to the next one. */
+    interval(config: LightningConfig): number;
+    /** Where a strike lands: metres and degrees clockwise from north. Draws the distance, then the bearing. */
+    place(config: LightningConfig): {
+        readonly distance: number;
+        readonly bearing: number;
+    };
+};
+/** The lightning's own seeded stream, apart from the scheduler's: the server can send the seed and every client sees the same strikes. */
+declare function createLightningStream(seed: number): LightningStream;
+
+/** Gameplay visibility of a dry day (the game's dry fog far, jogo.js L69141): `sightScale` is the visibility against it. */
+declare const DRY_VISIBILITY_METERS = 220;
+/** jogo.js L66872: sight is `perc[0] × (1 − 0.4 × nightF)`. */
+declare const NIGHT_SIGHT_LOSS = 0.4;
+type EffectsInput = {
+    readonly values: StateValues;
+    readonly nightFactor: number;
+    readonly temperatureC: number;
+    readonly humidityPercent: number;
+    readonly lightningReveal: number;
+};
+/** What the weather means for gameplay, as numbers for whoever has eyes, ears or feet in the world (perception, footsteps, heat). */
+declare function deriveEffects(input: EffectsInput): WeatherEffects;
+
+/**
+ * NOAA heat index in °C: the Steadman estimate averaged with the temperature, and from 80 °F up the Rothfusz regression with the low-humidity and
+ * high-humidity adjustments. Built from + - * / and `sqrt` only, so it is the same on every engine.
+ */
+declare function heatIndexC(temperatureC: number, relativeHumidityPercent: number): number;
+/** 0..1 across the NOAA bands (caution 27, extreme caution 32, danger 41, extreme danger 54 °C), linear between them. */
+declare function heatStress(heatIndex: number): number;
+
+/** A game day lasts 20 real minutes in the slice (jogo.js L69127: `dayT + dt / 1200`). */
+declare const DAY_REAL_SECONDS = 1200;
+declare const GAME_DAY_SECONDS = 86400;
+/** Game seconds per real second of the 20-minute day. */
+declare const DEFAULT_TIME_SCALE: number;
+type Daylight = {
+    /** Sun height 0..1 (`s` of the game). */
+    readonly sun: number;
+    /** 0 in full daylight, 1 in the darkest night. */
+    readonly nightFactor: number;
+};
+/** jogo.js L69128-L69130: `s = clamp(sin(dayT·2π − π/2)·0.5 + 0.5, 0, 1)`, `nightF = 1 − clamp(s·2.2, 0, 1)`. `dayFraction` 0 is midnight. */
+declare function daylight(dayFraction: number): Daylight;
+/** The fraction of the day after `gameSeconds` from `startHour`. */
+declare function dayFractionAt(startHour: number, gameSeconds: number): number;
+
+/** Deterministic mulberry32 generator; returns floats in [0, 1). */
+declare function createRng(seed: number): () => number;
+/** A seed for the stream called `name`: the same seed gives each name its own sequence, so lightning never shifts the schedule. */
+declare function streamSeed(seed: number, name: string): number;
+declare function createStream(seed: number, name: string): () => number;
+
+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;
+};
+/** 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 { CLIMATES, type Climate, DAY_REAL_SECONDS, DEFAULT_DRY_OUT_SECONDS, DEFAULT_START_HOUR, DEFAULT_TIME_SCALE, DEFAULT_WET_RISE_SECONDS, DRY_VISIBILITY_METERS, type Daylight, type DeepPartial, type EffectsInput, FLASH_END_SECONDS, GAME_DAY_SECONDS, type LightningConfig, type LightningStream, NIGHT_SIGHT_LOSS, type RegistryOptions, SPEED_OF_SOUND, STATE_VALUE_KEYS, type Scheduler, type StateValueKey, type StateValues, type Strike, type TimelineOptions, WEATHER_STATES, type Weather, type WeatherBenchText, type WeatherEffects, type WeatherEventMap, type WeatherOptions, type WeatherRegistry, type WeatherSample, type WeatherScenarioLike, type WeatherState, type WeatherTestModule, type WeatherTestModuleOptions, type WeatherTimeline, type Wetness, type WetnessOptions, blendValues, createLightningStream, createRng, createScheduler, createStream, createTimeline, createWeather, createWeatherRegistry, createWeatherTestModule, createWetness, dayFractionAt, daylight, deriveEffects, flashIntensity, heatIndexC, heatStress, streamSeed, thunderDelay, valuesOf, weatherBenchTextOf };