@its-not-rocket-science/ananke 0.1.69 → 0.5.4

package/dist/src/sim/resolvers/treat-resolver.js

@@ -0,0 +1,77 @@
+import { SCALE, clampQ, mulDiv, q } from "../../units.js";
+import { FRACTURE_THRESHOLD } from "../injury.js";
+import { TIER_RANK, TIER_MUL, ACTION_MIN_TIER, TIER_TECH_REQ } from "../medical.js";
+import { getSkill } from "../skills.js";
+import { TraceKinds } from "../kinds.js";
+export function resolveTreat(options) {
+    const { world, treater, cmd, index, trace, ctx } = options;
+    if (treater.injury.dead)
+        return;
+    const target = index.byId.get(cmd.targetId);
+    if (!target || target.injury.dead)
+        return;
+    const dx = target.position_m.x - treater.position_m.x;
+    const dy = target.position_m.y - treater.position_m.y;
+    const dist2 = dx * dx + dy * dy;
+    const MAX_TREAT_DIST_m = Math.trunc(2 * SCALE.m);
+    if (dist2 > MAX_TREAT_DIST_m * MAX_TREAT_DIST_m)
+        return;
+    const tierRank = TIER_RANK[cmd.tier];
+    const actionMinRank = TIER_RANK[ACTION_MIN_TIER[cmd.action]];
+    if (tierRank < actionMinRank)
+        return;
+    const techReq = TIER_TECH_REQ[cmd.tier];
+    if (techReq && ctx.techCtx && !ctx.techCtx.available.has(techReq))
+        return;
+    const tierMul = TIER_MUL[cmd.tier];
+    const medSkill = getSkill(treater.skills, "medical");
+    const effectMul = mulDiv(tierMul, medSkill.treatmentRateMul, SCALE.Q);
+    if (cmd.action === "tourniquet") {
+        const reg = cmd.regionId ? target.injury.byRegion[cmd.regionId] : undefined;
+        if (!reg)
+            return;
+        reg.bleedingRate = q(0);
+        reg.bleedDuration_ticks = 0;
+        target.injury.shock = clampQ(target.injury.shock + q(0.005), 0, SCALE.Q);
+    }
+    else if (cmd.action === "bandage") {
+        const reg = cmd.regionId ? target.injury.byRegion[cmd.regionId] : undefined;
+        if (!reg)
+            return;
+        const BASE_BANDAGE_RATE = q(0.0050);
+        const reduction = mulDiv(BASE_BANDAGE_RATE, effectMul, SCALE.Q);
+        reg.bleedingRate = clampQ((reg.bleedingRate - reduction), q(0), q(1.0));
+    }
+    else if (cmd.action === "surgery") {
+        const reg = cmd.regionId ? target.injury.byRegion[cmd.regionId] : undefined;
+        if (!reg)
+            return;
+        const BASE_SURGERY_RATE = q(0.0020);
+        const BASE_BANDAGE_RATE = q(0.0050);
+        const strReduction = mulDiv(BASE_SURGERY_RATE, effectMul, SCALE.Q);
+        const newStr = clampQ((reg.structuralDamage - strReduction), reg.permanentDamage, SCALE.Q);
+        reg.structuralDamage = newStr;
+        const bleedReduction = mulDiv(BASE_BANDAGE_RATE, effectMul, SCALE.Q);
+        reg.bleedingRate = clampQ((reg.bleedingRate - bleedReduction), q(0), q(1.0));
+        if (reg.fractured && reg.structuralDamage < FRACTURE_THRESHOLD) {
+            reg.fractured = false;
+        }
+        if (reg.infectedTick >= 0 && tierRank >= TIER_RANK["surgicalKit"]) {
+            reg.infectedTick = -1;
+        }
+    }
+    else if (cmd.action === "fluidReplacement") {
+        const BASE_FLUID_RATE = q(0.0050);
+        const recovery = mulDiv(BASE_FLUID_RATE, effectMul, SCALE.Q);
+        target.injury.fluidLoss = clampQ((target.injury.fluidLoss - recovery), q(0), SCALE.Q);
+        target.injury.shock = clampQ((target.injury.shock - q(0.002)), q(0), SCALE.Q);
+    }
+    trace.onEvent({
+        kind: TraceKinds.TreatmentApplied,
+        tick: world.tick,
+        treaterId: treater.id,
+        targetId: target.id,
+        action: cmd.action,
+        ...(cmd.regionId !== undefined ? { regionId: cmd.regionId } : {}),
+    });
+}

package/dist/src/sim/step/apply/intents.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "../../commands.js";
+import type { Entity } from "../../entity.js";
+import type { SimulationTuning } from "../../tuning.js";
+export declare function applyCommands(e: Entity, commands: readonly Command[]): void;
+export declare function applyFunctionalGating(e: Entity, tuning: SimulationTuning): void;
+export declare function applyStandAndKO(e: Entity, tuning: SimulationTuning): void;

package/dist/src/sim/step/apply/intents.js

@@ -0,0 +1,83 @@
+import { deriveFunctionalState, hasAllDisabledFunctions } from "../../impairment.js";
+import { SCALE, clampQ, q } from "../../../units.js";
+export function applyCommands(e, commands) {
+    e.intent.defence = { mode: "none", intensity: q(0) };
+    for (const c of commands) {
+        if (c.kind === "setProne")
+            e.condition.prone = c.prone;
+        else if (c.kind === "move")
+            e.intent.move = { dir: c.dir, intensity: c.intensity, mode: c.mode };
+        else if (c.kind === "defend")
+            e.intent.defence = { mode: c.mode, intensity: clampQ(c.intensity, 0, SCALE.Q) };
+    }
+}
+export function applyFunctionalGating(e, tuning) {
+    const func = deriveFunctionalState(e, tuning);
+    if (!func.canAct) {
+        e.intent.defence = { mode: "none", intensity: q(0) };
+        e.intent.move = { dir: { x: 0, y: 0, z: 0 }, intensity: q(0), mode: "walk" };
+        if (tuning.realism !== "arcade")
+            e.condition.prone = true;
+        return;
+    }
+    if (e.condition.pinned && tuning.realism !== "arcade") {
+        e.intent.defence = { mode: "none", intensity: q(0) };
+        e.condition.prone = true;
+    }
+    if (e.energy.reserveEnergy_J <= 0 && tuning.realism !== "arcade") {
+        e.condition.prone = true;
+        e.intent.defence = { mode: "none", intensity: q(0) };
+    }
+    if (!func.canStand && tuning.realism !== "arcade")
+        e.condition.prone = true;
+    if (tuning.realism !== "arcade") {
+        const armsOut = hasAllDisabledFunctions(func, "leftManipulation", "rightManipulation");
+        if (armsOut && (e.intent.defence.mode === "block" || e.intent.defence.mode === "parry")) {
+            e.intent.defence = { mode: "none", intensity: q(0) };
+        }
+        const legsOut = hasAllDisabledFunctions(func, "leftLocomotion", "rightLocomotion");
+        if (legsOut && e.intent.move.mode === "sprint") {
+            e.intent.move = { ...e.intent.move, mode: "walk" };
+        }
+    }
+}
+export function applyStandAndKO(e, tuning) {
+    const wasUnconscious = e.condition.unconsciousTicks > 0;
+    if (e.injury.consciousness <= tuning.unconsciousThreshold) {
+        if (!wasUnconscious) {
+            e.condition.unconsciousTicks = tuning.unconsciousBaseTicks;
+            e.condition.prone = true;
+            e.intent.defence = { mode: "none", intensity: q(0) };
+            e.intent.move = { dir: { x: 0, y: 0, z: 0 }, intensity: q(0), mode: "walk" };
+            if (tuning.dropWeaponsOnUnconscious) {
+                e.loadout.items = e.loadout.items.filter(it => it.kind !== "weapon");
+            }
+        }
+        else {
+            e.condition.prone = true;
+        }
+    }
+    if (e.condition.unconsciousTicks > 0) {
+        e.intent.defence = { mode: "none", intensity: q(0) };
+        e.intent.move = { dir: { x: 0, y: 0, z: 0 }, intensity: q(0), mode: "walk" };
+        e.condition.prone = true;
+        return;
+    }
+    if (!e.intent.prone && e.condition.prone) {
+        if (tuning.realism === "arcade") {
+            e.condition.prone = false;
+            return;
+        }
+        if (e.condition.standBlockedTicks > 0) {
+            e.condition.prone = true;
+            return;
+        }
+        const func = deriveFunctionalState(e, tuning);
+        const slow = (SCALE.Q - func.mobilityMul);
+        const extra = Math.trunc((slow * tuning.standUpMaxExtraTicks) / SCALE.Q);
+        const ticks = tuning.standUpBaseTicks + extra;
+        e.condition.standBlockedTicks = Math.max(1, ticks);
+        e.condition.prone = true;
+        e.intent.prone = true;
+    }
+}

package/dist/src/sim/step/kernel-pipeline.d.ts

@@ -0,0 +1,9 @@
+import type { CommandMap } from "../commands.js";
+import type { KernelContext } from "../context.js";
+import type { WorldState } from "../world.js";
+export interface KernelPhase {
+    name: string;
+    responsibility: string;
+    run(world: WorldState, cmds: CommandMap, ctx: KernelContext): void;
+}
+export declare const KERNEL_PHASE_ORDER: readonly ["prepare", "cooldowns", "capabilityCasting", "intent", "movement", "hazardsAndPush", "actions", "grappleMaintenance", "impactResolution", "effectPropagation", "physiology", "morale", "finalize"];

package/dist/src/sim/step/kernel-pipeline.js

@@ -0,0 +1,15 @@
+export const KERNEL_PHASE_ORDER = [
+    "prepare",
+    "cooldowns",
+    "capabilityCasting",
+    "intent",
+    "movement",
+    "hazardsAndPush",
+    "actions",
+    "grappleMaintenance",
+    "impactResolution",
+    "effectPropagation",
+    "physiology",
+    "morale",
+    "finalize",
+];

package/dist/src/sim/step/phases/capability-phase.d.ts

@@ -0,0 +1,8 @@
+import type { CapabilityEffect } from "../../capability.js";
+import type { Entity } from "../../entity.js";
+import type { TraceSink } from "../../trace.js";
+import type { WorldState } from "../../world.js";
+export interface CapabilityPhaseDeps {
+    applyCapabilityEffect: (world: WorldState, actor: Entity, targetId: number | undefined, effect: CapabilityEffect, trace: TraceSink, tick: number) => void;
+}
+export declare function runCapabilityPhase(world: WorldState, trace: TraceSink, deps: CapabilityPhaseDeps): void;

package/dist/src/sim/step/phases/capability-phase.js

@@ -0,0 +1,65 @@
+import { q } from "../../../units.js";
+import { TraceKinds } from "../../kinds.js";
+import { stepConcentration } from "../concentration.js";
+const CAST_INTERRUPT_SHOCK = q(0.30);
+export function runCapabilityPhase(world, trace, deps) {
+    for (const e of world.entities) {
+        if (!e.pendingActivation || e.injury.dead)
+            continue;
+        if (e.injury.shock >= CAST_INTERRUPT_SHOCK) {
+            trace.onEvent({ kind: TraceKinds.CastInterrupted, tick: world.tick, entityId: e.id });
+            delete e.pendingActivation;
+        }
+        else if (world.tick >= e.pendingActivation.resolveAtTick) {
+            const src = e.capabilitySources?.find(s => s.id === e.pendingActivation.sourceId);
+            const eff = src?.effects.find(ef => ef.id === e.pendingActivation.effectId);
+            if (src && eff) {
+                deps.applyCapabilityEffect(world, e, e.pendingActivation.targetId, eff, trace, world.tick);
+                trace.onEvent({ kind: TraceKinds.CapabilityActivated, tick: world.tick, entityId: e.id, sourceId: src.id, effectId: eff.id });
+                if (eff.sustainedTicks && eff.sustainedTicks > 1) {
+                    e.action.sustainedEmission = {
+                        sourceId: src.id,
+                        effectId: eff.id,
+                        ...(e.pendingActivation.targetId !== undefined ? { targetId: e.pendingActivation.targetId } : {}),
+                        remainingTicks: eff.sustainedTicks - 1,
+                    };
+                }
+            }
+            delete e.pendingActivation;
+        }
+    }
+    for (const e of world.entities) {
+        if (!e.activeConcentration || e.injury.dead)
+            continue;
+        stepConcentration(e, world, trace, world.tick);
+    }
+    for (const e of world.entities) {
+        if (!e.action.sustainedEmission || e.injury.dead)
+            continue;
+        const em = e.action.sustainedEmission;
+        if (e.injury.shock >= CAST_INTERRUPT_SHOCK) {
+            trace.onEvent({ kind: TraceKinds.CastInterrupted, tick: world.tick, entityId: e.id });
+            delete e.action.sustainedEmission;
+            continue;
+        }
+        const src = e.capabilitySources?.find(s => s.id === em.sourceId);
+        const eff = src?.effects.find(ef => ef.id === em.effectId);
+        if (!src || !eff) {
+            delete e.action.sustainedEmission;
+            continue;
+        }
+        const isBoundless = src.regenModel.type === "boundless";
+        if (!isBoundless) {
+            if (src.reserve_J < eff.cost_J) {
+                delete e.action.sustainedEmission;
+                continue;
+            }
+            src.reserve_J -= eff.cost_J;
+        }
+        deps.applyCapabilityEffect(world, e, em.targetId, eff, trace, world.tick);
+        em.remainingTicks -= 1;
+        if (em.remainingTicks <= 0) {
+            delete e.action.sustainedEmission;
+        }
+    }
+}

package/dist/src/sim/step/phases/cooldowns-phase.d.ts

@@ -0,0 +1,3 @@
+import type { TraceSink } from "../../trace.js";
+import type { WorldState } from "../../world.js";
+export declare function runCooldownsPhase(world: WorldState, trace: TraceSink): void;

package/dist/src/sim/step/phases/cooldowns-phase.js

@@ -0,0 +1,37 @@
+import { q, qMul } from "../../../units.js";
+import { TraceKinds } from "../../kinds.js";
+const SWING_MOMENTUM_DECAY = q(0.95);
+export function runCooldownsPhase(world, trace) {
+    for (const e of world.entities) {
+        e.action.attackCooldownTicks = Math.max(0, e.action.attackCooldownTicks - 1);
+        e.action.defenceCooldownTicks = Math.max(0, e.action.defenceCooldownTicks - 1);
+        e.action.grappleCooldownTicks = Math.max(0, e.action.grappleCooldownTicks - 1);
+        e.action.shootCooldownTicks = Math.max(0, e.action.shootCooldownTicks - 1);
+        e.action.swingMomentumQ = qMul(e.action.swingMomentumQ, SWING_MOMENTUM_DECAY);
+        if (e.action.capabilityCooldowns) {
+            for (const [key, ticks] of e.action.capabilityCooldowns) {
+                if (ticks <= 1)
+                    e.action.capabilityCooldowns.delete(key);
+                else
+                    e.action.capabilityCooldowns.set(key, ticks - 1);
+            }
+        }
+        e.condition.standBlockedTicks = Math.max(0, e.condition.standBlockedTicks - 1);
+        e.condition.unconsciousTicks = Math.max(0, e.condition.unconsciousTicks - 1);
+        e.condition.suppressedTicks = Math.max(0, e.condition.suppressedTicks - 1);
+        e.condition.blindTicks = Math.max(0, e.condition.blindTicks - 1);
+        if (e.action.staggerTicks)
+            e.action.staggerTicks = Math.max(0, e.action.staggerTicks - 1);
+        e.condition.rallyCooldownTicks = Math.max(0, e.condition.rallyCooldownTicks - 1);
+        if (e.action.weaponBindTicks > 0) {
+            e.action.weaponBindTicks = Math.max(0, e.action.weaponBindTicks - 1);
+            if (e.action.weaponBindTicks === 0) {
+                const partnerId = e.action.weaponBindPartnerId;
+                e.action.weaponBindPartnerId = 0;
+                if (partnerId !== 0 && e.id < partnerId) {
+                    trace.onEvent({ kind: TraceKinds.WeaponBindBreak, tick: world.tick, entityId: e.id, partnerId, reason: "timeout" });
+                }
+            }
+        }
+    }
+}

package/dist/src/sim/step/phases/prepare-phase.d.ts

@@ -0,0 +1,10 @@
+import { type WorldIndex } from "../../indexing.js";
+import { type SpatialIndex } from "../../spatial.js";
+import type { KernelContext } from "../../context.js";
+import type { WorldState } from "../../world.js";
+export interface PreparedKernelFrame {
+    cellSize_m: number;
+    index: WorldIndex;
+    spatial: SpatialIndex;
+}
+export declare function runPreparePhase(world: WorldState, ctx: KernelContext): PreparedKernelFrame;

package/dist/src/sim/step/phases/prepare-phase.js

@@ -0,0 +1,33 @@
+import { SCALE } from "../../../units.js";
+import { buildWorldIndex } from "../../indexing.js";
+import { buildSpatialIndex } from "../../spatial.js";
+import { computeDensityField } from "../../density.js";
+import { DEFAULT_SENSORY_ENV } from "../../sensory.js";
+import { deriveWeatherModifiers } from "../../weather.js";
+export function runPreparePhase(world, ctx) {
+    const runtimeState = world.runtimeState ?? (world.runtimeState = {});
+    runtimeState.sensoryEnv = ctx.sensoryEnv ?? DEFAULT_SENSORY_ENV;
+    if (ctx.weather) {
+        const wMod = deriveWeatherModifiers(ctx.weather);
+        ctx.tractionCoeff = Math.trunc((ctx.tractionCoeff * wMod.tractionMul_Q) / SCALE.Q);
+        const baseEnv = runtimeState.sensoryEnv;
+        runtimeState.sensoryEnv = {
+            ...baseEnv,
+            lightMul: Math.trunc((baseEnv.lightMul * wMod.lightMul_Q) / SCALE.Q),
+            smokeMul: Math.trunc((baseEnv.smokeMul * wMod.precipVisionMul_Q) / SCALE.Q),
+        };
+        if (ctx.thermalAmbient_Q !== undefined && wMod.thermalOffset_Q !== 0) {
+            ctx.thermalAmbient_Q = (ctx.thermalAmbient_Q + wMod.thermalOffset_Q);
+        }
+    }
+    world.entities.sort((a, b) => a.id - b.id);
+    const index = buildWorldIndex(world);
+    const cellSize_m = ctx.cellSize_m ?? Math.trunc(4 * SCALE.m);
+    const spatial = buildSpatialIndex(world, cellSize_m);
+    ctx.density = computeDensityField(world, index, spatial, {
+        personalRadius_m: Math.trunc(0.45 * SCALE.m),
+        maxNeighbours: 12,
+        crowdingAt: 6,
+    });
+    return { cellSize_m, index, spatial };
+}

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

@@ -0,0 +1,2 @@
+export declare const STEP_PHASE_ORDER: readonly ["prepare", "cooldowns", "capabilityLifecycle", "intent", "movement", "hazardsAndPush", "actions", "grappleMaintenance", "impactResolution", "effects", "physiology", "morale", "finalize"];
+export type StepPhaseName = (typeof STEP_PHASE_ORDER)[number];

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

@@ -0,0 +1,15 @@
+export const STEP_PHASE_ORDER = [
+    "prepare",
+    "cooldowns",
+    "capabilityLifecycle",
+    "intent",
+    "movement",
+    "hazardsAndPush",
+    "actions",
+    "grappleMaintenance",
+    "impactResolution",
+    "effects",
+    "physiology",
+    "morale",
+    "finalize",
+];

package/dist/src/sim/step/resolvers/impact-resolver.d.ts

@@ -0,0 +1,9 @@
+import type { TraceSink } from "../../trace.js";
+import type { WorldState } from "../../world.js";
+import type { WorldIndex } from "../../indexing.js";
+import type { ImpactEvent } from "../../events.js";
+import type { Weapon } from "../../../equipment.js";
+export interface ImpactResolverDeps {
+    applyImpactToInjury: (target: import("../../entity.js").Entity, wpn: Weapon, energy_J: number, region: string, armoured: boolean, trace: TraceSink, tick: number, tempCavityMul_Q?: number) => void;
+}
+export declare function applyResolvedImpacts(world: WorldState, index: WorldIndex, impacts: readonly ImpactEvent[], trace: TraceSink, deps: ImpactResolverDeps): void;

package/dist/src/sim/step/resolvers/impact-resolver.js

@@ -0,0 +1,55 @@
+import { computeKnockback, applyKnockback } from "../../knockback.js";
+import { computeTemporaryCavityMul, computeCavitationBleed } from "../../hydrostatic.js";
+import { TraceKinds } from "../../kinds.js";
+export function applyResolvedImpacts(world, index, impacts, trace, deps) {
+    for (const ev of impacts) {
+        const target = index.byId.get(ev.targetId);
+        if (!target || target.injury.dead)
+            continue;
+        let effectiveEnergy = ev.energy_J;
+        if ((target.condition.shieldReserve_J ?? 0) > 0 &&
+            target.condition.shieldExpiry_tick !== undefined &&
+            world.tick <= target.condition.shieldExpiry_tick) {
+            const absorbed = Math.min(target.condition.shieldReserve_J, effectiveEnergy);
+            target.condition.shieldReserve_J -= absorbed;
+            effectiveEnergy -= absorbed;
+        }
+        if (effectiveEnergy > 0) {
+            const region = ev.region;
+            const tempCavMul = ev.v_impact_mps
+                ? computeTemporaryCavityMul(ev.v_impact_mps, region)
+                : undefined;
+            deps.applyImpactToInjury(target, ev.wpn, effectiveEnergy, region, ev.protectedByArmour, trace, world.tick, tempCavMul);
+            if (ev.v_impact_mps) {
+                const rs = target.injury.byRegion[region];
+                if (rs) {
+                    rs.bleedingRate = computeCavitationBleed(ev.v_impact_mps, rs.bleedingRate, region);
+                }
+            }
+        }
+        if (effectiveEnergy > 0 && (ev.massEff_kg ?? 0) > 0) {
+            const attacker = index.byId.get(ev.attackerId);
+            if (attacker) {
+                const kbResult = computeKnockback(effectiveEnergy, ev.massEff_kg, target);
+                applyKnockback(target, kbResult, {
+                    dx: target.position_m.x - attacker.position_m.x,
+                    dy: target.position_m.y - attacker.position_m.y,
+                });
+            }
+        }
+        trace.onEvent({
+            kind: TraceKinds.Attack,
+            tick: world.tick,
+            attackerId: ev.attackerId,
+            targetId: ev.targetId,
+            weaponId: ev.weaponId,
+            region: ev.region,
+            energy_J: ev.energy_J,
+            blocked: ev.blocked,
+            parried: ev.parried,
+            shieldBlocked: ev.shieldBlocked,
+            armoured: ev.protectedByArmour,
+            hitQuality: ev.hitQuality,
+        });
+    }
+}

package/dist/src/sim/step/world-phases.d.ts

@@ -0,0 +1,7 @@
+import type { WorldStepContext } from "./world-step-context.js";
+export interface WorldStepPhase {
+    name: string;
+    run(stepCtx: WorldStepContext): void;
+}
+export declare const WORLD_STEP_PHASE_ORDER: readonly ["prepare", "cooldowns", "input", "movement", "actions", "impacts", "systems", "finalize"];
+export declare function runWorldStepPhases(stepCtx: WorldStepContext, phases: readonly WorldStepPhase[]): void;

package/dist/src/sim/step/world-phases.js

@@ -0,0 +1,15 @@
+export const WORLD_STEP_PHASE_ORDER = [
+    "prepare",
+    "cooldowns",
+    "input",
+    "movement",
+    "actions",
+    "impacts",
+    "systems",
+    "finalize",
+];
+export function runWorldStepPhases(stepCtx, phases) {
+    for (const phase of phases) {
+        phase.run(stepCtx);
+    }
+}

package/dist/src/sim/step/world-step-context.d.ts

@@ -0,0 +1,23 @@
+import type { CommandMap } from "../commands.js";
+import type { KernelContext } from "../context.js";
+import type { ImpactEvent } from "../events.js";
+import type { WorldIndex } from "../indexing.js";
+import type { SpatialIndex } from "../spatial.js";
+import type { TraceSink } from "../trace.js";
+import type { SimulationTuning } from "../tuning.js";
+import type { WorldState } from "../world.js";
+export interface WorldStepContext {
+    world: WorldState;
+    cmds: CommandMap;
+    ctx: KernelContext;
+    tuning: SimulationTuning;
+    trace: TraceSink;
+    cellSize_m: number;
+    index: WorldIndex;
+    spatial: SpatialIndex;
+    spatialAfterMove: SpatialIndex;
+    impacts: ImpactEvent[];
+    finalImpacts: ImpactEvent[];
+    aliveBeforeTick: Set<number>;
+    teamRoutingFrac: Map<number, number>;
+}

package/dist/src/sim/step/world-step-context.js

@@ -0,0 +1 @@
+export {};

package/dist/src/sim/systemic-toxicology.js

@@ -5,7 +5,7 @@
 //   - Cumulative exposure: heavy metals, radiation — irreversible dose accumulation
 //   - Withdrawal states after sustained addictive toxin use
 //
-// Follows the 1 Hz accumulator pattern; called from the kernel's __nutritionAccum gate.
+// Follows the 1 Hz accumulator pattern; called from the kernel's runtimeState.nutritionAccum gate.
 //
 // Data flow:
 //   ingestToxin(entity, id) → entity.activeIngestedToxins[]

package/dist/src/sim/team.js

@@ -14,7 +14,7 @@ export function areEntitiesHostile(a, b, world) {
         return false;
     const isInjured = a.injury.shock > 0 || a.injury.fluidLoss > 0;
     // party check
-    const partyRegistry = world.__partyRegistry;
+    const partyRegistry = world.runtimeState?.partyRegistry;
     if (partyRegistry) {
         // if parties are friendly, not hostile (unless injured)
         if (!isInjured && areEntitiesFriendlyByParty(partyRegistry, a, b))
@@ -24,7 +24,7 @@ export function areEntitiesHostile(a, b, world) {
             return true;
     }
     // faction check
-    const factionRegistry = world.__factionRegistry;
+    const factionRegistry = world.runtimeState?.factionRegistry;
     if (factionRegistry && a.faction && b.faction) {
         const standing = effectiveStanding(factionRegistry, a, b);
         if (!isInjured && standing >= STANDING_FRIENDLY_THRESHOLD)

package/dist/src/sim/testing.js

@@ -6,6 +6,7 @@ import { defaultCondition } from "./condition.js";
 import { defaultInjury } from "./injury.js";
 import { v3 } from "./vec3.js";
 import { q, SCALE } from "../units.js";
+import { normalizeWorldInPlace } from "./normalization.js";
 /**
  * Minimal humanoid entity for tests (deterministic attributes via generateIndividual()).
  * Positions are fixed-point metres (SCALE.m).
@@ -39,13 +40,13 @@ export function mkWorld(seed, arg) {
         if (dupes.length > 0) {
             throw new Error(`mkWorld: duplicate entity IDs detected: ${[...new Set(dupes)].join(", ")}`);
         }
-        return { tick: 0, seed, entities };
+        return normalizeWorldInPlace({ 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 {
+    return normalizeWorldInPlace({
         tick: 0,
         seed,
         entities: [
@@ -80,7 +81,7 @@ export function mkWorld(seed, arg) {
                 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 {

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

@@ -5,7 +5,7 @@
  * 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.
+ * kernel's runtimeState.nutritionAccum gate and from downtime.ts per-second loop.
  */
 import { type Q } from "../units.js";
 import type { Entity } from "./entity.js";

package/dist/src/sim/toxicology.js

@@ -5,7 +5,7 @@
  * 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.
+ * kernel's runtimeState.nutritionAccum gate and from downtime.ts per-second loop.
  */
 import { q, SCALE, clampQ } from "../units.js";
 // ── Venom catalogue ───────────────────────────────────────────────────────────

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

@@ -4,6 +4,20 @@ import { SensoryEnvironment } from "./sensory.js";
 import { FactionRegistry } from "../faction.js";
 import { PartyRegistry } from "../party.js";
 import { RelationshipGraph } from "../relationships.js";
+export interface WorldRuntimeState {
+    sensoryEnv?: SensoryEnvironment;
+    factionRegistry?: FactionRegistry;
+    partyRegistry?: PartyRegistry;
+    relationshipGraph?: RelationshipGraph;
+    nutritionAccum?: number;
+    contentRegistry?: {
+        packs: Map<string, unknown>;
+        archetypes: Map<string, unknown>;
+        weapons: Map<string, unknown>;
+        armour: Map<string, unknown>;
+        terrain: Map<string, unknown>;
+    };
+}
 /**
  * Top-level simulation container.
  *
@@ -24,29 +38,8 @@ export interface WorldState {
      */
     activeFieldEffects?: FieldEffect[];
     /**
-     * @subsystem(sensory) Ambient lighting and visibility environment.
-     * Consumed by `src/sim/sensory.ts` when provided.  Prefixed `__` to discourage
-     * direct access — use the sensory API instead.
-     */
-    __sensoryEnv?: SensoryEnvironment;
-    /**
-     * @subsystem(faction) Global faction-standing registry.
-     * Consumed by `src/faction.ts` and AI targeting.
-     */
-    __factionRegistry?: FactionRegistry;
-    /**
-     * @subsystem(party) Global party registry.
-     * Consumed by `src/party.ts` for morale and formation bonuses.
-     */
-    __partyRegistry?: PartyRegistry;
-    /**
-     * @subsystem(relationships) Inter-entity relationship graph.
-     * Consumed by `src/relationships.ts`.
-     */
-    __relationshipGraph?: RelationshipGraph;
-    /**
-     * @subsystem(nutrition) Cross-tick nutrition accumulator.
-     * Consumed by the nutrition sub-step in `src/sim/kernel.ts`.
+     * @subsystem(runtime) Explicit host/runtime state consumed by optional subsystems.
+     * Kept separate from core deterministic world data.
      */
-    __nutritionAccum?: number;
+    runtimeState?: WorldRuntimeState;
 }