@its-not-rocket-science/ananke 0.1.0

package/dist/src/dist.js

@@ -0,0 +1,39 @@
+import { SCALE, clampQ, mulDiv, qMul } from "./units.js";
+// half of SCALE.Q — the natural boundary of triSym output
+const HALF_Q = SCALE.Q >>> 1;
+export function tri01(rng) {
+    const u = rng.q01();
+    const v = rng.q01();
+    return (u + v) >>> 1;
+}
+export function triSym(rng) {
+    return (tri01(rng) - (SCALE.Q >>> 1));
+}
+export function mulFromVariation(variationSym, amplitude) {
+    const delta = mulDiv(variationSym, amplitude, SCALE.Q);
+    return clampQ((SCALE.Q + delta), 0, 3 * SCALE.Q);
+}
+/**
+ * Symmetric triangular sample shifted by `bias × 0.5` of half-range, then
+ * clamped back to the natural triSym bounds `[−SCALE.Q/2, SCALE.Q/2]`.
+ *
+ * `bias` ∈ [−1, 1]:
+ *   +1 strongly skews toward high-end attribute values
+ *   −1 strongly skews toward low-end attribute values
+ *    0 is identical to an unbiased `triSym(rng)` call
+ *
+ * Used by `generateIndividual` to implement `NarrativeBias`.
+ */
+export function biasedTriSym(rng, bias) {
+    const raw = triSym(rng);
+    if (bias === 0)
+        return raw;
+    const shift = Math.round(bias * HALF_Q * 0.5);
+    return Math.max(-HALF_Q, Math.min(HALF_Q, raw + shift));
+}
+export function skewUp(mult, steps) {
+    let out = mult;
+    for (let i = 0; i < steps; i++)
+        out = qMul(out, mult);
+    return (SCALE.Q + ((out - SCALE.Q) >>> 1));
+}

package/dist/src/downtime.d.ts

@@ -0,0 +1,89 @@
+import { type Q } from "./units.js";
+import type { InjuryState } from "./sim/injury.js";
+import type { MedicalTier } from "./sim/medical.js";
+import type { WorldState } from "./sim/world.js";
+export interface MedicalResource {
+    id: string;
+    name: string;
+    tier: MedicalTier;
+    /** Abstract cost units — host maps to currency of choice. */
+    costUnits: number;
+    massGrams: number;
+}
+export declare const MEDICAL_RESOURCES: MedicalResource[];
+/**
+ * Preset care levels: what treatment is available and applied automatically.
+ */
+export type CareLevel = "none" | "first_aid" | "field_medicine" | "hospital" | "autodoc";
+export interface TreatmentSchedule {
+    careLevel: CareLevel;
+    /** Seconds post-combat before first treatment can be applied. Default: 0. */
+    onsetDelay_s?: number;
+    /** Item inventory; if undefined, assume unlimited supply. */
+    inventory?: Map<string, number>;
+    /**
+     * Phase 34: surgeon's bodily-kinesthetic precision multiplier on surgery rate.
+     * Use computeSurgicalPrecision(surgeon) from src/competence/crafting.ts.
+     * Default q(1.0) (no effect).
+     */
+    surgicalPrecisionMul?: Q;
+}
+export interface DowntimeConfig {
+    /** entityId → treatment schedule. Entities not in this map are skipped. */
+    treatments: Map<number, TreatmentSchedule>;
+    ambientTemperature_Q?: Q;
+    /** Entities at rest heal 1.5× faster. */
+    rest: boolean;
+    /** Phase 29: ambient temperature in Phase 29 Q encoding (q(0.5) = 37°C).
+     *  When present, stepCoreTemp is called once per simulated second. */
+    thermalAmbient_Q?: Q;
+}
+export interface ResourceUsage {
+    resourceId: string;
+    name: string;
+    count: number;
+    totalCost: number;
+}
+/** Lightweight injury snapshot for start/end comparison. */
+export interface InjurySummary {
+    dead: boolean;
+    consciousness: number;
+    fluidLoss: number;
+    shock: number;
+    activeBleedingRegions: string[];
+    fracturedRegions: string[];
+    infectedRegions: string[];
+    maxStructuralDamage: number;
+}
+export interface EntityRecoveryReport {
+    entityId: number;
+    elapsedSeconds: number;
+    injuryAtStart: InjurySummary;
+    injuryAtEnd: InjurySummary;
+    died: boolean;
+    bleedingStopped: boolean;
+    infectionCleared: boolean;
+    fracturesSet: boolean;
+    combatReadyAt_s: number | null;
+    fullRecoveryAt_s: number | null;
+    resourcesUsed: ResourceUsage[];
+    totalCostUnits: number;
+    log: Array<{
+        second: number;
+        text: string;
+    }>;
+    /**
+     * Full final injury state after the simulated recovery period.
+     * Use this in campaign/persistence layers to update `entity.injury`
+     * with the healed state between sessions.
+     */
+    finalInjury?: InjuryState;
+    /** Phase 29: final core temperature Q after simulated recovery period. */
+    finalCoreTemp_Q?: Q;
+}
+/**
+ * Simulate wound recovery over `elapsedSeconds` at 1 Hz.
+ * Reads entity injury states from `world`; returns per-entity recovery reports.
+ * Does NOT mutate the world.
+ */
+export declare function stepDowntime(world: WorldState, elapsedSeconds: number, config: DowntimeConfig): EntityRecoveryReport[];

package/dist/src/downtime.js

@@ -0,0 +1,391 @@
+// src/downtime.ts — Phase 19: Downtime & Recovery Simulation
+//
+// Time-scale bridge between 20 Hz combat and hours-to-days wound recovery.
+// Each 1-second simulation step applies the same physics as 1 kernel tick,
+// giving 20× slower wall-clock healing than real-time combat — appropriate
+// for the hours-to-days recovery scale.
+//
+// No kernel import — only types and rate constants are used from engine modules.
+import { q, clampQ, qMul, mulDiv, SCALE } from "./units.js";
+import { FRACTURE_THRESHOLD } from "./sim/injury.js";
+import { TIER_MUL } from "./sim/medical.js";
+import { DT_S } from "./sim/tick.js";
+import { computeNewCoreQ, sumArmourInsulation, CORE_TEMP_NORMAL_Q, } from "./sim/thermoregulation.js";
+import { stepNutrition } from "./sim/nutrition.js";
+import { stepToxicology } from "./sim/toxicology.js";
+export const MEDICAL_RESOURCES = [
+    { id: "bandage", name: "Field bandage", tier: "bandage", costUnits: 1, massGrams: 50 },
+    { id: "suture_kit", name: "Suture kit", tier: "bandage", costUnits: 8, massGrams: 100 },
+    { id: "surgical_kit", name: "Surgical kit", tier: "surgicalKit", costUnits: 60, massGrams: 2000 },
+    { id: "antibiotic_dose", name: "Antibiotic dose", tier: "surgicalKit", costUnits: 15, massGrams: 50 },
+    { id: "iv_fluid_bag", name: "IV fluid bag", tier: "autodoc", costUnits: 25, massGrams: 500 },
+    { id: "autodoc_pack", name: "Autodoc consumable", tier: "autodoc", costUnits: 250, massGrams: 500 },
+    { id: "nanomed_dose", name: "Nanomed dose", tier: "nanomedicine", costUnits: 2000, massGrams: 50 },
+];
+const RESOURCE_BY_ID = new Map(MEDICAL_RESOURCES.map(r => [r.id, r]));
+// ── Internal rate constants ───────────────────────────────────────────────────
+//
+// Each 1-second downtime step uses the same constants as 1 kernel tick.
+// Sources: src/sim/step/injury.ts (clotting, infection), src/sim/kernel.ts (treatment).
+const CLOT_RATE = q(0.0002); // structureIntegrity × this per step → bleed reduction
+const INFECT_ONSET_SEC = 100; // continuous-bleed seconds before infection can start
+const INFECT_DMG_RATE = q(0.0003); // internal damage added per step while infected
+const BANDAGE_RATE = q(0.0050); // base bleed reduction per step (bandage tier)
+const SURGERY_RATE = q(0.0020); // base structural repair per step (surgicalKit tier)
+const FLUID_REPL_RATE = q(0.0050); // base fluid restoration per step (autodoc tier)
+const SHOCK_FROM_FLUID = q(0.0040); // shock += fluidLoss × this per step
+const SHOCK_FROM_INT = q(0.0020); // shock += torsoInternal × this per step
+const CONSC_FROM_SHOCK = q(0.0100); // consciousness -= shock × this per step
+const FATAL_FLUID = q(0.80);
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function cloneInjury(inj) {
+    const byRegion = {};
+    for (const [r, ri] of Object.entries(inj.byRegion))
+        byRegion[r] = { ...ri };
+    return { ...inj, byRegion };
+}
+function captureInjurySummary(inj) {
+    const activeBleedingRegions = [];
+    const fracturedRegions = [];
+    const infectedRegions = [];
+    let maxStr = 0;
+    for (const [r, ri] of Object.entries(inj.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 {
+        dead: inj.dead,
+        consciousness: inj.consciousness / SCALE.Q,
+        fluidLoss: inj.fluidLoss / SCALE.Q,
+        shock: inj.shock / SCALE.Q,
+        activeBleedingRegions,
+        fracturedRegions,
+        infectedRegions,
+        maxStructuralDamage: maxStr / SCALE.Q,
+    };
+}
+/** Treatment tier for most actions at a given care level. */
+function careTier(care) {
+    switch (care) {
+        case "first_aid": return "bandage";
+        case "field_medicine": return "surgicalKit";
+        case "hospital": return "surgicalKit";
+        case "autodoc": return "autodoc";
+        default: return "none";
+    }
+}
+/** Treatment tier for fluid replacement (needs autodoc regardless of care level). */
+function fluidTier(care) {
+    return (care === "hospital" || care === "autodoc") ? "autodoc" : "none";
+}
+/**
+ * Try to consume one unit of a resource from the inventory.
+ * Unlimited (undefined inventory) always succeeds and still tracks usage.
+ */
+function tryConsume(state, resourceId) {
+    if (state.inventory === undefined) {
+        state.usageMap.set(resourceId, (state.usageMap.get(resourceId) ?? 0) + 1);
+        return true;
+    }
+    const avail = state.inventory.get(resourceId) ?? 0;
+    if (avail <= 0)
+        return false;
+    state.inventory.set(resourceId, avail - 1);
+    state.usageMap.set(resourceId, (state.usageMap.get(resourceId) ?? 0) + 1);
+    return true;
+}
+// ── Per-second simulation step ────────────────────────────────────────────────
+function stepSecond(state, second, config) {
+    const inj = state.injury;
+    if (inj.dead)
+        return;
+    const onset = state.schedule.onsetDelay_s ?? 0;
+    const restMul = config.rest ? q(1.50) : q(1.0);
+    // ── 1. Natural clotting + infection tracking ──────────────────────────────
+    for (const [region, reg] of Object.entries(inj.byRegion)) {
+        if (reg.bleedingRate > 0) {
+            const integrity = clampQ((SCALE.Q - reg.structuralDamage), 0, SCALE.Q);
+            const clot = mulDiv(qMul(integrity, CLOT_RATE), restMul, SCALE.Q);
+            reg.bleedingRate = clampQ((reg.bleedingRate - clot), q(0), q(1.0));
+            const dur = (state.bleedDurationSec.get(region) ?? 0) + 1;
+            state.bleedDurationSec.set(region, dur);
+            if (dur >= INFECT_ONSET_SEC
+                && reg.internalDamage > q(0.10)
+                && reg.infectedTick < 0) {
+                reg.infectedTick = second;
+                state.log.push({ second, text: `infection onset: ${region}` });
+            }
+        }
+        else {
+            const dur = state.bleedDurationSec.get(region) ?? 0;
+            if (dur > 0)
+                state.bleedDurationSec.set(region, dur - 1);
+        }
+        // Infection damage progression
+        if (reg.infectedTick >= 0) {
+            reg.internalDamage = clampQ((reg.internalDamage + INFECT_DMG_RATE), 0, SCALE.Q);
+        }
+    }
+    // ── 2. Treatment (after onset delay) ──────────────────────────────────────
+    if (second >= onset && state.schedule.careLevel !== "none") {
+        applyTreatment(state, second, restMul);
+    }
+    // ── 3. Fluid loss from bleeding (same formula as kernel per tick) ──────────
+    let totalFluidThisSec = q(0);
+    for (const reg of Object.values(inj.byRegion)) {
+        if (reg.bleedingRate > 0) {
+            totalFluidThisSec = clampQ((totalFluidThisSec + mulDiv(reg.bleedingRate, DT_S, SCALE.s)), 0, SCALE.Q);
+        }
+    }
+    inj.fluidLoss = clampQ((inj.fluidLoss + totalFluidThisSec), 0, SCALE.Q);
+    // ── 4. Shock accumulation ─────────────────────────────────────────────────
+    const torsoInt = inj.byRegion["torso"]?.internalDamage
+        ?? (Object.values(inj.byRegion)[0]?.internalDamage ?? q(0));
+    const shockInc = clampQ((qMul(inj.fluidLoss, SHOCK_FROM_FLUID) + qMul(torsoInt, SHOCK_FROM_INT)), 0, SCALE.Q);
+    inj.shock = clampQ((inj.shock + shockInc), 0, SCALE.Q);
+    // ── 5. Consciousness loss ─────────────────────────────────────────────────
+    const conscLoss = qMul(inj.shock, CONSC_FROM_SHOCK);
+    inj.consciousness = clampQ((inj.consciousness - conscLoss), 0, SCALE.Q);
+    // ── 6. Death check ────────────────────────────────────────────────────────
+    if (inj.fluidLoss >= FATAL_FLUID || inj.shock >= SCALE.Q || inj.consciousness === 0) {
+        inj.dead = true;
+        inj.consciousness = q(0);
+        state.log.push({ second, text: "entity died" });
+    }
+}
+function applyTreatment(state, second, restMul) {
+    const inj = state.injury;
+    const care = state.schedule.careLevel;
+    const tier = careTier(care);
+    const effectMul = TIER_MUL[tier];
+    const precMul = (state.schedule.surgicalPrecisionMul ?? SCALE.Q);
+    const bleedRed = mulDiv(qMul(BANDAGE_RATE, restMul), effectMul, SCALE.Q);
+    const surgRed = mulDiv(mulDiv(qMul(SURGERY_RATE, restMul), effectMul, SCALE.Q), precMul, SCALE.Q);
+    for (const [region, reg] of Object.entries(inj.byRegion)) {
+        // Tourniquet: first time a region is seen bleeding, apply one bandage
+        if (reg.bleedingRate > 0 && !state.tourniquetedRegions.has(region)) {
+            if (tryConsume(state, "bandage")) {
+                state.tourniquetedRegions.add(region);
+                reg.bleedingRate = q(0);
+                reg.bleedDuration_ticks = 0;
+                state.bleedDurationSec.set(region, 0);
+                state.log.push({ second, text: `tourniquet: ${region}` });
+                continue; // no further bleed processing this step
+            }
+            // Out of bandages — fall through to rate reduction only
+        }
+        // Ongoing bleed reduction (bandage-rate)
+        if (reg.bleedingRate > 0) {
+            reg.bleedingRate = clampQ((reg.bleedingRate - bleedRed), q(0), q(1.0));
+        }
+        // Surgery for fractures (field_medicine+)
+        if ((care === "field_medicine" || care === "hospital" || care === "autodoc")
+            && reg.fractured && !state.surgeryStarted.has(region)) {
+            if (tryConsume(state, "surgical_kit")) {
+                state.surgeryStarted.add(region);
+                state.log.push({ second, text: `surgery started: ${region}` });
+            }
+        }
+        if (state.surgeryStarted.has(region)) {
+            const newStr = clampQ((reg.structuralDamage - surgRed), reg.permanentDamage, SCALE.Q);
+            reg.structuralDamage = newStr;
+            // Surgery also reduces bleeding
+            reg.bleedingRate = clampQ((reg.bleedingRate - bleedRed), q(0), q(1.0));
+            // Clear fracture once structural drops below threshold
+            if (reg.fractured && reg.structuralDamage < FRACTURE_THRESHOLD) {
+                reg.fractured = false;
+                state.log.push({ second, text: `fracture cleared: ${region}` });
+            }
+            // Surgery also clears infection
+            if (reg.infectedTick >= 0) {
+                reg.infectedTick = -1;
+                state.antibioticsApplied.add(region);
+                state.log.push({ second, text: `infection cleared (surgery): ${region}` });
+            }
+        }
+        // Antibiotics for infection (field_medicine+, not already cleared)
+        if ((care === "field_medicine" || care === "hospital" || care === "autodoc")
+            && reg.infectedTick >= 0 && !state.antibioticsApplied.has(region)) {
+            if (tryConsume(state, "antibiotic_dose")) {
+                state.antibioticsApplied.add(region);
+                reg.infectedTick = -1;
+                state.log.push({ second, text: `antibiotics: ${region}` });
+            }
+        }
+    }
+    // IV fluid replacement (hospital+)
+    if ((care === "hospital" || care === "autodoc") && inj.fluidLoss > 0) {
+        if (!state.fluidReplStarted) {
+            if (tryConsume(state, "iv_fluid_bag")) {
+                state.fluidReplStarted = true;
+                state.log.push({ second, text: "IV fluid replacement started" });
+            }
+        }
+        if (state.fluidReplStarted) {
+            const fMul = TIER_MUL[fluidTier(care)];
+            const fluidRec = mulDiv(qMul(FLUID_REPL_RATE, restMul), fMul, SCALE.Q);
+            inj.fluidLoss = clampQ((inj.fluidLoss - fluidRec), q(0), SCALE.Q);
+            inj.shock = clampQ((inj.shock - q(0.002)), q(0), SCALE.Q);
+        }
+    }
+    // Autodoc consumable (autodoc only, consumed once per session)
+    if (care === "autodoc" && !state.autodocStarted) {
+        if (tryConsume(state, "autodoc_pack")) {
+            state.autodocStarted = true;
+        }
+    }
+}
+// ── Recovery projection ───────────────────────────────────────────────────────
+function projectRecovery(state, endSummary, elapsedSec, config) {
+    if (endSummary.dead)
+        return { combatReadyAt_s: null, fullRecoveryAt_s: null };
+    const inj = state.injury;
+    const care = state.schedule.careLevel;
+    const restF = config.rest ? 1.5 : 1.0; // real multiplier for projection math
+    // ── Combat-ready: no active bleeding and shock < 30% ──────────────────────
+    const alreadyCombatReady = endSummary.activeBleedingRegions.length === 0 && endSummary.shock < 0.30;
+    let combatReadyAt_s;
+    if (alreadyCombatReady) {
+        combatReadyAt_s = elapsedSec;
+    }
+    else {
+        // Estimate based on slowest-clotting bleeding region
+        let worstBleedStopSec = 0;
+        for (const r of endSummary.activeBleedingRegions) {
+            const reg = inj.byRegion[r];
+            if (!reg || reg.bleedingRate <= 0)
+                continue;
+            const integrityF = Math.max(0, SCALE.Q - reg.structuralDamage) / SCALE.Q;
+            const clotPerSec = integrityF * (CLOT_RATE / SCALE.Q) * restF;
+            const secToStop = clotPerSec > 0
+                ? (reg.bleedingRate / SCALE.Q) / clotPerSec
+                : 3600;
+            worstBleedStopSec = Math.max(worstBleedStopSec, secToStop);
+        }
+        const shockBuffer = endSummary.shock >= 0.30 ? 120 : 0;
+        combatReadyAt_s = elapsedSec + Math.ceil(worstBleedStopSec) + shockBuffer;
+    }
+    // ── Full recovery: all structural damage at permanentDamage floor ──────────
+    if (care === "none" || care === "first_aid") {
+        // No structural treatment — can't estimate a full recovery date
+        return { combatReadyAt_s, fullRecoveryAt_s: null };
+    }
+    let totalRemainingFP = 0;
+    for (const reg of Object.values(inj.byRegion)) {
+        totalRemainingFP += Math.max(0, reg.structuralDamage - reg.permanentDamage);
+    }
+    if (totalRemainingFP <= 0) {
+        return { combatReadyAt_s, fullRecoveryAt_s: elapsedSec };
+    }
+    const tierMulF = TIER_MUL[careTier(care)] / SCALE.Q;
+    const surgPerSec = (SURGERY_RATE / SCALE.Q) * tierMulF * restF;
+    const secsToHeal = surgPerSec > 0
+        ? (totalRemainingFP / SCALE.Q) / surgPerSec
+        : null;
+    return {
+        combatReadyAt_s,
+        fullRecoveryAt_s: secsToHeal !== null
+            ? elapsedSec + Math.ceil(secsToHeal)
+            : null,
+    };
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Simulate wound recovery over `elapsedSeconds` at 1 Hz.
+ * Reads entity injury states from `world`; returns per-entity recovery reports.
+ * Does NOT mutate the world.
+ */
+export function stepDowntime(world, elapsedSeconds, config) {
+    const reports = [];
+    for (const entity of world.entities) {
+        const schedule = config.treatments.get(entity.id);
+        if (!schedule)
+            continue;
+        const injClone = cloneInjury(entity.injury);
+        const injuryAtStart = captureInjurySummary(injClone);
+        const state = {
+            entityId: entity.id,
+            injury: injClone,
+            schedule,
+            inventory: schedule.inventory ? new Map(schedule.inventory) : undefined,
+            usageMap: new Map(),
+            log: [],
+            tourniquetedRegions: new Set(),
+            antibioticsApplied: new Set(),
+            surgeryStarted: new Set(),
+            fluidReplStarted: false,
+            autodocStarted: false,
+            bleedDurationSec: new Map(),
+        };
+        // Pre-populate bleed duration for regions already bleeding on entry
+        for (const [region, reg] of Object.entries(injClone.byRegion)) {
+            if (reg.bleedDuration_ticks > 0) {
+                // Convert existing combat ticks → simulated seconds (1 sec = 1 tick here)
+                state.bleedDurationSec.set(region, reg.bleedDuration_ticks);
+            }
+            if (reg.infectedTick >= 0) {
+                // Already infected — mark bleed duration as past threshold
+                state.bleedDurationSec.set(region, INFECT_ONSET_SEC);
+            }
+        }
+        // Phase 29: initialise core temperature tracking (entity is resting during recovery)
+        const massReal_kg = entity.attributes.morphology.mass_kg / SCALE.kg;
+        const armourInsul = sumArmourInsulation(entity.loadout.items);
+        let coreTempQ = (entity.condition).coreTemp_Q ?? CORE_TEMP_NORMAL_Q;
+        // Simulation loop
+        for (let sec = 0; sec < elapsedSeconds; sec++) {
+            if (injClone.dead)
+                break;
+            stepSecond(state, sec, config);
+            // Phase 29: step core temperature once per simulated second (always resting during downtime)
+            if (config.thermalAmbient_Q !== undefined) {
+                coreTempQ = computeNewCoreQ(coreTempQ, massReal_kg, armourInsul, false /* resting */, config.thermalAmbient_Q, 1.0);
+            }
+            // Phase 30: nutrition drain once per simulated second (entity resting, activity = 0)
+            stepNutrition(entity, 1.0, q(0));
+            // Phase 32C: toxicology tick (venoms progress during downtime)
+            if (entity.activeVenoms?.length)
+                stepToxicology(entity, 1.0);
+        }
+        const injuryAtEnd = captureInjurySummary(injClone);
+        const bleedingStopped = injuryAtEnd.activeBleedingRegions.length === 0;
+        const infectionCleared = injuryAtEnd.infectedRegions.length === 0;
+        const fracturesSet = state.surgeryStarted.size > 0;
+        const { combatReadyAt_s, fullRecoveryAt_s } = projectRecovery(state, injuryAtEnd, elapsedSeconds, config);
+        // Collate resource usage
+        const resourcesUsed = [];
+        let totalCostUnits = 0;
+        for (const [rid, count] of state.usageMap) {
+            if (count === 0)
+                continue;
+            const res = RESOURCE_BY_ID.get(rid);
+            const cost = (res?.costUnits ?? 0) * count;
+            resourcesUsed.push({ resourceId: rid, name: res?.name ?? rid, count, totalCost: cost });
+            totalCostUnits += cost;
+        }
+        reports.push({
+            entityId: entity.id,
+            elapsedSeconds,
+            injuryAtStart,
+            injuryAtEnd,
+            died: injClone.dead,
+            bleedingStopped,
+            infectionCleared,
+            fracturesSet,
+            combatReadyAt_s,
+            fullRecoveryAt_s,
+            resourcesUsed,
+            totalCostUnits,
+            log: state.log,
+            finalInjury: injClone,
+            ...(config.thermalAmbient_Q !== undefined ? { finalCoreTemp_Q: coreTempQ } : {}),
+        });
+    }
+    return reports;
+}

package/dist/src/economy.d.ts

@@ -0,0 +1,116 @@
+import type { Q } from "./units.js";
+import type { Weapon, Item } from "./equipment.js";
+import type { MedicalResource } from "./downtime.js";
+import type { Entity } from "./sim/entity.js";
+export interface ItemValue {
+    itemId: string;
+    baseValue: number;
+    condition_Q: Q;
+    sellFraction: number;
+}
+export interface DropTable {
+    guaranteed: string[];
+    probabilistic: Array<{
+        itemId: string;
+        chance_Q: Q;
+    }>;
+}
+export interface TradeOffer {
+    give: Array<{
+        itemId: string;
+        count: number;
+        unitValue: number;
+    }>;
+    want: Array<{
+        itemId: string;
+        count: number;
+        unitValue: number;
+    }>;
+}
+export interface TradeEvaluation {
+    /** Positive = advantageous for the accepting party. */
+    netValue: number;
+    /** True when the accepting party has all "want" items in sufficient quantity. */
+    feasible: boolean;
+}
+/**
+ * Campaign-level item inventory: maps itemId → { count, unitValue }.
+ * `unitValue` is in cost units; used by totalInventoryValue.
+ */
+export type ItemInventory = Map<string, {
+    count: number;
+    unitValue: number;
+}>;
+export interface WearResult {
+    wear_Q: Q;
+    broke: boolean;
+    fumble: boolean;
+    penaltyActive: boolean;
+}
+/** Base wear increment at full intensity (q(1.0) per strike). */
+export declare const WEAR_BASE: Q;
+/** Wear threshold at which a −5% effective-mass penalty begins. */
+export declare const WEAR_PENALTY_THRESHOLD: Q;
+/** Wear threshold at which a 20% fumble chance triggers. */
+export declare const WEAR_FUMBLE_THRESHOLD: Q;
+/**
+ * Derive economic metadata for any item or medical resource.
+ *
+ * `wear_Q` is the caller's current wear value for the item.
+ *   - For melee weapons: use `weapon.wear_Q ?? q(0)`.
+ *   - For armour: derive via `armourConditionQ(resist_J, resistRemaining_J)`.
+ *   - Omit (defaults to `q(0)`) for consumables or new items.
+ *
+ * `condition_Q = q(1.0) − wear_Q`, clamped to [0, SCALE.Q].
+ */
+export declare function computeItemValue(item: Item | MedicalResource, wear_Q?: Q): ItemValue;
+/**
+ * Convert armour degradation state to a wear_Q fraction.
+ *
+ * ```
+ * wear = q(1.0) − resistRemaining_J / resist_J
+ * ```
+ * Used to derive `condition_Q` for ablative armour via `computeItemValue`.
+ */
+export declare function armourConditionQ(resist_J: number, resistRemaining_J: number): Q;
+/**
+ * Apply one strike's worth of use-wear to a melee weapon.
+ *
+ * @param weapon          - The weapon being used (reads `wear_Q` field if present).
+ * @param actionIntensity_Q - Strike intensity (q(0)..q(1.0)); higher = more wear.
+ *                           Use q(1.0) for strikes against hard targets (plate armour),
+ *                           lower values for soft/unarmoured opponents.
+ * @param seed            - Optional entropy seed for the deterministic fumble roll.
+ *                          Must be supplied when checking fumble; otherwise fumble = false.
+ *
+ * The returned `wear_Q` should be written back to `weapon.wear_Q` by the caller.
+ */
+export declare function applyWear(weapon: Weapon, actionIntensity_Q: Q, seed?: number): WearResult;
+/**
+ * Compute the list of item IDs dropped by an entity on death or incapacitation.
+ *
+ * Default behaviour:
+ *   - Dead entity → all equipped weapons, ranged weapons, and armour drop (guaranteed).
+ *   - Incapacitated but living → nothing drops (use `config.dropOnIncapacitated = true` to override).
+ *
+ * Additional items from `extra.guaranteed` always drop (when applicable).
+ * `extra.probabilistic` items are rolled deterministically from `seed`.
+ */
+export declare function resolveDrops(entity: Entity, seed: number, extra?: DropTable, config?: {
+    dropOnIncapacitated?: boolean;
+}): string[];
+/**
+ * Evaluate a trade offer from the accepting party's perspective.
+ *
+ * - `offer.give`:  items the proposing party puts on the table.
+ * - `offer.want`:  items the proposing party asks for in return.
+ * - `inventory`:   accepting party's current stock.
+ *
+ * `netValue` > 0 → advantageous for the accepting party (they receive more than they give).
+ * `feasible` — the accepting party has all `want` items in sufficient quantities.
+ */
+export declare function evaluateTradeOffer(offer: TradeOffer, inventory: ItemInventory): TradeEvaluation;
+/**
+ * Sum the total value of all items in an inventory (count × unitValue for each entry).
+ */
+export declare function totalInventoryValue(inventory: ItemInventory): number;