@its-not-rocket-science/ananke 0.1.0

package/dist/src/equipment.js

@@ -0,0 +1,598 @@
+import { SCALE, q, clampQ, qMul, mulDiv, to } from "./units.js";
+import { DamageChannel, channelMask } from "./channels.js";
+import { ALL_REGIONS, DEFAULT_REGION_WEIGHTS, weightedMean01 } from "./sim/body.js";
+export const DEFAULT_CARRY_RULES = {
+    capacityFactor: q(0.25),
+    bulkToMassFactor: q(0.06),
+};
+export function computeLoadoutTotals(loadout, armourIsWorn = true) {
+    let mass = 0;
+    let bulk = 0;
+    let wornMass = 0;
+    let wornBulk = 0;
+    for (const it of loadout.items) {
+        mass += it.mass_kg;
+        bulk = (bulk + it.bulk) | 0;
+        if (armourIsWorn && it.kind === "armour") {
+            wornMass += it.mass_kg;
+            wornBulk = (wornBulk + it.bulk) | 0;
+        }
+    }
+    return {
+        carriedMass_kg: mass,
+        carriedBulk: bulk,
+        wornMass_kg: wornMass,
+        wornBulk: wornBulk,
+        carriedMassFracOfBody: q(0),
+    };
+}
+export function deriveCarryCapacityMass_kg(a, rules = DEFAULT_CARRY_RULES) {
+    const peakForceScaled = a.performance.peakForce_N;
+    const numerator = BigInt(peakForceScaled) * BigInt(SCALE.kg) * BigInt(rules.capacityFactor);
+    const denom = BigInt(SCALE.N) * BigInt(SCALE.Q) * 9810n;
+    const kgScaled = Number(numerator / denom);
+    return Math.max(1, kgScaled);
+}
+export function computeEncumbrance(a, loadout, rules = DEFAULT_CARRY_RULES) {
+    const totals = computeLoadoutTotals(loadout);
+    const bodyMass = Math.max(1, a.morphology.mass_kg);
+    totals.carriedMassFracOfBody = mulDiv(totals.carriedMass_kg * SCALE.Q, SCALE.kg, bodyMass);
+    const capacity_kg = Math.max(1, deriveCarryCapacityMass_kg(a, rules));
+    const massRatio = mulDiv(totals.carriedMass_kg * SCALE.Q, 1, capacity_kg);
+    const bulkAbove1 = Math.max(0, totals.carriedBulk - SCALE.Q);
+    const bulkTerm = qMul(bulkAbove1, rules.bulkToMassFactor);
+    const r = clampQ((massRatio + bulkTerm), 0, 5 * SCALE.Q);
+    const penalties = encumbranceCurve(r, a);
+    return { totals, penalties };
+}
+function encumbranceCurve(r, a) {
+    const overloaded = r > q(1.5);
+    const speedMul = piecewiseMul(r, q(1.0), q(0.92), q(0.78), q(0.55));
+    const accelMul = piecewiseMul(r, q(1.0), q(0.88), q(0.70), q(0.45));
+    const jumpMul = piecewiseMul(r, q(1.0), q(0.90), q(0.68), q(0.40));
+    const baseDemand = piecewiseMul(r, q(1.0), q(1.10), q(1.30), q(1.65));
+    const energyDemandMul = clampQ(qMul(baseDemand, a.resilience.fatigueRate), q(0.5), q(3.0));
+    const controlMul = piecewiseMul(r, q(1.0), q(0.96), q(0.88), q(0.75));
+    const stabilityMul = piecewiseMul(r, q(1.0), q(0.94), q(0.82), q(0.65));
+    return { speedMul, accelMul, jumpMul, energyDemandMul, controlMul, stabilityMul, encumbranceRatio: r, overloaded };
+}
+function piecewiseMul(r, a, b, c, d) {
+    const r05 = q(0.5), r10 = q(1.0), r15 = q(1.5);
+    if (r <= r05)
+        return a;
+    if (r <= r10) {
+        const t = mulDiv((r - r05), SCALE.Q, (r10 - r05));
+        return (a + mulDiv((b - a), t, SCALE.Q));
+    }
+    if (r <= r15) {
+        const t = mulDiv((r - r10), SCALE.Q, (r15 - r10));
+        return (b + mulDiv((c - b), t, SCALE.Q));
+    }
+    return d;
+}
+function emptyCoverage() {
+    const out = {};
+    for (const r of ALL_REGIONS)
+        out[r] = q(0);
+    return out;
+}
+export function deriveArmourProfile(loadout, armourState) {
+    const items = [...loadout.items].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    let protects = 0;
+    let protectedMul = q(1.0);
+    let mobilityMul = q(1.0);
+    let fatigueMul = q(1.0);
+    const coverageByRegion = emptyCoverage();
+    let resist_J = 0;
+    let reflectivity = q(0);
+    const channelResistMul = {};
+    for (const it of items) {
+        if (it.kind !== "armour")
+            continue;
+        protects |= it.protects;
+        protectedMul = qMul(protectedMul, it.protectedDamageMul);
+        mobilityMul = qMul(mobilityMul, it.mobilityMul ?? q(1.0));
+        fatigueMul = qMul(fatigueMul, it.fatigueMul ?? q(1.0));
+        for (const r of ALL_REGIONS) {
+            const c = it.coverageByRegion[r] ?? q(0);
+            const oneMinus = q(1.0) - c;
+            coverageByRegion[r] = (q(1.0) - qMul(q(1.0) - coverageByRegion[r], oneMinus));
+        }
+        // Phase 11C: ablative — use remaining resist if tracked, else full
+        const effectiveResist = (it.ablative && armourState?.has(it.id))
+            ? armourState.get(it.id).resistRemaining_J
+            : it.resist_J;
+        resist_J += effectiveResist;
+        // Phase 11C: reflectivity — take the maximum across all items
+        if (it.reflectivity && it.reflectivity > reflectivity) {
+            reflectivity = it.reflectivity;
+        }
+        if (it.channelResistMul) {
+            for (const k of Object.keys(it.channelResistMul)) {
+                const ch = Number(k);
+                const mul = it.channelResistMul[ch];
+                channelResistMul[ch] = channelResistMul[ch] ? qMul(channelResistMul[ch], mul) : mul;
+            }
+        }
+    }
+    return {
+        protects,
+        coverageByRegion: coverageByRegion,
+        coverageOverall: weightedMean01(coverageByRegion, DEFAULT_REGION_WEIGHTS),
+        resist_J: Math.max(0, resist_J),
+        protectedDamageMul: clampQ(protectedMul, q(0.05), q(1.0)),
+        mobilityMul: clampQ(mobilityMul, q(0.30), q(1.0)),
+        fatigueMul: clampQ(fatigueMul, q(0.80), q(3.0)),
+        channelResistMul,
+        reflectivity,
+    };
+}
+export function findWeapon(loadout, weaponId) {
+    const weapons = loadout.items
+        .filter((x) => x.kind === "weapon");
+    if (weapons.length === 0)
+        return null;
+    if (!weaponId)
+        return weapons[0];
+    return weapons.find(w => w.id === weaponId) ?? weapons[0];
+}
+export function findRangedWeapon(loadout, weaponId) {
+    const ranged = loadout.items.filter((x) => x.kind === "ranged");
+    if (ranged.length === 0)
+        return null;
+    if (!weaponId)
+        return ranged[0];
+    return ranged.find(w => w.id === weaponId) ?? ranged[0];
+}
+export function findShield(loadout) {
+    return loadout.items.find(item => item?.kind === "shield");
+}
+export function findExoskeleton(loadout) {
+    return (loadout.items.find((it) => it.kind === "exoskeleton") ?? null);
+}
+/** Phase 11C: return the first Sensor in the loadout, or null. */
+export function findSensor(loadout) {
+    return (loadout.items.find((it) => it.kind === "sensor") ?? null);
+}
+/**
+ * Phase 11: check that every item in a loadout is usable in the given TechContext.
+ * Returns an array of error messages; empty array means the loadout is valid.
+ */
+export function validateLoadout(loadout, ctx) {
+    const errors = [];
+    for (const item of loadout.items) {
+        if (!item.requiredCapabilities)
+            continue;
+        for (const cap of item.requiredCapabilities) {
+            if (!ctx.available.has(cap)) {
+                errors.push(`"${item.id}" requires capability "${cap}"`);
+            }
+        }
+    }
+    return errors;
+}
+export function deriveWeaponHandling(w, ownerStature_m) {
+    const reach = w.reach_m ?? Math.trunc(ownerStature_m * 0.45);
+    return {
+        handedness: w.handedness ?? "oneHand",
+        momentArm_m: w.momentArm_m ?? Math.trunc(reach * 0.55),
+        handlingLoadMul: w.handlingLoadMul ?? q(1.0),
+    };
+}
+export const STARTER_WEAPONS = [
+    {
+        id: "wpn_club",
+        kind: "weapon",
+        name: "Wooden club",
+        mass_kg: Math.round(1.2 * SCALE.kg),
+        bulk: q(1.4),
+        reach_m: Math.round(0.7 * SCALE.m),
+        handedness: "oneHand",
+        momentArm_m: Math.round(0.45 * SCALE.m),
+        handlingMul: q(1.10),
+        strikeEffectiveMassFrac: q(0.18),
+        strikeSpeedMul: q(0.95),
+        damage: {
+            surfaceFrac: q(0.35),
+            internalFrac: q(0.20),
+            structuralFrac: q(0.45),
+            bleedFactor: q(0.25),
+            penetrationBias: q(0.10),
+        },
+    },
+    {
+        id: "wpn_knife",
+        kind: "weapon",
+        name: "Knife",
+        mass_kg: Math.round(0.3 * SCALE.kg),
+        bulk: q(1.1),
+        reach_m: Math.round(0.2 * SCALE.m),
+        handedness: "oneHand",
+        momentArm_m: Math.round(0.18 * SCALE.m),
+        handlingMul: q(0.85),
+        strikeEffectiveMassFrac: q(0.10),
+        strikeSpeedMul: q(1.05),
+        damage: {
+            surfaceFrac: q(0.30),
+            internalFrac: q(0.60),
+            structuralFrac: q(0.10),
+            bleedFactor: q(0.95),
+            penetrationBias: q(0.85),
+        },
+    },
+    {
+        id: "wpn_longsword",
+        kind: "weapon",
+        name: "Longsword",
+        mass_kg: Math.round(1.5 * SCALE.kg),
+        bulk: q(1.5),
+        reach_m: Math.round(0.90 * SCALE.m),
+        handedness: "twoHand",
+        momentArm_m: Math.round(0.55 * SCALE.m),
+        handlingMul: q(1.05),
+        strikeEffectiveMassFrac: q(0.15),
+        strikeSpeedMul: q(1.00),
+        readyTime_s: to.s(0.75),
+        damage: {
+            surfaceFrac: q(0.35),
+            internalFrac: q(0.45),
+            structuralFrac: q(0.20),
+            bleedFactor: q(0.70),
+            penetrationBias: q(0.40),
+        },
+    },
+    // Phase 15: boxing gloves — concussive, minimal cutting, fast punches
+    {
+        id: "wpn_boxing_gloves",
+        kind: "weapon",
+        name: "Boxing Gloves",
+        mass_kg: Math.round(0.28 * SCALE.kg), // 10 oz ≈ 0.28 kg
+        bulk: q(0.9),
+        reach_m: Math.trunc(0.32 * SCALE.m), // 0.32 m effective reach
+        handedness: "oneHand",
+        momentArm_m: Math.trunc(0.22 * SCALE.m),
+        handlingMul: q(0.95),
+        strikeEffectiveMassFrac: q(0.07), // padding distributes force over larger area
+        strikeSpeedMul: q(1.20), // fast punches
+        damage: {
+            surfaceFrac: q(0.10), // padding minimises cuts
+            internalFrac: q(0.60), // concussive — brain/organ shock dominates
+            structuralFrac: q(0.08),
+            bleedFactor: q(0.04), // almost no bleeding
+            penetrationBias: q(0.03),
+        },
+    },
+];
+// Phase 11: powered exoskeletons
+export const STARTER_EXOSKELETONS = [
+    {
+        id: "exo_combat",
+        kind: "exoskeleton",
+        name: "Combat exoskeleton",
+        mass_kg: Math.round(25.0 * SCALE.kg),
+        bulk: q(2.5),
+        requiredCapabilities: ["PoweredExoskeleton"],
+        speedMultiplier: q(1.25), // +25% effective sprint speed
+        forceMultiplier: q(1.40), // +40% melee strike energy
+        powerDrain_W: 200, // equivalent to a second continuous-power budget
+    },
+    {
+        id: "exo_heavy",
+        kind: "exoskeleton",
+        name: "Heavy assault exoskeleton",
+        mass_kg: Math.round(45.0 * SCALE.kg),
+        bulk: q(3.0),
+        requiredCapabilities: ["PoweredExoskeleton"],
+        speedMultiplier: q(1.10), // heavy — modest speed gain
+        forceMultiplier: q(1.80), // massive force amplification
+        powerDrain_W: 400,
+    },
+];
+export const STARTER_ARMOUR = [
+    {
+        id: "arm_leather",
+        kind: "armour",
+        name: "Leather armour",
+        mass_kg: Math.round(6.0 * SCALE.kg),
+        bulk: q(1.6),
+        protects: channelMask(DamageChannel.Kinetic, DamageChannel.Thermal),
+        coverageByRegion: {
+            head: q(0.10),
+            torso: q(0.70),
+            leftArm: q(0.45),
+            rightArm: q(0.45),
+            leftLeg: q(0.25),
+            rightLeg: q(0.25),
+        },
+        resist_J: 150,
+        protectedDamageMul: q(0.85),
+        channelResistMul: { [DamageChannel.Thermal]: q(1.10) },
+        mobilityMul: q(0.95),
+        fatigueMul: q(1.08),
+    },
+    {
+        id: "arm_mail",
+        kind: "armour",
+        name: "Mail armour",
+        mass_kg: Math.round(10.0 * SCALE.kg),
+        bulk: q(1.9),
+        requiredCapabilities: ["MetallicArmour"],
+        protects: channelMask(DamageChannel.Kinetic),
+        coverageByRegion: {
+            head: q(0.05),
+            torso: q(0.78),
+            leftArm: q(0.55),
+            rightArm: q(0.55),
+            leftLeg: q(0.20),
+            rightLeg: q(0.20),
+        },
+        resist_J: 350,
+        protectedDamageMul: q(0.75),
+        mobilityMul: q(0.90),
+        fatigueMul: q(1.15),
+    },
+    {
+        id: "arm_plate",
+        kind: "armour",
+        name: "Plate armour",
+        mass_kg: Math.round(20.0 * SCALE.kg),
+        bulk: q(2.2),
+        requiredCapabilities: ["MetallicArmour"],
+        protects: channelMask(DamageChannel.Kinetic, DamageChannel.Thermal),
+        coverageByRegion: {
+            head: q(0.75),
+            torso: q(0.90),
+            leftArm: q(0.80),
+            rightArm: q(0.80),
+            leftLeg: q(0.70),
+            rightLeg: q(0.70),
+        },
+        resist_J: 800,
+        protectedDamageMul: q(0.60),
+        mobilityMul: q(0.82),
+        fatigueMul: q(1.25),
+    },
+];
+export const STARTER_SHIELDS = [
+    {
+        id: "shd_small",
+        kind: "shield",
+        name: "Small shield",
+        mass_kg: Math.round(3.0 * SCALE.kg),
+        bulk: q(1.2),
+        coverageQ: q(0.65),
+        blockResist_J: 120,
+        deflectQ: q(0.30),
+        arcDeg: 90,
+        regions: ["torso", "leftArm", "rightArm"],
+        covers: ["torso", "arm", "head"],
+        coverageProfileId: "shield_small_default",
+        manipulationMul: q(0.95),
+        mobilityMul: q(0.98),
+        fatigueMul: q(1.05),
+    },
+];
+// Phase 3: starter ranged weapons
+// damage profile: projectiles are penetrating; surface fraction is low.
+const PROJECTILE_DAMAGE = {
+    surfaceFrac: q(0.20),
+    internalFrac: q(0.55),
+    structuralFrac: q(0.25),
+    bleedFactor: q(0.75),
+    penetrationBias: q(0.70),
+};
+export const STARTER_RANGED_WEAPONS = [
+    {
+        id: "rng_sling",
+        kind: "ranged",
+        name: "Sling",
+        category: "thrown",
+        mass_kg: Math.round(0.1 * SCALE.kg),
+        bulk: q(0.8),
+        launchEnergy_J: 0, // derived from thrower peakPower_W
+        projectileMass_kg: Math.round(0.08 * SCALE.kg),
+        dragCoeff_perM: q(0.012), // 1.2% energy loss per metre
+        dispersionQ: q(0.012), // 12 mrad base
+        recycleTime_s: to.s(2.0),
+        damage: PROJECTILE_DAMAGE,
+        suppressionFearMul: q(0.5),
+    },
+    {
+        id: "rng_shortbow",
+        kind: "ranged",
+        name: "Short bow",
+        category: "bow",
+        mass_kg: Math.round(0.8 * SCALE.kg),
+        bulk: q(1.3),
+        launchEnergy_J: 60,
+        projectileMass_kg: Math.round(0.025 * SCALE.kg),
+        dragCoeff_perM: q(0.007), // 0.7% loss/m
+        dispersionQ: q(0.012),
+        recycleTime_s: to.s(1.5),
+        damage: PROJECTILE_DAMAGE,
+        suppressionFearMul: q(1.0),
+    },
+    {
+        id: "rng_longbow",
+        kind: "ranged",
+        name: "Long bow",
+        category: "bow",
+        mass_kg: Math.round(1.2 * SCALE.kg),
+        bulk: q(1.6),
+        launchEnergy_J: 90,
+        projectileMass_kg: Math.round(0.025 * SCALE.kg),
+        dragCoeff_perM: q(0.005), // 0.5% loss/m
+        dispersionQ: q(0.008),
+        recycleTime_s: to.s(2.0),
+        damage: PROJECTILE_DAMAGE,
+        suppressionFearMul: q(1.5),
+    },
+    {
+        id: "rng_crossbow",
+        kind: "ranged",
+        name: "Crossbow",
+        category: "bow",
+        mass_kg: Math.round(3.5 * SCALE.kg),
+        bulk: q(2.0),
+        launchEnergy_J: 120,
+        projectileMass_kg: Math.round(0.040 * SCALE.kg),
+        dragCoeff_perM: q(0.004),
+        dispersionQ: q(0.006),
+        recycleTime_s: to.s(5.0),
+        damage: PROJECTILE_DAMAGE,
+        suppressionFearMul: q(1.5),
+    },
+    {
+        id: "rng_pistol",
+        kind: "ranged",
+        name: "Pistol",
+        category: "firearm",
+        mass_kg: Math.round(1.2 * SCALE.kg),
+        bulk: q(1.1),
+        requiredCapabilities: ["FirearmsPropellant"],
+        launchEnergy_J: 400,
+        projectileMass_kg: Math.round(0.015 * SCALE.kg),
+        dragCoeff_perM: q(0.002),
+        dispersionQ: q(0.015),
+        recycleTime_s: to.s(12.0),
+        damage: PROJECTILE_DAMAGE,
+        suppressionFearMul: q(2.0),
+    },
+    {
+        id: "rng_musket",
+        kind: "ranged",
+        name: "Musket",
+        category: "firearm",
+        mass_kg: Math.round(4.5 * SCALE.kg),
+        bulk: q(2.2),
+        requiredCapabilities: ["FirearmsPropellant"],
+        launchEnergy_J: 600,
+        projectileMass_kg: Math.round(0.030 * SCALE.kg),
+        dragCoeff_perM: q(0.0015), // 0.15% loss/m
+        dispersionQ: q(0.010),
+        recycleTime_s: to.s(18.0),
+        damage: PROJECTILE_DAMAGE,
+        suppressionFearMul: q(3.0),
+    },
+    {
+        id: "rng_plasma_rifle",
+        kind: "ranged",
+        name: "Plasma rifle",
+        category: "firearm",
+        mass_kg: Math.round(3.8 * SCALE.kg),
+        bulk: q(1.8),
+        requiredCapabilities: ["EnergyWeapons"],
+        launchEnergy_J: 2000,
+        projectileMass_kg: Math.round(0.001 * SCALE.kg),
+        dragCoeff_perM: q(0.0005), // near-negligible beam divergence
+        dispersionQ: q(0.004),
+        recycleTime_s: to.s(2.0),
+        energyType: "plasma", // Phase 11C: Energy channel; resisted by reflectivity
+        suppressionFearMul: q(1.0),
+        damage: {
+            surfaceFrac: q(0.35),
+            internalFrac: q(0.45),
+            structuralFrac: q(0.20),
+            bleedFactor: q(0.15), // plasma cauterises, low bleed
+            penetrationBias: q(0.90),
+        },
+    },
+];
+// ── Phase 11C starter items ────────────────────────────────────────────────────
+/** Reflective/ablative armour items for energy and kinetic threats. */
+export const STARTER_ARMOUR_11C = [
+    {
+        id: "arm_reflective",
+        kind: "armour",
+        name: "Reflective coating",
+        mass_kg: Math.round(0.5 * SCALE.kg),
+        bulk: q(0.3),
+        requiredCapabilities: ["EnergyWeapons"],
+        protects: channelMask(DamageChannel.Energy),
+        coverageByRegion: {
+            head: q(0.50), torso: q(0.80),
+            leftArm: q(0.50), rightArm: q(0.50),
+            leftLeg: q(0.30), rightLeg: q(0.30),
+        },
+        resist_J: 0,
+        protectedDamageMul: q(1.0),
+        reflectivity: q(0.40), // deflects 40% of energy weapon damage
+    },
+    {
+        id: "arm_reactive",
+        kind: "armour",
+        name: "Reactive plating",
+        mass_kg: Math.round(3.0 * SCALE.kg),
+        bulk: q(1.5),
+        requiredCapabilities: ["ReactivePlating"],
+        protects: channelMask(DamageChannel.Kinetic),
+        coverageByRegion: {
+            head: q(0.40), torso: q(0.85),
+            leftArm: q(0.40), rightArm: q(0.40),
+            leftLeg: q(0.20), rightLeg: q(0.20),
+        },
+        resist_J: 1500,
+        protectedDamageMul: q(0.65),
+        ablative: true, // degrades with use; tracked in entity.armourState
+    },
+];
+/** Phase 11C: sensor suites that boost vision and hearing range. */
+export const STARTER_SENSORS = [
+    {
+        id: "sens_nightvision",
+        kind: "sensor",
+        name: "Night-vision goggles",
+        mass_kg: Math.round(0.3 * SCALE.kg),
+        bulk: q(1.1),
+        requiredCapabilities: ["BallisticArmour"],
+        visionRangeMul: q(1.5), // +50% vision range
+        hearingRangeMul: q(1.0),
+    },
+    {
+        id: "sens_tactical",
+        kind: "sensor",
+        name: "Tactical sensor suite",
+        mass_kg: Math.round(0.8 * SCALE.kg),
+        bulk: q(1.3),
+        requiredCapabilities: ["PoweredExoskeleton"],
+        visionRangeMul: q(2.0), // double vision range
+        hearingRangeMul: q(1.5), // +50% hearing range
+    },
+];
+// ── Phase 3 extension: starter ammo types ─────────────────────────────────────
+/** Armour-piercing projectile damage profile: increased penetration, lower energy. */
+const AP_DAMAGE = {
+    surfaceFrac: q(0.10),
+    internalFrac: q(0.60),
+    structuralFrac: q(0.30),
+    bleedFactor: q(0.50),
+    penetrationBias: q(0.95),
+};
+/** Hollow-point projectile damage profile: maximum bleeding, lower penetration. */
+const HP_DAMAGE = {
+    surfaceFrac: q(0.40),
+    internalFrac: q(0.55),
+    structuralFrac: q(0.05),
+    bleedFactor: q(0.95),
+    penetrationBias: q(0.20),
+};
+export const STARTER_AMMO = [
+    {
+        id: "ammo_ap",
+        name: "Armour-Piercing",
+        damage: AP_DAMAGE,
+        launchEnergyMul: q(0.90), // slightly lower velocity than ball
+    },
+    {
+        id: "ammo_hv",
+        name: "High-Velocity",
+        launchEnergyMul: q(1.20), // +20% muzzle energy
+        dragCoeff_perM: q(0.002), // streamlined projectile
+    },
+    {
+        id: "ammo_hollow",
+        name: "Hollow-Point",
+        damage: HP_DAMAGE,
+        launchEnergyMul: q(0.95), // slightly heavier
+    },
+];

package/dist/src/faction.d.ts

@@ -0,0 +1,102 @@
+import type { Q } from "./units.js";
+import type { Entity } from "./sim/entity.js";
+import type { WorldState } from "./sim/world.js";
+import type { TraceEvent } from "./sim/trace.js";
+/** A named group of entities with defined relationships to other factions. */
+export interface Faction {
+    id: string;
+    name: string;
+    /** Faction ids with default hostile standing (q(0.20)). */
+    rivals: Set<string>;
+    /** Faction ids with default friendly standing (q(0.70)). */
+    allies: Set<string>;
+}
+/** A reputation-relevant event witnessed by a faction member. */
+export interface WitnessEvent {
+    actorId: number;
+    eventType: "kill" | "assault" | "theft" | "aid" | "surrender";
+    targetId: number;
+    /** Faction that cares about this event (typically the target's faction). */
+    factionId: string;
+    /** Signed reputation delta for the actor within `factionId`. */
+    delta: Q;
+    tick: number;
+}
+/**
+ * Persistent faction state for a scenario or campaign.
+ *
+ * `globalStanding`     — faction-to-faction base standing (initialised from rival/ally sets).
+ * `entityReputations`  — entity-level standing within factions; updated by `applyWitnessEvent`.
+ */
+export interface FactionRegistry {
+    factions: Map<string, Faction>;
+    globalStanding: Map<string, Map<string, Q>>;
+    entityReputations: Map<number, Map<string, Q>>;
+}
+export declare const STANDING_EXALTED: Q;
+export declare const STANDING_ALLY: Q;
+export declare const STANDING_NEUTRAL: Q;
+export declare const STANDING_RIVAL: Q;
+export declare const STANDING_KOS: Q;
+/** Standing below this → AI treats target as hostile. */
+export declare const STANDING_HOSTILE_THRESHOLD: Q;
+/** Standing above this → AI will not initiate combat. */
+export declare const STANDING_FRIENDLY_THRESHOLD: Q;
+/** Minimum detection quality for an entity to witness an event. */
+export declare const WITNESS_DETECTION_THRESHOLD: Q;
+/**
+ * Create a FactionRegistry pre-populated with rival/ally default standings.
+ *
+ * Only direct relations need to be specified; symmetric standings are NOT
+ * applied automatically (enemy of A is not necessarily enemy of B).
+ */
+export declare function createFactionRegistry(factions: Faction[]): FactionRegistry;
+/**
+ * Compute effective standing of entity `a` toward entity `b`.
+ *
+ * Priority (highest first):
+ * 1. Same faction → STANDING_EXALTED
+ * 2. Entity-level reputation (`registry.entityReputations.get(a.id)?.get(b.faction)`)
+ *    combined with faction default — max of the two is used.
+ * 3. Global faction-to-faction standing
+ * 4. Rival / ally default from faction definition
+ * 5. STANDING_NEUTRAL (q(0.50)) for all unknown combinations
+ */
+export declare function effectiveStanding(registry: FactionRegistry, a: Entity, b: Entity): Q;
+/**
+ * Apply a witness event: adjust the actor's standing within the specified faction.
+ *
+ * Deltas are clamped to [0, SCALE.Q].  A kill of a faction member reduces the
+ * actor's standing with that faction; aiding a member increases it.
+ */
+export declare function applyWitnessEvent(registry: FactionRegistry, event: WitnessEvent): void;
+/**
+ * Scan a TraceEvent stream and produce WitnessEvents for reputation-relevant
+ * actions (kills, assaults, aid).
+ *
+ * Only events where at least one bystander entity (not the actor or target) can
+ * detect the actor (`detectionQ ≥ WITNESS_DETECTION_THRESHOLD`) are included.
+ *
+ * Deduplication: at most one event per (actorId, eventType) per tick.
+ *
+ * @param factions  Map of entityId → factionId for the current scenario.
+ */
+export declare function extractWitnessEvents(events: TraceEvent[], world: WorldState, factions: Map<number, string>): WitnessEvent[];
+/**
+ * Adjust the global faction-to-faction standing of `factionAId` toward
+ * `factionBId` by `delta`, clamped to [0, SCALE.Q].
+ *
+ * Used by the Polity diplomacy system (Phase 61) to apply `standingDelta`
+ * from `resolveDiplomacy`.  The relation is one-directional; call twice with
+ * swapped arguments for a symmetric update.
+ */
+export declare function applyFactionStanding(registry: FactionRegistry, factionAId: string, factionBId: string, delta: Q): void;
+/**
+ * Serialise a FactionRegistry to a JSON string.
+ * Handles all nested Map and Set fields (rivals, allies, globalStanding, entityReputations).
+ */
+export declare function serialiseFactionRegistry(registry: FactionRegistry): string;
+/**
+ * Deserialise a FactionRegistry from a JSON string produced by `serialiseFactionRegistry`.
+ */
+export declare function deserialiseFactionRegistry(json: string): FactionRegistry;