@its-not-rocket-science/ananke 0.1.0

package/dist/src/model3d.js

@@ -0,0 +1,214 @@
+// src/model3d.ts
+//
+// Phase 14 — 3D Model Integration
+//
+// Pure data-extraction functions for driving 3D character rigs. No kernel
+// changes, no simulation state mutations. The host renderer maps the output
+// types to its own skeleton/animation system.
+import { q, SCALE } from "./units.js";
+import { DefenceModes } from "./sim/kinds.js";
+function lateralSign(id) {
+    if (id.includes("left") || id.endsWith("_l"))
+        return -1;
+    if (id.includes("right") || id.endsWith("_r"))
+        return 1;
+    return 0;
+}
+/**
+ * Canonical vertical and lateral offset for a segment, derived from its ID
+ * by keyword matching. Used for CoG and inertia estimation.
+ */
+function getCanonicalOffset(segId) {
+    const id = segId.toLowerCase();
+    const lat = lateralSign(id);
+    if (/head|skull|cranium/.test(id))
+        return { xFrac: 0, yFrac: 0.94 };
+    if (/neck/.test(id))
+        return { xFrac: 0, yFrac: 0.80 };
+    if (/thorax|torso|chest|trunk/.test(id))
+        return { xFrac: 0, yFrac: 0.63 };
+    if (/abdomen|belly/.test(id))
+        return { xFrac: 0, yFrac: 0.52 };
+    if (/pelvis|hip(?!bone)/.test(id))
+        return { xFrac: 0, yFrac: 0.43 };
+    if (/shoulder/.test(id))
+        return { xFrac: lat * 0.20, yFrac: 0.72 };
+    if (/forearm|lower.?arm/.test(id))
+        return { xFrac: lat * 0.22, yFrac: 0.56 };
+    if (/upper.?arm/.test(id))
+        return { xFrac: lat * 0.20, yFrac: 0.68 };
+    if (/arm/.test(id))
+        return { xFrac: lat * 0.20, yFrac: 0.62 };
+    if (/hand/.test(id))
+        return { xFrac: lat * 0.25, yFrac: 0.44 };
+    if (/thigh|upper.?leg/.test(id))
+        return { xFrac: lat * 0.07, yFrac: 0.33 };
+    if (/shin|calf|lower.?leg|foreleg|midleg|hindleg/.test(id))
+        return { xFrac: lat * 0.07, yFrac: 0.17 };
+    if (/leg/.test(id))
+        return { xFrac: lat * 0.07, yFrac: 0.25 };
+    if (/foot|hoof|paw/.test(id))
+        return { xFrac: lat * 0.07, yFrac: 0.03 };
+    if (/tail/.test(id))
+        return { xFrac: 0, yFrac: 0.35 };
+    if (/wing/.test(id))
+        return { xFrac: lat * 0.50, yFrac: 0.65 };
+    return { xFrac: 0, yFrac: 0.50 }; // unknown: geometric midpoint
+}
+/**
+ * Derive mass distribution and centre of gravity from entity body plan.
+ * Falls back to a single "body" segment at the geometric midpoint when no
+ * body plan is present.
+ */
+export function deriveMassDistribution(entity) {
+    const stature_m = entity.attributes.morphology.stature_m / SCALE.m;
+    if (entity.bodyPlan) {
+        const segs = entity.bodyPlan.segments;
+        const totalMass_kg = segs.reduce((s, seg) => s + seg.mass_kg, 0);
+        const totalReal = totalMass_kg / SCALE.kg;
+        let cogX = 0;
+        let cogY = 0;
+        const segments = segs.map(seg => {
+            const off = getCanonicalOffset(seg.id);
+            const mass_r = seg.mass_kg / SCALE.kg;
+            cogX += mass_r * off.xFrac * stature_m;
+            cogY += mass_r * off.yFrac * stature_m;
+            const fractionQ = (totalMass_kg > 0
+                ? Math.min(SCALE.Q, Math.round((seg.mass_kg / totalMass_kg) * SCALE.Q))
+                : 0);
+            return { segmentId: seg.id, mass_kg: seg.mass_kg, fractionQ };
+        });
+        return {
+            totalMass_kg,
+            segments,
+            cogOffset_m: {
+                x: totalReal > 0 ? cogX / totalReal : 0,
+                y: totalReal > 0 ? cogY / totalReal : stature_m / 2,
+            },
+        };
+    }
+    // No body plan: single point mass at geometric midpoint
+    const totalMass_kg = entity.attributes.morphology.mass_kg;
+    return {
+        totalMass_kg,
+        segments: [{ segmentId: "body", mass_kg: totalMass_kg, fractionQ: SCALE.Q }],
+        cogOffset_m: { x: 0, y: stature_m / 2 },
+    };
+}
+/**
+ * Derive a simplified diagonal inertia tensor from entity body plan.
+ * Falls back to a solid-sphere approximation when no body plan is present.
+ */
+export function deriveInertiaTensor(entity) {
+    const stature_m = entity.attributes.morphology.stature_m / SCALE.m;
+    if (entity.bodyPlan) {
+        let I_yaw = 0, I_pitch = 0, I_roll = 0;
+        for (const seg of entity.bodyPlan.segments) {
+            const off = getCanonicalOffset(seg.id);
+            const m = seg.mass_kg / SCALE.kg;
+            const x = off.xFrac * stature_m;
+            const y = off.yFrac * stature_m;
+            // I = m × r_perp² for rotation about each axis (z = 0)
+            I_yaw += m * (x * x);
+            I_pitch += m * (y * y);
+            I_roll += m * (x * x + y * y);
+        }
+        return { yaw_kgm2: I_yaw, pitch_kgm2: I_pitch, roll_kgm2: I_roll };
+    }
+    // Solid-sphere approximation: I = 2/5 × m × r²
+    const m = entity.attributes.morphology.mass_kg / SCALE.kg;
+    const r = stature_m / 4; // effective radius ≈ stature / 4
+    const I = 0.4 * m * r * r;
+    return { yaw_kgm2: I, pitch_kgm2: I, roll_kgm2: I };
+}
+/** Consciousness threshold below which the entity is treated as unconscious for animation. */
+const ANIM_UNCONSCIOUS_THRESHOLD = q(0.20);
+/**
+ * Derive animation hints from entity intent, condition, and injury state.
+ */
+export function deriveAnimationHints(entity) {
+    const dead = entity.injury.dead;
+    const unconscious = !dead && entity.injury.consciousness < ANIM_UNCONSCIOUS_THRESHOLD;
+    const prone = entity.intent.prone
+        || entity.grapple.position === "prone"
+        || entity.grapple.position === "pinned";
+    // Locomotion — zero out when not mobile
+    const mobile = !dead && !unconscious;
+    let idle = q(0);
+    let walk = q(0);
+    let run = q(0);
+    let sprint = q(0);
+    let crawl = q(0);
+    if (mobile) {
+        if (entity.intent.move.intensity === 0)
+            idle = SCALE.Q;
+        else if (entity.intent.move.mode === "walk")
+            walk = SCALE.Q;
+        else if (entity.intent.move.mode === "run")
+            run = SCALE.Q;
+        else if (entity.intent.move.mode === "sprint")
+            sprint = SCALE.Q;
+        else if (entity.intent.move.mode === "crawl")
+            crawl = SCALE.Q;
+        else
+            idle = SCALE.Q;
+    }
+    const guardingQ = (!dead && entity.intent.defence.mode !== DefenceModes.None
+        ? entity.intent.defence.intensity
+        : q(0));
+    const attackingQ = (!dead && entity.action.attackCooldownTicks > 0
+        ? SCALE.Q : 0);
+    return {
+        idle, walk, run, sprint, crawl,
+        guardingQ,
+        attackingQ,
+        shockQ: entity.injury.shock,
+        fearQ: entity.condition.fearQ ?? 0,
+        prone,
+        unconscious,
+        dead,
+    };
+}
+/**
+ * Derive per-region pose modifiers from entity injury state.
+ * Returns one entry per injury region (byRegion keys).
+ */
+export function derivePoseModifiers(entity) {
+    return Object.entries(entity.injury.byRegion).map(([segmentId, region]) => ({
+        segmentId,
+        structuralQ: region.structuralDamage,
+        surfaceQ: region.surfaceDamage,
+        impairmentQ: Math.max(region.structuralDamage, region.surfaceDamage),
+    }));
+}
+/**
+ * Derive grapple pose constraint from entity grapple state.
+ */
+export function deriveGrappleConstraint(entity) {
+    const g = entity.grapple;
+    return {
+        isHolder: g.holdingTargetId !== 0,
+        ...(g.holdingTargetId !== 0 ? { holdingEntityId: g.holdingTargetId } : {}),
+        isHeld: g.heldByIds.length > 0,
+        heldByIds: [...g.heldByIds],
+        position: g.position,
+        gripQ: g.gripQ,
+    };
+}
+/**
+ * Extract a full rig snapshot for every entity in the world.
+ * Combine with extractMotionVectors and extractConditionSamples from
+ * src/debug.ts for a complete per-tick visualisation feed.
+ */
+export function extractRigSnapshots(world) {
+    return world.entities.map(e => ({
+        entityId: e.id,
+        teamId: e.teamId,
+        tick: world.tick,
+        mass: deriveMassDistribution(e),
+        inertia: deriveInertiaTensor(e),
+        animation: deriveAnimationHints(e),
+        pose: derivePoseModifiers(e),
+        grapple: deriveGrappleConstraint(e),
+    }));
+}

package/dist/src/mythology.d.ts

@@ -0,0 +1,101 @@
+import { type Q } from "./units.js";
+import type { LegendRegistry } from "./legend.js";
+import type { ChronicleEntry } from "./chronicle.js";
+/** Six narrative archetypes produced by the compression pass. */
+export type MythArchetype = "hero" | "monster" | "great_plague" | "divine_wrath" | "golden_age" | "trickster";
+/**
+ * Cultural effects a myth applies to every member of a believing faction.
+ * All fields are signed Q deltas; 0 = no effect.
+ */
+export interface MythEffect {
+    /**
+     * Additive fear-threshold modifier for faction members in combat.
+     * Positive = braver (higher threshold before fleeing).
+     * Range advisory: ±q(0.10).
+     */
+    fearThresholdMod_Q: Q;
+    /**
+     * Additive modifier to diplomacy success probability vs. outsiders.
+     * Positive = more trusted; negative = feared/distrusted.
+     */
+    diplomacyMod_Q: Q;
+    /**
+     * Morale bonus when a faction member fights on behalf of the myth.
+     * (e.g., "fighting for the legacy of the hero").
+     */
+    moraleBonus_Q: Q;
+    /**
+     * Technology research speed modifier for believing factions.
+     * Positive = golden-age ambition; negative = fatalistic stagnation.
+     */
+    techMod_Q: Q;
+}
+/** An in-world myth held by one or more factions. */
+export interface Myth {
+    id: string;
+    archetype: MythArchetype;
+    /** Display name, e.g. "The Hero of the Eastern March". */
+    name: string;
+    /** One-sentence description of the myth's content. */
+    description: string;
+    /** Legend IDs and chronicle entry IDs that seeded this myth. */
+    sourceIds: string[];
+    /** Faction IDs that currently hold this belief. */
+    believingFactionIds: string[];
+    /** Simulated days since the myth crystallised. */
+    ageInDays: number;
+    /** How widely and deeply the myth is believed [0, SCALE.Q]. */
+    belief_Q: Q;
+    /** Cultural modifiers for believing factions. */
+    effects: MythEffect;
+}
+/** Collection of all myths in a world. */
+export interface MythRegistry {
+    myths: Map<string, Myth>;
+}
+/** Minimum number of related entries/legends required to trigger a myth. */
+export declare const MYTH_MIN_ENTRIES = 3;
+/** Maximum tick window (days) within which a death cluster counts as a "plague". */
+export declare const PLAGUE_WINDOW_DAYS = 30;
+/** Minimum death count in window to trigger great_plague myth. */
+export declare const PLAGUE_MIN_DEATHS = 3;
+/** Min run of constructive events to trigger golden_age myth. */
+export declare const GOLDEN_AGE_MIN_EVENTS = 5;
+/** Annual belief decay (fraction of belief_Q lost per simulated year). */
+export declare const BELIEF_DECAY_PER_YEAR_Q: Q;
+/** Belief floor — myths never fall below this once formed. */
+export declare const BELIEF_FLOOR_Q: Q;
+export declare function createMythRegistry(): MythRegistry;
+export declare function registerMyth(registry: MythRegistry, myth: Myth): void;
+export declare function getMythsByFaction(registry: MythRegistry, factionId: string): Myth[];
+/**
+ * Run the narrative compression pass over a LegendRegistry and chronicle entry
+ * list, returning any myths that emerge.
+ *
+ * @param legendRegistry     Phase 50 legend registry.
+ * @param entries            Flat list of chronicle entries (all scopes combined).
+ * @param believingFactionIds Faction IDs that will adopt the resulting myths.
+ * @param ticksPerDay        How many simulation ticks equal one simulated day
+ *                           (used for time-window calculations).  Default: 20.
+ */
+export declare function compressMythsFromHistory(legendRegistry: LegendRegistry, entries: ReadonlyArray<ChronicleEntry>, believingFactionIds: string[], ticksPerDay?: number): Myth[];
+/**
+ * Age all myths by one simulated year and decay belief.
+ * Myths below BELIEF_FLOOR_Q are NOT removed — they linger as faded folklore.
+ * Returns the updated registry (mutates in place).
+ */
+export declare function stepMythologyYear(registry: MythRegistry): void;
+/**
+ * Scale a MythEffect by the current belief_Q of the myth.
+ * A barely-believed myth (belief_Q = q(0.10)) contributes only 10% of its
+ * face-value effect.
+ */
+export declare function scaledMythEffect(myth: Myth): MythEffect;
+/**
+ * Aggregate the net cultural effect on a faction from all its myths.
+ * Each myth's effect is scaled by its current belief_Q.
+ *
+ * The host applies these deltas to polity morale, faction diplomacy weights,
+ * and tech-advance probability each polity-day.
+ */
+export declare function aggregateFactionMythEffect(registry: MythRegistry, factionId: string): MythEffect;

package/dist/src/mythology.js

@@ -0,0 +1,308 @@
+// src/mythology.ts — Phase 66: Generative Mythology
+//
+// Applies narrative compression to a Legend/Chronicle log, crystallising
+// recurring patterns into in-world myths held by factions.
+//
+// The compression pass scans for five archetypal patterns:
+//   hero          — heroic legend(s) of a named individual
+//   monster       — notorious legend(s) with high menace
+//   great_plague  — cluster of entity_death / tragic events in a short window
+//   divine_wrath  — settlement_destroyed coinciding with mass deaths
+//   golden_age    — run of masterwork_crafted / settlement_founded with no conflict
+//   trickster     — relationship_betrayal + quest_failed pattern
+//
+// Each myth carries cultural effects (MythEffect) that modifiers faction
+// behaviour: fear threshold, diplomacy probability, battle morale, and
+// technological ambition.  Effects are applied by the host each polity-day.
+//
+// Phase hooks:
+//   Phase 50 (Legend): Legend, LegendRegistry — source material for hero/monster
+//   Phase 56 (Disease): entity_death cluster triggers great_plague myth
+//   Phase 60 (Hazard): settlement_destroyed triggers divine_wrath
+//   Phase 24 (Faction): believingFactionIds gates who is influenced
+//   Phase 47 (Personality): legend tags map to myth personality impact
+import { q, clampQ, qMul, SCALE } from "./units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Minimum number of related entries/legends required to trigger a myth. */
+export const MYTH_MIN_ENTRIES = 3;
+/** Maximum tick window (days) within which a death cluster counts as a "plague". */
+export const PLAGUE_WINDOW_DAYS = 30;
+/** Minimum death count in window to trigger great_plague myth. */
+export const PLAGUE_MIN_DEATHS = 3;
+/** Min run of constructive events to trigger golden_age myth. */
+export const GOLDEN_AGE_MIN_EVENTS = 5;
+/** Annual belief decay (fraction of belief_Q lost per simulated year). */
+export const BELIEF_DECAY_PER_YEAR_Q = q(0.12);
+/** Belief floor — myths never fall below this once formed. */
+export const BELIEF_FLOOR_Q = q(0.10);
+// ── Effect profiles per archetype ─────────────────────────────────────────────
+const EFFECTS = {
+    hero: {
+        fearThresholdMod_Q: q(0.08), // believers are braver
+        diplomacyMod_Q: q(0.05), // hero's fame aids negotiation
+        moraleBonus_Q: q(0.10), // fighting in the hero's name
+        techMod_Q: q(0),
+    },
+    monster: {
+        fearThresholdMod_Q: q(-0.10), // monster story makes foes scarier
+        diplomacyMod_Q: q(-0.05), // fear of outsiders
+        moraleBonus_Q: q(0.05), // "slaying the monster" narrative
+        techMod_Q: q(0),
+    },
+    great_plague: {
+        fearThresholdMod_Q: q(-0.05),
+        diplomacyMod_Q: q(-0.08), // blame outsiders for plague
+        moraleBonus_Q: q(0),
+        techMod_Q: q(-0.05), // fatalistic stagnation
+    },
+    divine_wrath: {
+        fearThresholdMod_Q: q(-0.08),
+        diplomacyMod_Q: q(0.03), // appeasing gods through ritual
+        moraleBonus_Q: q(-0.05),
+        techMod_Q: q(-0.03),
+    },
+    golden_age: {
+        fearThresholdMod_Q: q(0.04),
+        diplomacyMod_Q: q(0.08), // pride of civilisation
+        moraleBonus_Q: q(0.06),
+        techMod_Q: q(0.10), // ambition to recapture greatness
+    },
+    trickster: {
+        fearThresholdMod_Q: q(0.03), // wariness, not fear
+        diplomacyMod_Q: q(-0.06), // distrust of deals
+        moraleBonus_Q: q(0),
+        techMod_Q: q(0.03), // cunning seen as virtue
+    },
+};
+// ── Registry helpers ──────────────────────────────────────────────────────────
+export function createMythRegistry() {
+    return { myths: new Map() };
+}
+export function registerMyth(registry, myth) {
+    registry.myths.set(myth.id, myth);
+}
+export function getMythsByFaction(registry, factionId) {
+    const result = [];
+    for (const myth of registry.myths.values()) {
+        if (myth.believingFactionIds.includes(factionId))
+            result.push(myth);
+    }
+    return result;
+}
+// ── Myth construction helpers ─────────────────────────────────────────────────
+let _nextId = 1;
+function nextMythId() { return `myth_${_nextId++}`; }
+function mkMyth(archetype, name, description, sourceIds, believingFactionIds, belief_Q = q(0.80)) {
+    return {
+        id: nextMythId(),
+        archetype,
+        name,
+        description,
+        sourceIds,
+        believingFactionIds,
+        ageInDays: 0,
+        belief_Q,
+        effects: EFFECTS[archetype],
+    };
+}
+// ── Pattern detectors ─────────────────────────────────────────────────────────
+/**
+ * Derive hero myths from `heroic` legends in the LegendRegistry.
+ * One hero myth per heroic legend with fame > q(0.30).
+ */
+function detectHeroMyths(legendRegistry, believingFactionIds) {
+    const myths = [];
+    for (const legend of legendRegistry.legends.values()) {
+        if (legend.reputation !== "heroic" && legend.reputation !== "legendary")
+            continue;
+        if (legend.fame_Q < q(0.30))
+            continue;
+        myths.push(mkMyth("hero", `The ${legend.reputation === "legendary" ? "Legend" : "Hero"} of ${legend.subjectName}`, `Tales of ${legend.subjectName}'s deeds pass from mouth to mouth, shaping the values of the people.`, [legend.legendId], believingFactionIds, clampQ(legend.fame_Q, q(0.30), SCALE.Q)));
+    }
+    return myths;
+}
+/**
+ * Derive monster myths from `notorious` legends.
+ */
+function detectMonsterMyths(legendRegistry, believingFactionIds) {
+    const myths = [];
+    for (const legend of legendRegistry.legends.values()) {
+        if (legend.reputation !== "notorious")
+            continue;
+        if (legend.fame_Q < q(0.20))
+            continue;
+        myths.push(mkMyth("monster", `The Shadow of ${legend.subjectName}`, `Fear of what ${legend.subjectName} wrought lingers in the communal memory.`, [legend.legendId], believingFactionIds, clampQ(legend.fame_Q, q(0.20), SCALE.Q)));
+    }
+    return myths;
+}
+/**
+ * Detect great_plague myth: PLAGUE_MIN_DEATHS entity_death / tragic entries
+ * within PLAGUE_WINDOW_DAYS of each other.
+ *
+ * Tick parameter is "ticks per day" so windows can be compared.
+ */
+function detectPlagueMyth(entries, believingFactionIds, ticksPerDay) {
+    const deathTypes = new Set(["entity_death", "tragic_event"]);
+    const deaths = entries.filter(e => deathTypes.has(e.eventType))
+        .sort((a, b) => a.tick - b.tick);
+    if (deaths.length < PLAGUE_MIN_DEATHS)
+        return null;
+    const windowTicks = PLAGUE_WINDOW_DAYS * ticksPerDay;
+    let maxCluster = 0;
+    let clusterEntries = [];
+    for (let i = 0; i < deaths.length; i++) {
+        const window = deaths.filter(e => e.tick >= deaths[i].tick && e.tick <= deaths[i].tick + windowTicks);
+        if (window.length > maxCluster) {
+            maxCluster = window.length;
+            clusterEntries = window;
+        }
+    }
+    if (maxCluster < PLAGUE_MIN_DEATHS)
+        return null;
+    return mkMyth("great_plague", "The Great Pestilence", `A time when death walked among the people, and no healer could stem the tide.`, clusterEntries.map(e => e.entryId), believingFactionIds, clampQ(Math.round(maxCluster * SCALE.Q / 10), q(0.40), SCALE.Q));
+}
+/**
+ * Detect divine_wrath myth: settlement_destroyed entry + death cluster within
+ * the same tick window.
+ */
+function detectDivineWrathMyth(entries, believingFactionIds, ticksPerDay) {
+    const destructions = entries.filter(e => e.eventType === "settlement_destroyed");
+    if (destructions.length === 0)
+        return null;
+    const windowTicks = 14 * ticksPerDay; // 14-day window around destruction
+    for (const destruction of destructions) {
+        const nearby = entries.filter(e => e.eventType === "entity_death" &&
+            Math.abs(e.tick - destruction.tick) <= windowTicks);
+        if (nearby.length >= 2) {
+            return mkMyth("divine_wrath", "The Wrath That Fell", `When the settlement crumbled and the dead lay unburied, the people spoke of divine judgement.`, [destruction.entryId, ...nearby.map(e => e.entryId)], believingFactionIds);
+        }
+    }
+    return null;
+}
+/**
+ * Detect golden_age myth: GOLDEN_AGE_MIN_EVENTS consecutive constructive events
+ * (masterwork_crafted, settlement_founded, settlement_upgraded, facility_completed)
+ * without any combat_defeat or settlement_raided in the same window.
+ */
+function detectGoldenAgeMyth(entries, believingFactionIds) {
+    const positiveTypes = new Set([
+        "masterwork_crafted", "settlement_founded", "settlement_upgraded", "facility_completed",
+    ]);
+    const negativeTypes = new Set([
+        "combat_defeat", "settlement_raided", "settlement_destroyed",
+    ]);
+    const sorted = [...entries].sort((a, b) => a.tick - b.tick);
+    let streak = [];
+    for (const entry of sorted) {
+        if (negativeTypes.has(entry.eventType)) {
+            streak = [];
+        }
+        else if (positiveTypes.has(entry.eventType)) {
+            streak.push(entry);
+            if (streak.length >= GOLDEN_AGE_MIN_EVENTS) {
+                return mkMyth("golden_age", "The Golden Age of Craft", `A remembered era of flourishing — settlements rose, masters plied their arts, and the land prospered.`, streak.map(e => e.entryId), believingFactionIds);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Detect trickster myth: at least one relationship_betrayal + one quest_failed
+ * anywhere in the chronicle.
+ */
+function detectTricksterMyth(entries, believingFactionIds) {
+    const betrayals = entries.filter(e => e.eventType === "relationship_betrayal");
+    const failures = entries.filter(e => e.eventType === "quest_failed");
+    if (betrayals.length === 0 || failures.length === 0)
+        return null;
+    const sourceIds = [
+        ...betrayals.slice(0, 2).map(e => e.entryId),
+        ...failures.slice(0, 2).map(e => e.entryId),
+    ];
+    return mkMyth("trickster", "The Deceiver of Pacts", `Stories of broken oaths and failed ventures teach that trust must be earned, never assumed.`, sourceIds, believingFactionIds, q(0.60));
+}
+// ── Main compression pass ─────────────────────────────────────────────────────
+/**
+ * Run the narrative compression pass over a LegendRegistry and chronicle entry
+ * list, returning any myths that emerge.
+ *
+ * @param legendRegistry     Phase 50 legend registry.
+ * @param entries            Flat list of chronicle entries (all scopes combined).
+ * @param believingFactionIds Faction IDs that will adopt the resulting myths.
+ * @param ticksPerDay        How many simulation ticks equal one simulated day
+ *                           (used for time-window calculations).  Default: 20.
+ */
+export function compressMythsFromHistory(legendRegistry, entries, believingFactionIds, ticksPerDay = 20) {
+    const myths = [];
+    myths.push(...detectHeroMyths(legendRegistry, believingFactionIds));
+    myths.push(...detectMonsterMyths(legendRegistry, believingFactionIds));
+    const plague = detectPlagueMyth(entries, believingFactionIds, ticksPerDay);
+    if (plague)
+        myths.push(plague);
+    const wrath = detectDivineWrathMyth(entries, believingFactionIds, ticksPerDay);
+    if (wrath)
+        myths.push(wrath);
+    const golden = detectGoldenAgeMyth(entries, believingFactionIds);
+    if (golden)
+        myths.push(golden);
+    const trickster = detectTricksterMyth(entries, believingFactionIds);
+    if (trickster)
+        myths.push(trickster);
+    return myths;
+}
+// ── Lifecycle ─────────────────────────────────────────────────────────────────
+/**
+ * Age all myths by one simulated year and decay belief.
+ * Myths below BELIEF_FLOOR_Q are NOT removed — they linger as faded folklore.
+ * Returns the updated registry (mutates in place).
+ */
+export function stepMythologyYear(registry) {
+    for (const myth of registry.myths.values()) {
+        myth.ageInDays += 365;
+        const decayed = qMul(myth.belief_Q, SCALE.Q - BELIEF_DECAY_PER_YEAR_Q);
+        myth.belief_Q = clampQ(decayed, BELIEF_FLOOR_Q, SCALE.Q);
+    }
+}
+/**
+ * Scale a MythEffect by the current belief_Q of the myth.
+ * A barely-believed myth (belief_Q = q(0.10)) contributes only 10% of its
+ * face-value effect.
+ */
+export function scaledMythEffect(myth) {
+    const scale = myth.belief_Q;
+    const s = (v) => Math.round(v * scale / SCALE.Q);
+    return {
+        fearThresholdMod_Q: s(myth.effects.fearThresholdMod_Q),
+        diplomacyMod_Q: s(myth.effects.diplomacyMod_Q),
+        moraleBonus_Q: s(myth.effects.moraleBonus_Q),
+        techMod_Q: s(myth.effects.techMod_Q),
+    };
+}
+/**
+ * Aggregate the net cultural effect on a faction from all its myths.
+ * Each myth's effect is scaled by its current belief_Q.
+ *
+ * The host applies these deltas to polity morale, faction diplomacy weights,
+ * and tech-advance probability each polity-day.
+ */
+export function aggregateFactionMythEffect(registry, factionId) {
+    let fearMod = 0;
+    let diploMod = 0;
+    let morale = 0;
+    let tech = 0;
+    for (const myth of registry.myths.values()) {
+        if (!myth.believingFactionIds.includes(factionId))
+            continue;
+        const eff = scaledMythEffect(myth);
+        fearMod += eff.fearThresholdMod_Q;
+        diploMod += eff.diplomacyMod_Q;
+        morale += eff.moraleBonus_Q;
+        tech += eff.techMod_Q;
+    }
+    return {
+        fearThresholdMod_Q: clampQ(fearMod, -SCALE.Q, SCALE.Q),
+        diplomacyMod_Q: clampQ(diploMod, -SCALE.Q, SCALE.Q),
+        moraleBonus_Q: clampQ(morale, 0, SCALE.Q),
+        techMod_Q: clampQ(tech, -SCALE.Q, SCALE.Q),
+    };
+}

package/dist/src/narrative-render.d.ts

@@ -0,0 +1,42 @@
+import type { ChronicleEntry, ChronicleEventType, StoryArc } from "./chronicle.js";
+/** A template function that generates prose from entry variables. */
+type TemplateFn = (vars: Record<string, string | number>) => string;
+/** Generate a summary for a story arc. */
+export declare function renderArcSummary(arc: StoryArc): string;
+/** Render a chronicle entry to prose. */
+export declare function renderEntry(entry: ChronicleEntry): string;
+/** Render an entry with full context. */
+export declare function renderEntryVerbose(entry: ChronicleEntry): string;
+export interface RenderOptions {
+    /** Include significance scores. */
+    showSignificance?: boolean;
+    /** Include actor IDs. */
+    showActors?: boolean;
+    /** Include settlement IDs. */
+    showSettlements?: boolean;
+    /** Minimum significance to include. */
+    minSignificance?: number;
+    /** Format: prose | chronological | compact */
+    format?: "prose" | "chronological" | "compact";
+}
+/** Render multiple entries to a narrative. */
+export declare function renderChronicle(entries: ChronicleEntry[], options?: RenderOptions): string;
+/** Render a complete story arc with its entries. */
+export declare function renderArcNarrative(arc: StoryArc, entryMap: Map<string, ChronicleEntry>): string;
+/** Render all arcs in a chronicle. */
+export declare function renderAllArcs(arcs: StoryArc[], entryMap: Map<string, ChronicleEntry>): string;
+/** Register a custom template for an event type. */
+export declare function registerTemplate(eventType: ChronicleEventType, templateFn: TemplateFn): void;
+/** Register multiple templates at once. */
+export declare function registerTemplates(templates: Partial<Record<ChronicleEventType, TemplateFn>>): void;
+export interface GeneratedNarrative {
+    title: string;
+    summary: string;
+    fullText: string;
+    keyFigures: number[];
+    keyEvents: string[];
+    estimatedDrama: number;
+}
+/** Generate a complete narrative from a set of arcs and entries. */
+export declare function generateNarrative(arcs: StoryArc[], entries: ChronicleEntry[]): GeneratedNarrative;
+export {};