@its-not-rocket-science/ananke 0.1.0

package/dist/src/story-arcs.d.ts

@@ -0,0 +1,17 @@
+import type { Chronicle, StoryArc } from "./chronicle.js";
+/** Detect all story arcs in a chronicle. */
+export declare function detectStoryArcs(chronicle: Chronicle): StoryArc[];
+/** Re-detect arcs and update chronicle. */
+export declare function updateDetectedArcs(chronicle: Chronicle): void;
+/** Get all arcs involving a specific entity. */
+export declare function getArcsForEntity(chronicle: Chronicle, entityId: number): StoryArc[];
+/** Get the most significant arc in a chronicle. */
+export declare function getMostSignificantArc(chronicle: Chronicle): StoryArc | undefined;
+/** Get arcs within a time period. */
+export declare function getArcsInPeriod(chronicle: Chronicle, startTick: number, endTick: number): StoryArc[];
+/** Check if an arc is ongoing (no end tick). */
+export declare function isOngoingArc(arc: StoryArc, currentTick: number): boolean;
+/** Generate a human-readable summary of an arc. */
+export declare function renderArcDescription(arc: StoryArc): string;
+/** Get arcs that form a connected narrative (shared actors). */
+export declare function getConnectedArcs(chronicle: Chronicle, arcId: string): StoryArc[];

package/dist/src/story-arcs.js

@@ -0,0 +1,276 @@
+// src/story-arcs.ts — Phase 45: Emergent Story Generation — Story Arc Detection
+//
+// Pattern detection across chronicle entries to identify emergent narratives.
+import { getEntriesForEntity } from "./chronicle.js";
+// ── Arc Detection Entry Points ─────────────────────────────────────────────────
+/** Detect all story arcs in a chronicle. */
+export function detectStoryArcs(chronicle) {
+    const arcs = [];
+    // Detect each arc type
+    const riseOfHeroArcs = detectRiseOfHeroArcs(chronicle);
+    arcs.push(...riseOfHeroArcs);
+    const tragicFallArcs = detectTragicFallArcs(chronicle);
+    arcs.push(...tragicFallArcs);
+    const rivalryArcs = detectRivalryArcs(chronicle);
+    arcs.push(...rivalryArcs);
+    const settlementGrowthArcs = detectSettlementGrowthArcs(chronicle);
+    arcs.push(...settlementGrowthArcs);
+    const legendaryCraftsmanArcs = detectLegendaryCraftsmanArcs(chronicle);
+    arcs.push(...legendaryCraftsmanArcs);
+    // Sort arcs by start tick
+    arcs.sort((a, b) => a.startTick - b.startTick);
+    return arcs;
+}
+/** Re-detect arcs and update chronicle. */
+export function updateDetectedArcs(chronicle) {
+    chronicle.detectedArcs = detectStoryArcs(chronicle);
+}
+// ── Rise of a Hero ────────────────────────────────────────────────────────────
+/**
+ * Detect "Rise of a Hero" arcs.
+ * Pattern: Entity survives multiple combats, gains positive reputation,
+ * completes difficult quests, doesn't die.
+ */
+function detectRiseOfHeroArcs(chronicle) {
+    const arcs = [];
+    const entityCompletions = new Map();
+    // Find quest completions and combat victories by entity
+    for (const entry of chronicle.entries) {
+        if (entry.eventType === "quest_completed" || entry.eventType === "combat_victory") {
+            for (const actor of entry.actors) {
+                if (!entityCompletions.has(actor)) {
+                    entityCompletions.set(actor, []);
+                }
+                entityCompletions.get(actor).push(entry);
+            }
+        }
+    }
+    // Check for entities with multiple successes
+    for (const [entityId, entries] of entityCompletions) {
+        if (entries.length >= 3) {
+            // Check if entity has a death entry (arc would be cut short)
+            const deathEntry = getEntriesForEntity(chronicle, entityId).find(e => e.eventType === "entity_death");
+            if (!deathEntry) {
+                // Living hero - check for legendary deed
+                const legendaryEntry = entries.find(e => e.eventType === "legendary_deed");
+                const significance = 60 + entries.length * 5 + (legendaryEntry ? 20 : 0);
+                arcs.push({
+                    arcId: `rise_hero_${entityId}_${entries[0].tick}`,
+                    arcType: "rise_of_hero",
+                    entryIds: entries.map(e => e.entryId),
+                    primaryActors: [entityId],
+                    startTick: entries[0].tick,
+                    endTick: entries[entries.length - 1].tick,
+                    significance: Math.min(100, significance),
+                    description: `The rise of a hero through ${entries.length} notable victories`,
+                });
+            }
+        }
+    }
+    return arcs;
+}
+// ── Tragic Fall ───────────────────────────────────────────────────────────────
+/**
+ * Detect "Tragic Fall" arcs.
+ * Pattern: Entity with high reputation commits betrayal, becomes villain,
+ * or falls from grace in some other way.
+ */
+function detectTragicFallArcs(chronicle) {
+    const arcs = [];
+    const entityEntries = new Map();
+    // Group entries by actor
+    for (const entry of chronicle.entries) {
+        for (const actor of entry.actors) {
+            if (!entityEntries.has(actor)) {
+                entityEntries.set(actor, []);
+            }
+            entityEntries.get(actor).push(entry);
+        }
+    }
+    // Look for betrayal after positive events
+    for (const [entityId, entries] of entityEntries) {
+        const betrayalIndex = entries.findIndex(e => e.eventType === "relationship_betrayal");
+        if (betrayalIndex > 0) {
+            // Check for prior positive events
+            const priorEntries = entries.slice(0, betrayalIndex);
+            const positiveEvents = priorEntries.filter(e => e.eventType === "quest_completed" || e.eventType === "relationship_formed");
+            if (positiveEvents.length >= 2) {
+                const relevantEntries = [...positiveEvents, entries[betrayalIndex]];
+                arcs.push({
+                    arcId: `tragic_fall_${entityId}_${entries[0].tick}`,
+                    arcType: "tragic_fall",
+                    entryIds: relevantEntries.map(e => e.entryId),
+                    primaryActors: [entityId],
+                    startTick: relevantEntries[0].tick,
+                    endTick: entries[entries.length - 1]?.tick,
+                    significance: 75,
+                    description: `A tragic fall from grace after betrayal of former allies`,
+                });
+            }
+        }
+    }
+    return arcs;
+}
+// ── Rivalry ───────────────────────────────────────────────────────────────────
+/**
+ * Detect "Rivalry" arcs.
+ * Pattern: Two entities repeatedly fight/combat, neither dies,
+ * relationship remains negative or hostile.
+ */
+function detectRivalryArcs(chronicle) {
+    const arcs = [];
+    const combatPairs = new Map();
+    // Find combats with exactly 2 actors
+    for (const entry of chronicle.entries) {
+        if ((entry.eventType === "combat_victory" || entry.eventType === "combat_defeat") &&
+            entry.actors.length === 2) {
+            const pairKey = entry.actors.sort().join("_");
+            if (!combatPairs.has(pairKey)) {
+                combatPairs.set(pairKey, []);
+            }
+            combatPairs.get(pairKey).push(entry);
+        }
+    }
+    // Check for repeated combats between same pair
+    for (const [pairKey, entries] of combatPairs) {
+        if (entries.length >= 2) {
+            const ids = pairKey.split("_").map(Number);
+            const entityA = ids[0];
+            const entityB = ids[1];
+            // Check neither has died
+            const deathA = getEntriesForEntity(chronicle, entityA).find(e => e.eventType === "entity_death");
+            const deathB = getEntriesForEntity(chronicle, entityB).find(e => e.eventType === "entity_death");
+            if (!deathA && !deathB) {
+                arcs.push({
+                    arcId: `rivalry_${pairKey}_${entries[0].tick}`,
+                    arcType: "rivalry",
+                    entryIds: entries.map(e => e.entryId),
+                    primaryActors: [entityA, entityB],
+                    startTick: entries[0].tick,
+                    endTick: entries[entries.length - 1].tick,
+                    significance: 50 + entries.length * 5,
+                    description: `An ongoing rivalry with ${entries.length} recorded confrontations`,
+                });
+            }
+        }
+    }
+    return arcs;
+}
+// ── Settlement Growth ─────────────────────────────────────────────────────────
+/**
+ * Detect "Settlement Growth" arcs.
+ * Pattern: Settlement founded → upgraded multiple times → population growth.
+ */
+function detectSettlementGrowthArcs(chronicle) {
+    const arcs = [];
+    const settlementEvents = new Map();
+    // Group settlement-related entries
+    for (const entry of chronicle.entries) {
+        if (entry.settlementId && (entry.eventType === "settlement_founded" ||
+            entry.eventType === "settlement_upgraded" ||
+            entry.eventType === "facility_completed")) {
+            if (!settlementEvents.has(entry.settlementId)) {
+                settlementEvents.set(entry.settlementId, []);
+            }
+            settlementEvents.get(entry.settlementId).push(entry);
+        }
+    }
+    // Check for settlements with growth trajectory
+    for (const [settlementId, entries] of settlementEvents) {
+        const hasFoundation = entries.some(e => e.eventType === "settlement_founded");
+        const upgrades = entries.filter(e => e.eventType === "settlement_upgraded").length;
+        if (hasFoundation && upgrades >= 1) {
+            arcs.push({
+                arcId: `settlement_growth_${settlementId}_${entries[0].tick}`,
+                arcType: "settlement_growth",
+                entryIds: entries.map(e => e.entryId),
+                primaryActors: [], // Settlement itself is the subject
+                startTick: entries[0].tick,
+                endTick: entries[entries.length - 1].tick,
+                significance: 55 + upgrades * 10,
+                description: `The growth of a settlement from founding through ${upgrades} upgrades`,
+            });
+        }
+    }
+    return arcs;
+}
+// ── Legendary Craftsman ───────────────────────────────────────────────────────
+/**
+ * Detect "Legendary Craftsman" arcs.
+ * Pattern: Entity produces multiple masterwork items, exceptional competence outcomes.
+ */
+function detectLegendaryCraftsmanArcs(chronicle) {
+    const arcs = [];
+    const entityCrafts = new Map();
+    // Find masterwork crafting events
+    for (const entry of chronicle.entries) {
+        if (entry.eventType === "masterwork_crafted") {
+            for (const actor of entry.actors) {
+                if (!entityCrafts.has(actor)) {
+                    entityCrafts.set(actor, []);
+                }
+                entityCrafts.get(actor).push(entry);
+            }
+        }
+    }
+    // Check for craftsmen with multiple masterworks
+    for (const [entityId, entries] of entityCrafts) {
+        if (entries.length >= 2) {
+            arcs.push({
+                arcId: `legendary_craftsman_${entityId}_${entries[0].tick}`,
+                arcType: "legendary_craftsman",
+                entryIds: entries.map(e => e.entryId),
+                primaryActors: [entityId],
+                startTick: entries[0].tick,
+                endTick: entries[entries.length - 1].tick,
+                significance: 60 + entries.length * 8,
+                description: `A legendary craftsman who created ${entries.length} masterwork items`,
+            });
+        }
+    }
+    return arcs;
+}
+// ── Arc Analysis ──────────────────────────────────────────────────────────────
+/** Get all arcs involving a specific entity. */
+export function getArcsForEntity(chronicle, entityId) {
+    return chronicle.detectedArcs.filter(arc => arc.primaryActors.includes(entityId));
+}
+/** Get the most significant arc in a chronicle. */
+export function getMostSignificantArc(chronicle) {
+    if (chronicle.detectedArcs.length === 0)
+        return undefined;
+    return chronicle.detectedArcs.reduce((max, arc) => arc.significance > max.significance ? arc : max);
+}
+/** Get arcs within a time period. */
+export function getArcsInPeriod(chronicle, startTick, endTick) {
+    return chronicle.detectedArcs.filter(arc => arc.startTick <= endTick && (arc.endTick ?? Infinity) >= startTick);
+}
+/** Check if an arc is ongoing (no end tick). */
+export function isOngoingArc(arc, currentTick) {
+    return arc.endTick === undefined || arc.endTick >= currentTick;
+}
+// ── Arc Rendering ─────────────────────────────────────────────────────────────
+/** Generate a human-readable summary of an arc. */
+export function renderArcDescription(arc) {
+    const typeDescriptions = {
+        rise_of_hero: "A hero's rise to prominence",
+        tragic_fall: "A tragic fall from grace",
+        rivalry: "An ongoing rivalry",
+        great_migration: "A great migration",
+        settlement_growth: "The growth of a settlement",
+        fallen_settlement: "The fall of a settlement",
+        legendary_craftsman: "A legendary craftsman's legacy",
+        notorious_villain: "The rise of a notorious villain",
+        unlikely_friendship: "An unlikely friendship",
+        betrayal_and_redemption: "A tale of betrayal and redemption",
+    };
+    return typeDescriptions[arc.arcType] || arc.description;
+}
+/** Get arcs that form a connected narrative (shared actors). */
+export function getConnectedArcs(chronicle, arcId) {
+    const targetArc = chronicle.detectedArcs.find(a => a.arcId === arcId);
+    if (!targetArc)
+        return [];
+    return chronicle.detectedArcs.filter(arc => arc.arcId !== arcId &&
+        arc.primaryActors.some(actor => targetArc.primaryActors.includes(actor)));
+}

package/dist/src/tech-diffusion.d.ts

@@ -0,0 +1,80 @@
+import { type Q } from "./units.js";
+import type { Polity, PolityRegistry, PolityPair } from "./polity.js";
+/** Maximum tech era index (DeepSpace = 8). */
+export declare const MAX_TECH_ERA: number;
+/**
+ * Base daily probability of era advance when the era gap is 1 and route quality
+ * is q(0.50) and there is one shared location.  At this rate a lagging polity
+ * advances roughly once per 200 days (~7 months) under median conditions.
+ */
+export declare const BASE_DIFFUSION_RATE_Q: Q;
+/**
+ * Multiplier applied per additional era of gap beyond 1.
+ * At gap=2: ×1.5×; gap=3: ×2.0×; capped at gap=4 (×2.5×).
+ * Ensures large knowledge gradients trigger faster catch-up.
+ */
+export declare const ERA_GAP_BONUS_Q: Q;
+/** Maximum era-gap bonus (caps at gap=4 → ×3.0× the base). */
+export declare const ERA_GAP_BONUS_MAX: Q;
+/**
+ * Route quality contributes up to this multiplier on top of the base rate.
+ * routeQuality_Q = q(1.0) → +100% boost → 2× base rate.
+ */
+export declare const ROUTE_QUALITY_MUL_MAX: Q;
+/**
+ * Each additional shared location beyond 1 adds this fractional bonus.
+ * e.g., 3 shared locations → +2 × q(0.20) = +40% of base rate.
+ */
+export declare const SHARED_LOCATION_BONUS: Q;
+/** Maximum combined bonus from shared locations (caps at 5 locations). */
+export declare const SHARED_LOCATION_MAX: Q;
+/**
+ * Stability threshold below which a polity cannot absorb new technology.
+ * Unstable societies are too disorganised to institutionalise advances.
+ */
+export declare const STABILITY_DIFFUSION_THRESHOLD: Q;
+/** Outcome of a single polity's tech advance in one day-tick. */
+export interface TechDiffusionResult {
+    polityId: string;
+    previousTechEra: number;
+    newTechEra: number;
+}
+/**
+ * Compute the daily diffusion pressure (probability of era advance) that the
+ * `source` polity exerts on the `target` via one `pair`.
+ *
+ * Returns q(0) when:
+ * - `source.techEra <= target.techEra`  (no gradient)
+ * - `target.stabilityQ < STABILITY_DIFFUSION_THRESHOLD` (target is unstable)
+ * - `warActive === true` (war disrupts cultural contact)
+ *
+ * Otherwise returns a Q in (0, SCALE.Q] representing the per-day probability
+ * of the target advancing one era.  The caller rolls against this value.
+ */
+export declare function computeDiffusionPressure(source: Polity, target: Polity, pair: PolityPair, warActive: boolean): Q;
+/**
+ * Advance technology through the polity pair graph for one simulated day.
+ *
+ * For each pair, checks both directions (A→B and B→A) and rolls against
+ * `computeDiffusionPressure`.  A polity that advances during this step is
+ * not eligible to advance again in the same tick (one advance per tick max).
+ *
+ * Mutates `polity.techEra` (and refreshes `militaryStrength_Q`) for any
+ * polity that advances.
+ *
+ * Returns a `TechDiffusionResult[]` for every polity that advanced this tick.
+ */
+export declare function stepTechDiffusion(registry: PolityRegistry, pairs: ReadonlyArray<PolityPair>, worldSeed: number, tick: number): TechDiffusionResult[];
+/**
+ * Compute the net inbound diffusion pressure on a single polity from all its
+ * neighbours in the pair graph.  Useful for AI queries ("how likely is this
+ * polity to advance soon?").
+ *
+ * War pairs are excluded.  Pressure values are summed (uncapped).
+ */
+export declare function totalInboundPressure(polityId: string, registry: PolityRegistry, pairs: ReadonlyArray<PolityPair>): Q;
+/**
+ * Return the set of tech-era names available for a given era index.
+ * Useful for display in tools and reports.
+ */
+export declare function techEraName(era: number): string;

package/dist/src/tech-diffusion.js

@@ -0,0 +1,185 @@
+// src/tech-diffusion.ts — Phase 67: Technology Diffusion at Polity Scale
+//
+// Technology eras spread from more-advanced polities to less-advanced neighbours
+// via trade routes and cultural contact.  Each day, for every pair where one
+// polity leads the other by at least one era, the lagging polity rolls for a
+// chance to advance — exactly one era at a time, never skipping.
+//
+// Diffusion pressure scales with:
+//   - era gap          : larger gaps produce stronger "pull" (knowledge gradient)
+//   - route quality    : better navigators carry ideas faster (Phase 61 routeQuality_Q)
+//   - shared locations : more border crossings → more cultural contact
+//   - war              : active war between the pair sets diffusion to 0
+//   - stability        : unstable polities are poor hosts for new ideas
+//
+// Historically grounded: trade routes (Silk Road, Mediterranean, Hanseatic League)
+// were the primary vector for technology transfer in the pre-modern world.
+// Model source: Bockstette, Chanda & Putterman (2002) "States and Markets: The
+// Advantage of an Early Start".
+//
+// Phase hooks:
+//   Phase 61 (Polity, PolityPair, areAtWar) — registry and route graph
+//   Phase 11C (TechEra) — 9-era progression 0 (Prehistoric) → 8 (DeepSpace)
+import { q, clampQ, qMul, SCALE } from "./units.js";
+import { eventSeed, hashString } from "./sim/seeds.js";
+import { makeRng } from "./rng.js";
+import { areAtWar, deriveMilitaryStrength } from "./polity.js";
+import { TechEra } from "./sim/tech.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Maximum tech era index (DeepSpace = 8). */
+export const MAX_TECH_ERA = TechEra.DeepSpace;
+/**
+ * Base daily probability of era advance when the era gap is 1 and route quality
+ * is q(0.50) and there is one shared location.  At this rate a lagging polity
+ * advances roughly once per 200 days (~7 months) under median conditions.
+ */
+export const BASE_DIFFUSION_RATE_Q = q(0.005);
+/**
+ * Multiplier applied per additional era of gap beyond 1.
+ * At gap=2: ×1.5×; gap=3: ×2.0×; capped at gap=4 (×2.5×).
+ * Ensures large knowledge gradients trigger faster catch-up.
+ */
+export const ERA_GAP_BONUS_Q = q(0.50);
+/** Maximum era-gap bonus (caps at gap=4 → ×3.0× the base). */
+export const ERA_GAP_BONUS_MAX = q(2.00);
+/**
+ * Route quality contributes up to this multiplier on top of the base rate.
+ * routeQuality_Q = q(1.0) → +100% boost → 2× base rate.
+ */
+export const ROUTE_QUALITY_MUL_MAX = q(1.00);
+/**
+ * Each additional shared location beyond 1 adds this fractional bonus.
+ * e.g., 3 shared locations → +2 × q(0.20) = +40% of base rate.
+ */
+export const SHARED_LOCATION_BONUS = q(0.20);
+/** Maximum combined bonus from shared locations (caps at 5 locations). */
+export const SHARED_LOCATION_MAX = q(0.80);
+/**
+ * Stability threshold below which a polity cannot absorb new technology.
+ * Unstable societies are too disorganised to institutionalise advances.
+ */
+export const STABILITY_DIFFUSION_THRESHOLD = q(0.25);
+// ── Core computation ──────────────────────────────────────────────────────────
+/**
+ * Compute the daily diffusion pressure (probability of era advance) that the
+ * `source` polity exerts on the `target` via one `pair`.
+ *
+ * Returns q(0) when:
+ * - `source.techEra <= target.techEra`  (no gradient)
+ * - `target.stabilityQ < STABILITY_DIFFUSION_THRESHOLD` (target is unstable)
+ * - `warActive === true` (war disrupts cultural contact)
+ *
+ * Otherwise returns a Q in (0, SCALE.Q] representing the per-day probability
+ * of the target advancing one era.  The caller rolls against this value.
+ */
+export function computeDiffusionPressure(source, target, pair, warActive) {
+    if (warActive)
+        return q(0);
+    if (source.techEra <= target.techEra)
+        return q(0);
+    if (target.stabilityQ < STABILITY_DIFFUSION_THRESHOLD)
+        return q(0);
+    // Era gap bonus: 0 for gap=1, +ERA_GAP_BONUS_Q per additional gap, capped
+    const gap = source.techEra - target.techEra;
+    const gapBonus = clampQ(ERA_GAP_BONUS_Q * (gap - 1), 0, ERA_GAP_BONUS_MAX);
+    const gapMul = (SCALE.Q + gapBonus);
+    // Route quality bonus: routeQuality scales from 0 → ROUTE_QUALITY_MUL_MAX bonus
+    const routeBonus = qMul(pair.routeQuality_Q, ROUTE_QUALITY_MUL_MAX);
+    const routeMul = (SCALE.Q + routeBonus);
+    // Shared locations bonus: extra locations beyond 1 add fractional boost
+    const extraLocs = Math.max(0, pair.sharedLocations - 1);
+    const locBonus = clampQ(SHARED_LOCATION_BONUS * extraLocs, 0, SHARED_LOCATION_MAX);
+    const locMul = (SCALE.Q + locBonus);
+    // Combine: base × gapMul × routeMul × locMul (all ÷ SCALE.Q after each multiply)
+    const step1 = qMul(BASE_DIFFUSION_RATE_Q, gapMul);
+    const step2 = qMul(step1, routeMul);
+    const step3 = qMul(step2, locMul);
+    return clampQ(step3, 0, SCALE.Q);
+}
+// ── Day step ──────────────────────────────────────────────────────────────────
+/**
+ * Advance technology through the polity pair graph for one simulated day.
+ *
+ * For each pair, checks both directions (A→B and B→A) and rolls against
+ * `computeDiffusionPressure`.  A polity that advances during this step is
+ * not eligible to advance again in the same tick (one advance per tick max).
+ *
+ * Mutates `polity.techEra` (and refreshes `militaryStrength_Q`) for any
+ * polity that advances.
+ *
+ * Returns a `TechDiffusionResult[]` for every polity that advanced this tick.
+ */
+export function stepTechDiffusion(registry, pairs, worldSeed, tick) {
+    const advanced = new Set(); // prevent double-advance per tick
+    const results = [];
+    for (const pair of pairs) {
+        const polityA = registry.polities.get(pair.polityAId);
+        const polityB = registry.polities.get(pair.polityBId);
+        if (!polityA || !polityB)
+            continue;
+        const atWar = areAtWar(registry, pair.polityAId, pair.polityBId);
+        // Check both directions
+        for (const [source, target] of [[polityA, polityB], [polityB, polityA]]) {
+            if (advanced.has(target.id))
+                continue;
+            if (target.techEra >= MAX_TECH_ERA)
+                continue;
+            const pressure = computeDiffusionPressure(source, target, pair, atWar);
+            if (pressure <= 0)
+                continue;
+            // Deterministic roll
+            const salt = hashString(source.id) ^ hashString(target.id);
+            const seed = eventSeed(worldSeed, tick, hashString(source.id), hashString(target.id), salt);
+            const rng = makeRng(seed, SCALE.Q);
+            const roll = rng.q01();
+            if (roll < pressure) {
+                const prev = target.techEra;
+                target.techEra = (target.techEra + 1);
+                deriveMilitaryStrength(target);
+                advanced.add(target.id);
+                results.push({ polityId: target.id, previousTechEra: prev, newTechEra: target.techEra });
+            }
+        }
+    }
+    return results;
+}
+// ── Query helpers ─────────────────────────────────────────────────────────────
+/**
+ * Compute the net inbound diffusion pressure on a single polity from all its
+ * neighbours in the pair graph.  Useful for AI queries ("how likely is this
+ * polity to advance soon?").
+ *
+ * War pairs are excluded.  Pressure values are summed (uncapped).
+ */
+export function totalInboundPressure(polityId, registry, pairs) {
+    const target = registry.polities.get(polityId);
+    if (!target)
+        return q(0);
+    let total = 0;
+    for (const pair of pairs) {
+        let sourceId = null;
+        if (pair.polityAId === polityId)
+            sourceId = pair.polityBId;
+        else if (pair.polityBId === polityId)
+            sourceId = pair.polityAId;
+        if (!sourceId)
+            continue;
+        const source = registry.polities.get(sourceId);
+        if (!source)
+            continue;
+        const atWar = areAtWar(registry, polityId, sourceId);
+        total += computeDiffusionPressure(source, target, pair, atWar);
+    }
+    return clampQ(total, 0, SCALE.Q);
+}
+/**
+ * Return the set of tech-era names available for a given era index.
+ * Useful for display in tools and reports.
+ */
+export function techEraName(era) {
+    const names = [
+        "Prehistoric", "Ancient", "Medieval", "EarlyModern",
+        "Industrial", "Modern", "NearFuture", "FarFuture", "DeepSpace",
+    ];
+    return names[era] ?? `Era${era}`;
+}

package/dist/src/traits.d.ts

@@ -0,0 +1,25 @@
+import { type ChannelMask } from "./channels.js";
+import { Q } from "./units.js";
+import type { IndividualAttributes } from "./types.js";
+export type TraitId = "sealed" | "nonConductive" | "distributedControl" | "noSurfaceLayer" | "noBulkMedium" | "highThermalMass" | "fragileStructure" | "reinforcedStructure" | "chemicalImmune" | "radiationHardened" | "leader" | "standardBearer";
+export type TraitMult = Partial<Record<TraitMultKey, Q>>;
+export interface TraitEffect {
+    id: TraitId;
+    name: string;
+    description: string;
+    immuneTo?: ChannelMask;
+    resistantTo?: ChannelMask;
+    mult?: TraitMult;
+}
+export declare const TRAITS: Record<TraitId, TraitEffect>;
+export type TraitMultKey = "shockTolerance" | "concussionTolerance" | "distressTolerance" | "surfaceIntegrity" | "bulkIntegrity" | "structureIntegrity" | "structureScale" | "heatTolerance" | "coldTolerance" | "controlQuality";
+type AttrMutator = (a: IndividualAttributes) => void;
+export declare const TRAIT_MUTATORS: Record<TraitId, AttrMutator>;
+export interface TraitProfile {
+    traits: TraitId[];
+    immuneMask: ChannelMask;
+    resistantMask: ChannelMask;
+}
+export declare function buildTraitProfile(traits: readonly TraitId[]): TraitProfile;
+export declare function applyTraitsToAttributes(base: IndividualAttributes, traits: readonly TraitId[]): IndividualAttributes;
+export {};