@its-not-rocket-science/ananke 0.1.0

package/dist/src/sim/step/capability.js

@@ -0,0 +1,77 @@
+import { terrainKey } from "../terrain.js";
+import { DT_S } from "../tick.js";
+import { SCALE } from "../../units.js";
+/**
+ * Per-entity per-tick regen of all capability sources.
+ * Called after stepMovement so velocity is current.
+ */
+export function stepCapabilitySources(e, world, ctx) {
+    if (!e.capabilitySources)
+        return;
+    const cellSize_m = ctx.cellSize_m ?? Math.trunc(4 * SCALE.m);
+    for (const source of e.capabilitySources) {
+        const model = source.regenModel;
+        if (model.type === "boundless")
+            continue;
+        let regenRate_W = 0;
+        switch (model.type) {
+            case "constant":
+                regenRate_W = model.regenRate_W;
+                break;
+            case "rest": {
+                const speedAbs = Math.max(Math.abs(e.velocity_mps.x), Math.abs(e.velocity_mps.y));
+                const isResting = speedAbs <= Math.trunc(0.05 * SCALE.mps) && e.action.attackCooldownTicks === 0;
+                if (isResting)
+                    regenRate_W = model.regenRate_W;
+                break;
+            }
+            case "ambient": {
+                const cx = Math.trunc(e.position_m.x / cellSize_m);
+                const cy = Math.trunc(e.position_m.y / cellSize_m);
+                const key = terrainKey(cx, cy);
+                const ambientVal = ctx.ambientGrid?.get(key) ?? 0;
+                if (ambientVal > 0) {
+                    regenRate_W = Math.trunc(model.maxRate_W * ambientVal / SCALE.Q);
+                }
+                break;
+            }
+            case "event": {
+                for (const trigger of model.triggers) {
+                    if (trigger.on === "tick") {
+                        if (trigger._nextTick === undefined)
+                            trigger._nextTick = world.tick + trigger.every_n;
+                        if (world.tick >= trigger._nextTick) {
+                            source.reserve_J = Math.min(source.maxReserve_J, source.reserve_J + trigger.amount_J);
+                            trigger._nextTick = world.tick + trigger.every_n;
+                        }
+                    }
+                    // kill triggers dispatched by kernel death-detection loop; terrain triggers below
+                }
+                break;
+            }
+        }
+        if (regenRate_W > 0) {
+            const regenThisTick = Math.trunc(regenRate_W * DT_S / SCALE.s);
+            source.reserve_J = Math.min(source.maxReserve_J, source.reserve_J + regenThisTick);
+        }
+    }
+    // Phase 12B: terrain-entry triggers — fire once per cell-boundary crossing
+    if (ctx.terrainTagGrid) {
+        const cx = Math.trunc(e.position_m.x / cellSize_m);
+        const cy = Math.trunc(e.position_m.y / cellSize_m);
+        const currentKey = terrainKey(cx, cy);
+        if (currentKey !== e.action.lastCellKey) {
+            const tags = ctx.terrainTagGrid.get(currentKey) ?? [];
+            for (const source of e.capabilitySources) {
+                if (source.regenModel.type !== "event")
+                    continue;
+                for (const trig of source.regenModel.triggers) {
+                    if (trig.on === "terrain" && tags.includes(trig.tag)) {
+                        source.reserve_J = Math.min(source.maxReserve_J, source.reserve_J + trig.amount_J);
+                    }
+                }
+            }
+        }
+        e.action.lastCellKey = currentKey;
+    }
+}

package/dist/src/sim/step/concentration.d.ts

@@ -0,0 +1,9 @@
+import type { WorldState } from "../world.js";
+import type { TraceSink } from "../trace.js";
+import type { Entity } from "../entity.js";
+/**
+ * Phase 12B: advance a concentration aura for one tick.
+ * Deducts cost_J from the source and applies the effect payload.
+ * Clears activeConcentration if reserve is exhausted or entity is shocked.
+ */
+export declare function stepConcentration(e: Entity, world: WorldState, trace: TraceSink, tick: number): void;

package/dist/src/sim/step/concentration.js

@@ -0,0 +1,25 @@
+import { applyCapabilityEffect } from "../kernel.js";
+import { TraceKinds } from "../kinds.js";
+import { q } from "../../units.js";
+/**
+ * Phase 12B: advance a concentration aura for one tick.
+ * Deducts cost_J from the source and applies the effect payload.
+ * Clears activeConcentration if reserve is exhausted or entity is shocked.
+ */
+export function stepConcentration(e, world, trace, tick) {
+    const { sourceId, effectId, targetId } = e.activeConcentration;
+    const source = e.capabilitySources?.find(s => s.id === sourceId);
+    const effect = source?.effects.find(ef => ef.id === effectId);
+    const isBoundless = source?.regenModel.type === "boundless";
+    const interrupted = !source || !effect ||
+        (!isBoundless && source.reserve_J < effect.cost_J) ||
+        e.injury.shock >= q(0.30);
+    if (interrupted) {
+        delete e.activeConcentration;
+        trace.onEvent({ kind: TraceKinds.CastInterrupted, tick, entityId: e.id });
+        return;
+    }
+    if (!isBoundless)
+        source.reserve_J -= effect.cost_J;
+    applyCapabilityEffect(world, e, targetId, effect, trace, tick);
+}

package/dist/src/sim/step/effects.d.ts

@@ -0,0 +1,17 @@
+import type { Entity } from "../entity.js";
+import type { WorldState } from "../world.js";
+import type { TraceSink } from "../trace.js";
+import { I32 } from "../../units.js";
+import { HazardGrid } from "../terrain.js";
+/**
+ * Phase 12B effect chains: apply chainPayload from each active FieldEffect to every
+ * living entity within its radius. Runs before expiry so the final tick still fires.
+ */
+export declare function stepChainEffects(world: WorldState, trace: TraceSink, tick: number): void;
+/**
+ * Decrement duration on timed field effects; remove expired ones.
+ * Permanent effects (duration_ticks === -1) are never removed.
+ */
+export declare function stepFieldEffects(world: WorldState): void;
+export declare function stepHazardEffects_legacy(entities: Entity[], grid: HazardGrid, cellSize_m: I32): void;
+export declare function stepHazardEffects(entities: readonly Entity[], grid: HazardGrid, cellSize_m: I32): void;

package/dist/src/sim/step/effects.js

@@ -0,0 +1,96 @@
+import { terrainKey } from "../terrain.js";
+import { applyHazardDamage } from "./hazards.js";
+import { applyPayload } from "../kernel.js";
+/**
+ * Phase 12B effect chains: apply chainPayload from each active FieldEffect to every
+ * living entity within its radius. Runs before expiry so the final tick still fires.
+ */
+export function stepChainEffects(world, trace, tick) {
+    if (!world.activeFieldEffects?.length)
+        return;
+    for (const fe of world.activeFieldEffects) {
+        if (!fe.chainPayload)
+            continue;
+        const actor = world.entities.find(e => e.id === fe.placedByEntityId);
+        if (!actor)
+            continue;
+        const payloads = Array.isArray(fe.chainPayload)
+            ? fe.chainPayload
+            : [fe.chainPayload];
+        const radSq = fe.radius_m * fe.radius_m;
+        for (const target of world.entities) {
+            if (target.injury.dead)
+                continue;
+            const dx = target.position_m.x - fe.origin.x;
+            const dy = target.position_m.y - fe.origin.y;
+            if (dx * dx + dy * dy > radSq)
+                continue;
+            for (const p of payloads) {
+                applyPayload(world, actor, target, p, trace, tick, fe.id);
+            }
+        }
+    }
+}
+/**
+ * Decrement duration on timed field effects; remove expired ones.
+ * Permanent effects (duration_ticks === -1) are never removed.
+ */
+export function stepFieldEffects(world) {
+    if (!world.activeFieldEffects?.length)
+        return;
+    world.activeFieldEffects = world.activeFieldEffects.filter(fe => {
+        if (fe.duration_ticks < 0)
+            return true; // permanent
+        fe.duration_ticks -= 1;
+        return fe.duration_ticks > 0;
+    });
+}
+export function stepHazardEffects_legacy(entities, grid, cellSize_m) {
+    const cs = Math.max(1, cellSize_m);
+    for (const e of entities) {
+        if (e.injury.dead)
+            continue;
+        const cx = Math.trunc(e.position_m.x / cs);
+        const cy = Math.trunc(e.position_m.y / cs);
+        const key = terrainKey(cx, cy);
+        const hazard = grid.get(key);
+        if (!hazard)
+            continue;
+        if (hazard.intensity > 0) {
+            applyHazardDamage(e, hazard);
+        }
+        if (hazard.duration_ticks > 0) {
+            hazard.duration_ticks -= 1;
+            if (hazard.duration_ticks === 0) {
+                grid.delete(key);
+            }
+        }
+    }
+}
+function hazardKeyForEntity(e, cellSize_m) {
+    const cx = Math.floor(e.position_m.x / cellSize_m);
+    const cy = Math.floor(e.position_m.y / cellSize_m);
+    return terrainKey(cx, cy);
+}
+export function stepHazardEffects(entities, grid, cellSize_m) {
+    // 1) Apply hazards to entities (no duration ticking here)
+    for (const e of entities) {
+        const key = hazardKeyForEntity(e, cellSize_m); // <-- replace with your actual key computation
+        const hazard = grid.get(key);
+        if (!hazard)
+            continue;
+        applyHazardDamage(e, hazard); // <-- replace with your actual application call(s)
+    }
+    // 2) Tick/expire hazards once per cell per tick
+    // Collect keys first to avoid mutating the map while iterating it.
+    const keysToDelete = [];
+    for (const [key, hazard] of grid) {
+        if (hazard.duration_ticks > 0) {
+            hazard.duration_ticks -= 1;
+            if (hazard.duration_ticks === 0)
+                keysToDelete.push(key);
+        }
+    }
+    for (const key of keysToDelete)
+        grid.delete(key);
+}

package/dist/src/sim/step/energy.d.ts

@@ -0,0 +1,3 @@
+import type { KernelContext } from "../context.js";
+import type { Entity } from "../entity.js";
+export declare function stepEnergy(e: Entity, ctx: KernelContext): void;

package/dist/src/sim/step/energy.js

@@ -0,0 +1,31 @@
+import { DT_S } from "../tick.js";
+import { q, qMul, clampQ, mulDiv, SCALE } from "../../units.js";
+import { stepEnergyAndFatigue } from "../../derive.js";
+import { getSkill } from "../skills.js";
+import { findExoskeleton } from "../../equipment.js";
+export function stepEnergy(e, ctx) {
+    const BASE_IDLE_W = 80;
+    const speedAbs = Math.max(Math.abs(e.velocity_mps.x), Math.abs(e.velocity_mps.y), Math.abs(e.velocity_mps.z));
+    const moving = speedAbs > Math.trunc(0.05 * SCALE.mps);
+    // Phase 11: powered exoskeleton adds continuous power draw to metabolic demand
+    const exoForEnergy = findExoskeleton(e.loadout);
+    // Phase 8B: flight increases stamina demand when entity is airborne
+    const flightSpecE = e.bodyPlan?.locomotion.flight;
+    const isFlying = flightSpecE !== undefined && e.attributes.morphology.mass_kg <= flightSpecE.liftCapacity_kg;
+    const flightDemandMul = (isFlying && moving) ? flightSpecE.flightStaminaCost : SCALE.Q;
+    const baseDemand = (moving ? 250 : BASE_IDLE_W) + (exoForEnergy ? exoForEnergy.powerDrain_W : 0);
+    const demand = mulDiv(baseDemand, flightDemandMul, SCALE.Q);
+    const fatigueBefore = e.energy.fatigue;
+    stepEnergyAndFatigue(e.attributes, e.energy, e.loadout, demand, DT_S, { tractionCoeff: ctx.tractionCoeff });
+    // Phase 7: athleticism.fatigueRateMul reduces fatigue accumulation each tick
+    const fatigueDelta = e.energy.fatigue - fatigueBefore;
+    if (fatigueDelta > 0) {
+        const athSkill = getSkill(e.skills, "athleticism");
+        if (athSkill.fatigueRateMul < SCALE.Q) {
+            e.energy.fatigue = clampQ((fatigueBefore + qMul(fatigueDelta, athSkill.fatigueRateMul)), 0, SCALE.Q);
+        }
+    }
+    if (!moving && e.injury.shock < q(0.4)) {
+        e.energy.fatigue = clampQ(e.energy.fatigue - q(0.0020), 0, SCALE.Q);
+    }
+}

package/dist/src/sim/step/hazards.d.ts

@@ -0,0 +1,4 @@
+import type { Entity } from "../entity.js";
+import type { HazardCell } from "../terrain.js";
+/** Apply a single hazard cell's per-tick effect to an entity. */
+export declare function applyHazardDamage(e: Entity, hazard: HazardCell): void;

package/dist/src/sim/step/hazards.js

@@ -0,0 +1,19 @@
+import { SCALE, q, clampQ, qMul } from "../../units.js";
+/** Apply a single hazard cell's per-tick effect to an entity. */
+export function applyHazardDamage(e, hazard) {
+    const torso = e.injury.byRegion["torso"];
+    if (!torso)
+        return;
+    const intensity = hazard.intensity;
+    if (hazard.type === "fire") {
+        torso.surfaceDamage = clampQ(torso.surfaceDamage + qMul(intensity, q(0.003)), 0, SCALE.Q);
+        e.injury.shock = clampQ(e.injury.shock + qMul(intensity, q(0.005)), 0, SCALE.Q);
+    }
+    else if (hazard.type === "radiation") {
+        torso.internalDamage = clampQ(torso.internalDamage + qMul(intensity, q(0.004)), 0, SCALE.Q);
+    }
+    else if (hazard.type === "poison_gas") {
+        torso.internalDamage = clampQ(torso.internalDamage + qMul(intensity, q(0.002)), 0, SCALE.Q);
+        e.injury.consciousness = clampQ(e.injury.consciousness - qMul(intensity, q(0.003)), 0, SCALE.Q);
+    }
+}

package/dist/src/sim/step/injury.d.ts

@@ -0,0 +1,10 @@
+import type { Entity } from "../entity.js";
+import type { WorldState } from "../world.js";
+import { type Q } from "../../units.js";
+export declare const SHOCK_FROM_FLUID: number;
+export declare const SHOCK_FROM_INTERNAL: number;
+export declare const CONSC_LOSS_FROM_SHOCK: number;
+export declare const CONSC_LOSS_FROM_SUFF: number;
+export declare const FATAL_FLUID_LOSS: Q;
+export declare function stepConditionsToInjury(e: Entity, world: WorldState, ambientTemperature_Q?: Q): void;
+export declare function stepInjuryProgression(e: Entity, tick: number): void;

package/dist/src/sim/step/injury.js

@@ -0,0 +1,353 @@
+import { q, clampQ, qMul, mulDiv, SCALE } from "../../units.js";
+import { buildTraitProfile } from "../../traits.js";
+import { deriveArmourProfile } from "../../equipment.js";
+import { ALL_REGIONS, DEFAULT_REGION_WEIGHTS } from "../body.js";
+import { getExposureWeight } from "../bodyplan.js";
+import { DamageChannel } from "../../channels.js";
+import { armourCoversHit } from "../kernel.js";
+import { regionKOFactor, totalBleedingRate } from "../injury.js";
+import { getSkill } from "../skills.js";
+import { v3 } from "../vec3.js";
+import { TICK_HZ, DT_S } from "../tick.js";
+/* ------------------ Conditions -> injury (armour-aware) ------------------ */
+export const SHOCK_FROM_FLUID = q(0.0040);
+export const SHOCK_FROM_INTERNAL = q(0.0020);
+export const CONSC_LOSS_FROM_SHOCK = q(0.0100);
+export const CONSC_LOSS_FROM_SUFF = q(0.0200);
+export const FATAL_FLUID_LOSS = q(0.80);
+export function stepConditionsToInjury(e, world, ambientTemperature_Q) {
+    const traitProfile = buildTraitProfile(e.traits);
+    const armour = deriveArmourProfile(e.loadout);
+    // Phase 8: use body plan segments when available; fall back to humanoid defaults.
+    const planSegments = e.bodyPlan?.segments ?? null;
+    // Exposure weights: "what tends to be exposed" for systemic hazards.
+    const exposureWeights = (channel) => {
+        if (planSegments) {
+            // Data-driven: per-segment per-channel weights from body plan
+            const out = {};
+            for (const seg of planSegments)
+                out[seg.id] = getExposureWeight(seg, channel);
+            return out;
+        }
+        // Humanoid fallback
+        switch (channel) {
+            case DamageChannel.Thermal:
+                // Fire: limbs tend to be exposed and catch/keep burning; torso often partly shielded.
+                return {
+                    head: q(0.18),
+                    torso: q(0.28),
+                    leftArm: q(0.14),
+                    rightArm: q(0.14),
+                    leftLeg: q(0.13),
+                    rightLeg: q(0.13),
+                };
+            case DamageChannel.Chemical:
+                // Chemical/corrosive aerosols: more even, but torso still prominent.
+                // Note: condition.corrosiveExposure feeds this channel — Chemical and
+                // Corrosive are unified here. DamageChannel.Corrosive is reserved for
+                // future liquid-contact mechanics with a distinct distribution profile.
+                return {
+                    head: q(0.16),
+                    torso: q(0.36),
+                    leftArm: q(0.12),
+                    rightArm: q(0.12),
+                    leftLeg: q(0.12),
+                    rightLeg: q(0.12),
+                };
+            case DamageChannel.Radiation:
+                // Penetrating radiation: roughly proportional to mass (torso dominant).
+                return {
+                    head: q(0.12),
+                    torso: q(0.52),
+                    leftArm: q(0.09),
+                    rightArm: q(0.09),
+                    leftLeg: q(0.09),
+                    rightLeg: q(0.09),
+                };
+            case DamageChannel.Electrical:
+                // Conductive contact often through extremities.
+                return {
+                    head: q(0.10),
+                    torso: q(0.22),
+                    leftArm: q(0.22),
+                    rightArm: q(0.22),
+                    leftLeg: q(0.12),
+                    rightLeg: q(0.12),
+                };
+            default:
+                // Fallback: assume proportional to area.
+                return DEFAULT_REGION_WEIGHTS;
+        }
+    };
+    const applyDoseToRegion = (channel, region, dose) => {
+        if (dose <= 0)
+            return q(0);
+        if ((traitProfile.immuneMask & (1 << channel)) !== 0)
+            return q(0);
+        let out = dose;
+        if ((traitProfile.resistantMask & (1 << channel)) !== 0)
+            out = Math.trunc(out / 2);
+        const cov = (armour.coverageByRegion)[region] ?? q(0);
+        const armCovers = armourCoversHit(world, cov, e.id, (e.id ^ 0xBEEF) + (channel << 8) + regionSalt(region));
+        if (armCovers && ((armour.protects & (1 << channel)) !== 0)) {
+            const mul = armour.channelResistMul[channel] ?? q(1.0);
+            // A simple "resist factor" curve; for non-kinetic we treat resist_J as a generalised protective capacity.
+            const resistFactor = clampQ(q(1.0) - (mulDiv(Math.min(armour.resist_J, 800) * SCALE.Q, 1, 800)), q(0.20), q(1.0));
+            out = qMul(qMul(out, resistFactor), armour.protectedDamageMul);
+            out = qMul(out, mul);
+        }
+        return out;
+    };
+    const distribute = (channel, dose) => {
+        const w = exposureWeights(channel);
+        const out = {};
+        const regionList = planSegments ? planSegments.map(s => s.id) : ALL_REGIONS;
+        for (const r of regionList)
+            out[r] = qMul(dose, w[r] ?? q(0));
+        return out;
+    };
+    const fireBy = distribute(DamageChannel.Thermal, e.condition.onFire);
+    const corrBy = distribute(DamageChannel.Chemical, e.condition.corrosiveExposure);
+    const elecBy = distribute(DamageChannel.Electrical, e.condition.electricalOverload);
+    const radBy = distribute(DamageChannel.Radiation, e.condition.radiation);
+    // Suffocation is global rather than surface-localised.
+    const suff = (() => {
+        if ((traitProfile.immuneMask & (1 << DamageChannel.Suffocation)) !== 0)
+            return q(0);
+        let out = e.condition.suffocation;
+        if ((traitProfile.resistantMask & (1 << DamageChannel.Suffocation)) !== 0)
+            out = Math.trunc(out / 2);
+        // Simple: masks/helmets reduce suffocation slightly if they protect Suffocation.
+        const armCovers = armourCoversHit(world, (armour.coverageByRegion)["head"] ?? q(0), e.id, e.id ^ 0x5AFF);
+        if (armCovers && ((armour.protects & (1 << DamageChannel.Suffocation)) !== 0)) {
+            out = qMul(out, armour.protectedDamageMul);
+        }
+        return out;
+    })();
+    const FIRE_SURFACE_PER_TICK = q(0.0020);
+    const FIRE_SHOCK_PER_TICK = q(0.0010);
+    const CORR_SURFACE_PER_TICK = q(0.0015);
+    const CORR_INTERNAL_PER_TICK = q(0.0008);
+    const SUFF_SHOCK_PER_TICK = q(0.0015);
+    const ELEC_INTERNAL_PER_TICK = q(0.0010);
+    const ELEC_STUNNED_RISE = q(0.0200);
+    // Radiation: primary effect is internal cellular damage accumulating slowly.
+    // Rate calibrated so continuous exposure at q(1.0) reaches ~50% internal
+    // damage on the torso (highest-weight region) after ~250 ticks (12.5 s).
+    const RAD_INTERNAL_PER_TICK = q(0.0008);
+    const RAD_SHOCK_PER_TICK = q(0.0003);
+    const allRegionIds = planSegments ? planSegments.map(s => s.id) : ALL_REGIONS;
+    for (const r of allRegionIds) {
+        const fire = applyDoseToRegion(DamageChannel.Thermal, r, fireBy[r] ?? q(0));
+        const corr = applyDoseToRegion(DamageChannel.Chemical, r, corrBy[r] ?? q(0));
+        const elec = applyDoseToRegion(DamageChannel.Electrical, r, elecBy[r] ?? q(0));
+        const rad = applyDoseToRegion(DamageChannel.Radiation, r, radBy[r] ?? q(0));
+        const reg = e.injury.byRegion[r];
+        if (!reg)
+            continue;
+        if (fire > 0) {
+            reg.surfaceDamage = clampQ(reg.surfaceDamage + qMul(fire, FIRE_SURFACE_PER_TICK), 0, SCALE.Q);
+            e.injury.shock = clampQ(e.injury.shock + qMul(fire, FIRE_SHOCK_PER_TICK), 0, SCALE.Q);
+        }
+        if (corr > 0) {
+            reg.surfaceDamage = clampQ(reg.surfaceDamage + qMul(corr, CORR_SURFACE_PER_TICK), 0, SCALE.Q);
+            reg.internalDamage = clampQ(reg.internalDamage + qMul(corr, CORR_INTERNAL_PER_TICK), 0, SCALE.Q);
+        }
+        if (elec > 0) {
+            reg.internalDamage = clampQ(reg.internalDamage + qMul(elec, ELEC_INTERNAL_PER_TICK), 0, SCALE.Q);
+            e.condition.stunned = clampQ(e.condition.stunned + qMul(elec, ELEC_STUNNED_RISE), 0, SCALE.Q);
+        }
+        if (rad > 0) {
+            reg.internalDamage = clampQ(reg.internalDamage + qMul(rad, RAD_INTERNAL_PER_TICK), 0, SCALE.Q);
+            e.injury.shock = clampQ(e.injury.shock + qMul(rad, RAD_SHOCK_PER_TICK), 0, SCALE.Q);
+        }
+    }
+    if (suff > 0) {
+        e.injury.shock = clampQ(e.injury.shock + qMul(suff, SUFF_SHOCK_PER_TICK), 0, SCALE.Q);
+    }
+    // Phase 10: ambient temperature stress
+    if (ambientTemperature_Q !== undefined) {
+        const COMFORT_HIGH = q(0.65);
+        const COMFORT_LOW = q(0.35);
+        if (ambientTemperature_Q > COMFORT_HIGH) {
+            // Heat stress: shock + mild surface damage; heatTolerance scales dose
+            const excess = clampQ((ambientTemperature_Q - COMFORT_HIGH), q(0), q(1.0));
+            const baseDose = qMul(excess, q(0.025));
+            const heatTol = Math.max(1, e.attributes.resilience.heatTolerance);
+            const dose = mulDiv(baseDose, SCALE.Q, heatTol);
+            e.injury.shock = clampQ((e.injury.shock + dose), 0, SCALE.Q);
+            const torsoReg = e.injury.byRegion["torso"] ?? Object.values(e.injury.byRegion)[0];
+            if (torsoReg) {
+                torsoReg.surfaceDamage = clampQ((torsoReg.surfaceDamage + qMul(dose, q(0.20))), 0, SCALE.Q);
+            }
+        }
+        else if (ambientTemperature_Q < COMFORT_LOW) {
+            // Cold stress: shock + fatigue; coldTolerance scales dose
+            const deficit = clampQ((COMFORT_LOW - ambientTemperature_Q), q(0), q(1.0));
+            const baseDose = qMul(deficit, q(0.020));
+            const coldTol = Math.max(1, e.attributes.resilience.coldTolerance);
+            const dose = mulDiv(baseDose, SCALE.Q, coldTol);
+            e.injury.shock = clampQ((e.injury.shock + dose), 0, SCALE.Q);
+            e.energy.fatigue = clampQ((e.energy.fatigue + qMul(dose, q(0.50))), 0, SCALE.Q);
+        }
+    }
+}
+export function stepInjuryProgression(e, tick) {
+    if (e.injury.dead)
+        return;
+    // Phase 9: natural clotting — bleedingRate decays proportional to structural integrity.
+    // Heavily damaged tissue clots slowly; intact tissue clots quickly.
+    const CLOT_RATE_PER_TICK = q(0.0002);
+    const INFECTION_BLEED_THRESHOLD = q(0.05);
+    const INFECTION_INT_THRESHOLD = q(0.10);
+    const INFECTION_ONSET_TICKS = 100;
+    const INFECTION_DAMAGE_PER_TICK = q(0.0003);
+    const PERMANENT_THRESHOLD = q(0.90);
+    const PERMANENT_FLOOR_MUL = q(0.75);
+    for (const reg of Object.values(e.injury.byRegion)) {
+        // Clotting
+        if (reg.bleedingRate > 0) {
+            const structureIntegrity = clampQ((SCALE.Q - reg.structuralDamage), q(0), q(1.0));
+            const clotRate = qMul(structureIntegrity, CLOT_RATE_PER_TICK);
+            reg.bleedingRate = clampQ((reg.bleedingRate - clotRate), q(0), q(1.0));
+        }
+        // Infection timer — track consecutive ticks of active bleeding
+        if (reg.bleedingRate > INFECTION_BLEED_THRESHOLD) {
+            reg.bleedDuration_ticks++;
+            if (reg.bleedDuration_ticks >= INFECTION_ONSET_TICKS
+                && reg.internalDamage > INFECTION_INT_THRESHOLD
+                && reg.infectedTick < 0) {
+                reg.infectedTick = tick;
+            }
+        }
+        else {
+            reg.bleedDuration_ticks = Math.max(0, reg.bleedDuration_ticks - 1);
+        }
+        // Infection progression — infected regions accumulate internal damage
+        if (reg.infectedTick >= 0) {
+            reg.internalDamage = clampQ(reg.internalDamage + INFECTION_DAMAGE_PER_TICK, 0, SCALE.Q);
+        }
+        // Permanent damage floor update — set when structural damage is very high
+        if (reg.structuralDamage >= PERMANENT_THRESHOLD) {
+            const newFloor = qMul(reg.structuralDamage, PERMANENT_FLOOR_MUL);
+            if (newFloor > reg.permanentDamage)
+                reg.permanentDamage = newFloor;
+        }
+    }
+    // Phase 8B: hemolymph accumulation — breached open-fluid segments leak each tick
+    if (e.bodyPlan) {
+        for (const seg of e.bodyPlan.segments) {
+            if (seg.fluidSystem !== "open" || seg.hemolymphLossRate === undefined)
+                continue;
+            const segState = e.injury.byRegion[seg.id];
+            if (!segState)
+                continue;
+            const breachAt = seg.breachThreshold ?? q(0.8);
+            if (segState.structuralDamage >= breachAt) {
+                const loss = qMul(seg.hemolymphLossRate, segState.structuralDamage);
+                e.injury.hemolymphLoss = clampQ((e.injury.hemolymphLoss ?? 0) + loss, 0, SCALE.Q);
+            }
+        }
+    }
+    // Phase 8B: hemolymph fatal threshold — same as fluidLoss
+    const FATAL_HEMOLYMPH = q(0.80);
+    if ((e.injury.hemolymphLoss ?? 0) >= FATAL_HEMOLYMPH) {
+        e.injury.dead = true;
+        e.injury.consciousness = q(0);
+        e.velocity_mps = v3(0, 0, 0);
+        return;
+    }
+    // Phase 8B: molting tick countdown and structural repair on completion
+    if (e.molting?.active) {
+        e.molting.ticksRemaining = Math.max(0, e.molting.ticksRemaining - 1);
+        if (e.molting.ticksRemaining === 0) {
+            e.molting.active = false;
+            // Repair regeneratesViaMolting segments
+            if (e.bodyPlan) {
+                for (const seg of e.bodyPlan.segments) {
+                    if (!seg.regeneratesViaMolting)
+                        continue;
+                    const segState = e.injury.byRegion[seg.id];
+                    if (!segState)
+                        continue;
+                    segState.structuralDamage = clampQ((segState.structuralDamage - q(0.10)), 0, SCALE.Q);
+                }
+            }
+        }
+    }
+    // Phase 8B: hemolymph clotting — passive decay of hemolymph loss each tick
+    const HEMOLYMPH_CLOT_RATE = q(0.0001);
+    if ((e.injury.hemolymphLoss ?? 0) > 0) {
+        e.injury.hemolymphLoss = clampQ(((e.injury.hemolymphLoss ?? 0) - HEMOLYMPH_CLOT_RATE), 0, SCALE.Q);
+    }
+    // Phase 8B: auto-molt trigger — fires when average structural damage on
+    // regeneratesViaMolting segments reaches MOLT_TRIGGER_THRESHOLD and no molt
+    // is already active. Post-molt repair (−q(0.10)) typically drops average below
+    // threshold, preventing immediate re-trigger for minor damage; severely damaged
+    // entities will re-molt until damage falls below the threshold.
+    const MOLT_TRIGGER_THRESHOLD = q(0.40);
+    const MOLT_DURATION_TICKS = TICK_HZ * 60; // 60 seconds at TICK_HZ fps
+    if (e.bodyPlan && !e.molting?.active) {
+        const regenSegs = e.bodyPlan.segments.filter(s => s.regeneratesViaMolting);
+        if (regenSegs.length > 0) {
+            let totalDmg = 0;
+            for (const seg of regenSegs) {
+                totalDmg += e.injury.byRegion[seg.id]?.structuralDamage ?? 0;
+            }
+            const avgDmg = Math.trunc(totalDmg / regenSegs.length);
+            if (avgDmg >= MOLT_TRIGGER_THRESHOLD) {
+                e.molting = {
+                    active: true,
+                    ticksRemaining: MOLT_DURATION_TICKS,
+                    softeningSegments: regenSegs.map(s => s.id),
+                };
+            }
+        }
+    }
+    // Phase 8B: wing passive regeneration — slow structural repair on wing segments
+    // when not actively molting (molting repair is handled above on completion).
+    const WING_REGEN_RATE = q(0.0001);
+    if (e.bodyPlan?.locomotion.flight && !e.molting?.active) {
+        for (const wid of e.bodyPlan.locomotion.flight.wingSegments) {
+            const ws = e.injury.byRegion[wid];
+            if (ws && ws.structuralDamage > 0) {
+                ws.structuralDamage = clampQ((ws.structuralDamage - WING_REGEN_RATE), 0, SCALE.Q);
+            }
+        }
+    }
+    const bleedRate = totalBleedingRate(e.injury);
+    const rawBleedThisTick = Math.trunc((bleedRate * DT_S) / SCALE.s);
+    // Phase 7: medical.treatmentRateMul reduces fluid loss (passive wound management)
+    const medSkill = getSkill(e.skills, "medical");
+    const bleedThisTick = medSkill.treatmentRateMul > SCALE.Q
+        ? mulDiv(rawBleedThisTick, SCALE.Q, medSkill.treatmentRateMul)
+        : rawBleedThisTick;
+    e.injury.fluidLoss = clampQ(e.injury.fluidLoss + bleedThisTick, 0, SCALE.Q);
+    e.injury.shock = clampQ(e.injury.shock + qMul(e.injury.fluidLoss, SHOCK_FROM_FLUID) + qMul(e.injury.byRegion["torso"]?.internalDamage ?? q(0), SHOCK_FROM_INTERNAL), 0, SCALE.Q);
+    const loss = clampQ(qMul(e.injury.shock, CONSC_LOSS_FROM_SHOCK) + qMul(e.condition.suffocation, CONSC_LOSS_FROM_SUFF) + qMul(regionKOFactor(e.injury), q(0.0100)), 0, SCALE.Q);
+    e.injury.consciousness = clampQ(e.injury.consciousness - loss, 0, SCALE.Q);
+    // Phase 9: explicit fatal fluid loss threshold (complements the shock path)
+    if (e.injury.fluidLoss >= FATAL_FLUID_LOSS || e.injury.shock >= SCALE.Q || e.injury.consciousness === 0) {
+        e.injury.dead = true;
+        e.injury.consciousness = q(0);
+        e.velocity_mps = v3(0, 0, 0);
+    }
+}
+function regionSalt(region) {
+    // Well-known humanoid regions get stable salts; others use a hash of the id string.
+    switch (region) {
+        case "head": return 0x11;
+        case "torso": return 0x22;
+        case "leftArm": return 0x33;
+        case "rightArm": return 0x44;
+        case "leftLeg": return 0x55;
+        case "rightLeg": return 0x66;
+        default: {
+            // Deterministic hash of the segment id (FNV-1a-like)
+            let h = 0x77;
+            for (let i = 0; i < region.length; i++)
+                h = ((h ^ region.charCodeAt(i)) * 0x1f) & 0xFF;
+            return h || 0x77;
+        }
+    }
+}

package/dist/src/sim/step/morale.d.ts

@@ -0,0 +1,11 @@
+import type { WorldState } from "../world.js";
+import type { Entity } from "../entity.js";
+import type { WorldIndex } from "../indexing.js";
+import type { SpatialIndex } from "../spatial.js";
+import type { TraceSink } from "../trace.js";
+import { KernelContext } from "../context.js";
+/**
+ * Per-entity morale update — accumulates fear from all sources and applies decay.
+ * Emits a MoraleRoute trace event whenever the entity crosses the routing threshold.
+ */
+export declare function stepMoraleForEntity(world: WorldState, e: Entity, index: WorldIndex, spatial: SpatialIndex, aliveBeforeTick: Set<number>, teamRoutingFrac: Map<number, number>, trace: TraceSink, ctx: KernelContext): void;