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

package/dist/src/sim/kernel.js

@@ -1,60 +1,52 @@
 import { ensureAnatomyRuntime } from "./entity.js";
 import { SCALE, q, clampQ, qMul, mulDiv, to } from "../units.js";
 import { DamageChannel } from "../channels.js";
-import { deriveArmourProfile, findWeapon, findShield, findRangedWeapon, findExoskeleton, findSensor } from "../equipment.js";
-import { isCapabilityAvailable } from "./tech.js";
-import { deriveFunctionalState, hasAllDisabledFunctions } from "./impairment.js";
+import { findWeapon } from "../equipment.js";
 import { TUNING } from "./tuning.js";
 import { vSub, vAdd } from "./vec3.js";
-import { defaultIntent } from "./intent.js";
-import { defaultAction } from "./action.js";
-import { resolveHit, shieldCovers, chooseArea } from "./combat.js";
+import { shieldCovers, chooseArea } from "./combat.js";
 import { normaliseDirCheapQ, dotDirQ } from "./vec3.js";
 import { eventSeed } from "./seeds.js";
 import { regionFromHit } from "./body.js";
 import { resolveHitSegment } from "./bodyplan.js";
 import { FRACTURE_THRESHOLD } from "./injury.js";
-import { TIER_RANK, TIER_MUL, ACTION_MIN_TIER, TIER_TECH_REQ } from "./medical.js";
 import { blastEnergyFracQ, fragmentsExpected, fragmentKineticEnergy } from "./explosion.js";
 import { makeRng } from "../rng.js";
-import { buildWorldIndex } from "./indexing.js";
 import { buildSpatialIndex } from "./spatial.js";
 import { sortEventsDeterministic } from "./events.js";
-import { parryLeverageQ } from "./combat.js";
 import { pickNearestEnemyInReach } from "./formation.js";
-import { isMeleeLaneOccludedByFriendly } from "./occlusion.js";
 import { applyFrontageCap } from "./frontage.js";
-import { computeDensityField } from "./density.js";
-import { coverFractionAtPosition, elevationAtPosition } from "./terrain.js";
 import { nullTrace } from "./trace.js";
 import { TraceKinds } from "./kinds.js";
-import { DEFAULT_SENSORY_ENV, DEFAULT_PERCEPTION, canDetect } from "./sensory.js";
-import { FEAR_SURPRISE, isRouting, painBlocksAction } from "./morale.js";
+import { runPreparePhase } from "./step/phases/prepare-phase.js";
+import { runCooldownsPhase } from "./step/phases/cooldowns-phase.js";
+import { runCapabilityPhase } from "./step/phases/capability-phase.js";
+import { isRouting } from "./morale.js";
+import { applyCommands, applyFunctionalGating, applyStandAndKO } from "./step/apply/intents.js";
+import { applyResolvedImpacts } from "./step/resolvers/impact-resolver.js";
+import { STEP_PHASE_ORDER } from "./step/pipeline.js";
 import { stepPushAndRepulsion } from "./step/push.js";
 import { stepMoraleForEntity } from "./step/morale.js";
 import { stepSubstances } from "./step/substances.js";
 import { stepEnergy } from "./step/energy.js";
-import { stepConcentration } from "./step/concentration.js";
-import { computeKnockback, applyKnockback } from "./knockback.js";
-import { computeTemporaryCavityMul, computeCavitationBleed } from "./hydrostatic.js";
-import { entityInCone } from "./cone.js";
 import { stepConditionsToInjury, stepInjuryProgression } from "./step/injury.js";
-import { stepCoreTemp, deriveTempModifiers, CORE_TEMP_NORMAL_Q } from "./thermoregulation.js";
+import { stepCoreTemp } from "./thermoregulation.js";
 import { stepNutrition } from "./nutrition.js";
 import { stepToxicology } from "./toxicology.js";
 import { stepIngestedToxicology } from "./systemic-toxicology.js";
-import { buildLimbStates, stepLimbFatigue } from "./limb.js";
+import { stepLimbFatigue } from "./limb.js";
 import { stepCapabilitySources } from "./step/capability.js";
 import { stepMovement } from "./step/movement.js";
 import { stepChainEffects, stepFieldEffects, stepHazardEffects } from "./step/effects.js";
-import { deriveWeatherModifiers, computeWindAimError } from "./weather.js";
-import { resolveGrappleAttempt, resolveGrappleThrow, resolveGrappleChoke, resolveGrappleJointLock, resolveBreakGrapple, stepGrappleTick, } from "./grapple.js";
-import { reachDomPenaltyQ, twoHandedAttackBonusQ, missRecoveryTicks, bindChanceQ, bindDurationTicks, breakBindContestQ, } from "./weapon_dynamics.js";
-import { energyAtRange_J, adjustedDispersionQ, groupingRadius_m, thrownLaunchEnergy_J, recycleTicks, shootCost_J, } from "./ranged.js";
-import { getSkill } from "./skills.js";
+import { resolveBreakGrapple, stepGrappleTick, } from "./grapple.js";
 import { TICK_HZ } from "./tick.js";
+import { assertDeterministicWorldLike, assertNoFloatUsageInProduction } from "../determinism.js";
+import { resolveAttack as resolveAttackFromResolver } from "./resolvers/attack-resolver.js";
+import { resolveShoot as resolveShootFromResolver } from "./resolvers/shoot-resolver.js";
+import { resolveGrappleCommand as resolveGrappleCommandFromResolver, resolveBreakBind as resolveBreakBindFromResolver } from "./resolvers/grapple-resolver.js";
+import { resolveTreat as resolveTreatFromResolver } from "./resolvers/treat-resolver.js";
+import { resolveActivation as resolveActivationFromResolver, applyPayload as applyPayloadFromResolver, applyCapabilityEffect as applyCapabilityEffectFromResolver } from "./resolvers/capability-resolver.js";
 // Phase 2 extension: swing momentum carry
-const SWING_MOMENTUM_DECAY = q(0.95); // 5% decay per tick
 const SWING_MOMENTUM_MAX = q(0.12); // max +12% energy bonus at full momentum
 // Phase 3 extension: aiming time
 const AIM_MAX_TICKS = 20; // 1 second at 20 ticks/s
@@ -107,225 +99,19 @@ function shieldBlocksSegment(shield, target, segmentId, area) {
     return shieldCovers(shield, effectiveArea);
 }
 export function stepWorld(world, cmds, ctx) {
+    assertNoFloatUsageInProduction(world);
+    const strictDeterminism = ctx.strictDeterminism ??
+        (typeof process !== "undefined" && process.env.ANANKE_STRICT_DETERMINISM === "1");
+    if (strictDeterminism)
+        assertDeterministicWorldLike(world, "step:start");
     const tuning = ctx.tuning ?? TUNING.tactical;
     const trace = ctx.trace ?? nullTrace;
-    // Phase 4: attach sensory environment to world for use in resolveAttack / resolveShoot.
-    // WorldState is a plain data object; we use a type-cast side-channel to avoid widening the type.
-    (world).__sensoryEnv = ctx.sensoryEnv ?? DEFAULT_SENSORY_ENV;
-    // Phase 51: apply weather modifiers to traction, sensory environment, and thermal ambient.
-    if (ctx.weather) {
-        const wMod = deriveWeatherModifiers(ctx.weather);
-        // Traction: rain/snow/ice reduce friction.
-        ctx.tractionCoeff = Math.trunc((ctx.tractionCoeff * wMod.tractionMul_Q) / SCALE.Q);
-        // Sensory: fog and precipitation reduce vision range.
-        const baseEnv = world.__sensoryEnv;
-        world.__sensoryEnv = {
-            ...baseEnv,
-            lightMul: Math.trunc((baseEnv.lightMul * wMod.lightMul_Q) / SCALE.Q),
-            smokeMul: Math.trunc((baseEnv.smokeMul * wMod.precipVisionMul_Q) / SCALE.Q),
-        };
-        // Thermal: precipitation cools the ambient temperature (Phase 29 encoding).
-        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);
-    const density = computeDensityField(world, index, spatial, {
-        personalRadius_m: Math.trunc(0.45 * SCALE.m),
-        maxNeighbours: 12,
-        crowdingAt: 6,
-    });
-    ctx.density = density;
+    void STEP_PHASE_ORDER;
+    const { cellSize_m, index, spatial } = runPreparePhase(world, ctx);
+    const runtimeState = world.runtimeState;
     const impacts = [];
-    for (const e of world.entities) {
-        if (!(e).intent)
-            (e).intent = defaultIntent();
-        if (!(e).action)
-            (e).action = defaultAction();
-        // Phase 2A: default new fields on entities created before this phase
-        if (!(e).grapple) {
-            (e).grapple = { holdingTargetId: 0, heldByIds: [], gripQ: q(0), position: "standing" };
-        }
-        else if ((e).grapple.position === undefined) {
-            (e).grapple.position = "standing";
-        }
-        if ((e).action.grappleCooldownTicks === undefined)
-            (e).action.grappleCooldownTicks = 0;
-        if ((e).condition?.pinned === undefined)
-            (e).condition.pinned = false;
-        // Phase 2C: default weapon bind fields
-        if ((e).action.weaponBindPartnerId === undefined)
-            (e).action.weaponBindPartnerId = 0;
-        if ((e).action.weaponBindTicks === undefined)
-            (e).action.weaponBindTicks = 0;
-        // Phase 3: ranged combat fields
-        if ((e).action.shootCooldownTicks === undefined)
-            (e).action.shootCooldownTicks = 0;
-        if ((e).condition.suppressedTicks === undefined)
-            (e).condition.suppressedTicks = 0;
-        // Phase 2 extension: swing momentum
-        if ((e).action.swingMomentumQ === undefined)
-            (e).action.swingMomentumQ = 0;
-        // Phase 3 extension: aiming time
-        if ((e).action.aimTicks === undefined)
-            (e).action.aimTicks = 0;
-        if ((e).action.aimTargetId === undefined)
-            (e).action.aimTargetId = 0;
-        // Phase 4: perception defaults and decision latency
-        if (!(e.attributes).perception)
-            (e.attributes).perception = DEFAULT_PERCEPTION;
-        if (!e.ai)
-            e.ai = { focusTargetId: 0, retargetCooldownTicks: 0, decisionCooldownTicks: 0 };
-        else if ((e.ai).decisionCooldownTicks === undefined)
-            (e.ai).decisionCooldownTicks = 0;
-        // Phase 5: fear / morale
-        if ((e.condition).fearQ === undefined)
-            (e.condition).fearQ = q(0);
-        // Phase 5 extensions: morale features
-        if ((e.condition).suppressionFearMul === undefined)
-            (e.condition).suppressionFearMul = SCALE.Q;
-        if ((e.condition).recentAllyDeaths === undefined)
-            (e.condition).recentAllyDeaths = 0;
-        if ((e.condition).lastAllyDeathTick === undefined)
-            (e.condition).lastAllyDeathTick = -1;
-        if ((e.condition).surrendered === undefined)
-            (e.condition).surrendered = false;
-        if ((e.condition).rallyCooldownTicks === undefined)
-            (e.condition).rallyCooldownTicks = 0;
-        // Phase 10C: flash blindness
-        if ((e.condition).blindTicks === undefined)
-            (e.condition).blindTicks = 0;
-        // Phase 9: new RegionInjury fields (default for entities created pre-Phase-9)
-        if ((e.injury).hemolymphLoss === undefined)
-            (e.injury).hemolymphLoss = q(0);
-        for (const reg of Object.values(e.injury.byRegion)) {
-            if ((reg).fractured === undefined)
-                (reg).fractured = false;
-            if ((reg).infectedTick === undefined)
-                (reg).infectedTick = -1;
-            if ((reg).bleedDuration_ticks === undefined)
-                (reg).bleedDuration_ticks = 0;
-            if ((reg).permanentDamage === undefined)
-                (reg).permanentDamage = q(0);
-        }
-        // Phase 11C: initialize ablative armour state for entities that don't have it yet
-        if (!e.armourState) {
-            const armourTiems = e.loadout.items.filter(it => it.kind === "armour");
-            const ablativeItems = armourTiems.filter(it => it.ablative);
-            if (ablativeItems.length > 0) {
-                e.armourState = new Map(ablativeItems.map(it => [it.id, { resistRemaining_J: (it).resist_J }]));
-            }
-        }
-        // Phase 32B: initialize per-limb state for multi-limb body plans (once only)
-        if (!e.limbStates && e.bodyPlan) {
-            const limbs = buildLimbStates(e.bodyPlan);
-            if (limbs.length > 0)
-                e.limbStates = limbs;
-        }
-    }
-    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); // Phase 3
-        e.action.swingMomentumQ = qMul(e.action.swingMomentumQ, SWING_MOMENTUM_DECAY); // Phase 2 ext
-        // Phase 12B: per-capability cooldown 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); // Phase 3
-        e.condition.blindTicks = Math.max(0, e.condition.blindTicks - 1); // Phase 10C
-        if (e.action.staggerTicks)
-            e.action.staggerTicks = Math.max(0, e.action.staggerTicks - 1); // Phase 26
-        e.condition.rallyCooldownTicks = Math.max(0, e.condition.rallyCooldownTicks - 1); // Phase 5 ext
-        // Phase 2C: weapon bind decay — emit trace only from the smaller-ID entity to avoid duplicates
-        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" });
-                }
-            }
-        }
-    }
-    // Phase 12: resolve or interrupt pending capability activations (cast-time completion)
-    const CAST_INTERRUPT_SHOCK = q(0.30);
-    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) {
-                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 });
-                // Phase 28: set up sustained emission for remaining ticks after cast completion
-                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;
-        }
-    }
-    // Phase 12B: step active concentration auras (castTime_ticks = -1 ongoing effects)
-    for (const e of world.entities) {
-        if (!e.activeConcentration || e.injury.dead)
-            continue;
-        stepConcentration(e, world, trace, world.tick);
-    }
-    // Phase 28: step sustained emission (breath weapons, flamethrowers, etc.)
-    for (const e of world.entities) {
-        if (!e.action.sustainedEmission || e.injury.dead)
-            continue;
-        const em = e.action.sustainedEmission;
-        // Concentration break: shock interrupts sustained emission (same threshold as cast)
-        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;
-        }
-        // Deduct cost per tick; stop if reserve exhausted
-        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;
-        }
-        applyCapabilityEffect(world, e, em.targetId, eff, trace, world.tick);
-        em.remainingTicks -= 1;
-        if (em.remainingTicks <= 0) {
-            delete e.action.sustainedEmission;
-        }
-    }
+    runCooldownsPhase(world, trace);
+    runCapabilityPhase(world, trace, { applyCapabilityEffect });
     for (const e of world.entities) {
         if (e.injury.dead)
             continue;
@@ -346,6 +132,8 @@ export function stepWorld(world, cmds, ctx) {
         trace.onEvent({ kind: TraceKinds.Move, tick: world.tick, entityId: e.id, pos: e.position_m, vel: e.velocity_mps });
     }
     const spatialAfterMove = buildSpatialIndex(world, cellSize_m);
+    if (strictDeterminism)
+        assertDeterministicWorldLike(world, "step:post-movement");
     // Phase 6: hazard damage — applied after movement so entities in hazard cells take damage each tick.
     if (ctx.hazardGrid) {
         stepHazardEffects(world.entities, ctx.hazardGrid, cellSize_m);
@@ -424,60 +212,9 @@ export function stepWorld(world, cmds, ctx) {
     sortEventsDeterministic(finalImpacts);
     // Phase 5: snapshot alive set before impacts are applied (used by morale step to detect ally deaths)
     const aliveBeforeTick = new Set(world.entities.filter(e => !e.injury.dead).map(e => e.id));
-    for (const ev of finalImpacts) {
-        const target = index.byId.get(ev.targetId);
-        if (!target || target.injury.dead)
-            continue;
-        // Phase 12: temporary shield absorption from armourLayer capability effects
-        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) {
-            // Phase 27: compute temporary-cavity multiplier from impact velocity
-            const region = ev.region;
-            const tempCavMul = ev.v_impact_mps
-                ? computeTemporaryCavityMul(ev.v_impact_mps, region)
-                : undefined;
-            applyImpactToInjury(target, ev.wpn, effectiveEnergy, region, ev.protectedByArmour, trace, world.tick, tempCavMul);
-            // Phase 27: cavitation bleed boost for fluid-saturated tissue
-            if (ev.v_impact_mps) {
-                const rs = target.injury.byRegion[region];
-                if (rs) {
-                    rs.bleedingRate = computeCavitationBleed(ev.v_impact_mps, rs.bleedingRate, region);
-                }
-            }
-        }
-        // Phase 26: apply knockback impulse to the target
-        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, // Phase 18
-            region: ev.region,
-            energy_J: ev.energy_J,
-            blocked: ev.blocked,
-            parried: ev.parried,
-            shieldBlocked: ev.shieldBlocked,
-            armoured: ev.protectedByArmour,
-            hitQuality: ev.hitQuality,
-        });
-    }
+    applyResolvedImpacts(world, index, finalImpacts, trace, { applyImpactToInjury });
+    if (strictDeterminism)
+        assertDeterministicWorldLike(world, "step:post-impacts");
     // Phase 12B: apply chain payloads from active field effects, then expire timed ones
     stepChainEffects(world, trace, world.tick);
     stepFieldEffects(world);
@@ -550,11 +287,11 @@ export function stepWorld(world, cmds, ctx) {
     // Phase 30: nutrition at 1 Hz (world-level accumulator avoids per-tick BMR calls)
     // Phase 32C: toxicology ticked at same 1 Hz cadence
     {
-        if ((world).__nutritionAccum === undefined)
-            (world).__nutritionAccum = 0;
-        (world).__nutritionAccum = (world).__nutritionAccum + (1 / TICK_HZ);
-        if ((world).__nutritionAccum >= 1.0) {
-            (world).__nutritionAccum -= 1.0;
+        if (runtimeState.nutritionAccum === undefined)
+            runtimeState.nutritionAccum = 0;
+        runtimeState.nutritionAccum += (1 / TICK_HZ);
+        if (runtimeState.nutritionAccum >= 1.0) {
+            runtimeState.nutritionAccum -= 1.0;
             for (const e of world.entities) {
                 if (!e.injury.dead) {
                     const nVMag = Math.sqrt(e.velocity_mps.x ** 2 + e.velocity_mps.y ** 2);
@@ -582,6 +319,8 @@ export function stepWorld(world, cmds, ctx) {
     }
     trace.onEvent({ kind: TraceKinds.TickEnd, tick: world.tick });
     world.tick += 1;
+    if (strictDeterminism)
+        assertDeterministicWorldLike(world, "step:end");
 }
 function resolveCapabilityHitSegment(world, tick, actor, target, salt) {
     const seed = eventSeed(world.seed, tick, actor.id, target.id, salt);
@@ -589,395 +328,23 @@ function resolveCapabilityHitSegment(world, tick, actor, target, salt) {
     const sideBit = (seed & 1);
     return resolveTargetHitSegment(target, rng.q01(), sideBit);
 }
-function applyFunctionalGating(e, tuning) {
-    const func = deriveFunctionalState(e, tuning);
-    // incapacity gates voluntary actions
-    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" };
-        // keep prone if already, and prefer prone for non-acting entities in tactical/sim
-        if (tuning.realism !== "arcade")
-            e.condition.prone = true;
-        return;
-    }
-    // Phase 2A: pinned entities cannot use normal defence (only breakGrapple applies)
-    if (e.condition.pinned && tuning.realism !== "arcade") {
-        e.intent.defence = { mode: "none", intensity: q(0) };
-        e.condition.prone = true;
-    }
-    // Phase 2B: exhaustion collapse — when reserve is fully depleted, entity
-    // cannot maintain posture or active defence (tactical/sim only).
-    if (e.energy.reserveEnergy_J <= 0 && tuning.realism !== "arcade") {
-        e.condition.prone = true;
-        e.intent.defence = { mode: "none", intensity: q(0) };
-    }
-    // forced prone if cannot stand (tactical/sim)
-    if (!func.canStand && tuning.realism !== "arcade")
-        e.condition.prone = true;
-    // hard limb disable hooks (tactical/sim)
-    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" };
-        }
-    }
-}
-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) };
-    }
-}
-function applyStandAndKO(e, tuning) {
-    // KO: if below threshold, go unconscious (but do NOT mark dead)
-    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" };
-            // SIM: drop weapons
-            if (tuning.dropWeaponsOnUnconscious) {
-                e.loadout.items = e.loadout.items.filter(it => it.kind !== "weapon");
-            }
-        }
-        else {
-            // keep them down
-            e.condition.prone = true;
-        }
-    }
-    // If unconscious, cannot act/stand
-    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;
-    }
-    // Standing rules: if player wants to stand but is blocked, force prone
-    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;
-        }
-        // Compute stand-up time based on leg damage + shock + fatigue + encumbrance
-        const func = deriveFunctionalState(e, tuning);
-        const slow = (SCALE.Q - func.mobilityMul); // 0..1
-        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; // reflect forced state
-    }
-}
 /* ------------------ Combat ------------------ */
 function resolveAttack(world, attacker, cmd, tuning, index, impacts, spatial, trace, ctx) {
-    if (attacker.action.attackCooldownTicks > 0)
-        return;
-    // Phase 2C: weapon bind gate — cannot attack while weapons are locked
-    if (attacker.action.weaponBindPartnerId !== 0)
-        return;
-    const target = index.byId.get(cmd.targetId);
-    if (!target || target.injury.dead)
-        return;
-    const funcA = deriveFunctionalState(attacker, tuning);
-    const funcB = deriveFunctionalState(target, tuning);
-    if (!funcA.canAct)
-        return;
-    // Phase 5: pain-induced action suppression (tactical/sim only)
-    if (tuning.realism !== "arcade") {
-        const painSeed = eventSeed(world.seed, world.tick, attacker.id, target.id, 0xA77A2);
-        if (painBlocksAction(painSeed, attacker.injury.shock, attacker.attributes.resilience.distressTolerance))
-            return;
-    }
-    const wpn = findWeapon(attacker.loadout, cmd.weaponId);
-    if (!wpn)
-        return;
-    const reach_m = wpn.reach_m ?? Math.trunc(attacker.attributes.morphology.stature_m * 0.45);
-    const dx = target.position_m.x - attacker.position_m.x;
-    const dy = target.position_m.y - attacker.position_m.y;
-    const dz = target.position_m.z - attacker.position_m.z;
-    // Phase 6: elevation differential adds to vertical separation in the reach check.
-    const cellSizeA = ctx.cellSize_m ?? Math.trunc(4 * SCALE.m);
-    const elevA = elevationAtPosition(ctx.elevationGrid, cellSizeA, attacker.position_m.x, attacker.position_m.y);
-    const elevT = elevationAtPosition(ctx.elevationGrid, cellSizeA, target.position_m.x, target.position_m.y);
-    const dzWithElev = dz + (elevT - elevA);
-    const dist2 = BigInt(dx) * BigInt(dx) + BigInt(dy) * BigInt(dy) + BigInt(dzWithElev) * BigInt(dzWithElev);
-    const reach2 = BigInt(reach_m) * BigInt(reach_m);
-    if (dist2 > reach2)
-        return;
-    if (tuning.realism !== "arcade") {
-        const blocked = isMeleeLaneOccludedByFriendly(world, attacker, target, index, spatial, { laneRadius_m: Math.trunc(0.35 * SCALE.m) });
-        if (blocked)
-            return;
-    }
-    const dirToTarget = normaliseDirCheapQ({ x: dx, y: dy, z: dz });
-    const readyTime_s = wpn.readyTime_s ?? to.s(0.6);
-    // Phase 7: meleeCombat.hitTimingOffset_s shortens attack recovery (max 67% reduction)
-    const attackerMeleeSkill = getSkill(attacker.skills, "meleeCombat");
-    const effectiveReadyTime = Math.max(Math.trunc(readyTime_s / 3), readyTime_s + attackerMeleeSkill.hitTimingOffset_s);
-    attacker.action.attackCooldownTicks = Math.max(1, Math.trunc((effectiveReadyTime * TICK_HZ) / SCALE.s));
-    // Phase 2B: deduct strike stamina cost (always — attacker expends effort whether hit or miss)
-    const clampedIntensity = clampQ(cmd.intensity ?? q(1.0), q(0.1), q(1.0));
-    attacker.energy.reserveEnergy_J = Math.max(0, attacker.energy.reserveEnergy_J - strikeCost_J(attacker, clampedIntensity));
-    const attackSkillBase = clampQ(qMul(attacker.attributes.control.controlQuality, attacker.attributes.control.fineControl), q(0.05), q(0.99));
-    let attackSkill = clampQ(qMul(attackSkillBase, qMul(funcA.coordinationMul, funcA.manipulationMul)), q(0.01), q(0.99));
-    const defenceSkillBase = clampQ(qMul(target.attributes.control.controlQuality, target.attributes.control.stability), q(0.05), q(0.99));
-    let defenceSkill = clampQ(qMul(defenceSkillBase, qMul(funcB.coordinationMul, funcB.mobilityMul)), q(0.01), q(0.99));
-    const geomDot = dotDirQ(attacker.action.facingDirQ, dirToTarget);
-    // Phase 2C: reach dominance — short weapon penalised vs longer weapon in open combat.
-    // Does not apply when attacker is grappling target (close contact negates reach), or target is prone.
-    const grappling = attacker.grapple.holdingTargetId === target.id;
-    if (tuning.realism !== "arcade" && !target.condition.prone && !grappling) {
-        const tgtWpn = findWeapon(target.loadout);
-        if (tgtWpn) {
-            const tgtReach_m = tgtWpn.reach_m ?? Math.trunc(target.attributes.morphology.stature_m * 0.45);
-            const penalty = reachDomPenaltyQ(reach_m, tgtReach_m);
-            attackSkill = clampQ(qMul(attackSkill, penalty), q(0.01), q(0.99));
-        }
-    }
-    // Phase 6: elevation advantage — higher ground boosts attack skill (tactical/sim only).
-    // Threshold is 0.5 m so the effect is achievable at practical melee ranges.
-    if (tuning.realism !== "arcade") {
-        const elevDiff = elevA - elevT; // positive = attacker is higher
-        if (elevDiff > to.m(0.5)) {
-            // +5% per metre above 0.5 m threshold, capped at +10%
-            const bonus = clampQ(mulDiv(elevDiff - to.m(0.5), q(0.05), to.m(1)), q(0), q(0.10));
-            attackSkill = clampQ(qMul(attackSkill, (SCALE.Q + bonus)), q(0.01), q(0.99));
-        }
-    }
-    // Phase 7: meleeDefence skill boosts effective defence quality (parry/block technique)
-    const defMeleeSkill = getSkill(target.skills, "meleeDefence");
-    defenceSkill = clampQ(qMul(defenceSkill, defMeleeSkill.energyTransferMul), q(0.01), q(0.99));
-    // Phase 2C: weapon bind also prevents the defender from parrying/blocking with their weapon
-    const defenceModeEffective = target.action.weaponBindPartnerId !== 0
-        ? "none"
-        : target.intent.defence.mode;
-    let defenceIntensityEffective = target.action.weaponBindPartnerId !== 0
-        ? q(0)
-        : target.intent.defence.intensity;
-    // Phase 7: shieldCraft boosts effective defence skill when actively blocking with a shield
-    if (defenceModeEffective === "block") {
-        const tgtShield = findShield(target.loadout);
-        if (tgtShield) {
-            const shieldSkill = getSkill(target.skills, "shieldCraft");
-            defenceSkill = clampQ(qMul(defenceSkill, shieldSkill.energyTransferMul), q(0.01), q(0.99));
-        }
-    }
-    // Phase 4: surprise mechanics — if the defender cannot perceive the attacker,
-    // their defensive response is reduced or eliminated.
-    if (tuning.realism !== "arcade") {
-        const sEnv = (world).__sensoryEnv ?? DEFAULT_SENSORY_ENV;
-        // Phase 11C: sensor boost from loadout
-        const tgtSensor = findSensor(target.loadout);
-        const tgtSensorBoost = tgtSensor
-            ? { visionRangeMul: tgtSensor.visionRangeMul, hearingRangeMul: tgtSensor.hearingRangeMul }
-            : undefined;
-        const detectionQ = canDetect(target, attacker, sEnv, tgtSensorBoost);
-        if (detectionQ <= 0) {
-            // Full surprise: defender has no defence
-            defenceIntensityEffective = q(0);
-            // Phase 5: fear spike from being attacked without warning
-            target.condition.fearQ = clampQ((target.condition.fearQ ?? 0) + FEAR_SURPRISE, 0, SCALE.Q);
-        }
-        else if (detectionQ < q(0.8)) {
-            // Partial surprise: scale defence intensity by detection quality
-            defenceIntensityEffective = qMul(defenceIntensityEffective, detectionQ);
-        }
-    }
-    // Phase 2C: reach dominance on defence — parrying with a shorter weapon is harder.
-    if (tuning.realism !== "arcade" && defenceModeEffective === "parry" && !grappling) {
-        const defWpnReach = findWeapon(target.loadout);
-        if (defWpnReach) {
-            const defReach = defWpnReach.reach_m ?? Math.trunc(target.attributes.morphology.stature_m * 0.45);
-            defenceSkill = clampQ(qMul(defenceSkill, reachDomPenaltyQ(defReach, reach_m)), q(0.01), q(0.99));
-        }
-    }
-    // Phase 17: flexible weapons (flail, morning star) partially bypass shield blocks
-    const meleeBypassQ = (wpn).shieldBypassQ ?? 0;
-    const defenceIntensityForHit = (meleeBypassQ > 0 && defenceModeEffective === "block")
-        ? qMul(defenceIntensityEffective, SCALE.Q - meleeBypassQ)
-        : defenceIntensityEffective;
-    const seed = eventSeed(world.seed, world.tick, attacker.id, target.id, 0xA11AC);
-    const res = resolveHit(seed, attackSkill, defenceSkill, geomDot, defenceModeEffective, defenceIntensityForHit);
-    trace.onEvent({
-        kind: TraceKinds.AttackAttempt,
-        tick: world.tick,
-        attackerId: attacker.id,
-        targetId: target.id,
-        hit: res.hit,
-        blocked: res.blocked,
-        parried: res.parried,
-        hitQuality: res.hitQuality,
-        area: res.area,
+    resolveAttackFromResolver({
+        world,
+        attacker,
+        cmd,
+        tuning,
+        index,
+        impacts,
+        spatial,
+        trace,
+        ctx,
+        resolveTargetHitSegment,
+        regionCoverageQ,
+        shieldBlocksSegment,
+        armourCoversHit,
     });
-    if (!res.hit) {
-        attacker.action.attackCooldownTicks += Math.trunc(mulDiv(missRecoveryTicks(wpn), clampedIntensity, SCALE.Q));
-        attacker.action.swingMomentumQ = q(0);
-        return;
-    }
-    const hitSeed = eventSeed(world.seed, world.tick, attacker.id, target.id, 0x51DE);
-    const sideBit = (hitSeed & 1);
-    const region = resolveTargetHitSegment(target, ((hitSeed >>> 8) % SCALE.Q), sideBit, res.area);
-    const defenderBlocking = (target.intent.defence.mode === "block"); // or cmd-derived if you do that elsewhere
-    const shield = findShield(target.loadout);
-    const shieldBlocked = res.hit &&
-        res.blocked &&
-        defenderBlocking &&
-        !!shield &&
-        shieldBlocksSegment(shield, target, region, res.area);
-    const baseIntensity = clampQ(cmd.intensity ?? q(1.0), q(0.1), q(1.0));
-    const handling = wpn.handlingMul ?? q(1.0);
-    const handlingPenalty = clampQ(q(1.0) - qMul(q(0.18), (handling - SCALE.Q)), q(0.70), q(1.0));
-    const intensity = clampQ(qMul(baseIntensity, qMul(funcA.manipulationMul, handlingPenalty)), q(0.1), q(1.0));
-    // Phase 29: apply core-temperature power modifier
-    const coreTempQ = (attacker.condition).coreTemp_Q ?? CORE_TEMP_NORMAL_Q;
-    const tempMods = deriveTempModifiers(coreTempQ);
-    const P = Math.trunc(qMul(attacker.attributes.performance.peakPower_W, tempMods.powerMul));
-    const base = clampI32(Math.trunc((P * SCALE.mps) / 200), Math.trunc(2 * SCALE.mps), Math.trunc(12 * SCALE.mps));
-    const wMul = wpn.strikeSpeedMul ?? q(1.0);
-    const cMul = attacker.attributes.control.controlQuality;
-    const qualMul = q(0.70) + qMul(res.hitQuality, q(0.30));
-    const vStrike = mulDiv(mulDiv(mulDiv(mulDiv(base, wMul, SCALE.Q), cMul, SCALE.Q), intensity, SCALE.Q), qualMul, SCALE.Q);
-    const vStrikeVec = scaleDirToSpeed(dirToTarget, vStrike);
-    // Clamp body-movement contribution to strike energy. Combatants decelerate before a controlled
-    // swing; pure sprint-on-sprint kinetic energy should not dominate. Cap at 2 m/s relative.
-    const APPROACH_CAP = Math.trunc(2.0 * SCALE.mps);
-    const bodyRelX = clampI32(attacker.velocity_mps.x - target.velocity_mps.x, -APPROACH_CAP, APPROACH_CAP);
-    const bodyRelY = clampI32(attacker.velocity_mps.y - target.velocity_mps.y, -APPROACH_CAP, APPROACH_CAP);
-    const bodyRelZ = clampI32(attacker.velocity_mps.z - target.velocity_mps.z, -APPROACH_CAP, APPROACH_CAP);
-    const rel = {
-        x: bodyRelX + vStrikeVec.x,
-        y: bodyRelY + vStrikeVec.y,
-        z: bodyRelZ + vStrikeVec.z,
-    };
-    // Phase 2C: two-handed leverage bonus — only when both arms are functional and no off-hand item
-    const hasOffHand = attacker.loadout.items.some(it => it.kind === "shield") ||
-        attacker.loadout.items.filter(it => it.kind === "weapon").length > 1;
-    const twoHandBonus = twoHandedAttackBonusQ(wpn, funcA.leftArmDisabled, funcA.rightArmDisabled, hasOffHand);
-    const baseEnergy_J = mulDiv(mulDiv((impactEnergy_J(attacker, wpn, rel)), funcA.manipulationMul, SCALE.Q), twoHandBonus, SCALE.Q);
-    // Phase 7: meleeCombat.energyTransferMul boosts strike energy delivery (technique bonus)
-    // Phase 11: exoskeleton force multiplier amplifies strike energy
-    const attackerExo = findExoskeleton(attacker.loadout);
-    const exoForceMul = attackerExo ? attackerExo.forceMultiplier : SCALE.Q;
-    let energy_J = mulDiv(mulDiv(baseEnergy_J, attackerMeleeSkill.energyTransferMul, SCALE.Q), exoForceMul, SCALE.Q);
-    // Phase 2 extension: swing momentum carry — bonus energy from rhythmic consecutive strikes
-    const momentumBonus_J = Math.trunc(qMul(energy_J, qMul(attacker.action.swingMomentumQ, SWING_MOMENTUM_MAX)));
-    energy_J += momentumBonus_J;
-    let mitigated = energy_J;
-    if (res.blocked || res.parried) {
-        // Phase 2B: deduct defence stamina cost from the defender
-        target.energy.reserveEnergy_J = Math.max(0, target.energy.reserveEnergy_J - defenceCost_J(target));
-        const leverage = parryLeverageQ(wpn, attacker);
-        const handed = (wpn.handedness ?? "oneHand") === "twoHand" ? q(1.10) : q(1.0);
-        const defenceMul = qMul(leverage, handed);
-        if (res.blocked) {
-            const m = clampQ(q(0.40) - qMul(q(0.12), (defenceMul - SCALE.Q)), q(0.25), q(0.60));
-            mitigated = mulDiv(mitigated, m, SCALE.Q);
-        }
-        if (res.parried) {
-            const m = clampQ(q(0.25) - qMul(q(0.15), (defenceMul - SCALE.Q)), q(0.10), q(0.45));
-            mitigated = mulDiv(mitigated, m, SCALE.Q);
-            // Phase 2C: weapon bind on parry — weapons may lock, requiring both to disengage
-            if (tuning.realism !== "arcade"
-                && attacker.action.weaponBindPartnerId === 0
-                && target.action.weaponBindPartnerId === 0) {
-                const defWpn = findWeapon(target.loadout);
-                if (defWpn) {
-                    const bindSeed = eventSeed(world.seed, world.tick, attacker.id, target.id, 0xB1DE);
-                    const bindRoll = (bindSeed % SCALE.Q);
-                    const bChanceBase = bindChanceQ(wpn, defWpn);
-                    // Phase 2C improvement #4: fatigue increases bind chance — tired fighters lose weapon control
-                    const avgFatigue = ((attacker.energy.fatigue + target.energy.fatigue) >>> 1);
-                    const fatigueMod = (SCALE.Q + qMul(avgFatigue, q(0.20))); // 1.0..1.20
-                    const bChance = clampQ(qMul(bChanceBase, fatigueMod), q(0), q(0.45));
-                    if (bindRoll < bChance) {
-                        const dur = bindDurationTicks(wpn, defWpn);
-                        attacker.action.weaponBindPartnerId = target.id;
-                        attacker.action.weaponBindTicks = dur;
-                        target.action.weaponBindPartnerId = attacker.id;
-                        target.action.weaponBindTicks = dur;
-                        trace.onEvent({
-                            kind: TraceKinds.WeaponBind,
-                            tick: world.tick,
-                            attackerId: attacker.id,
-                            targetId: target.id,
-                            durationTicks: dur,
-                        });
-                    }
-                }
-            }
-        }
-        if (res.shieldBlocked) {
-            const m = clampQ(q(0.35) - qMul(q(0.10), (defenceMul - SCALE.Q)), q(0.20), q(0.55));
-            mitigated = mulDiv(mitigated, m, SCALE.Q);
-        }
-    }
-    const armour = deriveArmourProfile(target.loadout, target.armourState);
-    const isEnergyWeapon = !!(wpn).energyType;
-    const CHANNEL_MASK = isEnergyWeapon ? (1 << DamageChannel.Energy) : (1 << DamageChannel.Kinetic);
-    const armourHit = armourCoversHit(world, regionCoverageQ(armour.coverageByRegion, region), attacker.id, target.id);
-    const protectedByArmour = armourHit && ((armour.protects & CHANNEL_MASK) !== 0);
-    let finalEnergy = mitigated;
-    if (protectedByArmour) {
-        if (isEnergyWeapon && armour.reflectivity > q(0)) {
-            // Phase 11C: reflective armour reduces energy weapon damage
-            finalEnergy = mulDiv(finalEnergy, SCALE.Q - armour.reflectivity, SCALE.Q);
-        }
-        else if (!isEnergyWeapon) {
-            finalEnergy = applyKineticArmourPenetration(mitigated, armour.resist_J, armour.protectedDamageMul);
-        }
-        // Phase 11C: decrement ablative armour resist
-        if (target.armourState) {
-            const armourItems = target.loadout.items.filter(it => it.kind === "armour");
-            for (const it of armourItems) {
-                if ((it).ablative && target.armourState.has(it.id)) {
-                    const st = target.armourState.get(it.id);
-                    st.resistRemaining_J = Math.max(0, st.resistRemaining_J - mitigated);
-                }
-            }
-        }
-    }
-    // Phase 26: effective mass for knockback — same formula used in impactEnergy_J
-    const kbBodyMass = mulDiv(attacker.attributes.morphology.mass_kg, wpn.strikeEffectiveMassFrac ?? q(0.10), SCALE.Q);
-    const kbMassEff = wpn.mass_kg + kbBodyMass;
-    impacts.push({
-        kind: "impact",
-        attackerId: attacker.id,
-        targetId: target.id,
-        region,
-        energy_J: finalEnergy,
-        protectedByArmour,
-        weaponId: wpn.id,
-        wpn,
-        blocked: res.blocked,
-        parried: res.parried,
-        hitQuality: clampQ(res.hitQuality, q(0.05), q(1.0)),
-        shieldBlocked,
-        massEff_kg: kbMassEff, // Phase 26
-    });
-    // Phase 2 extension: update swing momentum based on outcome
-    if (res.blocked || res.parried) {
-        // Blocked/parried — defender broke the rhythm
-        attacker.action.swingMomentumQ = q(0);
-    }
-    else {
-        // Clean hit — rhythm maintained; capture intensity for next strike bonus
-        attacker.action.swingMomentumQ = clampQ(qMul(clampedIntensity, q(0.80)), q(0), SCALE.Q);
-    }
 }
 export function clampSpeed(v, vmax_mps) {
     return { x: clampI32(v.x, -vmax_mps, vmax_mps), y: clampI32(v.y, -vmax_mps, vmax_mps), z: clampI32(v.z, -vmax_mps, vmax_mps) };
@@ -994,33 +361,7 @@ export function clampI32(x, lo, hi) {
 }
 /* ------------------ Grapple command dispatch (Phase 2A) ------------------ */
 function resolveGrappleCommand(world, e, c, tuning, index, impacts, trace) {
-    const target = index.byId.get(c.targetId);
-    if (!target || target.injury.dead)
-        return;
-    const mode = c.mode ?? "grapple";
-    if (mode === "grapple") {
-        if (e.grapple.holdingTargetId === 0 || e.grapple.holdingTargetId !== c.targetId) {
-            // Attempt new grapple
-            resolveGrappleAttempt(world, e, target, c.intensity, tuning, impacts, trace);
-        }
-        else {
-            // Already holding — tick trace (stepGrappleTick handles maintenance)
-            trace.onEvent({
-                kind: TraceKinds.Grapple,
-                tick: world.tick, attackerId: e.id, targetId: target.id,
-                phase: "tick", strengthQ: e.grapple.gripQ,
-            });
-        }
-    }
-    else if (mode === "throw") {
-        resolveGrappleThrow(world, e, target, c.intensity, tuning, impacts, trace);
-    }
-    else if (mode === "choke") {
-        resolveGrappleChoke(e, target, c.intensity, tuning);
-    }
-    else if (mode === "jointLock") {
-        resolveGrappleJointLock(world, e, target, c.intensity, tuning, impacts);
-    }
+    resolveGrappleCommandFromResolver({ world, entity: e, command: c, tuning, index, impacts, trace });
 }
 /* ------------------ Weapon bind breaking (Phase 2C) ------------------ */
 /**
@@ -1034,40 +375,7 @@ function resolveGrappleCommand(world, e, c, tuning, index, impacts, trace) {
  * The bind always clears if the partner entity is dead or no longer present.
  */
 function resolveBreakBind(world, e, intensity, index, trace) {
-    if (e.action.weaponBindPartnerId === 0)
-        return; // not bound
-    const partner = index.byId.get(e.action.weaponBindPartnerId);
-    if (!partner || partner.injury.dead) {
-        // Partner gone — trivially clear
-        e.action.weaponBindPartnerId = 0;
-        e.action.weaponBindTicks = 0;
-        return;
-    }
-    const breakerWpn = findWeapon(e.loadout);
-    const holderWpn = findWeapon(partner.loadout);
-    const breakerArm = breakerWpn?.momentArm_m ?? Math.trunc(0.55 * SCALE.m);
-    const holderArm = holderWpn?.momentArm_m ?? Math.trunc(0.55 * SCALE.m);
-    // Win probability, scaled by command intensity (half-hearted attempt is less likely to succeed)
-    const baseWinQ = breakBindContestQ(e.attributes.performance.peakForce_N, partner.attributes.performance.peakForce_N, breakerArm, holderArm);
-    const winQ = clampQ(qMul(baseWinQ, intensity), q(0.05), q(0.95));
-    const breakSeed = eventSeed(world.seed, world.tick, e.id, partner.id, 0xBB1D);
-    const breakRoll = (breakSeed % SCALE.Q);
-    if (breakRoll < winQ) {
-        // Success: clear bind for both; loser takes a brief stun
-        partner.condition.stunned = clampQ(partner.condition.stunned + q(0.05), 0, SCALE.Q);
-        e.action.weaponBindPartnerId = 0;
-        e.action.weaponBindTicks = 0;
-        partner.action.weaponBindPartnerId = 0;
-        partner.action.weaponBindTicks = 0;
-        trace.onEvent({
-            kind: TraceKinds.WeaponBindBreak,
-            tick: world.tick,
-            entityId: e.id,
-            partnerId: partner.id,
-            reason: "forced",
-        });
-    }
-    // On failure: bind persists; no trace (silence is the signal)
+    resolveBreakBindFromResolver({ world, entity: e, intensity, index, trace });
 }
 /* ------------------ Ranged combat (Phase 3) ------------------ */
 /** Integer square root of a BigInt (floor). Newton-Raphson. */
@@ -1083,207 +391,19 @@ function isqrtBig(n) {
     return r;
 }
 function resolveShoot(world, shooter, cmd, tuning, index, impacts, trace, ctx) {
-    // Phase 3 extension: aiming time accumulation — runs even during reload cooldown
-    {
-        const svx = shooter.velocity_mps.x;
-        const svy = shooter.velocity_mps.y;
-        const shooterVelMag = Math.trunc(Math.sqrt(svx * svx + svy * svy));
-        if (cmd.targetId !== shooter.action.aimTargetId || shooterVelMag > AIM_STILL_THRESHOLD) {
-            shooter.action.aimTicks = 0;
-            shooter.action.aimTargetId = cmd.targetId;
-        }
-        else if (shooter.action.shootCooldownTicks > 0 && shooterVelMag <= AIM_STILL_THRESHOLD) {
-            shooter.action.aimTicks = Math.min(shooter.action.aimTicks + 1, AIM_MAX_TICKS);
-        }
-    }
-    if (shooter.action.shootCooldownTicks > 0)
-        return;
-    const wpn = findRangedWeapon(shooter.loadout, cmd.weaponId);
-    if (!wpn)
-        return;
-    const target = index.byId.get(cmd.targetId);
-    if (!target || target.injury.dead)
-        return;
-    // Phase 3 extension: ammo type override
-    const ammo = cmd.ammoId ? wpn.ammo?.find(a => a.id === cmd.ammoId) : undefined;
-    const projMass_kg = ammo?.projectileMass_kg ?? wpn.projectileMass_kg;
-    const dragCoeff_perM = ammo?.dragCoeff_perM ?? wpn.dragCoeff_perM;
-    const ammoDamage = ammo?.damage ?? wpn.damage;
-    const launchMul = ammo?.launchEnergyMul ?? SCALE.Q;
-    const funcA = deriveFunctionalState(shooter, tuning);
-    if (!funcA.canAct)
-        return;
-    // 3D range (SCALE.m units); Phase 6: elevation differential lengthens the flight path.
-    const dx = BigInt(target.position_m.x - shooter.position_m.x);
-    const dy = BigInt(target.position_m.y - shooter.position_m.y);
-    const cellSizeRS = ctx.cellSize_m ?? Math.trunc(4 * SCALE.m);
-    const elevSh = elevationAtPosition(ctx.elevationGrid, cellSizeRS, shooter.position_m.x, shooter.position_m.y);
-    const elevTg = elevationAtPosition(ctx.elevationGrid, cellSizeRS, target.position_m.x, target.position_m.y);
-    const dz = BigInt(target.position_m.z - shooter.position_m.z + (elevTg - elevSh));
-    const dist_m = Number(isqrtBig(dx * dx + dy * dy + dz * dz));
-    const intensity = clampQ(cmd.intensity ?? q(1.0), q(0.1), q(1.0));
-    // Determine launch energy
-    // Phase 7: throwingWeapons.energyTransferMul boosts thrown weapon launch energy
-    // Phase 3 extension: ammo launchEnergyMul applied for non-thrown weapons
-    const launchEnergy = wpn.category === "thrown"
-        ? mulDiv(thrownLaunchEnergy_J(shooter.attributes.performance.peakPower_W), getSkill(shooter.skills, "throwingWeapons").energyTransferMul, SCALE.Q)
-        : Math.trunc(qMul(wpn.launchEnergy_J, launchMul));
-    // Energy at impact after drag (Phase 3 extension: use ammo drag coefficient)
-    const energy_J = energyAtRange_J(launchEnergy, dragCoeff_perM, dist_m);
-    // Phase 27: impact velocity from pre-armour energy (v = sqrt(2E/m))
-    const v_impact_mps = projMass_kg > 0
-        ? Math.trunc(Math.sqrt(2 * energy_J * SCALE.kg / projMass_kg) * SCALE.mps)
-        : 0;
-    // Shooter's aim quality
-    const ctrl = shooter.attributes.control;
-    const adjDisp = adjustedDispersionQ(wpn.dispersionQ, ctrl.controlQuality, ctrl.fineControl, shooter.energy.fatigue, intensity);
-    // Phase 7: rangedCombat.dispersionMul reduces effective dispersion (tighter grouping)
-    const rangedSkill = getSkill(shooter.skills, "rangedCombat");
-    const skillAdjDisp = qMul(adjDisp, rangedSkill.dispersionMul);
-    let gRadius_m = groupingRadius_m(skillAdjDisp, dist_m);
-    // Phase 3 extension: aiming time — reduce dispersion up to 50% at full aim
-    const aimReduction = mulDiv(SCALE.Q - AIM_MIN_MUL, Math.min(shooter.action.aimTicks, AIM_MAX_TICKS), AIM_MAX_TICKS);
-    const aimMul = (SCALE.Q - aimReduction);
-    gRadius_m = Math.trunc(qMul(gRadius_m, aimMul));
-    // Phase 3 extension: moving target penalty — lead error based on target velocity
-    const tvx = target.velocity_mps.x;
-    const tvy = target.velocity_mps.y;
-    const targetVelMag = Math.trunc(Math.sqrt(tvx * tvx + tvy * tvy));
-    const leadError_m = mulDiv(targetVelMag, 2_000, SCALE.mps); // 0.2s reaction × SCALE.m
-    gRadius_m += leadError_m;
-    // Phase 51: wind drift — crosswind component adds to grouping radius.
-    if (ctx.weather?.wind && v_impact_mps > 0 && dist_m > 0) {
-        gRadius_m += computeWindAimError(ctx.weather.wind, Number(dx), Number(dy), dist_m, v_impact_mps);
-    }
-    // Body half-width: ~20% of stature (≈0.35m for 1.75m human).
-    // Phase 6: cover fraction reduces effective target width → harder to hit.
-    const rawHalfWidth_m = mulDiv(shooter.attributes.morphology.stature_m, 2000, SCALE.Q);
-    const cover = ctx.obstacleGrid
-        ? coverFractionAtPosition(ctx.obstacleGrid, cellSizeRS, target.position_m.x, target.position_m.y)
-        : 0;
-    const bodyHalfWidth_m = cover > 0
-        ? mulDiv(rawHalfWidth_m, Math.max(0, SCALE.Q - cover), SCALE.Q)
-        : rawHalfWidth_m;
-    // Deterministic hit roll (salt 0xD15A)
-    const dispSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15A);
-    const errorMag_m = gRadius_m > 0
-        ? mulDiv(dispSeed % SCALE.Q, gRadius_m, SCALE.Q)
-        : 0;
-    const hit = errorMag_m <= bodyHalfWidth_m;
-    const suppressed = !hit && errorMag_m <= bodyHalfWidth_m * 3;
-    // Deduct stamina and set reload cooldown regardless of hit
-    shooter.energy.reserveEnergy_J = Math.max(0, shooter.energy.reserveEnergy_J - shootCost_J(wpn, intensity, shooter.attributes.performance.peakPower_W));
-    shooter.action.aimTicks = 0; // Phase 3 extension: reset aim after each shot
-    // Phase 17: magazine-based cooldown (modern/revolver firearms)
-    if (wpn.magCapacity !== undefined) {
-        if (shooter.action.roundsInMag === undefined) {
-            shooter.action.roundsInMag = wpn.magCapacity; // first draw: full mag
-        }
-        shooter.action.roundsInMag -= 1;
-        if (shooter.action.roundsInMag <= 0) {
-            shooter.action.roundsInMag = wpn.magCapacity; // magazine empty — reload
-            shooter.action.shootCooldownTicks = recycleTicks(wpn, TICK_HZ);
-        }
-        else {
-            shooter.action.shootCooldownTicks =
-                wpn.shotInterval_s !== undefined
-                    ? Math.ceil((wpn.shotInterval_s * TICK_HZ) / SCALE.s)
-                    : recycleTicks(wpn, TICK_HZ);
-        }
-    }
-    else {
-        shooter.action.shootCooldownTicks = recycleTicks(wpn, TICK_HZ);
-    }
-    if (suppressed) {
-        target.condition.suppressedTicks = Math.max(target.condition.suppressedTicks, 4);
-        target.condition.suppressionFearMul = wpn.suppressionFearMul ?? SCALE.Q;
-    }
-    let hitRegion;
-    if (hit && energy_J > 0) {
-        const sideSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15B);
-        const areaSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15C);
-        const hitArea = target.bodyPlan
-            ? undefined
-            : chooseArea((areaSeed % SCALE.Q));
-        const sideBit = (sideSeed & 1);
-        hitRegion = resolveTargetHitSegment(target, ((areaSeed >>> 8) % SCALE.Q), sideBit, hitArea);
-        // Shield interposition — Phase 17: projectile bypass for flexible weapons
-        const shield = findShield(target.loadout);
-        const shieldSeed = eventSeed(world.seed, world.tick, shooter.id, target.id, 0xD15D);
-        const projBypassQ = ("shieldBypassQ" in wpn) ? wpn.shieldBypassQ : 0;
-        const effectiveCoverageQ = projBypassQ > 0
-            ? Math.max(0, qMul((shield)?.coverageQ ?? 0, SCALE.Q - projBypassQ))
-            : ((shield)?.coverageQ ?? 0);
-        const shieldHit = shield !== undefined &&
-            ((shieldSeed % SCALE.Q) < effectiveCoverageQ) &&
-            shieldBlocksSegment(shield, target, hitRegion, hitArea);
-        // Armour
-        const armour = deriveArmourProfile(target.loadout, target.armourState);
-        const isEnergyProjectile = !!(wpn).energyType;
-        const PROJ_CHANNEL_MASK = isEnergyProjectile ? (1 << DamageChannel.Energy) : (1 << DamageChannel.Kinetic);
-        const armourHit = armourCoversHit(world, regionCoverageQ(armour.coverageByRegion, hitRegion), shooter.id, target.id);
-        const protectedByArmour = armourHit && ((armour.protects & PROJ_CHANNEL_MASK) !== 0);
-        let finalEnergy = energy_J;
-        if (shield && shieldHit) {
-            const shieldResidual = Math.max(0, energy_J - (shield).blockResist_J);
-            finalEnergy = mulDiv(shieldResidual, (shield).deflectQ ?? q(0.30), SCALE.Q);
-        }
-        if (protectedByArmour) {
-            if (isEnergyProjectile && armour.reflectivity > q(0)) {
-                finalEnergy = mulDiv(finalEnergy, SCALE.Q - armour.reflectivity, SCALE.Q);
-            }
-            else if (!isEnergyProjectile) {
-                finalEnergy = applyKineticArmourPenetration(finalEnergy, armour.resist_J, armour.protectedDamageMul);
-            }
-            // Phase 11C: decrement ablative armour resist
-            if (target.armourState) {
-                const armourItems = target.loadout.items.filter(it => it.kind === "armour");
-                for (const it of armourItems) {
-                    if ((it).ablative && target.armourState.has(it.id)) {
-                        const st = target.armourState.get(it.id);
-                        st.resistRemaining_J = Math.max(0, st.resistRemaining_J - energy_J);
-                    }
-                }
-            }
-        }
-        // Build a minimal Weapon proxy for applyImpactToInjury
-        // Phase 3 extension: use ammo-overridden damage and projectile mass
-        const wpnProxy = {
-            id: wpn.id,
-            kind: "weapon",
-            name: wpn.name,
-            mass_kg: projMass_kg,
-            bulk: q(0),
-            damage: ammoDamage,
-        };
-        impacts.push({
-            kind: "impact",
-            attackerId: shooter.id,
-            targetId: target.id,
-            region: hitRegion,
-            energy_J: finalEnergy,
-            protectedByArmour,
-            weaponId: wpn.id,
-            wpn: wpnProxy,
-            blocked: shieldHit ?? false,
-            parried: false,
-            hitQuality: q(0.75),
-            shieldBlocked: shieldHit ?? false,
-            massEff_kg: projMass_kg, // Phase 26: projectile mass drives knockback
-            v_impact_mps, // Phase 27: hydrostatic shock velocity
-        });
-    }
-    trace.onEvent({
-        kind: TraceKinds.ProjectileHit,
-        tick: world.tick,
-        shooterId: shooter.id,
-        targetId: target.id,
-        weaponId: wpn.id, // Phase 18
-        hit,
-        ...(hitRegion !== undefined ? { region: hitRegion } : {}),
-        distance_m: dist_m,
-        energyAtImpact_J: energy_J,
-        suppressed,
+    resolveShootFromResolver({
+        world,
+        shooter,
+        cmd,
+        tuning,
+        impacts,
+        trace,
+        ctx,
+        target: index.byId.get(cmd.targetId),
+        resolveTargetHitSegment,
+        shieldBlocksSegment,
+        regionCoverageQ,
+        armourCoversHit,
     });
 }
 // ---- Phase 2B: per-action stamina cost helpers ----
@@ -1613,86 +733,7 @@ export function applyExplosion(world, origin, spec, tick, trace) {
 }
 /* ── Phase 9: medical treatment ──────────────────────────────────────────── */
 function resolveTreat(world, treater, cmd, index, trace, ctx) {
-    if (treater.injury.dead)
-        return;
-    const target = index.byId.get(cmd.targetId);
-    if (!target || target.injury.dead)
-        return;
-    // Treater must be within 2 m of target (physical contact required)
-    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;
-    // Check equipment tier meets minimum requirement
-    const tierRank = TIER_RANK[cmd.tier];
-    const actionMinRank = TIER_RANK[ACTION_MIN_TIER[cmd.action]];
-    if (tierRank < actionMinRank)
-        return;
-    // Phase 11: technology gate — check if the tier's required capability is available
-    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");
-    // effectMul = tierMul × (treatmentRateMul / SCALE.Q)
-    // treatmentRateMul at q(1.0) = SCALE.Q baseline gives exactly tierMul
-    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;
-        // Slight shock from painful application
-        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, // cannot heal below permanent floor
-        SCALE.Q);
-        reg.structuralDamage = newStr;
-        // Surgery also stops active bleeding
-        const bleedReduction = mulDiv(BASE_BANDAGE_RATE, effectMul, SCALE.Q);
-        reg.bleedingRate = clampQ((reg.bleedingRate - bleedReduction), q(0), q(1.0));
-        // Clear fracture if structural drops below threshold
-        if (reg.fractured && reg.structuralDamage < FRACTURE_THRESHOLD) {
-            reg.fractured = false;
-        }
-        // Clear infection at surgicalKit tier or above
-        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);
-        // Fluid restoration also reduces shock slightly
-        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 } : {}),
-    });
+    resolveTreatFromResolver({ world, treater, cmd, index, trace, ctx });
 }
 /* ── Phase 12: capability sources and effects ─────────────────────────────── */
 /**
@@ -1716,103 +757,10 @@ const CAPABILITY_WEAPON_DEFAULT = {
  * magical from technological effects at this level.
  */
 export function applyPayload(world, actor, target, payload, trace, tick, effectId) {
-    switch (payload.kind) {
-        case "impact": {
-            const hitRegion = resolveCapabilityHitSegment(world, tick, actor, target, 0xCAB1);
-            if (!target.injury.byRegion[hitRegion])
-                break;
-            let effectiveEnergy = payload.spec.energy_J;
-            if ((target.condition.shieldReserve_J ?? 0) > 0 &&
-                target.condition.shieldExpiry_tick !== undefined &&
-                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 wpn = CAPABILITY_CHANNEL_WEAPONS[payload.spec.channel] ?? CAPABILITY_WEAPON_DEFAULT;
-                applyImpactToInjury(target, wpn, effectiveEnergy, hitRegion, false, trace, tick);
-            }
-            break;
-        }
-        case "treatment": {
-            // Direct healing — bypasses range/equipment checks; capability source IS the tool.
-            const BASE_CAP_HEAL = q(0.0050);
-            const healRate = qMul(BASE_CAP_HEAL, payload.rateMul);
-            for (const reg of Object.values(target.injury.byRegion)) {
-                if (reg.bleedingRate > 0) {
-                    reg.bleedingRate = clampQ((reg.bleedingRate - healRate), 0, SCALE.Q);
-                }
-            }
-            target.injury.shock = clampQ((target.injury.shock - qMul(q(0.01), payload.rateMul)), 0, SCALE.Q);
-            break;
-        }
-        case "armourLayer": {
-            // Accumulate into shield reserve; extend or set expiry.
-            target.condition.shieldReserve_J = (target.condition.shieldReserve_J ?? 0) + payload.resist_J;
-            const newExpiry = tick + payload.duration_ticks;
-            target.condition.shieldExpiry_tick = Math.max(target.condition.shieldExpiry_tick ?? 0, newExpiry);
-            break;
-        }
-        case "velocity": {
-            target.velocity_mps = vAdd(target.velocity_mps, payload.delta_mps);
-            break;
-        }
-        case "substance": {
-            if (!target.substances)
-                target.substances = [];
-            target.substances.push({ ...payload.substance });
-            break;
-        }
-        case "structuralRepair": {
-            const seg = target.injury.byRegion[payload.region];
-            if (seg) {
-                const floor = seg.permanentDamage ?? 0;
-                const repaired = Math.max(floor, seg.structuralDamage - payload.amount);
-                seg.structuralDamage = clampQ(repaired, 0, SCALE.Q);
-            }
-            break;
-        }
-        case "fieldEffect": {
-            if (!world.activeFieldEffects)
-                world.activeFieldEffects = [];
-            const fe = {
-                ...payload.spec,
-                id: `${actor.id}_${effectId}_${tick}`,
-                origin: { x: actor.position_m.x, y: actor.position_m.y, z: actor.position_m.z },
-                placedByEntityId: actor.id,
-            };
-            world.activeFieldEffects.push(fe);
-            break;
-        }
-        case "weaponImpact": {
-            // Phase 28: custom damage profile (fire breath, napalm, chemical burn, etc.)
-            // Bypasses armour like other capability impacts; damage mix is determined by profile.
-            const wpn = {
-                id: "cap_weaponimpact",
-                kind: "weapon",
-                name: "WeaponImpact",
-                mass_kg: 0,
-                bulk: q(0),
-                damage: payload.profile,
-            };
-            const hitRegion = resolveCapabilityHitSegment(world, tick, actor, target, 0xCAB2);
-            if (!target.injury.byRegion[hitRegion])
-                break;
-            let effectiveEnergy = payload.energy_J;
-            if ((target.condition.shieldReserve_J ?? 0) > 0 &&
-                target.condition.shieldExpiry_tick !== undefined &&
-                tick <= target.condition.shieldExpiry_tick) {
-                const absorbed = Math.min(target.condition.shieldReserve_J, effectiveEnergy);
-                target.condition.shieldReserve_J -= absorbed;
-                effectiveEnergy -= absorbed;
-            }
-            if (effectiveEnergy > 0) {
-                applyImpactToInjury(target, wpn, effectiveEnergy, hitRegion, false, trace, tick);
-            }
-            break;
-        }
-    }
+    applyPayloadFromResolver(world, actor, target, payload, trace, tick, effectId, {
+        resolveCapabilityHitSegment,
+        applyImpactToInjury,
+    });
 }
 /**
  * Resolve all payloads of a capability effect for the appropriate target set.
@@ -1820,179 +768,17 @@ export function applyPayload(world, actor, target, payload, trace, tick, effectI
  * Single-target: targetId entity, or self if absent.
  */
 export function applyCapabilityEffect(world, actor, targetId, effect, trace, tick) {
-    const payloads = Array.isArray(effect.payload)
-        ? effect.payload
-        : [effect.payload];
-    // Determine target entities
-    let targets;
-    if (effect.coneHalfAngle_rad !== undefined) {
-        // Phase 28: directional cone AoE — apply to all living entities within the cone
-        const range_m = effect.range_m ?? 0;
-        let dir;
-        if (effect.coneDir === "fixed" && effect.coneDirFixed) {
-            dir = effect.coneDirFixed;
-        }
-        else {
-            // "facing" (default) — use actor's current facingDirQ
-            const fx = actor.action.facingDirQ.x;
-            const fy = actor.action.facingDirQ.y;
-            const mag = Math.sqrt(fx * fx + fy * fy);
-            const sc = mag > 0 ? SCALE.m / mag : 1;
-            dir = { dx: Math.round(fx * sc), dy: Math.round(fy * sc) };
-        }
-        const cone = {
-            origin: { x: actor.position_m.x, y: actor.position_m.y },
-            dir,
-            halfAngle_rad: effect.coneHalfAngle_rad,
-            range_m,
-        };
-        targets = world.entities.filter(e => !e.injury.dead && entityInCone(e, cone));
-    }
-    else if (effect.aoeRadius_m !== undefined) {
-        const origin = targetId !== undefined
-            ? (world.entities.find(e => e.id === targetId)?.position_m ?? actor.position_m)
-            : actor.position_m;
-        const radSq = effect.aoeRadius_m * effect.aoeRadius_m;
-        targets = world.entities.filter(e => {
-            if (e.injury.dead)
-                return false;
-            const dx = e.position_m.x - origin.x;
-            const dy = e.position_m.y - origin.y;
-            return dx * dx + dy * dy <= radSq;
-        });
-    }
-    else if (targetId !== undefined) {
-        const t = world.entities.find(e => e.id === targetId);
-        targets = t && !t.injury.dead ? [t] : [];
-    }
-    else {
-        targets = [actor];
-    }
-    for (const target of targets) {
-        // Phase 12B: magic resistance — non-self targets may resist the effect
-        if (target.id !== actor.id) {
-            const mr = target.attributes.resilience.magicResist ?? 0;
-            if (mr > 0) {
-                const resistSeed = eventSeed(world.seed, tick, actor.id, target.id, 0x5E515);
-                if ((resistSeed % SCALE.Q) < mr)
-                    continue;
-            }
-        }
-        for (const p of payloads) {
-            applyPayload(world, actor, target, p, trace, tick, effect.id);
-        }
-    }
+    applyCapabilityEffectFromResolver(world, actor, targetId, effect, trace, tick, {
+        resolveCapabilityHitSegment,
+        applyImpactToInjury,
+    });
 }
 /**
  * Resolve a capability activation command for actor.
  * Validates suppression, range, and cost; handles cast time via pendingActivation.
  */
 function resolveActivation(world, actor, cmd, ctx, trace, tick) {
-    if (!actor.capabilitySources)
-        return;
-    const source = actor.capabilitySources.find(s => s.id === cmd.sourceId);
-    if (!source)
-        return;
-    const effect = source.effects.find(ef => ef.id === cmd.effectId);
-    if (!effect)
-        return;
-    // Phase 12B: cooldown gate — can't re-activate until cooldown expires
-    const cooldownKey = `${source.id}:${effect.id}`;
-    if ((actor.action.capabilityCooldowns?.get(cooldownKey) ?? 0) > 0)
-        return;
-    // Phase 12B: tech-context gate — requiredCapability must be available if techCtx is present
-    if (effect.requiredCapability !== undefined && ctx.techCtx !== undefined) {
-        if (!isCapabilityAvailable(ctx.techCtx, effect.requiredCapability))
-            return;
-    }
-    // Suppression check — any covering field whose tags overlap source tags blocks activation
-    const ax = actor.position_m.x;
-    const ay = actor.position_m.y;
-    const suppressed = (world.activeFieldEffects ?? []).some(fe => {
-        const dx = ax - fe.origin.x;
-        const dy = ay - fe.origin.y;
-        const distSq = dx * dx + dy * dy;
-        const radSq = fe.radius_m * fe.radius_m;
-        return distSq <= radSq && source.tags.some(t => fe.suppressesTags.includes(t));
+    resolveActivationFromResolver(world, actor, cmd, ctx, trace, tick, (effect) => {
+        applyCapabilityEffect(world, actor, cmd.targetId, effect, trace, tick);
     });
-    if (suppressed) {
-        trace.onEvent({ kind: TraceKinds.CapabilitySuppressed, tick, entityId: actor.id, sourceId: cmd.sourceId, effectId: cmd.effectId });
-        return;
-    }
-    // Range check
-    if (effect.range_m !== undefined && cmd.targetId !== undefined) {
-        const tgt = world.entities.find(e => e.id === cmd.targetId);
-        if (tgt) {
-            const dx = tgt.position_m.x - ax;
-            const dy = tgt.position_m.y - ay;
-            if (dx * dx + dy * dy > effect.range_m * effect.range_m)
-                return;
-        }
-    }
-    // Phase 12B: concentration aura — castTime_ticks < 0 means ongoing per-tick effect.
-    // No upfront cost; stepConcentration deducts cost_J each tick.
-    if (effect.castTime_ticks < 0) {
-        actor.activeConcentration = {
-            sourceId: source.id,
-            effectId: effect.id,
-            ...(cmd.targetId !== undefined ? { targetId: cmd.targetId } : {}),
-        };
-        trace.onEvent({ kind: TraceKinds.CapabilityActivated, tick, entityId: actor.id, sourceId: source.id, effectId: effect.id });
-        return;
-    }
-    // Cost check (boundless sources always have enough)
-    const isBoundless = source.regenModel.type === "boundless";
-    let sourceToDraw = source;
-    if (!isBoundless && source.reserve_J < effect.cost_J) {
-        // Phase 12B: try linked fallback source
-        if (source.linkedFallbackId) {
-            const fallback = actor.capabilitySources.find(s => s.id === source.linkedFallbackId);
-            if (fallback && (fallback.regenModel.type === "boundless" || fallback.reserve_J >= effect.cost_J)) {
-                sourceToDraw = fallback;
-            }
-            else {
-                return; // both depleted
-            }
-        }
-        else {
-            return;
-        }
-    }
-    const drawIsBoundless = sourceToDraw.regenModel.type === "boundless";
-    // Cast time — queue pending activation and deduct cost at cast-start
-    if (effect.castTime_ticks > 0) {
-        if (!actor.pendingActivation) {
-            if (!drawIsBoundless)
-                sourceToDraw.reserve_J -= effect.cost_J;
-            actor.pendingActivation = cmd.targetId !== undefined
-                ? { sourceId: cmd.sourceId, effectId: cmd.effectId, targetId: cmd.targetId, resolveAtTick: tick + effect.castTime_ticks }
-                : { sourceId: cmd.sourceId, effectId: cmd.effectId, resolveAtTick: tick + effect.castTime_ticks };
-            // Phase 12B: set cooldown at cast-start so the cast itself is gated
-            if (effect.cooldown_ticks && effect.cooldown_ticks > 0) {
-                if (!actor.action.capabilityCooldowns)
-                    actor.action.capabilityCooldowns = new Map();
-                actor.action.capabilityCooldowns.set(cooldownKey, effect.cooldown_ticks);
-            }
-        }
-        return;
-    }
-    // Instant — deduct, resolve, and set cooldown
-    if (!drawIsBoundless)
-        sourceToDraw.reserve_J -= effect.cost_J;
-    applyCapabilityEffect(world, actor, cmd.targetId, effect, trace, tick);
-    trace.onEvent({ kind: TraceKinds.CapabilityActivated, tick, entityId: actor.id, sourceId: cmd.sourceId, effectId: cmd.effectId });
-    if (effect.cooldown_ticks && effect.cooldown_ticks > 0) {
-        if (!actor.action.capabilityCooldowns)
-            actor.action.capabilityCooldowns = new Map();
-        actor.action.capabilityCooldowns.set(cooldownKey, effect.cooldown_ticks);
-    }
-    // Phase 28: if sustainedTicks, set up emission for the remaining ticks (first tick fired above)
-    if (effect.sustainedTicks && effect.sustainedTicks > 1) {
-        actor.action.sustainedEmission = {
-            sourceId: cmd.sourceId,
-            effectId: cmd.effectId,
-            ...(cmd.targetId !== undefined ? { targetId: cmd.targetId } : {}),
-            remainingTicks: effect.sustainedTicks - 1,
-        };
-    }
 }