@its-not-rocket-science/ananke 0.1.17 → 0.1.22

package/CHANGELOG.md

@@ -6,6 +6,118 @@ Versioning follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.1.22] — 2026-03-26
+
+### Added
+
+- **Phase 77 · Dynasty & Succession** (`src/succession.ts`)
+  - `SuccessionRuleType`: `"primogeniture" | "renown_based" | "election"`.
+  - `SuccessionCandidate { entityId, kinshipDegree, renown_Q, inheritedRenown_Q, claimStrength_Q }`.
+  - `SuccessionResult { heirId, candidates, rule, stabilityImpact_Q }` — signed Q stability delta.
+  - `findSuccessionCandidates(lineage, deceasedId, renownRegistry, maxDegree?)` — BFS over family graph (Phase 76), computes `renown_Q` and `inheritedRenown_Q` per candidate.
+  - `resolveSuccession(lineage, deceasedId, renownRegistry, rule, worldSeed, tick)` → `SuccessionResult`:
+    - **primogeniture**: first-born child (lowest entityId) gets SCALE.Q claim; others by distance.
+    - **renown_based**: claim = 70% own renown + 30% inherited renown.
+    - **election**: renown-weighted deterministic lottery via `eventSeed`.
+    - Stability: `+STABILITY_CLEAN_SUCCESSION_Q` for uncontested direct heir; `−STABILITY_DISTANT_HEIR_Q` per extra degree; `−STABILITY_CONTESTED_Q` when top-two gap < q(0.10); `−STABILITY_NO_HEIR_Q` if no candidates.
+  - `applySuccessionToPolity(polity, result)` — applies `stabilityImpact_Q` to `polity.stabilityQ` (clamped).
+  - Added `./succession` subpath export to `package.json`.
+  - 21 new tests; 4,142 total. Coverage maintained above all thresholds.
+
+---
+
+## [0.1.21] — 2026-03-26
+
+### Added
+
+- **Phase 76 · Kinship & Lineage** (`src/kinship.ts`)
+  - `LineageNode { entityId, parentIds, childIds, partnerIds }` — family links per entity.
+  - `LineageRegistry { nodes: Map<number, LineageNode> }` — flat registry, no Entity field changes.
+  - `createLineageRegistry()` / `getLineageNode(registry, entityId)` — factory and lazy-init accessor.
+  - `recordBirth(registry, childId, parentAId, parentBId?)` — links child to 1–2 parents; idempotent.
+  - `recordPartnership(registry, entityAId, entityBId)` — mutual partner link; idempotent.
+  - `getParents / getChildren / getSiblings` — direct family queries; siblings deduplicated.
+  - `findAncestors(registry, entityId, maxDepth?)` — BFS upward through parent links (default depth 4).
+  - `computeKinshipDegree(registry, entityA, entityB)` — BFS on undirected family graph (parents + children + partners); returns 0–4 or `null` beyond `MAX_KINSHIP_DEPTH = 4`.
+  - `isKin(registry, entityA, entityB, maxDegree?)` — convenience boolean.
+  - `getKinshipLabel(degree)` → `"self" | "immediate" | "close" | "extended" | "distant" | "unrelated"`.
+  - `computeInheritedRenown(lineage, entityId, renownRegistry, maxDepth?)` — sums ancestor `renown_Q` with geometric decay (`RENOWN_DEPTH_DECAY_Q = q(0.50)` per generation); clamped to SCALE.Q.
+  - Added `./kinship` subpath export to `package.json`.
+  - 42 new tests; 4,121 total. Coverage maintained above all thresholds.
+
+---
+
+## [0.1.20] — 2026-03-26
+
+### Added
+
+- **Phase 75 · Entity Renown & Legend Registry** (`src/renown.ts`)
+  - `RenownRecord { entityId, renown_Q, infamy_Q, entries: LegendEntry[] }` — per-entity reputation on two orthogonal axes.
+  - `LegendEntry { entryId, tick, eventType, significance }` — lightweight reference to a significant `ChronicleEntry`.
+  - `RenownRegistry { records: Map<number, RenownRecord> }` — flat registry, one record per entity.
+  - `createRenownRegistry()` / `getRenownRecord(registry, entityId)` — factory and lazy-init accessor.
+  - `updateRenownFromChronicle(registry, chronicle, entityId, minSignificance?)` — idempotent scan; renown events (legendary_deed, quest_completed, combat_victory, masterwork_crafted, rank_promotion, settlement_founded, first_contact) add to `renown_Q`; infamy events (relationship_betrayal, settlement_raided, settlement_destroyed, quest_failed) add to `infamy_Q`; both capped at SCALE.Q.
+  - `getRenownLabel(renown_Q)` → `"unknown" | "noted" | "known" | "renowned" | "legendary" | "mythic"` (6 tiers at q(0.10) boundaries).
+  - `getInfamyLabel(infamy_Q)` → `"innocent" | "suspect" | "notorious" | "infamous" | "reviled" | "condemned"`.
+  - `deriveFactionStandingAdjustment(renown_Q, infamy_Q, allianceBias)` — signed Q adjustment; heroic factions (bias=1.0) reward renown and punish infamy; criminal factions (bias=0.0) the reverse; clamped to [-SCALE.Q, SCALE.Q].
+  - `getTopLegendEntries(record, n)` — top N entries by significance (tick-descending tie-break).
+  - `renderLegendWithTone(record, entryMap, ctx, maxEntries?)` — renders top entries as prose via Phase 74's `renderEntryWithTone`.
+  - Added `./narrative-prose` and `./renown` subpath exports to `package.json`.
+  - 42 new tests; 4,079 total. Coverage maintained above all thresholds.
+
+---
+
+## [0.1.19] — 2026-03-26
+
+### Added
+
+- **Phase 74 · Simulation Trace → Narrative Prose** (`src/narrative-prose.ts`)
+  - 6 prose tones: `neutral | heroic | tragic | martial | spiritual | mercantile`
+  - Tone-varied templates for all 19 `ChronicleEventType` values.
+  - `deriveNarrativeTone(culture)` — maps dominant `CultureProfile` value → `ProseTone`
+    via `VALUE_TONE_MAP` (martial_virtue→martial, spiritual_devotion→spiritual,
+    commerce→mercantile, honour→heroic, fatalism→tragic; others fall back to neutral).
+  - `mythArchetypeFrame(archetype)` — returns a culturally-flavoured closing phrase for
+    each `MythArchetype` (hero, monster, trickster, great_plague, divine_wrath, golden_age).
+  - `createNarrativeContext(entityNames, culture?, myth?)` — bundles tone + name map + myth frame.
+  - `renderEntryWithTone(entry, ctx)` — picks the tone variant for each event, substitutes
+    `{name}`, `{target}`, computed helper strings (`{cause_str}`, `{location_str}`, etc.),
+    raw `entry.variables`, and appends the myth frame (replacing terminal period).
+  - `renderChronicleWithTone(chronicle, ctx, minSignificance?)` — filters by significance,
+    sorts chronologically, maps via `renderEntryWithTone`.
+  - **Success criterion met:** martial, spiritual, and mercantile tones produce clearly
+    distinguishable prose from the same chronicle events.
+  - 39 new tests; 4,037 total. Coverage: statements 96.81%, branches 86.87%, functions 94.80%.
+
+---
+
+## [0.1.18] — 2026-03-26
+
+### Added
+
+- **CE-18 · External Agent Interface** (`tools/agent-server.ts`)
+  - WebSocket server (default port 3001) implementing an agent observation/action loop
+    over the existing `stepWorld` kernel — no src/ changes, no new npm exports.
+  - **Protocol:**
+    - Client → `{ type: "step", commands?: AgentCommand[] }` or `{ type: "reset" }`
+    - Server → `{ type: "obs", tick, entities: ObservationSlice[], done, winner? }`
+    - On connect → `{ type: "init", config, obs }`
+  - **`ObservationSlice`** — safe subset: position, velocity, fatigue, shock/consciousness/dead,
+    detected nearby enemies (filtered via Phase 52 `canDetect`). No raw internals exposed.
+  - **`AgentCommand`** — validated high-level actions: `attack | move | dodge | flee | idle`.
+    Invalid team targeting silently dropped; `decideCommandsForEntity` fills in missing commands.
+  - Configurable scenario: `TEAM1_SIZE` / `TEAM2_SIZE` (1–4 each), `SEED`, `MAX_TICKS` via env vars.
+    Default: 1v1, Knight (longsword + mail) vs Brawler (club).
+  - Agent-driven stepping: server advances only when client sends `step` — agent controls tick rate.
+  - Determinism preserved: external commands injected via existing `CommandMap` before `stepWorld`.
+  - HTTP endpoints: `GET /config`, `GET /status`, `POST /reset`.
+  - Run: `npm run agent-server`
+  - **Success criterion met:** An external Python script using only `websockets` can drive a single
+    entity through a 1v1 fight, receiving `ObservationSlice` observations each tick and submitting
+    `attack` / `move` commands, without importing any Ananke TypeScript.
+
+---
+
 ## [0.1.17] — 2026-03-26
 
 ### Added

package/dist/src/kinship.d.ts

@@ -0,0 +1,92 @@
+import type { RenownRegistry } from "./renown.js";
+import type { Q } from "./units.js";
+/** A single entity's family links within the lineage graph. */
+export interface LineageNode {
+    entityId: number;
+    /** 0, 1, or 2 biological parent IDs. */
+    parentIds: number[];
+    /** All children recorded via `recordBirth`. */
+    childIds: number[];
+    /** All recorded partners (may grow over time). */
+    partnerIds: number[];
+}
+/** Registry of all lineage nodes, keyed by entityId. */
+export interface LineageRegistry {
+    nodes: Map<number, LineageNode>;
+}
+/** Human-readable kinship label derived from `computeKinshipDegree`. */
+export type KinshipLabel = "self" | "immediate" | "close" | "extended" | "distant" | "unrelated";
+/** Maximum BFS depth for kinship searches; beyond this entities are "unrelated". */
+export declare const MAX_KINSHIP_DEPTH = 4;
+/**
+ * Depth-decay factor for inherited renown.
+ * Each generation reduces the renown contribution by this fraction:
+ *   depth 1 (parent) → q(0.50) × parent renown
+ *   depth 2 (grandparent) → q(0.25) × grandparent renown
+ */
+export declare const RENOWN_DEPTH_DECAY_Q: Q;
+export declare function createLineageRegistry(): LineageRegistry;
+/**
+ * Return the `LineageNode` for `entityId`, creating a root node (no parents,
+ * no children, no partners) if one does not yet exist.
+ */
+export declare function getLineageNode(registry: LineageRegistry, entityId: number): LineageNode;
+/**
+ * Register a birth: create a node for `childId` and link it to up to two parents.
+ * Parent nodes are created if they do not already exist.
+ * No-op if `childId` already has a node (idempotent).
+ */
+export declare function recordBirth(registry: LineageRegistry, childId: number, parentAId: number, parentBId?: number): void;
+/**
+ * Record a partnership between two entities.
+ * Partners are considered degree-1 kin (immediate).
+ * Idempotent: duplicate calls are safe.
+ */
+export declare function recordPartnership(registry: LineageRegistry, entityAId: number, entityBId: number): void;
+/** Return the parent IDs of `entityId` (0–2 elements). */
+export declare function getParents(registry: LineageRegistry, entityId: number): number[];
+/** Return the child IDs of `entityId`. */
+export declare function getChildren(registry: LineageRegistry, entityId: number): number[];
+/**
+ * Return the sibling IDs of `entityId` — entities that share at least one parent,
+ * excluding `entityId` itself.
+ */
+export declare function getSiblings(registry: LineageRegistry, entityId: number): number[];
+/**
+ * Return all ancestors of `entityId` within `maxDepth` generations.
+ * Uses BFS upward through parent links only.
+ */
+export declare function findAncestors(registry: LineageRegistry, entityId: number, maxDepth?: number): Set<number>;
+/**
+ * Compute the degree of kinship between two entities via BFS on the undirected
+ * family graph (parents, children, and partners are all degree-1 neighbours).
+ *
+ * Returns:
+ *   - `0` if `entityA === entityB`
+ *   - `1`–`MAX_KINSHIP_DEPTH` for kin within range
+ *   - `null` if no path exists within `MAX_KINSHIP_DEPTH`
+ */
+export declare function computeKinshipDegree(registry: LineageRegistry, entityA: number, entityB: number): number | null;
+/** Whether two entities are kin within `maxDegree` (default `MAX_KINSHIP_DEPTH`). */
+export declare function isKin(registry: LineageRegistry, entityA: number, entityB: number, maxDegree?: number): boolean;
+/**
+ * Map a numeric kinship degree (or `null`) to a `KinshipLabel`.
+ *
+ * @param degree  Result of `computeKinshipDegree`; pass `null` for unrelated.
+ */
+export declare function getKinshipLabel(degree: number | null): KinshipLabel;
+/**
+ * Compute the renown bonus an entity inherits from their ancestors.
+ *
+ * For each ancestor at depth d, contribution = `ancestor.renown_Q × decay^d`
+ * where `decay = RENOWN_DEPTH_DECAY_Q / SCALE.Q` (default 0.5 per generation).
+ * The sum is clamped to `[0, SCALE.Q]`.
+ *
+ * Entities with no renown records or no ancestors return 0.
+ *
+ * @param registry       Lineage registry.
+ * @param entityId       Entity whose ancestors are being summed.
+ * @param renownRegistry Phase 75 renown registry.
+ * @param maxDepth       How many generations to look back (default 3).
+ */
+export declare function computeInheritedRenown(lineage: LineageRegistry, entityId: number, renownRegistry: RenownRegistry, maxDepth?: number): Q;

package/dist/src/kinship.js

@@ -0,0 +1,234 @@
+// src/kinship.ts — Phase 76: Kinship & Lineage
+//
+// Tracks parent-child-partner links for entities and provides ancestry queries,
+// degree-of-kinship computation, and inherited renown from the Phase 75 system.
+//
+// Design:
+//   - Separate from Entity — the lineage graph lives in a `LineageRegistry`,
+//     not in entity fields, so no kernel changes are required.
+//   - `computeKinshipDegree` uses BFS over the undirected family graph (parents,
+//     children, partners counted at degree 1).
+//   - `inheritedRenown` sums ancestor renown_Q with geometric depth-decay so that
+//     a mythic grandparent grants a modest but real reputation bonus.
+//   - Deterministic: no Math.random(); only pure data queries.
+import { q, SCALE, clampQ } from "./units.js";
+/** Maximum BFS depth for kinship searches; beyond this entities are "unrelated". */
+export const MAX_KINSHIP_DEPTH = 4;
+/**
+ * Depth-decay factor for inherited renown.
+ * Each generation reduces the renown contribution by this fraction:
+ *   depth 1 (parent) → q(0.50) × parent renown
+ *   depth 2 (grandparent) → q(0.25) × grandparent renown
+ */
+export const RENOWN_DEPTH_DECAY_Q = q(0.50);
+// ── Factory ───────────────────────────────────────────────────────────────────
+export function createLineageRegistry() {
+    return { nodes: new Map() };
+}
+// ── Node access ───────────────────────────────────────────────────────────────
+/**
+ * Return the `LineageNode` for `entityId`, creating a root node (no parents,
+ * no children, no partners) if one does not yet exist.
+ */
+export function getLineageNode(registry, entityId) {
+    let node = registry.nodes.get(entityId);
+    if (!node) {
+        node = { entityId, parentIds: [], childIds: [], partnerIds: [] };
+        registry.nodes.set(entityId, node);
+    }
+    return node;
+}
+// ── Mutation helpers ──────────────────────────────────────────────────────────
+/**
+ * Register a birth: create a node for `childId` and link it to up to two parents.
+ * Parent nodes are created if they do not already exist.
+ * No-op if `childId` already has a node (idempotent).
+ */
+export function recordBirth(registry, childId, parentAId, parentBId) {
+    // Ensure child node exists with the given parents
+    const existing = registry.nodes.get(childId);
+    if (!existing) {
+        const parentIds = parentBId != null
+            ? [parentAId, parentBId]
+            : [parentAId];
+        registry.nodes.set(childId, { entityId: childId, parentIds, childIds: [], partnerIds: [] });
+    }
+    // Ensure parent nodes exist and include childId
+    const nodeA = getLineageNode(registry, parentAId);
+    if (!nodeA.childIds.includes(childId))
+        nodeA.childIds.push(childId);
+    if (parentBId != null) {
+        const nodeB = getLineageNode(registry, parentBId);
+        if (!nodeB.childIds.includes(childId))
+            nodeB.childIds.push(childId);
+    }
+}
+/**
+ * Record a partnership between two entities.
+ * Partners are considered degree-1 kin (immediate).
+ * Idempotent: duplicate calls are safe.
+ */
+export function recordPartnership(registry, entityAId, entityBId) {
+    const nodeA = getLineageNode(registry, entityAId);
+    const nodeB = getLineageNode(registry, entityBId);
+    if (!nodeA.partnerIds.includes(entityBId))
+        nodeA.partnerIds.push(entityBId);
+    if (!nodeB.partnerIds.includes(entityAId))
+        nodeB.partnerIds.push(entityAId);
+}
+// ── Family queries ────────────────────────────────────────────────────────────
+/** Return the parent IDs of `entityId` (0–2 elements). */
+export function getParents(registry, entityId) {
+    return registry.nodes.get(entityId)?.parentIds ?? [];
+}
+/** Return the child IDs of `entityId`. */
+export function getChildren(registry, entityId) {
+    return registry.nodes.get(entityId)?.childIds ?? [];
+}
+/**
+ * Return the sibling IDs of `entityId` — entities that share at least one parent,
+ * excluding `entityId` itself.
+ */
+export function getSiblings(registry, entityId) {
+    const parents = getParents(registry, entityId);
+    const result = new Set();
+    for (const pid of parents) {
+        for (const sibId of getChildren(registry, pid)) {
+            if (sibId !== entityId)
+                result.add(sibId);
+        }
+    }
+    return [...result];
+}
+/**
+ * Return all ancestors of `entityId` within `maxDepth` generations.
+ * Uses BFS upward through parent links only.
+ */
+export function findAncestors(registry, entityId, maxDepth = MAX_KINSHIP_DEPTH) {
+    const ancestors = new Set();
+    const queue = [{ id: entityId, depth: 0 }];
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (item.depth >= maxDepth)
+            continue;
+        for (const pid of getParents(registry, item.id)) {
+            if (!ancestors.has(pid)) {
+                ancestors.add(pid);
+                queue.push({ id: pid, depth: item.depth + 1 });
+            }
+        }
+    }
+    return ancestors;
+}
+/**
+ * Compute the degree of kinship between two entities via BFS on the undirected
+ * family graph (parents, children, and partners are all degree-1 neighbours).
+ *
+ * Returns:
+ *   - `0` if `entityA === entityB`
+ *   - `1`–`MAX_KINSHIP_DEPTH` for kin within range
+ *   - `null` if no path exists within `MAX_KINSHIP_DEPTH`
+ */
+export function computeKinshipDegree(registry, entityA, entityB) {
+    if (entityA === entityB)
+        return 0;
+    const visited = new Set([entityA]);
+    const queue = [{ id: entityA, depth: 0 }];
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (item.depth >= MAX_KINSHIP_DEPTH)
+            continue;
+        const node = registry.nodes.get(item.id);
+        if (!node)
+            continue;
+        // BFS over parents + children + partners (undirected)
+        const neighbours = [
+            ...node.parentIds,
+            ...node.childIds,
+            ...node.partnerIds,
+        ];
+        for (const nbr of neighbours) {
+            if (nbr === entityB)
+                return item.depth + 1;
+            if (!visited.has(nbr)) {
+                visited.add(nbr);
+                queue.push({ id: nbr, depth: item.depth + 1 });
+            }
+        }
+    }
+    return null; // unrelated within MAX_KINSHIP_DEPTH
+}
+/** Whether two entities are kin within `maxDegree` (default `MAX_KINSHIP_DEPTH`). */
+export function isKin(registry, entityA, entityB, maxDegree = MAX_KINSHIP_DEPTH) {
+    const degree = computeKinshipDegree(registry, entityA, entityB);
+    return degree !== null && degree <= maxDegree;
+}
+// ── Label ─────────────────────────────────────────────────────────────────────
+/**
+ * Map a numeric kinship degree (or `null`) to a `KinshipLabel`.
+ *
+ * @param degree  Result of `computeKinshipDegree`; pass `null` for unrelated.
+ */
+export function getKinshipLabel(degree) {
+    if (degree === null)
+        return "unrelated";
+    if (degree === 0)
+        return "self";
+    if (degree === 1)
+        return "immediate";
+    if (degree === 2)
+        return "close";
+    if (degree === 3)
+        return "extended";
+    if (degree <= MAX_KINSHIP_DEPTH)
+        return "distant";
+    return "unrelated";
+}
+// ── Inherited renown ──────────────────────────────────────────────────────────
+/**
+ * Compute the renown bonus an entity inherits from their ancestors.
+ *
+ * For each ancestor at depth d, contribution = `ancestor.renown_Q × decay^d`
+ * where `decay = RENOWN_DEPTH_DECAY_Q / SCALE.Q` (default 0.5 per generation).
+ * The sum is clamped to `[0, SCALE.Q]`.
+ *
+ * Entities with no renown records or no ancestors return 0.
+ *
+ * @param registry       Lineage registry.
+ * @param entityId       Entity whose ancestors are being summed.
+ * @param renownRegistry Phase 75 renown registry.
+ * @param maxDepth       How many generations to look back (default 3).
+ */
+export function computeInheritedRenown(lineage, entityId, renownRegistry, maxDepth = 3) {
+    // BFS upward through parent links only (not children/partners)
+    let total = 0;
+    const visited = new Set([entityId]);
+    const queue = [];
+    for (const pid of getParents(lineage, entityId)) {
+        if (!visited.has(pid)) {
+            visited.add(pid);
+            queue.push({ id: pid, depth: 1 });
+        }
+    }
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (item.depth > maxDepth)
+            continue;
+        const record = renownRegistry.records.get(item.id);
+        if (record && record.renown_Q > 0) {
+            // decay^depth applied via repeated integer multiplication
+            let contribution = record.renown_Q;
+            for (let i = 0; i < item.depth; i++) {
+                contribution = Math.round(contribution * RENOWN_DEPTH_DECAY_Q / SCALE.Q);
+            }
+            total += contribution;
+        }
+        for (const pid of getParents(lineage, item.id)) {
+            if (!visited.has(pid)) {
+                visited.add(pid);
+                queue.push({ id: pid, depth: item.depth + 1 });
+            }
+        }
+    }
+    return clampQ(total, 0, SCALE.Q);
+}

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

@@ -0,0 +1,58 @@
+import type { ChronicleEntry } from "./chronicle.js";
+import type { Chronicle } from "./chronicle.js";
+import type { CultureProfile } from "./culture.js";
+import type { MythArchetype, Myth } from "./mythology.js";
+/**
+ * Voice tone used when rendering chronicle entries.
+ * Derived from the dominant cultural values of the originating polity.
+ */
+export type ProseTone = "neutral" | "heroic" | "tragic" | "martial" | "spiritual" | "mercantile";
+/**
+ * Context bundle for a tone-aware rendering pass.
+ * Created by `createNarrativeContext` and passed to render functions.
+ */
+export interface NarrativeContext {
+    /** Map of entity id → display name. Missing ids fall back to "entity {id}". */
+    entityNames: Map<number, string>;
+    /** Prose tone for this rendering pass. */
+    tone: ProseTone;
+    /**
+     * Optional myth-archetype closing phrase appended to each rendered sentence.
+     * Produced by `mythArchetypeFrame(archetype)`.
+     */
+    mythFrame?: string;
+}
+/** Returns a closing phrase appropriate to the myth archetype. */
+export declare function mythArchetypeFrame(archetype: MythArchetype): string;
+/**
+ * Derive the best matching `ProseTone` from a `CultureProfile`.
+ *
+ * Uses the top-ranked cultural value; falls back to `"neutral"` for values
+ * without a direct tone mapping (hospitality, hierarchy, innovation, etc.).
+ */
+export declare function deriveNarrativeTone(culture: CultureProfile): ProseTone;
+/**
+ * Create a `NarrativeContext` for a rendering pass.
+ *
+ * @param entityNames  Map of entity id → display name (numeric ids are looked up here).
+ * @param culture      Optional culture profile — used to derive tone automatically.
+ * @param myth         Optional myth — used to append archetype-framing suffix.
+ */
+export declare function createNarrativeContext(entityNames: Map<number, string>, culture?: CultureProfile, myth?: Myth): NarrativeContext;
+/**
+ * Render a single `ChronicleEntry` with cultural-tone awareness.
+ *
+ * Selects the tone variant for `entry.eventType`; falls back to `"neutral"` if
+ * the requested tone has no specific variant.  Appends `ctx.mythFrame` if set.
+ *
+ * Does NOT mutate `entry.rendered` — call `entry.rendered = renderEntryWithTone(...)`
+ * manually if caching is desired.
+ */
+export declare function renderEntryWithTone(entry: ChronicleEntry, ctx: NarrativeContext): string;
+/**
+ * Render all entries in a `Chronicle` above `minSignificance` (default 50),
+ * returned in chronological order.
+ *
+ * Uses `renderEntryWithTone` for each entry.
+ */
+export declare function renderChronicleWithTone(chronicle: Chronicle, ctx: NarrativeContext, minSignificance?: number): string[];