@its-not-rocket-science/ananke 0.1.53 → 0.1.55

package/CHANGELOG.md

@@ -6,6 +6,35 @@ Versioning follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.1.55] — 2026-03-30
+
+### Added
+
+- **PA-6 — Unified Atmosphere Model (complete):**
+  - `src/atmosphere.ts` (new): single `AtmosphericState` struct derived from Phase 51 `WeatherState` and Phase 68 `BiomeContext`, with a unified per-pair query API.
+  - `deriveAtmosphericState(weather?, biome?)` → `AtmosphericState`: maps WeatherState wind to 3D `AtmosphericWind` (adds `dz_m`, derives `turbulence_Q` from speed); derives `precipIntensity_Q` from precipitation type; computes `baseVisibility_Sm` from fog × precipitation; computes `acousticMask_Q` from wind noise; maps biome `soundPropagation_Q` (vacuum = 0, water = 4×, standard air = 1×); derives `tractionMod_Q` and `thermalOffset_Q` from `deriveWeatherModifiers`.
+  - `queryAtmosphericModifiers(from, to, state)` → `AtmosphericModifiers`: single call yields all position-pair atmospheric effects — `crossWindSpeed_mps` (perpendicular wind for projectile drift), `hazardConeMul_Q` (gas/smoke cone range 0.5×–1.5× from headwind/tailwind), `acousticMaskMul_Q` (hearing range including upwind bonus and biome propagation), `visibilityRange_Sm` (headwind-boosted precipitation degradation), `tractionMod_Q`, `scentStrength_Q` (q(1.0) fully downwind of target, q(0) upwind — prerequisite for PA-7), `thermalOffset_Q`.
+  - `"./atmosphere"` subpath export added to `package.json`.
+  - Exports: `AtmosphericWind`, `AtmosphericState`, `AtmosphericModifiers`, `deriveAtmosphericState`, `queryAtmosphericModifiers`; constants `ATMO_BASE_VISIBILITY_Sm`, `ATMO_ACOUSTIC_FULL_MASK_MPS`, `ATMO_TURBULENCE_FULL_MPS`, `ATMO_HAZARD_TAILWIND_MUL_MAX`, `ATMO_HAZARD_HEADWIND_MUL_MIN`, `ATMO_HEARING_UPWIND_BONUS`.
+- 53 new tests (186 test files, 5,452 tests total). Build: clean.
+
+---
+
+## [0.1.54] — 2026-03-28
+
+### Added
+
+- **PA-5 — Campaign ↔ Tactical Terrain Bridge (complete):**
+  - `src/terrain-bridge.ts` (new): maps campaign hex tiles to tactical battlefield parameters consumable by `KernelContext`, and merges tactical battle results back into `CampaignState`.
+  - `extractTerrainParams(hexType)` → deterministic 10×8-cell (100 m × 80 m) battlefield with `TerrainGrid`, `ObstacleGrid`, `ElevationGrid`, `SlopeGrid`, and `CoverSegment[]` for all 8 hex types: `plains`, `forest`, `hills`, `marsh`, `urban`, `mountain`, `river_crossing`, `coastal`.
+  - `generateBattleSite(ctx)` → full `BattleTerrainParams` including `EntryVector[]` — attacker/defender spawn positions (y=5 m south, y=75 m north) with `facingY` direction.
+  - `mergeBattleOutcome(campaign, outcome)` → merges post-battle `WorldState` into `CampaignState`: removes `injury.dead` entities, copies post-battle `injury`/`condition` onto survivors, transfers looted weapons/items from captured entities to winner's inventory, advances `worldTime_s`, appends a log entry.
+  - Exports: `CampaignHexType`, `EntryVector`, `BattleTerrainParams`, `BattleSiteContext`, `BattleOutcome`; field constants `FIELD_WIDTH_Sm`, `FIELD_HEIGHT_Sm`, `CELL_SIZE_Sm`, `GRID_COLS`, `GRID_ROWS`.
+  - `"./terrain-bridge"` subpath export added to `package.json`.
+- 67 new tests (185 test files, 5,397 tests total). Coverage: 97.05% stmt, 87.88% branch, 95.75% func, 97.05% lines. Build: clean.
+
+---
+
 ## [0.1.53] — 2026-03-28
 
 ### Added

package/dist/src/atmosphere.d.ts

@@ -0,0 +1,222 @@
+import { type Q } from "./units.js";
+import { type WeatherState } from "./sim/weather.js";
+import type { BiomeContext } from "./sim/biome.js";
+/**
+ * Wind speed [WindField mps units, 100 per m/s] that produces maximum acoustic
+ * masking (q(1.0)).  Calibrated at 40 m/s (gale / violent storm).
+ */
+export declare const ATMO_ACOUSTIC_FULL_MASK_MPS = 4000;
+/**
+ * Wind speed [WindField mps units] that produces maximum turbulence (q(1.0)).
+ * Calibrated at 50 m/s (hurricane-force).
+ */
+export declare const ATMO_TURBULENCE_FULL_MPS = 5000;
+/**
+ * Clear-sky baseline visibility range [SCALE.m].  1 000 m = 10 000 000 SCALE.m.
+ */
+export declare const ATMO_BASE_VISIBILITY_Sm = 10000000;
+/**
+ * Maximum hazard-cone range multiplier from a strong tailwind (1.5× base range).
+ * Stored as a raw multiplier where SCALE.Q = 1.0.
+ */
+export declare const ATMO_HAZARD_TAILWIND_MUL_MAX = 15000;
+/**
+ * Minimum hazard-cone range multiplier from a strong headwind (0.5× base range).
+ */
+export declare const ATMO_HAZARD_HEADWIND_MUL_MIN = 5000;
+/**
+ * Acoustic hearing range bonus when the sound source is directly upwind
+ * (sound carries toward the listener): +20% of SCALE.Q.
+ */
+export declare const ATMO_HEARING_UPWIND_BONUS = 2000;
+/**
+ * 3-D wind field with vertical component and turbulence.
+ *
+ * Extends `WeatherState.WindField` (2-D) — `deriveAtmosphericState` maps the
+ * existing 2-D wind field and adds a zero vertical component when the source
+ * has no vertical wind data.
+ *
+ * Speed units: 100 units = 1 m/s (same convention as WeatherState.WindField).
+ */
+export interface AtmosphericWind {
+    /** X component of wind direction — unit vector in SCALE.m space. */
+    dx_m: number;
+    /** Y component of wind direction — unit vector in SCALE.m space. */
+    dy_m: number;
+    /**
+     * Vertical (Z) component — positive = rising (updraft).
+     * Unit vector in SCALE.m space.  `0` for standard horizontal wind.
+     */
+    dz_m: number;
+    /** Wind speed [100 units = 1 m/s]. */
+    speed_mps: number;
+    /**
+     * Turbulence intensity [Q 0..SCALE.Q].
+     * q(0) = laminar flow; q(1.0) = severe gusts (hurricane-force).
+     * Added to aim-error grouping radius for ranged attacks; derived from wind
+     * speed by `deriveAtmosphericState`.
+     */
+    turbulence_Q: Q;
+}
+/**
+ * Unified atmospheric state — combines wind, precipitation, visibility,
+ * acoustic environment, and thermal offset into a single queryable struct.
+ *
+ * Build once per tick from `WeatherState` and `BiomeContext` via
+ * `deriveAtmosphericState`, then query per entity-pair via
+ * `queryAtmosphericModifiers`.
+ */
+export interface AtmosphericState {
+    /** 3-D wind field. */
+    wind: AtmosphericWind;
+    /**
+     * Precipitation intensity [Q 0..SCALE.Q].
+     * q(0) = none; q(1.0) = blizzard/torrential rain.
+     * Affects traction, visibility, and acoustic masking.
+     */
+    precipIntensity_Q: Q;
+    /**
+     * Baseline visibility range [SCALE.m] — clear-sky minus fog and precipitation.
+     * `queryAtmosphericModifiers` adjusts this for headwind-driven precipitation.
+     */
+    baseVisibility_Sm: number;
+    /**
+     * Surface traction multiplier [Q].
+     * Multiply `KernelContext.tractionCoeff` by this value (already derived from
+     * `deriveWeatherModifiers().tractionMul_Q`).
+     */
+    tractionMod_Q: Q;
+    /**
+     * Ambient acoustic masking from wind noise [Q 0..SCALE.Q].
+     * q(0) = still air (no masking); q(1.0) = severe wind noise (hearing near zero).
+     * Applied to base hearing range before directional adjustments in
+     * `queryAtmosphericModifiers`.
+     */
+    acousticMask_Q: Q;
+    /**
+     * Sound propagation multiplier from biome [Q].
+     * q(1.0) = normal air propagation (default).
+     * q(0.0) = vacuum (no sound).
+     * q(4.0) = water (~4× faster propagation).
+     * Multiplies the post-masking hearing range in `queryAtmosphericModifiers`.
+     */
+    soundPropagation_Q: Q;
+    /**
+     * Thermal offset in Phase-29 Q encoding.
+     * Add to `KernelContext.thermalAmbient_Q`.
+     */
+    thermalOffset_Q: number;
+}
+/**
+ * Per-pair atmospheric modifiers returned by `queryAtmosphericModifiers`.
+ *
+ * All values are ready to apply:
+ * - Multiply Q fields using `Math.round(value × mul / SCALE.Q)`.
+ * - Add offset fields directly.
+ *
+ * @see queryAtmosphericModifiers
+ */
+export interface AtmosphericModifiers {
+    /**
+     * Perpendicular wind component relative to the shot/query direction
+     * [100 units = 1 m/s].
+     *
+     * Convert to projectile drift [SCALE.m]:
+     * ```
+     * drift_Sm = crossWindSpeed_mps × range_Sm / proj_speed_mps
+     * ```
+     * where `range_Sm` is in SCALE.m and `proj_speed_mps` is in the same
+     * 100-per-m/s wind units.  Zero when the query pair is coincident.
+     */
+    crossWindSpeed_mps: number;
+    /**
+     * Hazard-cone range multiplier for gas/smoke cones aimed from `from` to `to`
+     * [raw factor, SCALE.Q = 1.0].
+     *
+     * Values > SCALE.Q are valid and intentional:
+     * - Tailwind extends range up to `ATMO_HAZARD_TAILWIND_MUL_MAX` (1.5×).
+     * - Headwind reduces range down to `ATMO_HAZARD_HEADWIND_MUL_MIN` (0.5×).
+     * - Crosswind or calm → SCALE.Q (1.0×, no change).
+     *
+     * Apply: `adjustedRange_Sm = Math.round(baseRange_Sm × hazardConeMul_Q / SCALE.Q)`.
+     */
+    hazardConeMul_Q: number;
+    /**
+     * Effective hearing range multiplier [Q 0..SCALE.Q + ATMO_HEARING_UPWIND_BONUS].
+     *
+     * Combines wind noise masking and directional propagation:
+     * - Values < SCALE.Q: hearing degraded (wind noise or vacuum).
+     * - Values up to SCALE.Q + ATMO_HEARING_UPWIND_BONUS: enhanced (sound downwind of listener).
+     *
+     * Apply: `effectiveRange_Sm = Math.round(baseRange_Sm × acousticMaskMul_Q / SCALE.Q)`.
+     */
+    acousticMaskMul_Q: number;
+    /**
+     * Effective visibility range [SCALE.m] for the query direction.
+     * Already adjusted for headwind-driven precipitation and fog.
+     * Use as maximum ranged-detection distance for this query pair.
+     */
+    visibilityRange_Sm: number;
+    /**
+     * Surface traction modifier [Q] — same as `AtmosphericState.tractionMod_Q`.
+     * Included here for convenience so callers can read all mods from one struct.
+     */
+    tractionMod_Q: Q;
+    /**
+     * Scent propagation strength from `to` toward `from` [Q 0..SCALE.Q].
+     *
+     * Physics: the observer at `from` smells the entity at `to` when the wind
+     * blows from `to` toward `from` (i.e., `from` is downwind of `to`).
+     *
+     * - q(1.0) = `from` is directly downwind of `to` (maximum scent).
+     * - q(0)   = `from` is upwind of `to` (no scent reaches observer).
+     * - Intermediate values for crosswind/partial alignment.
+     *
+     * Used by PA-7 olfactory detection.
+     */
+    scentStrength_Q: Q;
+    /**
+     * Thermal offset in Phase-29 Q encoding.
+     * Same as `AtmosphericState.thermalOffset_Q`.
+     */
+    thermalOffset_Q: number;
+}
+/**
+ * Build an `AtmosphericState` from Phase 51 `WeatherState` and Phase 68
+ * `BiomeContext`.
+ *
+ * Both parameters are optional — absent values produce calm, clear-sky,
+ * standard-air atmosphere with no modifiers.
+ *
+ * @example
+ * ```ts
+ * const atmo = deriveAtmosphericState(ctx.weather, ctx.biome);
+ * // Use once per tick, query per entity-pair:
+ * const mods = queryAtmosphericModifiers(attacker, target, atmo);
+ * ```
+ */
+export declare function deriveAtmosphericState(weather?: WeatherState, biome?: BiomeContext): AtmosphericState;
+/**
+ * Query all atmospheric modifiers for a position pair.
+ *
+ * Computes wind-relative effects along the `from → to` vector:
+ * - Crosswind component for projectile drift.
+ * - Tailwind/headwind ratio for hazard-cone range.
+ * - Directional acoustic effects.
+ * - Headwind-boosted precipitation degrading visibility.
+ * - Scent propagation strength (downwind = strong, upwind = none).
+ *
+ * Pure function — no mutation, safe to call multiple times per tick.
+ *
+ * @param from  Observer / attacker position [SCALE.m].
+ * @param to    Target / source position [SCALE.m].
+ * @param state Atmospheric state built by `deriveAtmosphericState`.
+ * @returns     All modifiers for this position pair.
+ */
+export declare function queryAtmosphericModifiers(from: {
+    x_Sm: number;
+    y_Sm: number;
+}, to: {
+    x_Sm: number;
+    y_Sm: number;
+}, state: AtmosphericState): AtmosphericModifiers;

package/dist/src/atmosphere.js

@@ -0,0 +1,200 @@
+// src/atmosphere.ts — PA-6: Unified Atmosphere Model
+//
+// Provides a single `AtmosphericState` struct that derives from WeatherState
+// (Phase 51) and BiomeContext (Phase 68) and exposes a unified query API.
+//
+// `queryAtmosphericModifiers(from, to, state)` returns all atmospheric effects
+// relevant to a position pair in one call — projectile drift, hazard cone
+// distortion, acoustic masking, visibility, traction, and scent propagation —
+// so hosts no longer need per-system wind configuration.
+//
+// Integration:
+//   1. Build once per tick: state = deriveAtmosphericState(weather, biome)
+//   2. Query per-pair:     mods  = queryAtmosphericModifiers(from, to, state)
+//   3. Apply mods to:
+//      - resolveShoot: gRadius_m += crossWindSpeed_mps × range / proj_speed
+//      - adjustConeRange: multiply result by hazardConeMul_Q / SCALE.Q
+//      - sensoryEnv.hearingRange_m: multiply by acousticMaskMul_Q / SCALE.Q
+//      - KernelContext.tractionCoeff: multiply by mods.tractionMod_Q / SCALE.Q
+//      - PA-7 senses: use scentStrength_Q for olfactory detection
+import { SCALE, q, clampQ } from "./units.js";
+import { deriveWeatherModifiers, } from "./sim/weather.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/**
+ * Wind speed [WindField mps units, 100 per m/s] that produces maximum acoustic
+ * masking (q(1.0)).  Calibrated at 40 m/s (gale / violent storm).
+ */
+export const ATMO_ACOUSTIC_FULL_MASK_MPS = 4_000;
+/**
+ * Wind speed [WindField mps units] that produces maximum turbulence (q(1.0)).
+ * Calibrated at 50 m/s (hurricane-force).
+ */
+export const ATMO_TURBULENCE_FULL_MPS = 5_000;
+/**
+ * Clear-sky baseline visibility range [SCALE.m].  1 000 m = 10 000 000 SCALE.m.
+ */
+export const ATMO_BASE_VISIBILITY_Sm = 10_000_000;
+/**
+ * Maximum hazard-cone range multiplier from a strong tailwind (1.5× base range).
+ * Stored as a raw multiplier where SCALE.Q = 1.0.
+ */
+export const ATMO_HAZARD_TAILWIND_MUL_MAX = 15_000; // 1.5 × SCALE.Q
+/**
+ * Minimum hazard-cone range multiplier from a strong headwind (0.5× base range).
+ */
+export const ATMO_HAZARD_HEADWIND_MUL_MIN = 5_000; // 0.5 × SCALE.Q
+/**
+ * Acoustic hearing range bonus when the sound source is directly upwind
+ * (sound carries toward the listener): +20% of SCALE.Q.
+ */
+export const ATMO_HEARING_UPWIND_BONUS = 2_000; // 0.2 × SCALE.Q
+// ── Zero-wind sentinel ────────────────────────────────────────────────────────
+const ZERO_WIND = {
+    dx_m: SCALE.m, // direction irrelevant at zero speed; default East
+    dy_m: 0,
+    dz_m: 0,
+    speed_mps: 0,
+    turbulence_Q: q(0),
+};
+// ── deriveAtmosphericState ────────────────────────────────────────────────────
+/**
+ * Build an `AtmosphericState` from Phase 51 `WeatherState` and Phase 68
+ * `BiomeContext`.
+ *
+ * Both parameters are optional — absent values produce calm, clear-sky,
+ * standard-air atmosphere with no modifiers.
+ *
+ * @example
+ * ```ts
+ * const atmo = deriveAtmosphericState(ctx.weather, ctx.biome);
+ * // Use once per tick, query per entity-pair:
+ * const mods = queryAtmosphericModifiers(attacker, target, atmo);
+ * ```
+ */
+export function deriveAtmosphericState(weather, biome) {
+    // ── Wind ──────────────────────────────────────────────────────────────────
+    const srcWind = weather?.wind;
+    const turbulence_Q = srcWind
+        ? clampQ(Math.round(srcWind.speed_mps * SCALE.Q / ATMO_TURBULENCE_FULL_MPS), q(0), SCALE.Q)
+        : q(0);
+    const wind = srcWind
+        ? { dx_m: srcWind.dx_m, dy_m: srcWind.dy_m, dz_m: 0, speed_mps: srcWind.speed_mps, turbulence_Q }
+        : ZERO_WIND;
+    // ── Weather-derived modifiers ─────────────────────────────────────────────
+    const wmod = weather ? deriveWeatherModifiers(weather) : null;
+    const tractionMod_Q = (wmod?.tractionMul_Q ?? SCALE.Q);
+    const thermalOffset_Q = wmod?.thermalOffset_Q ?? 0;
+    // ── Precipitation intensity ───────────────────────────────────────────────
+    // Map WeatherModifiers.precipVisionMul_Q inversely: q(1.0) = none, q(0.30) = blizzard
+    const precipVisionMul = wmod?.precipVisionMul_Q ?? SCALE.Q;
+    // precipIntensity = 1.0 - precipVisionMul (inverted, clamped to [0, 1])
+    const precipIntensity_Q = clampQ((SCALE.Q - precipVisionMul), q(0), SCALE.Q);
+    // ── Visibility ────────────────────────────────────────────────────────────
+    // Fog: q(0) → full visibility; q(1.0) → 1% of baseline
+    const fogDensity = weather?.fogDensity_Q ?? 0;
+    const fogMul = Math.max(100, SCALE.Q - Math.round(fogDensity * 9_900 / SCALE.Q)); // 100..10000
+    const precipMul = precipVisionMul; // already in [q(0.30), q(1.0)]
+    // Combined: fog + precip (multiplicative)
+    const combinedVisionMul = Math.round(fogMul * precipMul / SCALE.Q);
+    const baseVisibility_Sm = Math.max(10 * SCALE.m, // minimum: 10 m visibility
+    Math.round(ATMO_BASE_VISIBILITY_Sm * combinedVisionMul / SCALE.Q));
+    // ── Acoustic masking (ambient wind noise) ─────────────────────────────────
+    const acousticMask_Q = clampQ(Math.round(wind.speed_mps * SCALE.Q / ATMO_ACOUSTIC_FULL_MASK_MPS), q(0), SCALE.Q);
+    // ── Sound propagation from biome ──────────────────────────────────────────
+    const soundPropagation_Q = biome?.soundPropagation !== undefined
+        ? biome.soundPropagation
+        : SCALE.Q;
+    return {
+        wind,
+        precipIntensity_Q,
+        baseVisibility_Sm,
+        tractionMod_Q,
+        acousticMask_Q,
+        soundPropagation_Q,
+        thermalOffset_Q,
+    };
+}
+// ── queryAtmosphericModifiers ─────────────────────────────────────────────────
+/**
+ * Query all atmospheric modifiers for a position pair.
+ *
+ * Computes wind-relative effects along the `from → to` vector:
+ * - Crosswind component for projectile drift.
+ * - Tailwind/headwind ratio for hazard-cone range.
+ * - Directional acoustic effects.
+ * - Headwind-boosted precipitation degrading visibility.
+ * - Scent propagation strength (downwind = strong, upwind = none).
+ *
+ * Pure function — no mutation, safe to call multiple times per tick.
+ *
+ * @param from  Observer / attacker position [SCALE.m].
+ * @param to    Target / source position [SCALE.m].
+ * @param state Atmospheric state built by `deriveAtmosphericState`.
+ * @returns     All modifiers for this position pair.
+ */
+export function queryAtmosphericModifiers(from, to, state) {
+    const shotDx = to.x_Sm - from.x_Sm;
+    const shotDy = to.y_Sm - from.y_Sm;
+    const distSq = shotDx * shotDx + shotDy * shotDy;
+    const dist_Sm = distSq > 0 ? Math.trunc(Math.sqrt(distSq)) : 0;
+    const { wind } = state;
+    // ── Wind-direction geometry ────────────────────────────────────────────────
+    // Dot and cross products of wind direction (unit vector × SCALE.m) with shot
+    // direction (SCALE.m).  Both raw values have units SCALE.m², scaled by dist.
+    // We normalise by dividing by dist_Sm to recover SCALE.m-range cosine/sine.
+    // dotNorm ∈ [-SCALE.m, SCALE.m]: positive = tailwind, negative = headwind.
+    // crossNorm ∈ [0, SCALE.m]: magnitude of perpendicular component.
+    let dotNorm = 0;
+    let crossNorm = 0;
+    if (dist_Sm > 0 && wind.speed_mps > 0) {
+        const dotRaw = wind.dx_m * shotDx + wind.dy_m * shotDy;
+        const crossRaw = wind.dx_m * shotDy - wind.dy_m * shotDx;
+        dotNorm = Math.trunc(dotRaw / dist_Sm); // SCALE.m units (cosine component)
+        crossNorm = Math.trunc(Math.abs(crossRaw) / dist_Sm); // SCALE.m units (sine component)
+        // Clamp to valid range (floating-point-free but integer rounding can exceed SCALE.m)
+        dotNorm = Math.max(-SCALE.m, Math.min(SCALE.m, dotNorm));
+        crossNorm = Math.min(SCALE.m, crossNorm);
+    }
+    // ── Crosswind speed (projectile drift) ───────────────────────────────────
+    // crossWindSpeed_mps = |sin θ| × wind.speed_mps
+    const crossWindSpeed_mps = Math.round(crossNorm * wind.speed_mps / SCALE.m);
+    // ── Hazard-cone multiplier ────────────────────────────────────────────────
+    // At full tailwind (dotNorm = +SCALE.m): 1.5× range.
+    // At full headwind (dotNorm = -SCALE.m): 0.5× range.
+    // Range: [ATMO_HAZARD_HEADWIND_MUL_MIN, ATMO_HAZARD_TAILWIND_MUL_MAX].
+    const HAZARD_HALF_RANGE = Math.round((ATMO_HAZARD_TAILWIND_MUL_MAX - ATMO_HAZARD_HEADWIND_MUL_MIN) / 2);
+    const hazardConeMul_Q = Math.max(ATMO_HAZARD_HEADWIND_MUL_MIN, Math.min(ATMO_HAZARD_TAILWIND_MUL_MAX, SCALE.Q + Math.round(dotNorm * HAZARD_HALF_RANGE / SCALE.m)));
+    // ── Acoustic masking multiplier ───────────────────────────────────────────
+    // Base: 1.0 − ambient wind noise masking.
+    // Directional bonus: source upwind of listener (negative dotNorm) → sound
+    // carries toward the listener → up to +ATMO_HEARING_UPWIND_BONUS.
+    const baseHearing = SCALE.Q - state.acousticMask_Q;
+    const upwindBonus = Math.max(0, Math.round(-dotNorm * ATMO_HEARING_UPWIND_BONUS / SCALE.m));
+    // Apply biome sound propagation (e.g. ×4 in water, ×0 in vacuum)
+    const rawAcousticMul = Math.round((baseHearing + upwindBonus) * state.soundPropagation_Q / SCALE.Q);
+    const acousticMaskMul_Q = Math.max(0, rawAcousticMul);
+    // ── Visibility (directional) ──────────────────────────────────────────────
+    // Headwind drives precipitation particles directly at the sensor, increasing
+    // effective precipitation density and reducing visibility further.
+    const headwindFrac = Math.max(0, -dotNorm); // 0..SCALE.m for headwind
+    // precipBoostPenalty: extra vision reduction from headwind-driven precipitation
+    const precipBoostPenalty = Math.round(headwindFrac * state.precipIntensity_Q / SCALE.m * q(0.30) / SCALE.Q);
+    const visionMul = Math.max(100, // ≥ 1% of base
+    SCALE.Q - Math.round(state.precipIntensity_Q * 3_000 / SCALE.Q) - precipBoostPenalty);
+    const visibilityRange_Sm = Math.max(10 * SCALE.m, Math.round(state.baseVisibility_Sm * visionMul / SCALE.Q));
+    // ── Scent strength ────────────────────────────────────────────────────────
+    // "from" smells "to" when wind blows from to→from (reversed shot direction
+    // aligns with wind direction).
+    // scentDotNorm = -dotNorm (positive = wind blows from `to` toward `from`).
+    const scentDotNorm = -dotNorm;
+    const scentStrength_Q = clampQ(Math.round(scentDotNorm * SCALE.Q / SCALE.m), q(0), SCALE.Q);
+    return {
+        crossWindSpeed_mps,
+        hazardConeMul_Q,
+        acousticMaskMul_Q,
+        visibilityRange_Sm,
+        tractionMod_Q: state.tractionMod_Q,
+        scentStrength_Q,
+        thermalOffset_Q: state.thermalOffset_Q,
+    };
+}

package/dist/src/terrain-bridge.d.ts

@@ -0,0 +1,161 @@
+import { type I32 } from "./units.js";
+import { type TerrainGrid, type ObstacleGrid, type ElevationGrid, type SlopeGrid, type SurfaceType } from "./sim/terrain.js";
+import { type CoverSegment } from "./sim/cover.js";
+import type { CampaignState } from "./campaign.js";
+import type { WorldState } from "./sim/world.js";
+/** Battlefield width [SCALE.m]. 100 m. */
+export declare const FIELD_WIDTH_Sm: I32;
+/** Battlefield depth [SCALE.m]. 80 m. */
+export declare const FIELD_HEIGHT_Sm: I32;
+/** Terrain cell size [SCALE.m]. 10 m per cell → 10 × 8 grid. */
+export declare const CELL_SIZE_Sm: I32;
+/** Number of grid columns (field width / cell size). */
+export declare const GRID_COLS = 10;
+/** Number of grid rows (field height / cell size). */
+export declare const GRID_ROWS = 8;
+/** Attacker spawn y [SCALE.m] — 5 m from the south (y=0) edge. */
+export declare const ATTACKER_SPAWN_Y_Sm: I32;
+/** Defender spawn y [SCALE.m] — 5 m from the north edge. */
+export declare const DEFENDER_SPAWN_Y_Sm: I32;
+/**
+ * Campaign map tile type.
+ *
+ * Each hex type produces a distinct battlefield layout — surface type, cover
+ * density, elevation profile, and obstacle placement.
+ */
+export type CampaignHexType = "plains" | "forest" | "hills" | "marsh" | "urban" | "mountain" | "river_crossing" | "coastal";
+/**
+ * Initial spawn position and facing for one team entering the battlefield.
+ *
+ * Attackers (south-entry) have `facingY: 1` (moving toward increasing y).
+ * Defenders (north-entry) have `facingY: -1`.
+ */
+export interface EntryVector {
+    /** Team identifier matching `entity.teamId`. */
+    teamId: number;
+    /** Spawn x-coordinate [SCALE.m]. */
+    x_Sm: number;
+    /** Spawn y-coordinate [SCALE.m]. */
+    y_Sm: number;
+    /**
+     * Initial movement direction along the y-axis.
+     * `1`  = attacker advancing north.
+     * `-1` = defender holding or advancing south.
+     */
+    facingY: 1 | -1;
+}
+/**
+ * Complete tactical battlefield specification derived from a campaign hex encounter.
+ *
+ * ## Integration
+ * ```ts
+ * const site = generateBattleSite({ hexType: "forest", ... });
+ * const ctx: KernelContext = {
+ *   tractionCoeff: SURFACE_TRACTION[site.dominantSurface],
+ *   cellSize_m:    site.cellSize_Sm,
+ *   terrainGrid:   site.terrainGrid,
+ *   obstacleGrid:  site.obstacleGrid,
+ *   elevationGrid: site.elevationGrid,
+ *   slopeGrid:     site.slopeGrid,
+ * };
+ * // Position entities at site.entryVectors[n].x_Sm / y_Sm before first stepWorld.
+ * ```
+ */
+export interface BattleTerrainParams {
+    /** Total battlefield width [SCALE.m]. */
+    width_Sm: number;
+    /** Total battlefield depth [SCALE.m]. */
+    height_Sm: number;
+    /** Cell size used for terrain grid lookups [SCALE.m]. */
+    cellSize_Sm: number;
+    /** Per-cell surface type — pass to `KernelContext.terrainGrid`. */
+    terrainGrid: TerrainGrid;
+    /** Per-cell cover fraction — pass to `KernelContext.obstacleGrid`. */
+    obstacleGrid: ObstacleGrid;
+    /** Per-cell elevation above ground [SCALE.m] — pass to `KernelContext.elevationGrid`. */
+    elevationGrid: ElevationGrid;
+    /** Per-cell slope direction and grade — pass to `KernelContext.slopeGrid`. */
+    slopeGrid: SlopeGrid;
+    /** Structural cover segments to place in the world before battle begins. */
+    coverSegments: CoverSegment[];
+    /** Entry spawn positions for each team. */
+    entryVectors: EntryVector[];
+    /**
+     * Dominant surface type — use `SURFACE_TRACTION[dominantSurface]` as
+     * the default `KernelContext.tractionCoeff`.
+     */
+    dominantSurface: SurfaceType;
+}
+/**
+ * Context provided to `generateBattleSite`.
+ */
+export interface BattleSiteContext {
+    /** Campaign hex tile where the battle occurs. */
+    hexType: CampaignHexType;
+    /** Attacking team ids — they enter from the south (y ≈ 0). */
+    attackerTeamIds: number[];
+    /** Defending team ids — they enter from the north (y ≈ FIELD_HEIGHT). */
+    defenderTeamIds: number[];
+    /**
+     * World seed from the campaign — reserved for future micro-variance.
+     * Currently unused but forwarded for determinism documentation purposes.
+     */
+    seed?: number;
+}
+/**
+ * Outcome produced by the tactical simulation, passed to `mergeBattleOutcome`.
+ */
+export interface BattleOutcome {
+    /** Final `WorldState` after the tactical battle ends. */
+    worldState: WorldState;
+    /**
+     * Battle duration in simulated seconds, added to `CampaignState.worldTime_s`.
+     */
+    elapsedSeconds: number;
+    /**
+     * Entity ids of combatants incapacitated or captured on the losing side.
+     * Their weapons and armour will be transferred to the winning team's inventory.
+     */
+    capturedEntityIds?: number[];
+    /**
+     * Team id of the victorious side.  When `undefined` the battle is a draw and
+     * no equipment transfer occurs.
+     */
+    winnerTeamId?: number;
+}
+/**
+ * Build terrain, obstacle, elevation, and slope grids for a campaign hex type.
+ *
+ * Fully deterministic — produces the same output for the same `hexType` every
+ * call.  Does not include `entryVectors`; use `generateBattleSite` for a full
+ * site including team spawn positions.
+ *
+ * Grid layout: 10 columns × 8 rows, each cell 10 m (100 000 SCALE.m).
+ * Total field: 100 m wide × 80 m deep.
+ */
+export declare function extractTerrainParams(hexType: CampaignHexType): Omit<BattleTerrainParams, "entryVectors">;
+/**
+ * Generate a complete battle site for a campaign encounter.
+ *
+ * Calls `extractTerrainParams` and appends `EntryVector` entries for each
+ * attacking and defending team.
+ *
+ * Teams with more than three members reuse spawn positions (cyclic).
+ */
+export declare function generateBattleSite(ctx: BattleSiteContext): BattleTerrainParams;
+/**
+ * Merge a completed tactical battle back into campaign state.
+ *
+ * **What this does:**
+ * - Advances `campaign.worldTime_s` by `outcome.elapsedSeconds`.
+ * - Removes entities that died in battle (`injury.dead === true`) from the
+ *   campaign entity registry, location map, and inventory map.
+ * - Copies post-battle `injury` and `condition` state onto surviving campaign
+ *   entities so wounds persist between encounters.
+ * - Transfers weapons and armour from `capturedEntityIds` to the winning
+ *   team's first surviving entity inventory (item id → count).
+ * - Appends a human-readable battle summary to `campaign.log`.
+ *
+ * Mutates `campaign` in-place.
+ */
+export declare function mergeBattleOutcome(campaign: CampaignState, outcome: BattleOutcome): void;

package/dist/src/terrain-bridge.js

@@ -0,0 +1,322 @@
+// src/terrain-bridge.ts — PA-5: Campaign ↔ Tactical Terrain Bridge
+//
+// Maps campaign hex tiles to tactical battlefield parameters consumable by
+// KernelContext, and merges tactical battle results back into CampaignState.
+//
+// Typical workflow:
+//   1. Army enters a forest hex on the campaign map.
+//   2. Call generateBattleSite({ hexType: "forest", ... }) → BattleTerrainParams.
+//   3. Build KernelContext from terrain params; run stepWorld until battle ends.
+//   4. Call mergeBattleOutcome(campaign, { worldState, elapsedSeconds }) to
+//      apply casualties, injuries, and looted equipment back to campaign.
+import { q } from "./units.js";
+import { buildTerrainGrid, buildObstacleGrid, buildElevationGrid, buildSlopeGrid, terrainKey, } from "./sim/terrain.js";
+import { createCoverSegment } from "./sim/cover.js";
+// ── Field constants ────────────────────────────────────────────────────────────
+/** Battlefield width [SCALE.m]. 100 m. */
+export const FIELD_WIDTH_Sm = 1_000_000;
+/** Battlefield depth [SCALE.m]. 80 m. */
+export const FIELD_HEIGHT_Sm = 800_000;
+/** Terrain cell size [SCALE.m]. 10 m per cell → 10 × 8 grid. */
+export const CELL_SIZE_Sm = 100_000;
+/** Number of grid columns (field width / cell size). */
+export const GRID_COLS = 10;
+/** Number of grid rows (field height / cell size). */
+export const GRID_ROWS = 8;
+/** Attacker spawn y [SCALE.m] — 5 m from the south (y=0) edge. */
+export const ATTACKER_SPAWN_Y_Sm = 50_000;
+/** Defender spawn y [SCALE.m] — 5 m from the north edge. */
+export const DEFENDER_SPAWN_Y_Sm = (FIELD_HEIGHT_Sm - 50_000);
+// ── extractTerrainParams ──────────────────────────────────────────────────────
+/**
+ * Build terrain, obstacle, elevation, and slope grids for a campaign hex type.
+ *
+ * Fully deterministic — produces the same output for the same `hexType` every
+ * call.  Does not include `entryVectors`; use `generateBattleSite` for a full
+ * site including team spawn positions.
+ *
+ * Grid layout: 10 columns × 8 rows, each cell 10 m (100 000 SCALE.m).
+ * Total field: 100 m wide × 80 m deep.
+ */
+export function extractTerrainParams(hexType) {
+    switch (hexType) {
+        case "plains": return _plains();
+        case "forest": return _forest();
+        case "hills": return _hills();
+        case "marsh": return _marsh();
+        case "urban": return _urban();
+        case "mountain": return _mountain();
+        case "river_crossing": return _riverCrossing();
+        case "coastal": return _coastal();
+    }
+}
+// ── generateBattleSite ────────────────────────────────────────────────────────
+/** Three evenly-spaced x spawn positions (15 m, 50 m, 85 m). */
+const SPAWN_X_Sm = [150_000, 500_000, 850_000];
+/**
+ * Generate a complete battle site for a campaign encounter.
+ *
+ * Calls `extractTerrainParams` and appends `EntryVector` entries for each
+ * attacking and defending team.
+ *
+ * Teams with more than three members reuse spawn positions (cyclic).
+ */
+export function generateBattleSite(ctx) {
+    const base = extractTerrainParams(ctx.hexType);
+    const entryVectors = [];
+    for (let i = 0; i < ctx.attackerTeamIds.length; i++) {
+        entryVectors.push({
+            teamId: ctx.attackerTeamIds[i],
+            x_Sm: SPAWN_X_Sm[i % SPAWN_X_Sm.length],
+            y_Sm: ATTACKER_SPAWN_Y_Sm,
+            facingY: 1,
+        });
+    }
+    for (let i = 0; i < ctx.defenderTeamIds.length; i++) {
+        entryVectors.push({
+            teamId: ctx.defenderTeamIds[i],
+            x_Sm: SPAWN_X_Sm[i % SPAWN_X_Sm.length],
+            y_Sm: DEFENDER_SPAWN_Y_Sm,
+            facingY: -1,
+        });
+    }
+    return { ...base, entryVectors };
+}
+// ── mergeBattleOutcome ────────────────────────────────────────────────────────
+/**
+ * Merge a completed tactical battle back into campaign state.
+ *
+ * **What this does:**
+ * - Advances `campaign.worldTime_s` by `outcome.elapsedSeconds`.
+ * - Removes entities that died in battle (`injury.dead === true`) from the
+ *   campaign entity registry, location map, and inventory map.
+ * - Copies post-battle `injury` and `condition` state onto surviving campaign
+ *   entities so wounds persist between encounters.
+ * - Transfers weapons and armour from `capturedEntityIds` to the winning
+ *   team's first surviving entity inventory (item id → count).
+ * - Appends a human-readable battle summary to `campaign.log`.
+ *
+ * Mutates `campaign` in-place.
+ */
+export function mergeBattleOutcome(campaign, outcome) {
+    campaign.worldTime_s += outcome.elapsedSeconds;
+    const { worldState, capturedEntityIds = [], winnerTeamId } = outcome;
+    let killed = 0;
+    let survived = 0;
+    for (const entity of worldState.entities) {
+        const campaignEntity = campaign.entities.get(entity.id);
+        if (campaignEntity === undefined)
+            continue; // not in this campaign
+        if (_isDead(entity)) {
+            campaign.entities.delete(entity.id);
+            campaign.entityLocations.delete(entity.id);
+            campaign.entityInventories.delete(entity.id);
+            killed++;
+        }
+        else {
+            // Carry forward post-battle wounds and psychological state
+            if (entity.injury !== undefined)
+                campaignEntity.injury = entity.injury;
+            if (entity.condition !== undefined)
+                campaignEntity.condition = entity.condition;
+            survived++;
+        }
+    }
+    // Equipment transfer: looted gear from captured/incapacitated enemies
+    if (winnerTeamId !== undefined && capturedEntityIds.length > 0) {
+        const winnerId = _firstAliveInTeam(worldState, winnerTeamId);
+        if (winnerId !== undefined) {
+            const winInv = campaign.entityInventories.get(winnerId) ?? new Map();
+            for (const capturedId of capturedEntityIds) {
+                // Carry items from campaign inventory
+                const inv = campaign.entityInventories.get(capturedId);
+                if (inv !== undefined) {
+                    for (const [itemId, count] of inv) {
+                        winInv.set(itemId, (winInv.get(itemId) ?? 0) + count);
+                    }
+                }
+                // Transfer equipped items (weapons, armour) by id
+                const capEntity = campaign.entities.get(capturedId);
+                if (capEntity !== undefined) {
+                    for (const item of capEntity.loadout.items) {
+                        winInv.set(item.id, (winInv.get(item.id) ?? 0) + 1);
+                    }
+                }
+            }
+            campaign.entityInventories.set(winnerId, winInv);
+        }
+    }
+    const outcome_note = winnerTeamId !== undefined
+        ? ` Team ${winnerTeamId} victorious.`
+        : " Draw.";
+    campaign.log.push({
+        worldTime_s: campaign.worldTime_s,
+        text: `Battle concluded (${survived} survived, ${killed} killed).${outcome_note}`,
+    });
+}
+// ── Internal helpers ──────────────────────────────────────────────────────────
+function _isDead(entity) {
+    return entity.injury?.dead === true;
+}
+function _firstAliveInTeam(world, teamId) {
+    for (const e of world.entities) {
+        if (e.teamId === teamId && !_isDead(e))
+            return e.id;
+    }
+    return undefined;
+}
+function _base() {
+    return {
+        width_Sm: FIELD_WIDTH_Sm,
+        height_Sm: FIELD_HEIGHT_Sm,
+        cellSize_Sm: CELL_SIZE_Sm,
+        terrainGrid: new Map(),
+        obstacleGrid: new Map(),
+        elevationGrid: new Map(),
+        slopeGrid: new Map(),
+        coverSegments: [],
+        dominantSurface: "normal",
+    };
+}
+function ck(col, row) {
+    return terrainKey(col, row);
+}
+/** Plains: open ground, two dirt berm defensive lines. */
+function _plains() {
+    const r = _base();
+    r.coverSegments.push(createCoverSegment("plains_berm_s", 200_000, 250_000, 600_000, 8_000, "dirt"), createCoverSegment("plains_berm_n", 200_000, 550_000, 600_000, 8_000, "dirt"));
+    return r;
+}
+/** Forest: muddy undergrowth, partial cover, two wood tree-lines flanking a central path. */
+function _forest() {
+    const r = _base();
+    r.dominantSurface = "mud";
+    const terrain = {};
+    const obstacles = {};
+    for (let col = 0; col < GRID_COLS; col++) {
+        for (let row = 0; row < GRID_ROWS; row++) {
+            const key = ck(col, row);
+            if (row !== 3 && row !== 4) { // rows 3-4 = natural path (no mud)
+                terrain[key] = "mud";
+                obstacles[key] = q(0.40); // dense undergrowth — 40% cover
+            }
+        }
+    }
+    r.terrainGrid = buildTerrainGrid(terrain);
+    r.obstacleGrid = buildObstacleGrid(obstacles);
+    // Tree-lines flanking the path (y = 25 m and y = 50 m)
+    r.coverSegments.push(createCoverSegment("forest_tree_s", 0, 250_000, 1_000_000, 12_000, "wood"), createCoverSegment("forest_tree_n", 0, 500_000, 1_000_000, 12_000, "wood"));
+    return r;
+}
+/** Hills: gradient elevation south-to-north, stone cover on the crest. */
+function _hills() {
+    const r = _base();
+    r.dominantSurface = "slope_up";
+    const terrain = {};
+    const elevation = {};
+    const slopes = {};
+    for (let col = 0; col < GRID_COLS; col++) {
+        for (let row = 0; row < GRID_ROWS; row++) {
+            const key = ck(col, row);
+            if (row < 4) {
+                // South half — uphill approach; elevation rises 5 m per row (0–15 m)
+                terrain[key] = "slope_up";
+                elevation[key] = (row * 50_000);
+                slopes[key] = { type: "uphill", grade: q(0.50) };
+            }
+            else {
+                // North half — downhill on far side of crest
+                terrain[key] = "slope_down";
+                elevation[key] = ((GRID_ROWS - 1 - row) * 50_000);
+                slopes[key] = { type: "downhill", grade: q(0.50) };
+            }
+        }
+    }
+    r.terrainGrid = buildTerrainGrid(terrain);
+    r.elevationGrid = buildElevationGrid(elevation);
+    r.slopeGrid = buildSlopeGrid(slopes);
+    // Stone wall along the ridgeline (y ≈ 40 m)
+    r.coverSegments.push(createCoverSegment("hills_ridgeline", 100_000, 400_000, 800_000, 10_000, "stone"));
+    return r;
+}
+/** Marsh: all-mud terrain, no cover — speed heavily penalised. */
+function _marsh() {
+    const r = _base();
+    r.dominantSurface = "mud";
+    const terrain = {};
+    for (let col = 0; col < GRID_COLS; col++) {
+        for (let row = 0; row < GRID_ROWS; row++) {
+            terrain[ck(col, row)] = "mud";
+        }
+    }
+    r.terrainGrid = buildTerrainGrid(terrain);
+    return r;
+}
+/** Urban: dense stone and wood cover forming a street grid; partial obstacle cells. */
+function _urban() {
+    const r = _base();
+    // Stone building walls — south block, mid block, north block
+    r.coverSegments.push(createCoverSegment("urban_s1", 0, 200_000, 350_000, 20_000, "stone"), createCoverSegment("urban_s2", 450_000, 200_000, 350_000, 20_000, "stone"), createCoverSegment("urban_s3", 200_000, 300_000, 200_000, 20_000, "stone"), createCoverSegment("urban_m1", 0, 400_000, 250_000, 20_000, "stone"), createCoverSegment("urban_m2", 350_000, 400_000, 300_000, 20_000, "stone"), createCoverSegment("urban_m3", 750_000, 400_000, 250_000, 20_000, "stone"), createCoverSegment("urban_n1", 100_000, 600_000, 350_000, 20_000, "stone"), createCoverSegment("urban_n2", 550_000, 600_000, 350_000, 20_000, "stone"), createCoverSegment("urban_barr1", 350_000, 350_000, 100_000, 10_000, "wood"), createCoverSegment("urban_barr2", 350_000, 500_000, 100_000, 10_000, "wood"));
+    // Partial obstacles in building interiors (~50% cover)
+    r.obstacleGrid = buildObstacleGrid({
+        [ck(1, 2)]: q(0.50),
+        [ck(5, 2)]: q(0.50),
+        [ck(2, 4)]: q(0.50),
+        [ck(7, 4)]: q(0.50),
+    });
+    return r;
+}
+/** Mountain: steep icy ascent, high elevation, rocky outcrops. */
+function _mountain() {
+    const r = _base();
+    r.dominantSurface = "slope_up";
+    const terrain = {};
+    const elevation = {};
+    const slopes = {};
+    for (let col = 0; col < GRID_COLS; col++) {
+        for (let row = 0; row < GRID_ROWS; row++) {
+            const key = ck(col, row);
+            elevation[key] = (row * 100_000); // 0–70 m rise
+            terrain[key] = row >= 4 ? "ice" : "slope_up";
+            slopes[key] = {
+                type: "uphill",
+                grade: (row >= 4 ? q(0.80) : q(0.60)),
+            };
+        }
+    }
+    r.terrainGrid = buildTerrainGrid(terrain);
+    r.elevationGrid = buildElevationGrid(elevation);
+    r.slopeGrid = buildSlopeGrid(slopes);
+    // Rocky outcrops for cover
+    r.coverSegments.push(createCoverSegment("mtn_rock1", 100_000, 200_000, 150_000, 15_000, "stone"), createCoverSegment("mtn_rock2", 600_000, 350_000, 200_000, 15_000, "stone"), createCoverSegment("mtn_rock3", 300_000, 500_000, 150_000, 15_000, "stone"));
+    return r;
+}
+/** River crossing: muddy ford in the center, sandbag cover on the defending bank. */
+function _riverCrossing() {
+    const r = _base();
+    r.dominantSurface = "mud";
+    // Mud band at rows 3-4 (30–50 m) — the ford
+    const terrain = {};
+    for (let col = 0; col < GRID_COLS; col++) {
+        terrain[ck(col, 3)] = "mud";
+        terrain[ck(col, 4)] = "mud";
+    }
+    r.terrainGrid = buildTerrainGrid(terrain);
+    // Sandbag defensive line on the far (north) bank
+    r.coverSegments.push(createCoverSegment("river_cover_w", 50_000, 500_000, 350_000, 12_000, "sandbag"), createCoverSegment("river_cover_e", 600_000, 500_000, 350_000, 12_000, "sandbag"));
+    return r;
+}
+/** Coastal: muddy beach approach (south 2 rows), dunes and rocky outcrops for cover. */
+function _coastal() {
+    const r = _base();
+    // Soft sand / surf zone — rows 0-1 (0–20 m from south)
+    const terrain = {};
+    for (let col = 0; col < GRID_COLS; col++) {
+        terrain[ck(col, 0)] = "mud";
+        terrain[ck(col, 1)] = "mud";
+    }
+    r.terrainGrid = buildTerrainGrid(terrain);
+    // Dunes and rocky coastal outcrops
+    r.coverSegments.push(createCoverSegment("coastal_dune1", 100_000, 150_000, 300_000, 8_000, "dirt"), createCoverSegment("coastal_dune2", 600_000, 150_000, 300_000, 8_000, "dirt"), createCoverSegment("coastal_rock1", 0, 350_000, 200_000, 12_000, "stone"), createCoverSegment("coastal_rock2", 800_000, 450_000, 200_000, 12_000, "stone"));
+    return r;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@its-not-rocket-science/ananke",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "description": "Deterministic lockstep-friendly SI-units RPG/physics core (fixed-point TS)",
   "license": "MIT",
@@ -181,6 +181,14 @@
     "./content-pack": {
       "import": "./dist/src/content-pack.js",
       "types": "./dist/src/content-pack.d.ts"
+    },
+    "./terrain-bridge": {
+      "import": "./dist/src/terrain-bridge.js",
+      "types": "./dist/src/terrain-bridge.d.ts"
+    },
+    "./atmosphere": {
+      "import": "./dist/src/atmosphere.js",
+      "types": "./dist/src/atmosphere.d.ts"
     }
   },
   "workspaces": [