@its-not-rocket-science/ananke 0.1.0

package/dist/src/bridge/types.d.ts

@@ -0,0 +1,94 @@
+import type { Vec3 } from "../sim/vec3.js";
+import type { Q } from "../units.js";
+import type { AnimationHints, PoseModifier, GrapplePoseConstraint } from "../model3d.js";
+import type { MotionVector, ConditionSample } from "../debug.js";
+/**
+ * Maps a simulation segment ID to a renderer bone name, with optional offsets.
+ */
+export interface SegmentMapping {
+    segmentId: string;
+    boneName: string;
+    /** Optional offset in fixed-point metres (SCALE.m). */
+    positionOffset?: Vec3;
+    /** Optional rotation offset (Euler angles) in fixed-point degrees? Not used yet. */
+    rotationOffset?: Vec3;
+}
+/**
+ * Complete mapping for a body plan.
+ */
+export interface BodyPlanMapping {
+    /** Matches BodyPlan.id */
+    bodyPlanId: string;
+    segments: SegmentMapping[];
+}
+/**
+ * Bridge configuration supplied by the host renderer.
+ */
+export interface BridgeConfig {
+    mappings: BodyPlanMapping[];
+    /** Allow extrapolation when render time is ahead of the latest simulation tick. Default false. */
+    extrapolationAllowed?: boolean;
+    /** Bone name to use for unmapped segments (default "root"). */
+    defaultBoneName?: string;
+}
+/**
+ * Per‑segment pose data after mapping to bone names.
+ */
+export interface MappedPoseModifier {
+    segmentId: string;
+    boneName: string;
+    impairmentQ: Q;
+    structuralQ: Q;
+    surfaceQ: Q;
+}
+/**
+ * Fully interpolated state for a single entity at a specific render time.
+ */
+export interface InterpolatedState {
+    entityId: number;
+    teamId: number;
+    position_m: Vec3;
+    velocity_mps: Vec3;
+    facing: Vec3;
+    animation: AnimationHints;
+    poseModifiers: MappedPoseModifier[];
+    grapple: GrapplePoseConstraint;
+    condition: {
+        shockQ: Q;
+        fearQ: Q;
+        consciousness: Q;
+        fluidLoss: Q;
+        dead: boolean;
+    };
+    /** Interpolation factor t ∈ [0, SCALE.Q] between fromTick and toTick. */
+    interpolationFactor: Q;
+    fromTick: number;
+    toTick: number;
+}
+/**
+ * Aggregated snapshot for one entity at one tick.
+ */
+export interface TickSnapshot {
+    entityId: number;
+    teamId: number;
+    tick: number;
+    position_m: Vec3;
+    velocity_mps: Vec3;
+    facing: Vec3;
+    animation: AnimationHints;
+    poseModifiers: PoseModifier[];
+    grapple: GrapplePoseConstraint;
+    condition: {
+        shockQ: Q;
+        fearQ: Q;
+        consciousness: Q;
+        fluidLoss: Q;
+        dead: boolean;
+    };
+}
+export interface BridgeUpdate {
+    snapshots: TickSnapshot[];
+    motion?: MotionVector[];
+    condition?: ConditionSample[];
+}
+export type InterpolationMode = "lerp" | "extrapolate" | "hold";

package/dist/src/bridge/types.js

@@ -0,0 +1,2 @@
+// src/bridge/types.ts — Bridge core interfaces
+export {};

package/dist/src/campaign.d.ts

@@ -0,0 +1,141 @@
+import type { Q } from "./units.js";
+import type { Polity } from "./polity.js";
+import type { Entity } from "./sim/entity.js";
+import type { DowntimeConfig, EntityRecoveryReport } from "./downtime.js";
+/**
+ * A named region in the campaign world.
+ *
+ * `travelCost` maps destination locationId → travel time in seconds.
+ * Only direct routes need to be specified; multi-hop routing is the host's responsibility.
+ */
+export interface Location {
+    id: string;
+    name: string;
+    /** Phase 29 integration: ambient temperature for thermoregulation during travel/rest. */
+    ambientTemp_Q?: Q;
+    /** Altitude above sea level in real metres (not fixed-point). Used for environmental reference. */
+    elevation_m: number;
+    travelCost: Map<string, number>;
+}
+/**
+ * Full persistent state of an ongoing campaign.
+ *
+ * Designed to be serialised and deserialised between play sessions.
+ * Maps survive round-trip via `serialiseCampaign` / `deserialiseCampaign`.
+ */
+export interface CampaignState {
+    id: string;
+    epoch: string;
+    worldTime_s: number;
+    entities: Map<number, Entity>;
+    locations: Map<string, Location>;
+    /** Current location of each entity, keyed by entityId. */
+    entityLocations: Map<number, string>;
+    /**
+     * Campaign-level item stockpiles per entity (arrows, rations, bandages, etc.).
+     * Separate from combat loadout (`entity.loadout`), which represents equipped gear.
+     * Map<entityId, Map<itemId, count>>
+     */
+    entityInventories: Map<number, Map<string, number>>;
+    log: Array<{
+        worldTime_s: number;
+        text: string;
+    }>;
+    /**
+     * Polities active in this campaign (Phase 61).
+     * Absent until the first call to `addPolity`.
+     */
+    polities?: Map<string, Polity>;
+}
+/**
+ * Create a new campaign with a set of starting entities.
+ *
+ * Entities are deep-cloned into the registry; the originals are not retained.
+ * worldTime_s starts at 0.
+ *
+ * @param epoch  ISO timestamp string (defaults to current system time if omitted).
+ */
+export declare function createCampaign(id: string, entities: Entity[], epoch?: string): CampaignState;
+/** Register or update a location in the campaign registry. */
+export declare function addLocation(campaign: CampaignState, location: Location): void;
+/** Get the current locationId for an entity, or undefined if not placed. */
+export declare function getEntityLocation(campaign: CampaignState, entityId: number): string | undefined;
+/**
+ * Merge updated entity states from a completed encounter back into the registry.
+ *
+ * All entities in `worldEntities` are deep-cloned into the campaign registry.
+ * Entities not present in the world are left unchanged.
+ */
+export declare function mergeEntityState(campaign: CampaignState, worldEntities: Entity[]): void;
+/**
+ * Advance the campaign clock by `delta_s` seconds and apply wound recovery.
+ *
+ * Delegates to `stepDowntime` for all registered entities.  If
+ * `opts.downtimeConfig` is supplied, it is used directly.  Otherwise a
+ * default config is built: rest=true, careLevel="none" for every entity
+ * (natural clotting only — no treatment resources consumed).
+ *
+ * After the simulation, each entity's `injury` in the registry is replaced
+ * with the final simulated injury state (`report.finalInjury`), so the
+ * campaign registry always reflects the current physical condition.
+ *
+ * @returns Recovery reports for all entities that were processed.
+ */
+export declare function stepCampaignTime(campaign: CampaignState, delta_s: number, opts?: {
+    downtimeConfig?: DowntimeConfig;
+}): EntityRecoveryReport[];
+/**
+ * Move an entity to a new location.
+ *
+ * Looks up the travel time between the entity's current location and
+ * `toLocationId` from the destination location's `travelCost` map (or from
+ * the source location's map if no current location is set, assumes 0 travel
+ * time for first placement).
+ *
+ * Advances `campaign.worldTime_s` by the travel time.
+ *
+ * @returns Travel time in seconds, or -1 if the destination is unknown or
+ *          no travel route exists between current and destination.
+ */
+export declare function travel(campaign: CampaignState, entityId: number, toLocationId: string): number;
+/**
+ * Debit `count` units of `itemId` from the entity's campaign inventory.
+ *
+ * Returns `true` if the debit succeeded (sufficient stock available).
+ * Returns `false` if the entity does not have enough of the item.
+ * Stock is never reduced below 0.
+ */
+export declare function debitInventory(campaign: CampaignState, entityId: number, itemId: string, count: number): boolean;
+/**
+ * Credit `count` units of `itemId` to the entity's campaign inventory.
+ * Creates the inventory entry if it does not yet exist.
+ */
+export declare function creditInventory(campaign: CampaignState, entityId: number, itemId: string, count: number): void;
+/**
+ * Get the current count of `itemId` in the entity's campaign inventory.
+ * Returns 0 if the entity has no inventory or no entry for the item.
+ */
+export declare function getInventoryCount(campaign: CampaignState, entityId: number, itemId: string): number;
+/**
+ * Register a Polity in the campaign.
+ *
+ * The polity is stored by reference (not cloned); the caller owns the object.
+ * Initialises `campaign.polities` on first use.
+ */
+export declare function addPolity(campaign: CampaignState, polity: Polity): void;
+/**
+ * Retrieve a Polity by id, or undefined if not registered.
+ */
+export declare function getPolity(campaign: CampaignState, polityId: string): Polity | undefined;
+/**
+ * Serialise a CampaignState to a JSON string.
+ *
+ * Handles all nested Map fields (entities, locations, entityLocations,
+ * entityInventories, entity.armourState, entity.skills, location.travelCost)
+ * using the `__ananke_map__` marker pattern (same as src/replay.ts).
+ */
+export declare function serialiseCampaign(campaign: CampaignState): string;
+/**
+ * Deserialise a CampaignState from a JSON string produced by `serialiseCampaign`.
+ */
+export declare function deserialiseCampaign(json: string): CampaignState;

package/dist/src/campaign.js

@@ -0,0 +1,235 @@
+// src/campaign.ts — Phase 22: Campaign & World State
+//
+// Persistence layer for campaigns that span multiple encounters.
+// Tracks world time, entity state, location, and campaign inventory
+// between sessions.  Delegates wound recovery to Phase 19 stepDowntime.
+//
+// No kernel import — this is a pure data-management and bookkeeping module.
+import { stepDowntime } from "./downtime.js";
+// ── Map-aware serialisation helpers ──────────────────────────────────────────
+// (Same pattern as src/replay.ts; duplicated to avoid a cross-module dependency.)
+const MAP_MARKER = "__ananke_map__";
+function mapReplacer(_key, value) {
+    if (value instanceof Map) {
+        return { [MAP_MARKER]: true, entries: [...value.entries()] };
+    }
+    return value;
+}
+function mapReviver(_key, value) {
+    if (value !== null &&
+        typeof value === "object" &&
+        value[MAP_MARKER] === true) {
+        return new Map(value.entries);
+    }
+    return value;
+}
+// ── Factory ───────────────────────────────────────────────────────────────────
+/**
+ * Create a new campaign with a set of starting entities.
+ *
+ * Entities are deep-cloned into the registry; the originals are not retained.
+ * worldTime_s starts at 0.
+ *
+ * @param epoch  ISO timestamp string (defaults to current system time if omitted).
+ */
+export function createCampaign(id, entities, epoch) {
+    const entityMap = new Map();
+    for (const e of entities)
+        entityMap.set(e.id, structuredClone(e));
+    return {
+        id,
+        epoch: epoch ?? new Date().toISOString(),
+        worldTime_s: 0,
+        entities: entityMap,
+        locations: new Map(),
+        entityLocations: new Map(),
+        entityInventories: new Map(),
+        log: [],
+    };
+}
+// ── Location management ───────────────────────────────────────────────────────
+/** Register or update a location in the campaign registry. */
+export function addLocation(campaign, location) {
+    campaign.locations.set(location.id, location);
+}
+/** Get the current locationId for an entity, or undefined if not placed. */
+export function getEntityLocation(campaign, entityId) {
+    return campaign.entityLocations.get(entityId);
+}
+// ── Entity registry ───────────────────────────────────────────────────────────
+/**
+ * Merge updated entity states from a completed encounter back into the registry.
+ *
+ * All entities in `worldEntities` are deep-cloned into the campaign registry.
+ * Entities not present in the world are left unchanged.
+ */
+export function mergeEntityState(campaign, worldEntities) {
+    for (const e of worldEntities) {
+        campaign.entities.set(e.id, structuredClone(e));
+    }
+}
+// ── Time advancement ──────────────────────────────────────────────────────────
+/**
+ * Advance the campaign clock by `delta_s` seconds and apply wound recovery.
+ *
+ * Delegates to `stepDowntime` for all registered entities.  If
+ * `opts.downtimeConfig` is supplied, it is used directly.  Otherwise a
+ * default config is built: rest=true, careLevel="none" for every entity
+ * (natural clotting only — no treatment resources consumed).
+ *
+ * After the simulation, each entity's `injury` in the registry is replaced
+ * with the final simulated injury state (`report.finalInjury`), so the
+ * campaign registry always reflects the current physical condition.
+ *
+ * @returns Recovery reports for all entities that were processed.
+ */
+export function stepCampaignTime(campaign, delta_s, opts) {
+    campaign.worldTime_s += delta_s;
+    // Build a minimal WorldState from campaign entities
+    const world = {
+        tick: 0,
+        seed: 1,
+        entities: [...campaign.entities.values()],
+    };
+    let config;
+    if (opts?.downtimeConfig) {
+        config = opts.downtimeConfig;
+    }
+    else {
+        // Default: rest with no active treatment for all entities
+        const treatments = new Map();
+        for (const id of campaign.entities.keys()) {
+            treatments.set(id, { careLevel: "none" });
+        }
+        config = { treatments, rest: true };
+    }
+    const reports = stepDowntime(world, delta_s, config);
+    // Apply healed injury states back to the campaign registry
+    for (const report of reports) {
+        const entity = campaign.entities.get(report.entityId);
+        if (!entity)
+            continue;
+        if (report.finalInjury) {
+            entity.injury = report.finalInjury;
+        }
+        if (report.died) {
+            campaign.log.push({
+                worldTime_s: campaign.worldTime_s,
+                text: `Entity ${report.entityId} died during recovery.`,
+            });
+        }
+    }
+    return reports;
+}
+// ── Travel ────────────────────────────────────────────────────────────────────
+/**
+ * Move an entity to a new location.
+ *
+ * Looks up the travel time between the entity's current location and
+ * `toLocationId` from the destination location's `travelCost` map (or from
+ * the source location's map if no current location is set, assumes 0 travel
+ * time for first placement).
+ *
+ * Advances `campaign.worldTime_s` by the travel time.
+ *
+ * @returns Travel time in seconds, or -1 if the destination is unknown or
+ *          no travel route exists between current and destination.
+ */
+export function travel(campaign, entityId, toLocationId) {
+    const dest = campaign.locations.get(toLocationId);
+    if (!dest)
+        return -1;
+    const currentLoc = campaign.entityLocations.get(entityId);
+    let travelTime = 0;
+    if (currentLoc !== undefined && currentLoc !== toLocationId) {
+        const src = campaign.locations.get(currentLoc);
+        // Look up travel time from source first, then from destination (bidirectional)
+        const cost = src?.travelCost.get(toLocationId) ?? dest.travelCost.get(currentLoc);
+        if (cost === undefined)
+            return -1; // no route
+        travelTime = cost;
+    }
+    campaign.entityLocations.set(entityId, toLocationId);
+    campaign.worldTime_s += travelTime;
+    campaign.log.push({
+        worldTime_s: campaign.worldTime_s,
+        text: `Entity ${entityId} travelled to ${dest.name} (${travelTime}s).`,
+    });
+    return travelTime;
+}
+// ── Inventory ─────────────────────────────────────────────────────────────────
+/**
+ * Debit `count` units of `itemId` from the entity's campaign inventory.
+ *
+ * Returns `true` if the debit succeeded (sufficient stock available).
+ * Returns `false` if the entity does not have enough of the item.
+ * Stock is never reduced below 0.
+ */
+export function debitInventory(campaign, entityId, itemId, count) {
+    const inv = campaign.entityInventories.get(entityId);
+    const current = inv?.get(itemId) ?? 0;
+    if (current < count)
+        return false;
+    const updatedInv = inv ?? new Map();
+    updatedInv.set(itemId, current - count);
+    campaign.entityInventories.set(entityId, updatedInv);
+    campaign.log.push({
+        worldTime_s: campaign.worldTime_s,
+        text: `Entity ${entityId} used ${count}× ${itemId} (${current - count} remaining).`,
+    });
+    return true;
+}
+/**
+ * Credit `count` units of `itemId` to the entity's campaign inventory.
+ * Creates the inventory entry if it does not yet exist.
+ */
+export function creditInventory(campaign, entityId, itemId, count) {
+    let inv = campaign.entityInventories.get(entityId);
+    if (!inv) {
+        inv = new Map();
+        campaign.entityInventories.set(entityId, inv);
+    }
+    inv.set(itemId, (inv.get(itemId) ?? 0) + count);
+}
+/**
+ * Get the current count of `itemId` in the entity's campaign inventory.
+ * Returns 0 if the entity has no inventory or no entry for the item.
+ */
+export function getInventoryCount(campaign, entityId, itemId) {
+    return campaign.entityInventories.get(entityId)?.get(itemId) ?? 0;
+}
+// ── Polity integration (Phase 61) ────────────────────────────────────────────
+/**
+ * Register a Polity in the campaign.
+ *
+ * The polity is stored by reference (not cloned); the caller owns the object.
+ * Initialises `campaign.polities` on first use.
+ */
+export function addPolity(campaign, polity) {
+    if (!campaign.polities)
+        campaign.polities = new Map();
+    campaign.polities.set(polity.id, polity);
+}
+/**
+ * Retrieve a Polity by id, or undefined if not registered.
+ */
+export function getPolity(campaign, polityId) {
+    return campaign.polities?.get(polityId);
+}
+// ── Serialisation ─────────────────────────────────────────────────────────────
+/**
+ * Serialise a CampaignState to a JSON string.
+ *
+ * Handles all nested Map fields (entities, locations, entityLocations,
+ * entityInventories, entity.armourState, entity.skills, location.travelCost)
+ * using the `__ananke_map__` marker pattern (same as src/replay.ts).
+ */
+export function serialiseCampaign(campaign) {
+    return JSON.stringify(campaign, mapReplacer);
+}
+/**
+ * Deserialise a CampaignState from a JSON string produced by `serialiseCampaign`.
+ */
+export function deserialiseCampaign(json) {
+    return JSON.parse(json, mapReviver);
+}

package/dist/src/channels.d.ts

@@ -0,0 +1,15 @@
+export declare enum DamageChannel {
+    Kinetic = 0,
+    Thermal = 1,
+    Electrical = 2,
+    Chemical = 3,
+    Radiation = 4,
+    Corrosive = 5,
+    Suffocation = 6,
+    ControlDisruption = 7,
+    /** Phase 11C: directed energy — plasma, laser, sonic. Armour resists via reflectivity. */
+    Energy = 8
+}
+export type ChannelMask = number;
+export declare const channelMask: (...chs: DamageChannel[]) => ChannelMask;
+export declare const hasChannel: (mask: ChannelMask, ch: DamageChannel) => boolean;

package/dist/src/channels.js

@@ -0,0 +1,20 @@
+export var DamageChannel;
+(function (DamageChannel) {
+    DamageChannel[DamageChannel["Kinetic"] = 0] = "Kinetic";
+    DamageChannel[DamageChannel["Thermal"] = 1] = "Thermal";
+    DamageChannel[DamageChannel["Electrical"] = 2] = "Electrical";
+    DamageChannel[DamageChannel["Chemical"] = 3] = "Chemical";
+    DamageChannel[DamageChannel["Radiation"] = 4] = "Radiation";
+    DamageChannel[DamageChannel["Corrosive"] = 5] = "Corrosive";
+    DamageChannel[DamageChannel["Suffocation"] = 6] = "Suffocation";
+    DamageChannel[DamageChannel["ControlDisruption"] = 7] = "ControlDisruption";
+    /** Phase 11C: directed energy — plasma, laser, sonic. Armour resists via reflectivity. */
+    DamageChannel[DamageChannel["Energy"] = 8] = "Energy";
+})(DamageChannel || (DamageChannel = {}));
+export const channelMask = (...chs) => {
+    let m = 0;
+    for (const c of chs)
+        m |= (1 << c);
+    return m;
+};
+export const hasChannel = (mask, ch) => (mask & (1 << ch)) !== 0;

package/dist/src/chronicle.d.ts

@@ -0,0 +1,124 @@
+/** A single entry in a chronicle. */
+export interface ChronicleEntry {
+    entryId: string;
+    tick: number;
+    /** Significance score 0-100 for filtering/summarizing. */
+    significance: number;
+    eventType: ChronicleEventType;
+    /** Entity IDs involved in the event. */
+    actors: number[];
+    /** Template key for rendering. */
+    template: string;
+    /** Variables for template substitution. */
+    variables: Record<string, string | number>;
+    /** Rendered prose (generated on demand or at creation). */
+    rendered?: string | undefined;
+    /** Settlement ID if event occurred at a settlement. */
+    settlementId?: string | undefined;
+    /** Quest ID if event relates to a quest. */
+    questId?: string | undefined;
+}
+/** Types of events that can be recorded in a chronicle. */
+export type ChronicleEventType = "entity_death" | "entity_birth" | "relationship_formed" | "relationship_broken" | "relationship_betrayal" | "quest_completed" | "quest_failed" | "quest_accepted" | "settlement_founded" | "settlement_upgraded" | "settlement_raided" | "settlement_destroyed" | "facility_completed" | "masterwork_crafted" | "first_contact" | "combat_victory" | "combat_defeat" | "rank_promotion" | "legendary_deed" | "tragic_event";
+/** Chronicle scope determines visibility and ownership. */
+export type ChronicleScope = "world" | "faction" | "settlement" | "entity";
+/** A collection of chronicle entries forming a narrative history. */
+export interface Chronicle {
+    chronicleId: string;
+    scope: ChronicleScope;
+    /** Owner ID for entity/faction/settlement-specific chronicles. */
+    ownerId?: number | string | undefined;
+    entries: ChronicleEntry[];
+    /** When the chronicle was created. */
+    createdAtTick: number;
+    /** Last entry tick. */
+    lastEntryTick: number;
+    /** Detected story arcs in this chronicle. */
+    detectedArcs: StoryArc[];
+}
+/** A detected story arc (pattern across multiple events). */
+export interface StoryArc {
+    arcId: string;
+    arcType: StoryArcType;
+    /** Entry IDs that form this arc. */
+    entryIds: string[];
+    /** Primary actors in the arc. */
+    primaryActors: number[];
+    /** When the arc began. */
+    startTick: number;
+    /** When the arc ended (undefined if ongoing). */
+    endTick?: number | undefined;
+    /** Arc significance score. */
+    significance: number;
+    /** Human-readable arc description. */
+    description: string;
+}
+export type StoryArcType = "rise_of_hero" | "tragic_fall" | "rivalry" | "great_migration" | "settlement_growth" | "fallen_settlement" | "legendary_craftsman" | "notorious_villain" | "unlikely_friendship" | "betrayal_and_redemption";
+/** Base significance scores by event type. */
+export declare const SIGNIFICANCE_SCORES: Record<ChronicleEventType, number>;
+/** Modifiers for significance calculation. */
+export interface SignificanceContext {
+    /** Entity was of high reputation/fame. */
+    actorWasFamous?: boolean;
+    /** Event was a first (first death in world, etc.). */
+    wasFirst?: boolean;
+    /** Multiple entities involved. */
+    involvedMultipleParties?: boolean;
+    /** Outcome was unexpected (underdog victory). */
+    unexpectedOutcome?: boolean;
+    /** Event had lasting consequences. */
+    lastingConsequences?: boolean;
+}
+/** Calculate significance score for an event. */
+export declare function calculateSignificance(eventType: ChronicleEventType, context?: SignificanceContext): number;
+/** Check if an event is significant enough to record. */
+export declare function isSignificant(eventType: ChronicleEventType, threshold?: number, context?: SignificanceContext): boolean;
+/** Create a new chronicle. */
+export declare function createChronicle(chronicleId: string, scope: ChronicleScope, tick: number, ownerId?: number | string): Chronicle;
+/** Add an entry to a chronicle. */
+export declare function addChronicleEntry(chronicle: Chronicle, entry: Omit<ChronicleEntry, "entryId">, seed?: number): ChronicleEntry;
+/** Get entries above a significance threshold. */
+export declare function getSignificantEntries(chronicle: Chronicle, minSignificance?: number): ChronicleEntry[];
+/** Get entries within a tick range. */
+export declare function getEntriesInRange(chronicle: Chronicle, startTick: number, endTick: number): ChronicleEntry[];
+/** Get entries involving a specific entity. */
+export declare function getEntriesForEntity(chronicle: Chronicle, entityId: number): ChronicleEntry[];
+/** Get entries of a specific type. */
+export declare function getEntriesByType(chronicle: Chronicle, eventType: ChronicleEventType): ChronicleEntry[];
+/** Global chronicle registry. */
+export interface ChronicleRegistry {
+    /** World-level chronicle (all significant events). */
+    worldChronicle: Chronicle;
+    /** Per-entity chronicles. */
+    entityChronicles: Map<number, Chronicle>;
+    /** Per-faction chronicles. */
+    factionChronicles: Map<number, Chronicle>;
+    /** Per-settlement chronicles. */
+    settlementChronicles: Map<string, Chronicle>;
+}
+/** Create a new chronicle registry. */
+export declare function createChronicleRegistry(tick: number): ChronicleRegistry;
+/** Record an event to appropriate chronicles. */
+export declare function recordEvent(registry: ChronicleRegistry, entry: Omit<ChronicleEntry, "entryId">, options?: {
+    entityIds?: number[];
+    factionIds?: number[];
+    settlementId?: string;
+}): void;
+export type SummaryLevel = "full" | "chapter" | "synopsis";
+export interface ChronicleSummary {
+    level: SummaryLevel;
+    totalEntries: number;
+    includedEntries: number;
+    summaryText: string;
+    keyEvents: ChronicleEntry[];
+}
+/** Summarize a chronicle at different granularities. */
+export declare function summarizeChronicle(chronicle: Chronicle, level?: SummaryLevel): ChronicleSummary;
+/** Serialize chronicle to JSON-friendly format. */
+export declare function serializeChronicle(chronicle: Chronicle): unknown;
+/** Deserialize chronicle. */
+export declare function deserializeChronicle(data: unknown): Chronicle;
+/** Serialize chronicle registry. */
+export declare function serializeChronicleRegistry(registry: ChronicleRegistry): unknown;
+/** Deserialize chronicle registry. */
+export declare function deserializeChronicleRegistry(data: unknown): ChronicleRegistry;