@its-not-rocket-science/ananke 0.1.0

package/dist/src/sim/terrain.js

@@ -0,0 +1,141 @@
+// src/sim/terrain.ts — Phase 6: terrain friction and surface types
+import { SCALE, q } from "../units.js";
+/**
+ * Traction coefficient (Q) per surface type.
+ *
+ * Normal ground ≈ 0.80 (existing KernelContext default).
+ * Mud roughly halves usable force; ice allows only ~0.25×.
+ */
+export const SURFACE_TRACTION = {
+    normal: q(0.80),
+    mud: q(0.40), // wet/muddy: ~50 % of normal traction
+    ice: q(0.20), // icy: ~25 % of normal traction
+    slope_up: q(0.65), // uphill: harder push-off, reduced effective force
+    slope_down: q(0.90), // downhill: slightly aided but less controlled
+};
+/**
+ * Terrain speed multiplier (Q) per surface type.
+ *
+ * Applied directly to maxSprintSpeed to capture effects that traction alone
+ * does not model (viscous drag in mud, slip uncertainty on ice, grade resistance).
+ *
+ * Normal = q(1.0) (no penalty).
+ */
+export const SURFACE_SPEED_MUL = {
+    normal: q(1.00),
+    mud: q(0.60), // mud saps sprint speed: ~60 % of open-ground speed
+    ice: q(0.45), // ice: very hard to sprint without slipping (~45 %)
+    slope_up: q(0.75), // uphill grade: ~75 %
+    slope_down: q(1.10), // downhill assist: ~10 % bonus (capped in use)
+};
+/**
+ * Encode integer cell coordinates as a lookup key.
+ */
+export function terrainKey(cellX, cellY) {
+    return `${cellX},${cellY}`;
+}
+/**
+ * Decode a terrain key back into cell coordinates.
+ */
+export function parseTerrainKey(key) {
+    const [cx, cy] = key.split(",").map(Number);
+    return { cellX: cx, cellY: cy };
+}
+/**
+ * Look up the surface type at a given world position, or return undefined if
+ * the position has no terrain entry.
+ */
+function surfaceAtPosition(grid, cellSize_m, pos_x, pos_y) {
+    if (!grid || grid.size === 0)
+        return undefined;
+    const cs = Math.max(1, cellSize_m);
+    const cx = Math.trunc(pos_x / cs);
+    const cy = Math.trunc(pos_y / cs);
+    return grid.get(terrainKey(cx, cy));
+}
+/**
+ * Look up the traction coefficient at a given world position.
+ *
+ * @param grid        Terrain grid (may be undefined or empty)
+ * @param cellSize_m  Cell size in SCALE.m units (e.g. 4*SCALE.m for 4 m cells)
+ * @param pos_x       Entity x position in SCALE.m units
+ * @param pos_y       Entity y position in SCALE.m units
+ * @param defaultTraction  Fallback traction when no grid cell is found
+ * @returns Traction coefficient Q
+ */
+export function tractionAtPosition(grid, cellSize_m, pos_x, pos_y, defaultTraction) {
+    const surf = surfaceAtPosition(grid, cellSize_m, pos_x, pos_y);
+    return surf !== undefined ? SURFACE_TRACTION[surf] : defaultTraction;
+}
+/**
+ * Look up the speed multiplier at a given world position.
+ *
+ * Returns q(1.0) when the position has no terrain entry (no penalty).
+ */
+export function speedMulAtPosition(grid, cellSize_m, pos_x, pos_y) {
+    const surf = surfaceAtPosition(grid, cellSize_m, pos_x, pos_y);
+    return surf !== undefined ? SURFACE_SPEED_MUL[surf] : SCALE.Q;
+}
+/**
+ * Convenience: build a TerrainGrid from a flat record of "cx,cy" → SurfaceType.
+ */
+export function buildTerrainGrid(cells) {
+    return new Map(Object.entries(cells));
+}
+/**
+ * Look up cover fraction at a world position.
+ * Returns 0 (no cover) if the grid is absent or the cell has no entry.
+ */
+export function coverFractionAtPosition(grid, cellSize_m, pos_x, pos_y) {
+    if (!grid || grid.size === 0)
+        return 0;
+    const cs = Math.max(1, cellSize_m);
+    const cx = Math.trunc(pos_x / cs);
+    const cy = Math.trunc(pos_y / cs);
+    return (grid.get(terrainKey(cx, cy)) ?? 0);
+}
+/**
+ * Convenience: build an ObstacleGrid from a record of "cx,cy" → cover fraction Q.
+ * Use q(1.0) for impassable walls; fractional values for partial cover.
+ */
+export function buildObstacleGrid(cells) {
+    return new Map(Object.entries(cells));
+}
+/**
+ * Look up elevation (height in SCALE.m units) at a world position.
+ * Returns 0 (ground level) if the grid is absent or the cell has no entry.
+ */
+export function elevationAtPosition(grid, cellSize_m, pos_x, pos_y) {
+    if (!grid || grid.size === 0)
+        return 0;
+    const cs = Math.max(1, cellSize_m);
+    const cx = Math.trunc(pos_x / cs);
+    const cy = Math.trunc(pos_y / cs);
+    return grid.get(terrainKey(cx, cy)) ?? 0;
+}
+/**
+ * Convenience: build an ElevationGrid from a record of "cx,cy" → height (SCALE.m units).
+ */
+export function buildElevationGrid(cells) {
+    return new Map(Object.entries(cells));
+}
+/**
+ * Look up slope info at a world position.
+ * Returns undefined if the grid is absent or the cell has no entry.
+ */
+export function slopeAtPosition(grid, cellSize_m, pos_x, pos_y) {
+    if (!grid || grid.size === 0)
+        return undefined;
+    const cs = Math.max(1, cellSize_m);
+    const cx = Math.trunc(pos_x / cs);
+    const cy = Math.trunc(pos_y / cs);
+    return grid.get(terrainKey(cx, cy));
+}
+/** Convenience: build a SlopeGrid from a record of "cx,cy" → SlopeInfo. */
+export function buildSlopeGrid(cells) {
+    return new Map(Object.entries(cells));
+}
+/** Convenience: build a HazardGrid from a record of "cx,cy" → HazardCell. */
+export function buildHazardGrid(cells) {
+    return new Map(Object.entries(cells));
+}

package/dist/src/sim/testing.d.ts

@@ -0,0 +1,13 @@
+import { Weapon, type Loadout } from "../equipment.js";
+import type { Entity } from "./entity.js";
+import type { WorldState } from "./world.js";
+import { ImpactEvent } from "./events.js";
+/**
+ * Minimal humanoid entity for tests (deterministic attributes via generateIndividual()).
+ * Positions are fixed-point metres (SCALE.m).
+ */
+export declare function mkHumanoidEntity(id: number, teamId: number, x_m: number, y_m: number, z_m?: number): Entity;
+export declare function mkWorld(seed: number, entities: Entity[]): WorldState;
+/** @deprecated Pass an explicit entity array instead: mkWorld(seed, [a, b]) */
+export declare function mkWorld(seed: number, loadoutA: Loadout): WorldState;
+export declare function mkImpactEvent(attackerId: number, targetId: number, region?: string, energy_J?: number, protectedByArmour?: boolean, blocked?: boolean, parried?: boolean, weaponId?: string, wpn?: Weapon, hitQuality?: number, shieldBlocked?: boolean): ImpactEvent;

package/dist/src/sim/testing.js

@@ -0,0 +1,100 @@
+import { generateIndividual } from "../generate.js";
+import { HUMAN_BASE } from "../archetypes.js";
+import { defaultIntent } from "./intent.js";
+import { defaultAction } from "./action.js";
+import { defaultCondition } from "./condition.js";
+import { defaultInjury } from "./injury.js";
+import { v3 } from "./vec3.js";
+import { q, SCALE } from "../units.js";
+/**
+ * Minimal humanoid entity for tests (deterministic attributes via generateIndividual()).
+ * Positions are fixed-point metres (SCALE.m).
+ */
+export function mkHumanoidEntity(id, teamId, x_m, y_m, z_m = 0) {
+    const attrs = generateIndividual(id, HUMAN_BASE);
+    return {
+        id,
+        teamId,
+        attributes: attrs,
+        energy: { reserveEnergy_J: attrs.performance.reserveEnergy_J, fatigue: q(0) },
+        loadout: { items: [] },
+        traits: [],
+        position_m: v3(x_m, y_m, z_m),
+        velocity_mps: v3(0, 0, 0),
+        intent: defaultIntent(),
+        action: defaultAction(),
+        condition: defaultCondition(),
+        injury: defaultInjury(),
+        grapple: { holdingTargetId: 0, heldByIds: [], gripQ: q(0), position: "standing" },
+    };
+}
+// implementation
+export function mkWorld(seed, arg) {
+    // General form: mkWorld(seed, entities[])
+    if (Array.isArray(arg)) {
+        const entities = [...arg].sort((a, b) => a.id - b.id);
+        // Catch duplicate IDs early; they cause silent wrong results at runtime.
+        const ids = entities.map(e => e.id);
+        const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
+        if (dupes.length > 0) {
+            throw new Error(`mkWorld: duplicate entity IDs detected: ${[...new Set(dupes)].join(", ")}`);
+        }
+        return { tick: 0, seed, entities };
+    }
+    // Back-compat duel form: mkWorld(seed, loadoutA)
+    const loadoutA = (('items' in arg) ? arg : { items: [] });
+    const aAttrs = generateIndividual(1, HUMAN_BASE);
+    const bAttrs = generateIndividual(2, HUMAN_BASE);
+    return {
+        tick: 0,
+        seed,
+        entities: [
+            {
+                id: 1,
+                teamId: 1,
+                attributes: aAttrs,
+                energy: { reserveEnergy_J: aAttrs.performance.reserveEnergy_J, fatigue: q(0) },
+                loadout: loadoutA,
+                traits: [],
+                position_m: v3(0, 0, 0),
+                velocity_mps: v3(0, 0, 0),
+                intent: defaultIntent(),
+                action: defaultAction(),
+                condition: defaultCondition(),
+                injury: defaultInjury(),
+                grapple: { holdingTargetId: 0, heldByIds: [], gripQ: q(0), position: "standing" },
+            },
+            {
+                id: 2,
+                teamId: 2,
+                attributes: bAttrs,
+                energy: { reserveEnergy_J: bAttrs.performance.reserveEnergy_J, fatigue: q(0) },
+                loadout: { items: [] },
+                traits: [],
+                position_m: v3(Math.trunc(2.0 * SCALE.m), 0, 0),
+                velocity_mps: v3(0, 0, 0),
+                intent: defaultIntent(),
+                action: defaultAction(),
+                condition: defaultCondition(),
+                injury: defaultInjury(),
+                grapple: { holdingTargetId: 0, heldByIds: [], gripQ: q(0), position: "standing" },
+            },
+        ],
+    };
+}
+export function mkImpactEvent(attackerId, targetId, region = "", energy_J = 0, protectedByArmour = false, blocked = false, parried = false, weaponId = "", wpn = {}, hitQuality = q(0), shieldBlocked = false) {
+    return {
+        kind: "impact",
+        attackerId,
+        targetId,
+        region,
+        energy_J,
+        protectedByArmour,
+        blocked,
+        parried,
+        weaponId,
+        wpn,
+        hitQuality,
+        shieldBlocked,
+    };
+}

package/dist/src/sim/thermoregulation.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Phase 29 — Environmental Stress: Staged Hypothermia & Hyperthermia
+ *
+ * Core temperature model: linear Q encoding where q(0.5) = 37°C (normal body temp),
+ * 0 = 10°C, SCALE.Q = 64°C — so 1°C ≈ 185.2 Q units over the 54°C span.
+ *
+ * Heat balance (per second):
+ *   ΔT_°C = (metabolicHeat − conductiveLoss) × delta_s / thermalMass
+ *   metabolicHeat  = peakPower_W × activityFrac × (1 − EFFICIENCY)
+ *   conductiveLoss = (coreTemp_°C − ambientTemp_°C) / thermalResistance
+ *   thermalResistance = 0.09 + sum(armour.insulation_m2KW)   [°C/W]
+ *   thermalMass = (mass_kg_real) × 3500                       [J/°C]
+ */
+import { Item } from "../equipment.js";
+import { type Q } from "../units.js";
+import type { Entity } from "./entity.js";
+/** Celsius → Q-coded temperature (rounds to nearest integer). */
+export declare function cToQ(celsius: number): Q;
+/** Normal body temperature (37.0 °C). */
+export declare const CORE_TEMP_NORMAL_Q: Q;
+/** Mild hyperthermia entry (~37.8 °C). */
+export declare const CORE_TEMP_HEAT_MILD: Q;
+/** Heat exhaustion entry (~38.6 °C). */
+export declare const CORE_TEMP_HEAT_EXHAUS: Q;
+/** Heat stroke entry (~39.4 °C). */
+export declare const CORE_TEMP_HEAT_STROKE: Q;
+/** Mild hypothermia entry (~36.2 °C; below normal). */
+export declare const CORE_TEMP_HYPOTHERMIA_MILD: Q;
+/** Moderate hypothermia entry (~34.6 °C). */
+export declare const CORE_TEMP_HYPOTHERMIA_MOD: Q;
+/** Severe hypothermia entry (~33.0 °C). */
+export declare const CORE_TEMP_HYPOTHERMIA_SEVERE: Q;
+/** Helper: derive total armour insulation from loadout items. */
+export declare function sumArmourInsulation(items: Item[]): number;
+/**
+ * Compute the new core temperature Q value given explicit parameters (no entity mutation).
+ *
+ * Used by stepCoreTemp and by the downtime simulator (which does not hold an entity reference).
+ * Note: floating-point accumulation is intentional — sub-unit Q fractions accumulate correctly
+ * across successive calls since Q is stored as `number` (JS float).
+ */
+export declare function computeNewCoreQ(coreQ: number, massReal_kg: number, // real kg (entity.attributes.morphology.mass_kg / SCALE.kg)
+armourInsulation: number, isActive: boolean, // true if entity velocity ≥ 1 m/s
+ambientTemp: Q, delta_s: number): Q;
+/**
+ * Advance an entity's core temperature by `delta_s` seconds given the ambient temperature.
+ *
+ * Reads `entity.condition.coreTemp_Q` (defaults to CORE_TEMP_NORMAL_Q if absent).
+ * Writes the new value back to `entity.condition.coreTemp_Q` and returns it.
+ */
+export declare function stepCoreTemp(entity: Entity, ambientTemp: Q, // Phase 29 Q-coded temperature (same scale as coreTemp_Q)
+delta_s: number): Q;
+export interface TempModifiers {
+    /** Effective multiplier on peakPower_W for action resolution. */
+    powerMul: Q;
+    /** Penalty subtracted from controlQuality. */
+    fineControlPen: Q;
+    /** Multiplier on decision latency. */
+    latencyMul: Q;
+    /** True when temperature is in death-trajectory range. */
+    dead: boolean;
+}
+/**
+ * Derive performance modifiers from current core temperature.
+ *
+ * Stages (high → low):
+ *   > CRITICAL_HIGH  : critical hyperthermia (dead=true)
+ *   > HEAT_STROKE    : heat stroke
+ *   > HEAT_EXHAUS    : heat exhaustion
+ *   > HEAT_MILD      : mild hyperthermia
+ *   >= NORMAL        : normal
+ *   >= HYPO_MILD     : mild hypothermia
+ *   >= HYPO_MOD      : moderate hypothermia
+ *   >= HYPO_SEVERE   : severe hypothermia
+ *   < HYPO_SEVERE    : critical hypothermia (dead=true)
+ */
+export declare function deriveTempModifiers(coreTemp_Q: Q): TempModifiers;

package/dist/src/sim/thermoregulation.js

@@ -0,0 +1,161 @@
+/**
+ * Phase 29 — Environmental Stress: Staged Hypothermia & Hyperthermia
+ *
+ * Core temperature model: linear Q encoding where q(0.5) = 37°C (normal body temp),
+ * 0 = 10°C, SCALE.Q = 64°C — so 1°C ≈ 185.2 Q units over the 54°C span.
+ *
+ * Heat balance (per second):
+ *   ΔT_°C = (metabolicHeat − conductiveLoss) × delta_s / thermalMass
+ *   metabolicHeat  = peakPower_W × activityFrac × (1 − EFFICIENCY)
+ *   conductiveLoss = (coreTemp_°C − ambientTemp_°C) / thermalResistance
+ *   thermalResistance = 0.09 + sum(armour.insulation_m2KW)   [°C/W]
+ *   thermalMass = (mass_kg_real) × 3500                       [J/°C]
+ */
+import { q, SCALE } from "../units.js";
+// ── Temperature encoding helpers ──────────────────────────────────────────────
+const TEMP_MIN_C = 10; // °C at Q = 0
+const TEMP_RANGE_C = 54; // °C spanned by [0, SCALE.Q]
+/** Q-coded temperature → Celsius (floating-point, for physics calculations only). */
+function qToC(qVal) {
+    return TEMP_MIN_C + (qVal / SCALE.Q) * TEMP_RANGE_C;
+}
+/** Celsius → Q-coded temperature (rounds to nearest integer). */
+export function cToQ(celsius) {
+    return Math.round(((celsius - TEMP_MIN_C) / TEMP_RANGE_C) * SCALE.Q);
+}
+// ── Exported threshold constants ──────────────────────────────────────────────
+/** Normal body temperature (37.0 °C). */
+export const CORE_TEMP_NORMAL_Q = q(0.500);
+/** Mild hyperthermia entry (~37.8 °C). */
+export const CORE_TEMP_HEAT_MILD = q(0.515);
+/** Heat exhaustion entry (~38.6 °C). */
+export const CORE_TEMP_HEAT_EXHAUS = q(0.529);
+/** Heat stroke entry (~39.4 °C). */
+export const CORE_TEMP_HEAT_STROKE = q(0.544);
+/** Mild hypothermia entry (~36.2 °C; below normal). */
+export const CORE_TEMP_HYPOTHERMIA_MILD = q(0.485);
+/** Moderate hypothermia entry (~34.6 °C). */
+export const CORE_TEMP_HYPOTHERMIA_MOD = q(0.456);
+/** Severe hypothermia entry (~33.0 °C). */
+export const CORE_TEMP_HYPOTHERMIA_SEVERE = q(0.426);
+// Internal critical thresholds (not exported; outside the named stage range)
+const CORE_TEMP_CRITICAL_HIGH = q(0.558); // ~40.1 °C — death trajectory
+// Critical hypothermia is below HYPOTHERMIA_SEVERE (q(0.426) ≈ 33 °C)
+/** Helper: derive total armour insulation from loadout items. */
+export function sumArmourInsulation(items) {
+    let total = 0;
+    for (const item of items) {
+        if (item.kind === "armour" && item.insulation_m2KW != null)
+            total += item.insulation_m2KW;
+    }
+    return total;
+}
+// ── Metabolic heat model ──────────────────────────────────────────────────────
+//
+// Metabolic heat depends on body mass and activity level, NOT on combat peak power.
+// Using W/kg specific metabolic heat production (tissue heat output directly):
+//   Resting (BMR): ~1.06 W/kg — standard basal metabolic rate for adults
+//   Active (brisk walk/march): ~5.5 W/kg — ≈ 5 MET
+//
+// These produce ≈ 80 W and ≈ 412 W for a 75 kg human, matching real physiology.
+const REST_SPECIFIC_W = 1.06; // W / real kg — resting metabolic heat
+const ACT_SPECIFIC_W = 5.50; // W / real kg — active/marching metabolic heat
+/** Velocity threshold for "active" in SCALE.mps units (1.0 m/s). */
+const ACTIVE_VEL_THRESH = Math.trunc(1.0 * SCALE.mps); // 10000
+// ── Pure computation helper ───────────────────────────────────────────────────
+/**
+ * Compute the new core temperature Q value given explicit parameters (no entity mutation).
+ *
+ * Used by stepCoreTemp and by the downtime simulator (which does not hold an entity reference).
+ * Note: floating-point accumulation is intentional — sub-unit Q fractions accumulate correctly
+ * across successive calls since Q is stored as `number` (JS float).
+ */
+export function computeNewCoreQ(coreQ, massReal_kg, // real kg (entity.attributes.morphology.mass_kg / SCALE.kg)
+armourInsulation, isActive, // true if entity velocity ≥ 1 m/s
+ambientTemp, delta_s) {
+    if (massReal_kg <= 0)
+        return coreQ;
+    const coreC = qToC(coreQ);
+    const ambC = qToC(ambientTemp);
+    // Metabolic heat: mass-proportional (independent of combat peak power)
+    const specificW = isActive ? ACT_SPECIFIC_W : REST_SPECIFIC_W;
+    const metabolicHeat = massReal_kg * specificW; // W
+    const thermalResistance = 0.09 + armourInsulation; // °C/W
+    const thermalMass = massReal_kg * 3500; // J/°C
+    const conductiveLoss = (coreC - ambC) / thermalResistance; // W
+    const deltaTc = (metabolicHeat - conductiveLoss) * delta_s / thermalMass; // °C
+    const deltaTq = (deltaTc / TEMP_RANGE_C) * SCALE.Q; // fractional Q
+    return Math.max(0, Math.min(SCALE.Q, coreQ + deltaTq));
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Advance an entity's core temperature by `delta_s` seconds given the ambient temperature.
+ *
+ * Reads `entity.condition.coreTemp_Q` (defaults to CORE_TEMP_NORMAL_Q if absent).
+ * Writes the new value back to `entity.condition.coreTemp_Q` and returns it.
+ */
+export function stepCoreTemp(entity, ambientTemp, // Phase 29 Q-coded temperature (same scale as coreTemp_Q)
+delta_s) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cond = entity.condition;
+    const coreQ = cond.coreTemp_Q ?? CORE_TEMP_NORMAL_Q;
+    const mReal = entity.attributes.morphology.mass_kg / SCALE.kg;
+    const insul = sumArmourInsulation(entity.loadout.items)
+        + (entity.physiology?.naturalInsulation_m2KW ?? 0);
+    const vx = entity.velocity_mps.x;
+    const vy = entity.velocity_mps.y;
+    const vMag = Math.sqrt(vx * vx + vy * vy);
+    const newCoreQ = computeNewCoreQ(coreQ, mReal, insul, vMag >= ACTIVE_VEL_THRESH, ambientTemp, delta_s);
+    cond.coreTemp_Q = newCoreQ;
+    return newCoreQ;
+}
+/**
+ * Derive performance modifiers from current core temperature.
+ *
+ * Stages (high → low):
+ *   > CRITICAL_HIGH  : critical hyperthermia (dead=true)
+ *   > HEAT_STROKE    : heat stroke
+ *   > HEAT_EXHAUS    : heat exhaustion
+ *   > HEAT_MILD      : mild hyperthermia
+ *   >= NORMAL        : normal
+ *   >= HYPO_MILD     : mild hypothermia
+ *   >= HYPO_MOD      : moderate hypothermia
+ *   >= HYPO_SEVERE   : severe hypothermia
+ *   < HYPO_SEVERE    : critical hypothermia (dead=true)
+ */
+export function deriveTempModifiers(coreTemp_Q) {
+    if (coreTemp_Q >= CORE_TEMP_CRITICAL_HIGH) {
+        // Critical hyperthermia (> ~40°C) — death trajectory
+        return { powerMul: q(0.60), fineControlPen: q(0.30), latencyMul: q(3.0), dead: true };
+    }
+    if (coreTemp_Q >= CORE_TEMP_HEAT_STROKE) {
+        // Heat stroke (~39–40°C) — −40% power, decision latency ×2
+        return { powerMul: q(0.60), fineControlPen: q(0.20), latencyMul: q(2.0), dead: false };
+    }
+    if (coreTemp_Q >= CORE_TEMP_HEAT_EXHAUS) {
+        // Heat exhaustion (~38.6–39.4°C) — −15% power, fine control penalty
+        return { powerMul: q(0.85), fineControlPen: q(0.10), latencyMul: q(1.0), dead: false };
+    }
+    if (coreTemp_Q >= CORE_TEMP_HEAT_MILD) {
+        // Mild hyperthermia (~37.8–38.6°C) — −5% power
+        return { powerMul: q(0.95), fineControlPen: q(0), latencyMul: q(1.0), dead: false };
+    }
+    if (coreTemp_Q >= CORE_TEMP_NORMAL_Q) {
+        // Normal (37.0–37.8°C)
+        return { powerMul: q(1.0), fineControlPen: q(0), latencyMul: q(1.0), dead: false };
+    }
+    if (coreTemp_Q >= CORE_TEMP_HYPOTHERMIA_MILD) {
+        // Mild hypothermia (~36.2–37.0°C) — shivering, −5% power
+        return { powerMul: q(0.95), fineControlPen: q(0.05), latencyMul: q(1.0), dead: false };
+    }
+    if (coreTemp_Q >= CORE_TEMP_HYPOTHERMIA_MOD) {
+        // Moderate hypothermia (~34.6–36.2°C) — −20% power, reaction time +20%
+        return { powerMul: q(0.80), fineControlPen: q(0.15), latencyMul: q(1.2), dead: false };
+    }
+    if (coreTemp_Q >= CORE_TEMP_HYPOTHERMIA_SEVERE) {
+        // Severe hypothermia (~33.0–34.6°C) — −50% power, decision latency ×3
+        return { powerMul: q(0.50), fineControlPen: q(0.20), latencyMul: q(3.0), dead: false };
+    }
+    // Critical hypothermia (< ~33°C) — cardiac arrest, death trajectory
+    return { powerMul: q(0.50), fineControlPen: q(0.30), latencyMul: q(4.0), dead: true };
+}

package/dist/src/sim/tick.d.ts

@@ -0,0 +1,3 @@
+import { I32 } from "../units.js";
+export declare const TICK_HZ = 20;
+export declare const DT_S: I32;

package/dist/src/sim/tick.js

@@ -0,0 +1,3 @@
+import { to } from "../units.js";
+export const TICK_HZ = 20; // Hz (good for tactical combat)
+export const DT_S = to.s(1 / TICK_HZ); // seconds per tick

package/dist/src/sim/toxicology.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Phase 32C — Venom & Chemical Injection
+ *
+ * Models wound-injection venom: onset delay, per-second internal damage and fear
+ * accumulation, duration, and antidote clearance.
+ *
+ * Follows the 1 Hz accumulator pattern from Phase 30 (nutrition). Called from the
+ * kernel's __nutritionAccum gate and from downtime.ts per-second loop.
+ */
+import { type Q } from "../units.js";
+import type { Entity } from "./entity.js";
+export interface VenomProfile {
+    id: string;
+    name: string;
+    /** Seconds before symptoms begin (onset latency). */
+    onsetDelay_s: number;
+    /** Per-second internal damage as Q fraction of max internal health. */
+    damageRate_Q: Q;
+    /** Per-second fear increment while symptomatic. */
+    fearRate_Q: Q;
+    /** Total duration without antidote [seconds]. */
+    duration_s: number;
+    /** Antidote consumable id (matches a FOOD_ITEMS entry or equipment catalogue item). */
+    antidoteId?: string;
+}
+export interface ActiveVenom {
+    profile: VenomProfile;
+    /** Accumulated seconds since injection (includes pre-onset time). */
+    elapsedSeconds: number;
+}
+export declare const VENOM_PROFILES: readonly VenomProfile[];
+/** Look up a VenomProfile by id. Returns undefined if unknown. */
+export declare function getVenomProfile(id: string): VenomProfile | undefined;
+/**
+ * Advance all active venoms on an entity by `delta_s` seconds.
+ *
+ * Mutates:
+ *   entity.activeVenoms (elapsedSeconds incremented; expired entries removed)
+ *   entity.injury (torso internalDamage incremented per symptomatic venom)
+ *   entity.condition.fearQ (incremented per symptomatic venom)
+ */
+export declare function stepToxicology(entity: Entity, delta_s: number): void;
+/**
+ * Inject a venom into an entity by profile id.
+ * Returns false if the id is unknown.
+ */
+export declare function injectVenom(entity: Entity, venomId: string): boolean;
+/**
+ * Apply an antidote, clearing all active venoms that list the given item id.
+ * Returns true if at least one venom was cleared.
+ */
+export declare function applyAntidote(entity: Entity, antidoteId: string): boolean;

package/dist/src/sim/toxicology.js

@@ -0,0 +1,104 @@
+/**
+ * Phase 32C — Venom & Chemical Injection
+ *
+ * Models wound-injection venom: onset delay, per-second internal damage and fear
+ * accumulation, duration, and antidote clearance.
+ *
+ * Follows the 1 Hz accumulator pattern from Phase 30 (nutrition). Called from the
+ * kernel's __nutritionAccum gate and from downtime.ts per-second loop.
+ */
+import { q, SCALE, clampQ } from "../units.js";
+// ── Venom catalogue ───────────────────────────────────────────────────────────
+export const VENOM_PROFILES = [
+    {
+        id: "venom_insect",
+        name: "Insect venom",
+        onsetDelay_s: 30,
+        damageRate_Q: q(0.008), // ~0.08% max internal/s → lethal in ~200s without aid
+        fearRate_Q: q(0.005),
+        duration_s: 300,
+    },
+    {
+        id: "venom_snake",
+        name: "Serpent venom",
+        onsetDelay_s: 60,
+        damageRate_Q: q(0.012), // ~0.12% max internal/s → lethal in ~140s without aid
+        fearRate_Q: q(0.010),
+        duration_s: 600,
+        antidoteId: "antivenom",
+    },
+    {
+        id: "venom_paralytic",
+        name: "Paralytic toxin",
+        onsetDelay_s: 10,
+        damageRate_Q: q(0.003), // low damage, but high fear and rapid onset
+        fearRate_Q: q(0.020),
+        duration_s: 120,
+        antidoteId: "antivenom",
+    },
+];
+const VENOM_BY_ID = new Map(VENOM_PROFILES.map(v => [v.id, v]));
+/** Look up a VenomProfile by id. Returns undefined if unknown. */
+export function getVenomProfile(id) {
+    return VENOM_BY_ID.get(id);
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Advance all active venoms on an entity by `delta_s` seconds.
+ *
+ * Mutates:
+ *   entity.activeVenoms (elapsedSeconds incremented; expired entries removed)
+ *   entity.injury (torso internalDamage incremented per symptomatic venom)
+ *   entity.condition.fearQ (incremented per symptomatic venom)
+ */
+export function stepToxicology(entity, delta_s) {
+    const venoms = entity.activeVenoms;
+    if (!venoms || venoms.length === 0)
+        return;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cond = entity.condition;
+    const torsoRegion = entity.injury.byRegion?.["torso"];
+    for (const av of venoms) {
+        av.elapsedSeconds += delta_s;
+        if (av.elapsedSeconds < av.profile.onsetDelay_s)
+            continue; // still pre-onset
+        // Internal damage to torso (if body plan has torso; otherwise apply to shock)
+        const dmgInc = Math.trunc(av.profile.damageRate_Q * delta_s);
+        if (torsoRegion !== undefined) {
+            torsoRegion.internalDamage = clampQ((torsoRegion.internalDamage + dmgInc), q(0), q(1.0));
+        }
+        else {
+            // Fallback: apply as shock when no torso region
+            entity.injury.shock = clampQ((entity.injury.shock + dmgInc), q(0), q(1.0));
+        }
+        // Fear increment
+        const fearInc = Math.trunc(av.profile.fearRate_Q * delta_s);
+        cond.fearQ = clampQ((cond.fearQ + fearInc), q(0), SCALE.Q);
+    }
+    // Remove expired entries
+    entity.activeVenoms = venoms.filter(av => av.elapsedSeconds < av.profile.duration_s);
+}
+/**
+ * Inject a venom into an entity by profile id.
+ * Returns false if the id is unknown.
+ */
+export function injectVenom(entity, venomId) {
+    const profile = VENOM_BY_ID.get(venomId);
+    if (!profile)
+        return false;
+    if (!entity.activeVenoms)
+        entity.activeVenoms = [];
+    entity.activeVenoms.push({ profile, elapsedSeconds: 0 });
+    return true;
+}
+/**
+ * Apply an antidote, clearing all active venoms that list the given item id.
+ * Returns true if at least one venom was cleared.
+ */
+export function applyAntidote(entity, antidoteId) {
+    if (!entity.activeVenoms || entity.activeVenoms.length === 0)
+        return false;
+    const before = entity.activeVenoms.length;
+    entity.activeVenoms = entity.activeVenoms.filter(av => av.profile.antidoteId !== antidoteId);
+    return entity.activeVenoms.length < before;
+}