@its-not-rocket-science/ananke 0.1.69 → 0.5.4

package/dist/src/snapshot.js

@@ -27,6 +27,7 @@
  *   0x09 object (uint32 LE count + key-value pairs, keys as 0x07 strings)
  *   0x0A undefined/absent (skipped in round-trip)
  */
+import { normalizeWorldInPlace } from "./sim/normalization.js";
 // ── Diff ──────────────────────────────────────────────────────────────────────
 /**
  * Compute the diff between two `WorldState` snapshots.
@@ -46,11 +47,7 @@ export function diffWorldState(prev, next) {
     const worldKeys = [
         "tick", "seed",
         "activeFieldEffects",
-        "__sensoryEnv",
-        "__factionRegistry",
-        "__partyRegistry",
-        "__relationshipGraph",
-        "__nutritionAccum",
+        "runtimeState",
     ];
     for (const key of worldKeys) {
         if (key === "entities")
@@ -120,7 +117,7 @@ export function applyDiff(base, diff) {
     entities = [...entities, ...diff.added];
     // Restore canonical sort order (ascending id)
     entities.sort((a, b) => a.id - b.id);
-    return { ...next, entities };
+    return normalizeWorldInPlace({ ...next, entities });
 }
 // ── isEmpty / stats ───────────────────────────────────────────────────────────
 /**

package/dist/src/tier2.d.ts

@@ -0,0 +1,19 @@
+export * from "./archetypes.js";
+export * from "./generate.js";
+export * from "./equipment.js";
+export * from "./weapons.js";
+export * from "./presets.js";
+export * from "./channels.js";
+export * from "./traits.js";
+export * from "./describe.js";
+export * from "./sim/vec3.js";
+export * from "./sim/condition.js";
+export * from "./sim/injury.js";
+export * from "./sim/kinds.js";
+export * from "./sim/body.js";
+export * from "./model3d.js";
+export * from "./bridge/index.js";
+export * from "./world-factory.js";
+export * from "./scenario.js";
+export * from "./navigation/causal-chain.js";
+export * from "./data-governance.js";

package/dist/src/tier2.js

@@ -0,0 +1,21 @@
+// Tier 2 — Experimental host-facing surface.
+// Usable, but subject to change across minor versions.
+export * from "./archetypes.js";
+export * from "./generate.js";
+export * from "./equipment.js";
+export * from "./weapons.js";
+export * from "./presets.js";
+export * from "./channels.js";
+export * from "./traits.js";
+export * from "./describe.js";
+export * from "./sim/vec3.js";
+export * from "./sim/condition.js";
+export * from "./sim/injury.js";
+export * from "./sim/kinds.js";
+export * from "./sim/body.js";
+export * from "./model3d.js";
+export * from "./bridge/index.js";
+export * from "./world-factory.js";
+export * from "./scenario.js";
+export * from "./navigation/causal-chain.js";
+export * from "./data-governance.js";

package/dist/src/tier3.d.ts

@@ -0,0 +1,10 @@
+export * from "./catalog.js";
+export * from "./sim/formation-combat.js";
+export * from "./sim/cover.js";
+export * from "./sim/ai/behavior-trees.js";
+export * from "./snapshot.js";
+export * from "./parallel.js";
+export * from "./modding.js";
+export * from "./serialization/binary.js";
+export * from "./history/timetravel.js";
+export * from "./history/autosave.js";

package/dist/src/tier3.js

@@ -0,0 +1,12 @@
+// Tier 3 — Internal / advanced surface.
+// No stability guarantees; pin commit hashes if consumed directly.
+export * from "./catalog.js";
+export * from "./sim/formation-combat.js";
+export * from "./sim/cover.js";
+export * from "./sim/ai/behavior-trees.js";
+export * from "./snapshot.js";
+export * from "./parallel.js";
+export * from "./modding.js";
+export * from "./serialization/binary.js";
+export * from "./history/timetravel.js";
+export * from "./history/autosave.js";

package/dist/src/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runtime engine version used for compatibility checks.
+ *
+ * Source of truth: package.json "version".
+ */
+export declare const ANANKE_ENGINE_VERSION = "0.5.3";

package/dist/src/version.js

@@ -0,0 +1,8 @@
+// AUTO-GENERATED by tools/sync-version.mjs
+// Canonical source: package.json "version"
+/**
+ * Runtime engine version used for compatibility checks.
+ *
+ * Source of truth: package.json "version".
+ */
+export const ANANKE_ENGINE_VERSION = "0.5.3";

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

@@ -0,0 +1,14 @@
+export interface WasmSnapshotEntity {
+    x: number;
+    y: number;
+    hp: number;
+    alive: number;
+}
+export interface AnankeWasmBridge {
+    backend: "wasm" | "ts";
+    world_create: (seed: number) => number;
+    world_step: (commands: Int32Array) => number;
+    world_stepBatch?: (commands: Int32Array, commandCount: number) => number;
+    world_extractSnapshot: () => WasmSnapshotEntity[];
+}
+export declare function initAnankeWasm(): Promise<AnankeWasmBridge>;

package/dist/src/wasm/bridge.js

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+function createTsFallback() {
+    const entities = [];
+    let seed = 1;
+    const next = () => (seed = (seed * 1664525 + 1013904223) | 0);
+    return {
+        backend: "ts",
+        world_create(worldSeed) {
+            entities.length = 0;
+            seed = worldSeed | 0;
+            for (let i = 0; i < 256; i++) {
+                entities.push({ x: (next() & 0x3fff) - 0x1fff, y: (next() & 0x3fff) - 0x1fff, hp: 1000, alive: 1 });
+            }
+            return entities.length;
+        },
+        world_step(commands) {
+            for (let i = 0; i < commands.length; i += 3) {
+                const idx = commands[i];
+                if (!entities[idx] || entities[idx].alive === 0)
+                    continue;
+                entities[idx].x += commands[i + 1];
+                entities[idx].y += commands[i + 2];
+            }
+            return entities.length;
+        },
+        world_extractSnapshot() {
+            return entities.map((entity) => ({ ...entity }));
+        },
+    };
+}
+export async function initAnankeWasm() {
+    try {
+        if (typeof WebAssembly === "undefined")
+            return createTsFallback();
+        const wasmPath = fileURLToPath(new URL("../../wasm/ananke-core.wasm", import.meta.url));
+        const bytes = await readFile(wasmPath);
+        const instance = await WebAssembly.instantiate(bytes, {});
+        const ex = instance.instance.exports;
+        let commandPtr = 0;
+        let commandCapacity = 0;
+        function ensureCommandBuffer(commandsLength) {
+            if (commandsLength <= commandCapacity && commandPtr !== 0)
+                return commandPtr;
+            commandPtr = ex.alloc(commandsLength * Int32Array.BYTES_PER_ELEMENT);
+            commandCapacity = commandsLength;
+            return commandPtr;
+        }
+        return {
+            backend: "wasm",
+            world_create(seed) {
+                return ex.world_create(seed | 0);
+            },
+            world_step(commands) {
+                const ptr = ensureCommandBuffer(commands.length);
+                new Int32Array(ex.memory.buffer, ptr, commands.length).set(commands);
+                return ex.world_step(ptr, Math.trunc(commands.length / 3));
+            },
+            world_stepBatch(commands, commandCount) {
+                const used = Math.max(0, Math.min(commands.length, commandCount * 3));
+                const ptr = ensureCommandBuffer(used);
+                new Int32Array(ex.memory.buffer, ptr, used).set(commands.subarray(0, used));
+                return ex.world_step(ptr, Math.trunc(used / 3));
+            },
+            world_extractSnapshot() {
+                const count = ex.world_step(ex.alloc(0), 0);
+                const size = ex.snapshot_size_for(count);
+                const outPtr = ex.alloc(size);
+                ex.world_extractSnapshot(outPtr);
+                const raw = new Int32Array(ex.memory.buffer, outPtr, Math.trunc(size / 4));
+                const entities = [];
+                const n = raw[0] ?? 0;
+                for (let i = 0; i < n; i++) {
+                    const o = 1 + i * 4;
+                    entities.push({ x: raw[o], y: raw[o + 1], hp: raw[o + 2], alive: raw[o + 3] });
+                }
+                return entities;
+            },
+        };
+    }
+    catch {
+        return createTsFallback();
+    }
+}

package/dist/src/wasm-kernel.d.ts

@@ -15,6 +15,7 @@ interface InjuryExports {
     readConsciousness: (slot: number) => number;
     readDead: (slot: number) => number;
     stepBleedAndShock: (n: number) => void;
+    readBleedingRate: (slot: number, region: number) => number;
 }
 export interface WasmEntityReport {
     entityId: number;
@@ -26,6 +27,7 @@ export interface WasmEntityReport {
     projShock: number;
     projConsciousness: number;
     projDead: boolean;
+    projHeadBleedingRate: number;
 }
 export interface WasmStepReport {
     tick: number;

package/dist/src/wasm-kernel.js

@@ -64,6 +64,7 @@ export class WasmKernel {
                 projShock: this.injury.readShock(i),
                 projConsciousness: this.injury.readConsciousness(i),
                 projDead: this.injury.readDead(i) === 1,
+                projHeadBleedingRate: this.injury.readBleedingRate(i, 0),
             });
         }
         const summary = reports

package/dist/src/world-evolution-backend/engine.d.ts

@@ -0,0 +1,4 @@
+import { type WorldEvolutionRunRequest, type WorldEvolutionRunResult, type WorldEvolutionRulesetProfile, type WorldEvolutionSnapshot } from "./types.js";
+export declare function runWorldEvolution(request: WorldEvolutionRunRequest): WorldEvolutionRunResult;
+export declare function createWorldEvolutionSnapshot(snapshot: WorldEvolutionSnapshot): WorldEvolutionSnapshot;
+export declare function listAvailableWorldEvolutionProfiles(): WorldEvolutionRulesetProfile[];

package/dist/src/world-evolution-backend/engine.js

@@ -0,0 +1,347 @@
+import { aggregateClimateEffects, generateClimateEvent, isClimateEventExpired, stepClimateEvent, } from "../climate.js";
+import { isTreatyExpired, stepTreatyStrength, } from "../diplomacy.js";
+import { computeEpidemicDeathPressure, deriveHealthCapacity, stepEpidemic, } from "../epidemic.js";
+import { computeGovernanceModifiers, stepGovernanceCooldown, stepGovernanceStability, } from "../governance.js";
+import { applyMigrationFlows, resolveMigration, } from "../migration.js";
+import { createPolityRegistry, stepPolityDay, } from "../polity.js";
+import { applyDailyTrade, isRouteViable, routeKey, stepRouteEfficiency, } from "../trade-routes.js";
+import { hashString } from "../sim/seeds.js";
+import { SCALE, clampQ } from "../units.js";
+import { listWorldEvolutionProfiles, mergeWorldEvolutionProfileWithOverrides } from "./profiles.js";
+import { WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION, } from "./types.js";
+export function runWorldEvolution(request) {
+    const steps = Math.max(0, Math.floor(request.steps));
+    const initialSnapshot = normalizeSnapshot(request.snapshot);
+    const runtime = createRuntimeState(initialSnapshot, request);
+    const timeline = [];
+    const deltas = [];
+    const checkpoints = [];
+    for (let step = 1; step <= steps; step++) {
+        const before = snapshotPolityStats(runtime.snapshot.polities);
+        const event = evolveSingleStep(runtime, step);
+        timeline.push(event);
+        if (request.includeDeltas) {
+            deltas.push(buildDelta(step, runtime.snapshot.tick, before, runtime.snapshot.polities));
+        }
+        if (request.checkpointInterval != null && request.checkpointInterval > 0 && step % request.checkpointInterval === 0) {
+            checkpoints.push({
+                step,
+                tick: runtime.snapshot.tick,
+                snapshot: exportSnapshot(runtime),
+            });
+        }
+    }
+    const finalSnapshot = exportSnapshot(runtime);
+    const result = {
+        initialSnapshot,
+        finalSnapshot,
+        profile: runtime.profile,
+        timeline,
+        metrics: computeWorldMetrics(runtime, [], 0),
+    };
+    if (request.includeDeltas)
+        result.deltas = deltas;
+    if (request.checkpointInterval != null && request.checkpointInterval > 0)
+        result.checkpoints = checkpoints;
+    return result;
+}
+export function createWorldEvolutionSnapshot(snapshot) {
+    return normalizeSnapshot(snapshot);
+}
+export function listAvailableWorldEvolutionProfiles() {
+    return listWorldEvolutionProfiles();
+}
+function createRuntimeState(snapshot, request) {
+    const profile = mergeWorldEvolutionProfileWithOverrides(request.profileId, request.profile);
+    const polityRegistry = createPolityRegistry(snapshot.polities.map(clonePolity));
+    for (const [a, b] of snapshot.activeWars) {
+        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+        polityRegistry.activeWars.add(key);
+    }
+    const treaties = new Map(snapshot.treaties.map((t) => [t.treatyId, { ...t }]));
+    const routes = new Map(snapshot.tradeRoutes.map((r) => [r.routeId, { ...r }]));
+    const governanceByPolity = new Map(snapshot.governanceStates.map((g) => [g.polityId, { ...g, activeLawIds: [...g.activeLawIds] }]));
+    const lawRegistry = new Map(snapshot.governanceLawRegistry.map((law) => [law.lawId, { ...law }]));
+    const epidemicsByPolity = new Map();
+    for (const e of snapshot.epidemics) {
+        const list = epidemicsByPolity.get(e.polityId) ?? [];
+        list.push({ ...e });
+        epidemicsByPolity.set(e.polityId, list);
+    }
+    const diseasesById = new Map(snapshot.diseases.map((d) => [d.id, { ...d }]));
+    const climateByPolity = new Map(snapshot.climateByPolity.map((entry) => [entry.polityId, entry.active.map(cloneClimateEvent)]));
+    return {
+        profile,
+        snapshot: normalizeSnapshot({
+            ...snapshot,
+            polities: [...polityRegistry.polities.values()],
+            activeWars: [...snapshot.activeWars],
+            treaties: [...treaties.values()],
+            tradeRoutes: [...routes.values()],
+            governanceStates: [...governanceByPolity.values()],
+            governanceLawRegistry: [...lawRegistry.values()],
+            epidemics: [...snapshot.epidemics],
+            diseases: [...diseasesById.values()],
+            climateByPolity: [...climateByPolity.entries()].map(([polityId, active]) => ({ polityId, active })),
+        }),
+        polityRegistry,
+        lawRegistry,
+        governanceByPolity,
+        treaties,
+        routes,
+        epidemicsByPolity,
+        diseasesById,
+        climateByPolity,
+    };
+}
+function evolveSingleStep(runtime, step) {
+    const { snapshot, polityRegistry, profile } = runtime;
+    const tick = snapshot.tick;
+    const polityDayResult = profile.polityDayEnabled
+        ? stepPolityDay(polityRegistry, snapshot.pairs, snapshot.worldSeed, tick)
+        : { trade: [], moraleDeltas: new Map(), stabilityDeltas: new Map() };
+    const wars = applyWarEffectsForMetrics(polityRegistry, snapshot.worldSeed, tick);
+    if (profile.governanceEnabled) {
+        for (const polity of sortedPolities(polityRegistry)) {
+            const state = runtime.governanceByPolity.get(polity.id);
+            if (!state)
+                continue;
+            stepGovernanceCooldown(state, 1);
+            stepGovernanceStability(polity, state, profile.governanceStabilityDaysPerStep, runtime.lawRegistry);
+            const modifiers = computeGovernanceModifiers(state, runtime.lawRegistry);
+            const taxDaily = Math.floor(polity.population * modifiers.taxEfficiencyMul_Q / SCALE.Q / 1000);
+            polity.treasury_cu += Math.max(0, taxDaily);
+        }
+    }
+    if (profile.diplomacyEnabled) {
+        for (const treaty of [...runtime.treaties.values()].sort((a, b) => a.treatyId.localeCompare(b.treatyId))) {
+            stepTreatyStrength(treaty, profile.treatyStrengthBoost_Q);
+            if (isTreatyExpired(treaty, tick) || treaty.strength_Q <= 0) {
+                runtime.treaties.delete(treaty.treatyId);
+            }
+        }
+    }
+    if (profile.tradeEnabled) {
+        for (const route of [...runtime.routes.values()].sort((a, b) => a.routeId.localeCompare(b.routeId))) {
+            stepRouteEfficiency(route, profile.routeEfficiencyBoost_Q);
+            const polityA = polityRegistry.polities.get(route.polityAId);
+            const polityB = polityRegistry.polities.get(route.polityBId);
+            if (!polityA || !polityB)
+                continue;
+            const hasTradePact = hasTreaty(runtime.treaties, route.polityAId, route.polityBId, "trade_pact");
+            applyDailyTrade(polityA, polityB, route, hasTradePact);
+        }
+    }
+    const migrations = profile.migrationEnabled
+        ? resolveMigration([...polityRegistry.polities.values()], buildMigrationContext(polityRegistry))
+        : [];
+    if (profile.migrationEnabled) {
+        applyMigrationFlows(polityRegistry, migrations);
+    }
+    let epidemicPopulationDelta = 0;
+    const climateEventIds = [];
+    if (profile.climateEnabled || profile.epidemicEnabled) {
+        for (const polity of sortedPolities(polityRegistry)) {
+            const climateEvents = runtime.climateByPolity.get(polity.id) ?? [];
+            if (profile.climateEnabled) {
+                const generated = generateClimateEvent(hashString(polity.id), snapshot.worldSeed, tick);
+                if (generated) {
+                    climateEvents.push({ event: generated, remainingDays: generated.durationDays, elapsedDays: 0 });
+                    climateEventIds.push(generated.eventId);
+                }
+            }
+            const climateEffects = aggregateClimateEffects(climateEvents);
+            polity.stabilityQ = clampQ(polity.stabilityQ - climateEffects.unrestPressure_Q, 0, SCALE.Q);
+            if (profile.epidemicEnabled) {
+                const states = runtime.epidemicsByPolity.get(polity.id) ?? [];
+                const health = clampQ(deriveHealthCapacity(polity) + profile.epidemicHealthBuffer_Q - climateEffects.epidemicGrowthBonus_Q, 0, SCALE.Q);
+                for (const state of states) {
+                    const disease = runtime.diseasesById.get(state.diseaseId);
+                    if (!disease)
+                        continue;
+                    stepEpidemic(state, disease, 1, health);
+                    const deathPressure_Q = computeEpidemicDeathPressure(state, disease);
+                    const deathFromEpidemic = Math.floor(polity.population * deathPressure_Q / SCALE.Q);
+                    const deathFromClimate = Math.floor(polity.population * climateEffects.deathPressure_Q / SCALE.Q / 100);
+                    const totalDeaths = Math.max(0, deathFromEpidemic + deathFromClimate);
+                    polity.population = Math.max(0, polity.population - totalDeaths);
+                    epidemicPopulationDelta -= totalDeaths;
+                }
+            }
+            if (profile.climateEnabled) {
+                for (const active of climateEvents) {
+                    stepClimateEvent(active, 1);
+                }
+                runtime.climateByPolity.set(polity.id, climateEvents.filter((a) => !isClimateEventExpired(a)));
+            }
+        }
+    }
+    snapshot.tick += 1;
+    syncRuntimeSnapshot(runtime);
+    return {
+        step,
+        tick: snapshot.tick,
+        trade: polityDayResult.trade,
+        wars,
+        migrations,
+        climateEventIds,
+        epidemicPopulationDelta,
+        metrics: computeWorldMetrics(runtime, migrations, epidemicPopulationDelta),
+    };
+}
+function applyWarEffectsForMetrics(registry, worldSeed, tick) {
+    // Wars are already stepped inside stepPolityDay; this returns a deterministic log representation.
+    const wars = [];
+    for (const pair of [...registry.activeWars].sort()) {
+        const [aId, bId] = pair.split(":");
+        if (!aId || !bId)
+            continue;
+        const attacker = registry.polities.get(aId);
+        const defender = registry.polities.get(bId);
+        if (!attacker || !defender)
+            continue;
+        wars.push({
+            attackerId: attacker.id,
+            defenderId: defender.id,
+            attackerWins: attacker.militaryStrength_Q >= defender.militaryStrength_Q,
+            stabilityDeltaAttacker: 0,
+            stabilityDeltaDefender: 0,
+            territoryGained: [],
+        });
+        // worldSeed and tick remain part of signature to preserve deterministic call-site identity.
+        void worldSeed;
+        void tick;
+    }
+    return wars;
+}
+function buildMigrationContext(registry) {
+    const atWar = new Set();
+    for (const pair of registry.activeWars) {
+        const [a, b] = pair.split(":");
+        if (!a || !b)
+            continue;
+        atWar.add(a);
+        atWar.add(b);
+    }
+    const out = new Map();
+    for (const polity of registry.polities.values()) {
+        out.set(polity.id, { polityId: polity.id, isAtWar: atWar.has(polity.id) });
+    }
+    return out;
+}
+function hasTreaty(treaties, polityAId, polityBId, type) {
+    const lo = polityAId < polityBId ? polityAId : polityBId;
+    const hi = polityAId < polityBId ? polityBId : polityAId;
+    const expected = `${lo}:${hi}:${type}`;
+    return treaties.has(expected);
+}
+function computeWorldMetrics(runtime, migrations, migrationsTotalPopulation) {
+    const polities = [...runtime.polityRegistry.polities.values()];
+    const totalPopulation = polities.reduce((sum, p) => sum + p.population, 0);
+    const totalTreasury_cu = polities.reduce((sum, p) => sum + p.treasury_cu, 0);
+    const avgStability_Q = polities.length > 0
+        ? Math.floor(polities.reduce((sum, p) => sum + p.stabilityQ, 0) / polities.length)
+        : 0;
+    const avgMorale_Q = polities.length > 0
+        ? Math.floor(polities.reduce((sum, p) => sum + p.moraleQ, 0) / polities.length)
+        : 0;
+    return {
+        totalPopulation,
+        totalTreasury_cu,
+        avgStability_Q,
+        avgMorale_Q,
+        activeWars: runtime.polityRegistry.activeWars.size,
+        activeTreaties: runtime.treaties.size,
+        viableTradeRoutes: [...runtime.routes.values()].filter(isRouteViable).length,
+        activeEpidemics: [...runtime.epidemicsByPolity.values()].reduce((sum, list) => sum + list.length, 0),
+        activeClimateEvents: [...runtime.climateByPolity.values()].reduce((sum, list) => sum + list.length, 0),
+        migrationsThisStep: migrations.length,
+        migrationsTotalPopulation,
+    };
+}
+function syncRuntimeSnapshot(runtime) {
+    runtime.snapshot.polities = sortedPolities(runtime.polityRegistry).map(clonePolity);
+    runtime.snapshot.activeWars = [...runtime.polityRegistry.activeWars]
+        .sort()
+        .map((pair) => pair.split(":"));
+    runtime.snapshot.treaties = [...runtime.treaties.values()].sort((a, b) => a.treatyId.localeCompare(b.treatyId)).map((t) => ({ ...t }));
+    runtime.snapshot.tradeRoutes = [...runtime.routes.values()].sort((a, b) => a.routeId.localeCompare(b.routeId)).map((r) => ({ ...r }));
+    runtime.snapshot.governanceStates = [...runtime.governanceByPolity.values()]
+        .sort((a, b) => a.polityId.localeCompare(b.polityId))
+        .map((g) => ({ ...g, activeLawIds: [...g.activeLawIds] }));
+    runtime.snapshot.epidemics = [...runtime.epidemicsByPolity.values()].flat().map((e) => ({ ...e }));
+    runtime.snapshot.climateByPolity = [...runtime.climateByPolity.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([polityId, active]) => ({ polityId, active: active.map(cloneClimateEvent) }));
+}
+function exportSnapshot(runtime) {
+    syncRuntimeSnapshot(runtime);
+    return normalizeSnapshot(runtime.snapshot);
+}
+function normalizeSnapshot(snapshot) {
+    return {
+        schemaVersion: WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION,
+        worldSeed: snapshot.worldSeed,
+        tick: snapshot.tick,
+        polities: [...snapshot.polities].map(clonePolity).sort((a, b) => a.id.localeCompare(b.id)),
+        pairs: [...snapshot.pairs].map((p) => ({ ...p })).sort((a, b) => routeKey(a.polityAId, a.polityBId).localeCompare(routeKey(b.polityAId, b.polityBId))),
+        activeWars: [...snapshot.activeWars].map((pair) => sortWarPair(pair)).sort((a, b) => `${a[0]}:${a[1]}`.localeCompare(`${b[0]}:${b[1]}`)),
+        treaties: [...snapshot.treaties].map((t) => ({ ...t })).sort((a, b) => a.treatyId.localeCompare(b.treatyId)),
+        tradeRoutes: [...snapshot.tradeRoutes].map((r) => ({ ...r })).sort((a, b) => a.routeId.localeCompare(b.routeId)),
+        governanceStates: [...snapshot.governanceStates].map((g) => ({ ...g, activeLawIds: [...g.activeLawIds] })).sort((a, b) => a.polityId.localeCompare(b.polityId)),
+        governanceLawRegistry: [...snapshot.governanceLawRegistry].map((law) => ({ ...law })).sort((a, b) => a.lawId.localeCompare(b.lawId)),
+        epidemics: [...snapshot.epidemics].map((e) => ({ ...e })).sort((a, b) => `${a.polityId}:${a.diseaseId}`.localeCompare(`${b.polityId}:${b.diseaseId}`)),
+        diseases: [...snapshot.diseases].map((d) => ({ ...d })).sort((a, b) => a.id.localeCompare(b.id)),
+        climateByPolity: [...snapshot.climateByPolity]
+            .map((entry) => ({ polityId: entry.polityId, active: entry.active.map(cloneClimateEvent) }))
+            .sort((a, b) => a.polityId.localeCompare(b.polityId)),
+    };
+}
+function sortWarPair([a, b]) {
+    return a < b ? [a, b] : [b, a];
+}
+function sortedPolities(registry) {
+    return [...registry.polities.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+function clonePolity(polity) {
+    return {
+        ...polity,
+        locationIds: [...polity.locationIds],
+    };
+}
+function cloneClimateEvent(active) {
+    return {
+        event: {
+            ...active.event,
+        },
+        remainingDays: active.remainingDays,
+        elapsedDays: active.elapsedDays,
+    };
+}
+function snapshotPolityStats(polities) {
+    const map = new Map();
+    for (const polity of polities) {
+        map.set(polity.id, {
+            population: polity.population,
+            treasury: polity.treasury_cu,
+            stability: polity.stabilityQ,
+            morale: polity.moraleQ,
+        });
+    }
+    return map;
+}
+function buildDelta(step, tick, before, afterPolities) {
+    const polityDeltas = [...afterPolities]
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map((p) => {
+        const prev = before.get(p.id);
+        return {
+            polityId: p.id,
+            populationDelta: p.population - (prev?.population ?? 0),
+            treasuryDelta_cu: p.treasury_cu - (prev?.treasury ?? 0),
+            stabilityDelta_Q: p.stabilityQ - (prev?.stability ?? 0),
+            moraleDelta_Q: p.moraleQ - (prev?.morale ?? 0),
+        };
+    });
+    return { step, tick, polityDeltas };
+}