@its-not-rocket-science/ananke 0.1.0

package/dist/src/arena.js

@@ -0,0 +1,695 @@
+// src/arena.ts — Phase 20: Arena Simulation Framework
+//
+// Declarative scenario system: define a fight (+ optional recovery), run it over
+// many seeds, validate outcomes against expectations, and produce statistical reports.
+// Integrates Phase 18 (narrative) and Phase 19 (downtime) into one ergonomic tool.
+import { q, SCALE } from "./units.js";
+import { generateIndividual } from "./generate.js";
+import { HUMAN_BASE, KNIGHT_INFANTRY } from "./archetypes.js";
+import { defaultIntent } from "./sim/intent.js";
+import { defaultAction } from "./sim/action.js";
+import { defaultCondition } from "./sim/condition.js";
+import { defaultInjury } from "./sim/injury.js";
+import { HUMANOID_PLAN, segmentIds } from "./sim/bodyplan.js";
+import { v3 } from "./sim/vec3.js";
+import { STARTER_WEAPONS, STARTER_ARMOUR } from "./equipment.js";
+import { buildSkillMap } from "./sim/skills.js";
+import { AI_PRESETS } from "./sim/ai/presets.js";
+import { stepWorld } from "./sim/kernel.js";
+import { buildWorldIndex } from "./sim/indexing.js";
+import { buildSpatialIndex } from "./sim/spatial.js";
+import { buildAICommands } from "./sim/ai/system.js";
+import { TUNING } from "./sim/tuning.js";
+import { TICK_HZ } from "./sim/tick.js";
+import { CollectingTrace } from "./metrics.js";
+import { buildCombatLog } from "./narrative.js";
+import { stepDowntime, } from "./downtime.js";
+export function expectWinRate(teamId, min, max) {
+    const desc = max !== undefined
+        ? `team ${teamId} wins ${(min * 100).toFixed(0)}–${(max * 100).toFixed(0)}%`
+        : `team ${teamId} wins ≥ ${(min * 100).toFixed(0)}%`;
+    return {
+        description: desc,
+        check(r) {
+            const wr = r.winRateByTeam.get(teamId) ?? 0;
+            return wr >= min && (max === undefined || wr <= max);
+        },
+    };
+}
+export function expectSurvivalRate(entityId, min) {
+    return {
+        description: `entity ${entityId} survives ≥ ${(min * 100).toFixed(0)}% of trials`,
+        check(r) { return (r.survivalRateByEntity.get(entityId) ?? 0) >= min; },
+    };
+}
+export function expectMeanDuration(minSeconds, maxSeconds) {
+    return {
+        description: `mean combat duration ${minSeconds}–${maxSeconds} s`,
+        check(r) {
+            return r.meanCombatDuration_s >= minSeconds && r.meanCombatDuration_s <= maxSeconds;
+        },
+    };
+}
+export function expectRecovery(entityId, maxDays, _careLevel) {
+    return {
+        description: `entity ${entityId} combat-ready within ${maxDays} days`,
+        check(r) {
+            const stats = r.recoveryStats?.find(s => s.entityId === entityId);
+            if (!stats || stats.meanCombatReadyDays === null)
+                return false;
+            return stats.meanCombatReadyDays <= maxDays;
+        },
+    };
+}
+export function expectResourceCost(teamId, maxCostUnits) {
+    return {
+        description: `team ${teamId} mean resource cost ≤ ${maxCostUnits} units`,
+        check(r) {
+            const teamEntities = r.scenario.combatants
+                .filter(c => c.teamId === teamId)
+                .map(c => c.id);
+            if (teamEntities.length === 0)
+                return true;
+            const stats = (r.recoveryStats ?? []).filter(s => teamEntities.includes(s.entityId));
+            if (stats.length === 0)
+                return true;
+            const mean = stats.reduce((sum, s) => sum + s.meanResourceCostUnits, 0) / stats.length;
+            return mean <= maxCostUnits;
+        },
+    };
+}
+// ── Internal helpers ──────────────────────────────────────────────────────────
+const DEFEATED_CONSCIOUSNESS = q(0.10); // tactical threshold
+const DEFAULT_MAX_TICKS = 30 * TICK_HZ; // 30 s × 20 Hz = 600 ticks
+const DEFAULT_CELL_SIZE_M = Math.trunc(4 * SCALE.m);
+function buildTrialEntity(c, trialSeed) {
+    const entitySeed = c.seed ?? (trialSeed * 1000 + c.id);
+    const attrs = generateIndividual(entitySeed, c.archetype);
+    const segs = segmentIds(HUMANOID_PLAN);
+    const entity = {
+        id: c.id,
+        teamId: c.teamId,
+        attributes: attrs,
+        energy: { reserveEnergy_J: attrs.performance.reserveEnergy_J, fatigue: q(0) },
+        loadout: { items: [...c.loadout.items] },
+        traits: [],
+        ...(c.skills !== undefined && { skills: c.skills }),
+        bodyPlan: HUMANOID_PLAN,
+        position_m: { ...c.position_m },
+        velocity_mps: v3(0, 0, 0),
+        intent: defaultIntent(),
+        action: defaultAction(),
+        condition: defaultCondition(),
+        injury: defaultInjury(segs),
+        grapple: { holdingTargetId: 0, heldByIds: [], gripQ: q(0), position: "standing" },
+    };
+    c.mutateOnCreate?.(entity);
+    return entity;
+}
+function buildTrialWorld(scenario, trialSeed) {
+    const entities = scenario.combatants.map(c => buildTrialEntity(c, trialSeed));
+    return { tick: 0, seed: trialSeed, entities };
+}
+function isDefeated(e) {
+    return e.injury.dead || e.injury.consciousness <= DEFEATED_CONSCIOUSNESS;
+}
+function detectOutcome(world) {
+    const byTeam = new Map();
+    for (const e of world.entities) {
+        if (!byTeam.has(e.teamId))
+            byTeam.set(e.teamId, { alive: 0, total: 0 });
+        const t = byTeam.get(e.teamId);
+        t.total++;
+        if (!isDefeated(e))
+            t.alive++;
+    }
+    const allTeamIds = [...byTeam.keys()];
+    const activeTeams = allTeamIds.filter(id => byTeam.get(id).alive > 0);
+    // Multiple teams: combat over only when ≤1 team remains active
+    if (allTeamIds.length <= 1)
+        return null; // single-team — never "over" via team victory
+    if (activeTeams.length === 0)
+        return "draw";
+    if (activeTeams.length === 1) {
+        const winner = activeTeams[0];
+        if (winner === 1)
+            return "team1_wins";
+        if (winner === 2)
+            return "team2_wins";
+        return "draw";
+    }
+    return null; // still fighting
+}
+function captureArenaInjury(e) {
+    const activeBleedingRegions = [];
+    const fracturedRegions = [];
+    const infectedRegions = [];
+    let maxStr = 0;
+    for (const [r, ri] of Object.entries(e.injury.byRegion)) {
+        if (ri.bleedingRate > 0)
+            activeBleedingRegions.push(r);
+        if (ri.fractured)
+            fracturedRegions.push(r);
+        if (ri.infectedTick >= 0)
+            infectedRegions.push(r);
+        if (ri.structuralDamage > maxStr)
+            maxStr = ri.structuralDamage;
+    }
+    return {
+        entityId: e.id,
+        dead: e.injury.dead,
+        unconscious: e.injury.consciousness <= DEFEATED_CONSCIOUSNESS,
+        consciousness: e.injury.consciousness / SCALE.Q,
+        fluidLoss: e.injury.fluidLoss / SCALE.Q,
+        shock: e.injury.shock / SCALE.Q,
+        activeBleedingRegions,
+        fracturedRegions,
+        infectedRegions,
+        maxStructuralDamage: maxStr / SCALE.Q,
+    };
+}
+function runTrialRecovery(world, scenario) {
+    const rec = scenario.recovery;
+    const elapsedSeconds = Math.round(rec.recoveryHours * 3600);
+    const treatments = new Map();
+    for (const e of world.entities) {
+        const careLevel = rec.careByTeam?.get(e.teamId) ?? rec.careLevel;
+        const sched = { careLevel };
+        if (rec.inventory)
+            sched.inventory = new Map(rec.inventory);
+        treatments.set(e.id, sched);
+    }
+    const reports = stepDowntime(world, elapsedSeconds, {
+        treatments,
+        rest: rec.rest ?? false,
+    });
+    return reports.map((r) => ({
+        entityId: r.entityId,
+        died: r.died,
+        combatReadyAt_s: r.combatReadyAt_s,
+        fullRecoveryAt_s: r.fullRecoveryAt_s,
+        resourcesUsed: r.resourcesUsed,
+        totalCostUnits: r.totalCostUnits,
+    }));
+}
+// ── Main runner ───────────────────────────────────────────────────────────────
+export function runArena(scenario, trials, options) {
+    const maxTicks = scenario.maxTicks ?? DEFAULT_MAX_TICKS;
+    const cellSize_m = scenario.terrain?.cellSize_m != null
+        ? Math.trunc(scenario.terrain.cellSize_m * SCALE.m)
+        : DEFAULT_CELL_SIZE_M;
+    const baseCtx = {
+        tractionCoeff: q(1.0),
+        tuning: TUNING.tactical,
+        ...(scenario.terrain?.terrainGrid && { terrainGrid: scenario.terrain.terrainGrid }),
+        ...(scenario.terrain?.obstacleGrid && { obstacleGrid: scenario.terrain.obstacleGrid }),
+        ...(scenario.terrain?.elevationGrid && { elevationGrid: scenario.terrain.elevationGrid }),
+        ...(scenario.terrain?.hazardGrid && { hazardGrid: scenario.terrain.hazardGrid }),
+        cellSize_m,
+        ...options?.ctx,
+    };
+    const policyMap = new Map();
+    for (const c of scenario.combatants) {
+        policyMap.set(c.id, (c.aiPolicy ?? AI_PRESETS["lineInfantry"]));
+    }
+    const trialResults = [];
+    for (let i = 0; i < trials; i++) {
+        const trialSeed = (options?.seedOffset ?? 0) + i + 1;
+        const world = buildTrialWorld(scenario, trialSeed);
+        const tracer = options?.narrativeCfg ? new CollectingTrace() : undefined;
+        const ctx = tracer
+            ? { ...baseCtx, trace: tracer }
+            : baseCtx;
+        let ticks = 0;
+        let outcome = detectOutcome(world);
+        while (outcome === null && ticks < maxTicks) {
+            const index = buildWorldIndex(world);
+            const spatial = buildSpatialIndex(world, cellSize_m);
+            const cmds = buildAICommands(world, index, spatial, id => policyMap.get(id));
+            stepWorld(world, cmds, ctx);
+            ticks++;
+            outcome = detectOutcome(world);
+        }
+        const finalOutcome = outcome ?? "timeout";
+        const survivors = world.entities.filter(e => !isDefeated(e)).map(e => e.id);
+        const injuries = world.entities.map(e => captureArenaInjury(e));
+        // Combat log
+        let combatLog;
+        if (tracer && options?.narrativeCfg) {
+            const lines = [];
+            for (const ev of tracer.events) {
+                const text = buildCombatLog([ev], options.narrativeCfg)[0];
+                if (text)
+                    lines.push({ tick: (ev).tick ?? 0, text });
+            }
+            combatLog = lines;
+        }
+        // Recovery
+        let recoveryOutcomes;
+        if (scenario.recovery) {
+            recoveryOutcomes = runTrialRecovery(world, scenario);
+        }
+        const trialResult = {
+            trialIndex: i,
+            seed: trialSeed,
+            ticks,
+            outcome: finalOutcome,
+            survivors,
+            injuries,
+        };
+        if (recoveryOutcomes !== undefined)
+            trialResult.recoveryOutcomes = recoveryOutcomes;
+        if (combatLog !== undefined)
+            trialResult.combatLog = combatLog;
+        trialResults.push(trialResult);
+    }
+    return aggregateResults(scenario, trialResults);
+}
+// ── Aggregation ───────────────────────────────────────────────────────────────
+function aggregateResults(scenario, trialResults) {
+    const n = trialResults.length;
+    if (n === 0) {
+        const empty = {
+            scenario, trials: 0, trialResults: [],
+            winRateByTeam: new Map(), drawRate: 0, timeoutRate: 0,
+            meanCombatDuration_s: 0, p50CombatDuration_s: 0,
+            survivalRateByEntity: new Map(), meanTTI_s: new Map(),
+            injuryDistribution: [], expectationResults: [],
+        };
+        return empty;
+    }
+    // Win rates
+    const winCounts = new Map();
+    let drawCount = 0;
+    let timeoutCount = 0;
+    for (const t of trialResults) {
+        if (t.outcome === "draw")
+            drawCount++;
+        else if (t.outcome === "timeout")
+            timeoutCount++;
+        else {
+            // team1_wins or team2_wins
+            const teamId = t.outcome === "team1_wins" ? 1 : 2;
+            winCounts.set(teamId, (winCounts.get(teamId) ?? 0) + 1);
+        }
+    }
+    const winRateByTeam = new Map();
+    for (const [id, cnt] of winCounts)
+        winRateByTeam.set(id, cnt / n);
+    // Combat durations
+    const durations = trialResults.map(t => t.ticks / TICK_HZ);
+    const meanCombatDuration_s = durations.reduce((a, b) => a + b, 0) / n;
+    const sorted = [...durations].sort((a, b) => a - b);
+    const p50CombatDuration_s = sorted[Math.floor(n / 2)] ?? 0;
+    // Survival rates
+    const survivalRateByEntity = new Map();
+    for (const c of scenario.combatants) {
+        const alive = trialResults.filter(t => t.survivors.includes(c.id)).length;
+        survivalRateByEntity.set(c.id, alive / n);
+    }
+    // Mean TTI (in seconds)
+    const meanTTI_s = new Map();
+    for (const c of scenario.combatants) {
+        const ttiSums = trialResults.map(t => {
+            const inj = t.injuries.find(i => i.entityId === c.id);
+            if (!inj)
+                return t.ticks / TICK_HZ; // not in trial — survived
+            if (inj.dead || inj.unconscious) {
+                // Estimate TTI as total ticks (conservative; no per-tick event tracking here)
+                return t.ticks / TICK_HZ;
+            }
+            return t.ticks / TICK_HZ; // survived full duration
+        });
+        meanTTI_s.set(c.id, ttiSums.reduce((a, b) => a + b, 0) / n);
+    }
+    // Injury distribution
+    const injuryDistribution = scenario.combatants.map(c => {
+        const trials_inj = trialResults.map(t => t.injuries.find(i => i.entityId === c.id));
+        const meanFluidLoss = avg(trials_inj.map(i => i?.fluidLoss ?? 0));
+        const fractureProbability = trials_inj.filter(i => (i?.fracturedRegions.length ?? 0) > 0).length / n;
+        const deathProbability = trials_inj.filter(i => i?.dead).length / n;
+        return { entityId: c.id, meanFluidLoss, fractureProbability, deathProbability };
+    });
+    // Recovery stats (if any trial has recoveryOutcomes)
+    let recoveryStats;
+    const hasRecovery = scenario.recovery != null && trialResults.some(t => t.recoveryOutcomes);
+    if (hasRecovery) {
+        recoveryStats = scenario.combatants.map(c => {
+            const outcomes = trialResults
+                .flatMap(t => t.recoveryOutcomes ?? [])
+                .filter(o => o.entityId === c.id);
+            const survivalRatePostRecovery = outcomes.length === 0
+                ? 1.0
+                : outcomes.filter(o => !o.died).length / outcomes.length;
+            const readyTimes_days = outcomes
+                .map(o => o.combatReadyAt_s !== null ? o.combatReadyAt_s / 86400 : null)
+                .filter((v) => v !== null);
+            const fullTimes_days = outcomes
+                .map(o => o.fullRecoveryAt_s !== null ? o.fullRecoveryAt_s / 86400 : null)
+                .filter((v) => v !== null);
+            const meanCombatReadyDays = readyTimes_days.length > 0
+                ? readyTimes_days.reduce((a, b) => a + b, 0) / readyTimes_days.length
+                : null;
+            const meanFullRecoveryDays = fullTimes_days.length > 0
+                ? fullTimes_days.reduce((a, b) => a + b, 0) / fullTimes_days.length
+                : null;
+            const costs = outcomes.map(o => o.totalCostUnits);
+            const meanResourceCostUnits = costs.length > 0 ? avg(costs) : 0;
+            const costsSorted = [...costs].sort((a, b) => a - b);
+            const p90ResourceCostUnits = costs.length > 0
+                ? costsSorted[Math.floor(0.90 * costs.length)] ?? costsSorted.at(-1) ?? 0
+                : 0;
+            return {
+                entityId: c.id,
+                survivalRatePostRecovery,
+                meanCombatReadyDays,
+                meanFullRecoveryDays,
+                meanResourceCostUnits,
+                p90ResourceCostUnits,
+            };
+        });
+    }
+    // Expectation checking
+    const result = {
+        scenario, trials: n, trialResults,
+        winRateByTeam, drawRate: drawCount / n, timeoutRate: timeoutCount / n,
+        meanCombatDuration_s, p50CombatDuration_s,
+        survivalRateByEntity, meanTTI_s, injuryDistribution,
+        expectationResults: [],
+    };
+    if (recoveryStats !== undefined)
+        result.recoveryStats = recoveryStats;
+    result.expectationResults = (scenario.expectations ?? []).map(exp => {
+        const passed = exp.check(result);
+        return {
+            description: exp.description,
+            passed,
+            ...(passed ? {} : { detail: `failed: ${exp.description}` }),
+        };
+    });
+    return result;
+}
+function avg(nums) {
+    if (nums.length === 0)
+        return 0;
+    return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+// ── Reporting ─────────────────────────────────────────────────────────────────
+/** Machine-readable summary (JSON-safe — no Maps or Functions). */
+export function summariseArena(result) {
+    return {
+        scenario: result.scenario.name,
+        trials: result.trials,
+        winRates: Object.fromEntries(result.winRateByTeam),
+        drawRate: result.drawRate,
+        timeoutRate: result.timeoutRate,
+        meanCombatDuration_s: result.meanCombatDuration_s,
+        p50CombatDuration_s: result.p50CombatDuration_s,
+        survivalRates: Object.fromEntries(result.survivalRateByEntity),
+        injuryDistribution: result.injuryDistribution,
+        recoveryStats: result.recoveryStats,
+        expectations: result.expectationResults,
+    };
+}
+/** Human-readable statistical report. */
+export function formatArenaReport(result) {
+    const lines = [];
+    lines.push(`=== ${result.scenario.name} (${result.trials} trials) ===`);
+    if (result.scenario.description)
+        lines.push(result.scenario.description);
+    lines.push("");
+    lines.push("Combat outcomes:");
+    for (const [teamId, rate] of result.winRateByTeam) {
+        lines.push(`  Team ${teamId} wins: ${(rate * 100).toFixed(1)}%`);
+    }
+    if (result.drawRate > 0)
+        lines.push(`  Draws:    ${(result.drawRate * 100).toFixed(1)}%`);
+    if (result.timeoutRate > 0)
+        lines.push(`  Timeouts: ${(result.timeoutRate * 100).toFixed(1)}%`);
+    lines.push(`  Mean duration: ${result.meanCombatDuration_s.toFixed(1)} s`);
+    lines.push(`  p50 duration:  ${result.p50CombatDuration_s.toFixed(1)} s`);
+    lines.push("");
+    lines.push("Injury distribution:");
+    for (const d of result.injuryDistribution) {
+        lines.push(`  Entity ${d.entityId}: fluid loss ${(d.meanFluidLoss * 100).toFixed(1)}%  ` +
+            `fracture ${(d.fractureProbability * 100).toFixed(0)}%  ` +
+            `death ${(d.deathProbability * 100).toFixed(0)}%`);
+    }
+    lines.push("");
+    if (result.recoveryStats?.length) {
+        lines.push("Recovery stats:");
+        for (const s of result.recoveryStats) {
+            const crDays = s.meanCombatReadyDays !== null ? s.meanCombatReadyDays.toFixed(2) : "N/A";
+            const frDays = s.meanFullRecoveryDays !== null ? s.meanFullRecoveryDays.toFixed(2) : "N/A";
+            lines.push(`  Entity ${s.entityId}: ` +
+                `survival ${(s.survivalRatePostRecovery * 100).toFixed(0)}%  ` +
+                `combat-ready ${crDays} days  ` +
+                `full recovery ${frDays} days  ` +
+                `cost ${s.meanResourceCostUnits.toFixed(1)} units (p90: ${s.p90ResourceCostUnits.toFixed(1)})`);
+        }
+        lines.push("");
+    }
+    if (result.expectationResults.length > 0) {
+        lines.push("Expectations:");
+        for (const e of result.expectationResults) {
+            lines.push(`  [${e.passed ? "PASS" : "FAIL"}] ${e.description}`);
+            if (!e.passed && e.detail)
+                lines.push(`         ${e.detail}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Full narrative of the median-duration trial (representative fight).
+ * Falls back to first trial if no narrative was collected.
+ */
+export function narrateRepresentativeTrial(result) {
+    if (result.trialResults.length === 0)
+        return "(no trials)";
+    // Pick the trial closest to median duration
+    const sorted = [...result.trialResults].sort((a, b) => a.ticks - b.ticks);
+    const rep = sorted[Math.floor(sorted.length / 2)];
+    if (rep.combatLog && rep.combatLog.length > 0) {
+        return rep.combatLog.map(e => `[t${e.tick}] ${e.text}`).join("\n");
+    }
+    // Fallback: no narrative collected — build summary from result data
+    const lines = [
+        `Trial ${rep.trialIndex} (seed ${rep.seed}) — ${rep.ticks} ticks — ${rep.outcome}`,
+        `Survivors: ${rep.survivors.length > 0 ? rep.survivors.join(", ") : "none"}`,
+    ];
+    for (const inj of rep.injuries) {
+        lines.push(`  Entity ${inj.entityId}: ${inj.dead ? "dead" : inj.unconscious ? "unconscious" : "standing"}`);
+    }
+    return lines.join("\n");
+}
+// ── Built-in calibration scenarios ───────────────────────────────────────────
+const _longsword = STARTER_WEAPONS.find(w => w.id === "wpn_longsword");
+const _knife = STARTER_WEAPONS.find(w => w.id === "wpn_knife");
+const _plateMail = STARTER_ARMOUR[2]; // arm_plate, resist_J = 800
+/**
+ * Armed trained human vs. unarmed untrained human.
+ * Source: criminal assault literature, self-defence training studies.
+ */
+export const CALIBRATION_ARMED_VS_UNARMED = {
+    name: "Armed vs. Unarmed",
+    description: "Armed trained human vs. unarmed untrained human.",
+    combatants: [
+        {
+            id: 1, teamId: 1,
+            archetype: HUMAN_BASE,
+            loadout: { items: [_longsword] },
+            skills: buildSkillMap({ meleeCombat: { energyTransferMul: q(1.10) } }),
+            position_m: v3(0, 0, 0),
+        },
+        {
+            id: 2, teamId: 2,
+            archetype: HUMAN_BASE,
+            loadout: { items: [] },
+            position_m: v3(Math.trunc(0.85 * SCALE.m), 0, 0),
+        },
+    ],
+    maxTicks: DEFAULT_MAX_TICKS,
+    expectations: [
+        expectWinRate(1, 0.70),
+        expectMeanDuration(1, 30),
+    ],
+};
+/**
+ * Post-combat entity with severe knife wound, no treatment, 60 min downtime.
+ * Source: Sperry (2013) untreated penetrating abdominal trauma mortality.
+ */
+export const CALIBRATION_UNTREATED_KNIFE_WOUND = {
+    name: "Untreated Knife Wound",
+    description: "Severe torso laceration, no treatment, 60 min downtime.",
+    combatants: [
+        {
+            id: 1, teamId: 1,
+            archetype: HUMAN_BASE,
+            loadout: { items: [] },
+            position_m: v3(0, 0, 0),
+            mutateOnCreate(e) {
+                e.injury.byRegion["torso"].bleedingRate = q(0.06);
+            },
+        },
+    ],
+    maxTicks: 0,
+    recovery: {
+        careLevel: "none",
+        recoveryHours: 1,
+    },
+    expectations: [
+        {
+            description: "≥ 80% of entities die within 60 simulated minutes",
+            check(r) {
+                const stats = r.recoveryStats?.find(s => s.entityId === 1);
+                return stats !== undefined && stats.survivalRatePostRecovery <= 0.20;
+            },
+        },
+    ],
+};
+/**
+ * Same severe knife wound, first_aid applied within onset delay = 0.
+ * Source: TCCC tourniquet outcome data.
+ */
+export const CALIBRATION_FIRST_AID_SAVES_LIVES = {
+    name: "First Aid Saves Lives",
+    description: "Severe torso laceration, first aid applied, 60 min downtime.",
+    combatants: [
+        {
+            id: 1, teamId: 1,
+            archetype: HUMAN_BASE,
+            loadout: { items: [] },
+            position_m: v3(0, 0, 0),
+            mutateOnCreate(e) {
+                e.injury.byRegion["torso"].bleedingRate = q(0.06);
+            },
+        },
+    ],
+    maxTicks: 0,
+    recovery: {
+        careLevel: "first_aid",
+        recoveryHours: 1,
+        rest: true,
+    },
+    expectations: [
+        {
+            description: "≥ 90% survive 60 simulated minutes with first aid",
+            check(r) {
+                const stats = r.recoveryStats?.find(s => s.entityId === 1);
+                return stats !== undefined && stats.survivalRatePostRecovery >= 0.90;
+            },
+        },
+        {
+            description: "entity 1 combat-ready within 0.1 simulated days (tourniquet immediate)",
+            check(r) {
+                const stats = r.recoveryStats?.find(s => s.entityId === 1);
+                return stats !== undefined
+                    && stats.meanCombatReadyDays !== null
+                    && stats.meanCombatReadyDays <= 0.1;
+            },
+        },
+    ],
+};
+/**
+ * Fresh long-bone fracture, field_medicine care, extended downtime.
+ * Source: orthopaedic rehabilitation literature.
+ */
+export const CALIBRATION_FRACTURE_RECOVERY = {
+    name: "Fracture Recovery",
+    description: "Long-bone fracture, field_medicine, 6000 s downtime.",
+    combatants: [
+        {
+            id: 1, teamId: 1,
+            archetype: HUMAN_BASE,
+            loadout: { items: [] },
+            position_m: v3(0, 0, 0),
+            mutateOnCreate(e) {
+                const leg = e.injury.byRegion["leftLeg"] ?? e.injury.byRegion["torso"];
+                if (leg) {
+                    leg.structuralDamage = q(0.75);
+                    leg.fractured = true;
+                }
+            },
+        },
+    ],
+    maxTicks: 0,
+    recovery: {
+        careLevel: "field_medicine",
+        recoveryHours: 6000 / 3600,
+    },
+    expectations: [
+        {
+            description: "≥ 90% achieve structural recovery within 6000 simulated seconds",
+            check(r) {
+                const stats = r.recoveryStats?.find(s => s.entityId === 1);
+                if (!stats || stats.meanFullRecoveryDays === null)
+                    return false;
+                return stats.meanFullRecoveryDays <= (6000 / 86400) * 1.5; // generous upper bound
+            },
+        },
+    ],
+};
+/**
+ * Moderate internal wound with active infection, no antibiotics, 24h downtime.
+ * Source: pre-antibiotic era wound infection mortality (Ogston, Lister era data).
+ */
+export const CALIBRATION_INFECTION_UNTREATED = {
+    name: "Untreated Infection",
+    description: "Active infection + internal damage, no treatment, 24 h downtime.",
+    combatants: [
+        {
+            id: 1, teamId: 1,
+            archetype: HUMAN_BASE,
+            loadout: { items: [] },
+            position_m: v3(0, 0, 0),
+            mutateOnCreate(e) {
+                const torso = e.injury.byRegion["torso"];
+                torso.infectedTick = 0;
+                torso.internalDamage = q(0.20);
+            },
+        },
+    ],
+    maxTicks: 0,
+    recovery: {
+        careLevel: "none",
+        recoveryHours: 24,
+    },
+    expectations: [
+        {
+            description: "≥ 60% fatal within 24 simulated hours (untreated sepsis)",
+            check(r) {
+                const stats = r.recoveryStats?.find(s => s.entityId === 1);
+                return stats !== undefined && stats.survivalRatePostRecovery <= 0.40;
+            },
+        },
+    ],
+};
+/**
+ * Armoured knight vs. unarmoured swordsman, matched skill and archetype.
+ * Source: HEMA literature on plate armour effectiveness.
+ */
+export const CALIBRATION_PLATE_ARMOUR = {
+    name: "Plate Armour Effectiveness",
+    description: "Knight (plate armour) vs. unarmoured swordsman.",
+    combatants: [
+        {
+            id: 1, teamId: 1,
+            archetype: KNIGHT_INFANTRY,
+            loadout: { items: [_longsword, _plateMail] },
+            skills: buildSkillMap({ meleeCombat: { energyTransferMul: q(1.15) } }),
+            position_m: v3(0, 0, 0),
+        },
+        {
+            id: 2, teamId: 2,
+            archetype: HUMAN_BASE,
+            loadout: { items: [_longsword] },
+            skills: buildSkillMap({ meleeCombat: { energyTransferMul: q(1.15) } }),
+            position_m: v3(Math.trunc(0.85 * SCALE.m), 0, 0),
+        },
+    ],
+    maxTicks: DEFAULT_MAX_TICKS,
+    expectations: [
+        expectWinRate(1, 0.45),
+    ],
+};