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

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

@@ -0,0 +1,337 @@
+import { SCALE } from "../units.js";
+const CATEGORY_ORDER = {
+    polity: 0,
+    governance: 1,
+    diplomacy: 2,
+    economy: 3,
+    infrastructure: 4,
+    migration: 5,
+    conflict: 6,
+    climate: 7,
+    disease: 8,
+    mythology_culture: 9,
+};
+const CATEGORY_WEIGHT = {
+    polity: 16,
+    migration: 14,
+    conflict: 20,
+    diplomacy: 12,
+    economy: 10,
+    disease: 18,
+    climate: 15,
+    infrastructure: 8,
+    governance: 11,
+    mythology_culture: 7,
+};
+export function buildEvolutionTimeline(result, options = {}) {
+    const includeSummaryText = options.includeSummaryText === true;
+    const events = [];
+    let previousMetrics;
+    let sequence = 0;
+    for (const stepEvent of result.timeline) {
+        const metricsDelta = deriveMetricsDelta(previousMetrics, stepEvent.metrics);
+        appendTradeEvents(events, result.initialSnapshot.worldSeed, stepEvent, includeSummaryText, () => sequence++);
+        appendConflictEvents(events, result.initialSnapshot.worldSeed, stepEvent, includeSummaryText, () => sequence++);
+        appendMigrationEvents(events, result.initialSnapshot.worldSeed, stepEvent, includeSummaryText, () => sequence++);
+        appendClimateEvents(events, result.initialSnapshot.worldSeed, stepEvent, includeSummaryText, () => sequence++);
+        appendDiseaseEvents(events, result.initialSnapshot.worldSeed, stepEvent, includeSummaryText, () => sequence++);
+        appendMetricDerivedEvents(events, result.initialSnapshot.worldSeed, stepEvent, metricsDelta, includeSummaryText, () => sequence++);
+        previousMetrics = stepEvent.metrics;
+    }
+    return events.sort((a, b) => a.tick - b.tick
+        || a.step - b.step
+        || CATEGORY_ORDER[a.category] - CATEGORY_ORDER[b.category]
+        || a.sequence - b.sequence
+        || a.id.localeCompare(b.id));
+}
+export function sortTimelineEventsBySignificance(events) {
+    return [...events].sort((a, b) => b.significance - a.significance
+        || b.severity - a.severity
+        || a.tick - b.tick
+        || a.id.localeCompare(b.id));
+}
+function appendTradeEvents(target, worldSeed, step, includeSummaryText, nextSequence) {
+    for (let index = 0; index < step.trade.length; index++) {
+        const trade = step.trade[index];
+        if (!trade)
+            continue;
+        const severity = clampPercent(Math.floor(trade.incomeEach_cu / 250));
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "economy",
+            severity,
+            significanceBoost: 5,
+            entityIds: [trade.polityAId, trade.polityBId],
+            factRefs: [factRef("trade", step, index)],
+            detail: { incomeEach_cu: trade.incomeEach_cu },
+            includeSummaryText,
+            summary: `Trade volume expanded between ${trade.polityAId} and ${trade.polityBId} (+${trade.incomeEach_cu} cu each).`,
+            sequence: nextSequence(),
+            localIndex: index,
+        }));
+    }
+}
+function appendConflictEvents(target, worldSeed, step, includeSummaryText, nextSequence) {
+    for (let index = 0; index < step.wars.length; index++) {
+        const war = step.wars[index];
+        if (!war)
+            continue;
+        const territoryPressure = Math.abs(war.territoryGained.length) * 8;
+        const severity = clampPercent(35 + territoryPressure + Math.floor((Math.abs(war.stabilityDeltaAttacker) + Math.abs(war.stabilityDeltaDefender)) * 100 / SCALE.Q));
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "conflict",
+            severity,
+            significanceBoost: 12,
+            entityIds: [war.attackerId, war.defenderId],
+            factRefs: [factRef("wars", step, index)],
+            detail: { attackerWins: war.attackerWins, territoryGained: [...war.territoryGained] },
+            includeSummaryText,
+            summary: `${war.attackerId} ${war.attackerWins ? "prevailed over" : "failed against"} ${war.defenderId}.`,
+            sequence: nextSequence(),
+            localIndex: index,
+        }));
+    }
+}
+function appendMigrationEvents(target, worldSeed, step, includeSummaryText, nextSequence) {
+    for (let index = 0; index < step.migrations.length; index++) {
+        const migration = step.migrations[index];
+        if (!migration)
+            continue;
+        const severity = clampPercent(Math.floor(migration.population / 40));
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "migration",
+            severity,
+            significanceBoost: 8,
+            entityIds: [migration.fromPolityId, migration.toPolityId],
+            factRefs: [factRef("migrations", step, index)],
+            detail: { population: migration.population },
+            includeSummaryText,
+            summary: `${migration.population} people migrated from ${migration.fromPolityId} to ${migration.toPolityId}.`,
+            sequence: nextSequence(),
+            localIndex: index,
+        }));
+    }
+}
+function appendClimateEvents(target, worldSeed, step, includeSummaryText, nextSequence) {
+    for (let index = 0; index < step.climateEventIds.length; index++) {
+        const climateEventId = step.climateEventIds[index];
+        if (!climateEventId)
+            continue;
+        const severity = clampPercent(30 + Math.floor(climateEventId.length / 3));
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "climate",
+            severity,
+            significanceBoost: 10,
+            entityIds: [],
+            factRefs: [factRef("climateEventIds", step, index)],
+            detail: { climateEventId },
+            includeSummaryText,
+            summary: `Climate pressure event triggered (${climateEventId}).`,
+            sequence: nextSequence(),
+            localIndex: index,
+        }));
+    }
+}
+function appendDiseaseEvents(target, worldSeed, step, includeSummaryText, nextSequence) {
+    if (step.epidemicPopulationDelta === 0)
+        return;
+    const severity = clampPercent(Math.floor(Math.abs(step.epidemicPopulationDelta) / 20));
+    target.push(makeEvent({
+        worldSeed,
+        step,
+        category: "disease",
+        severity,
+        significanceBoost: 14,
+        entityIds: [],
+        factRefs: [factRef("epidemicPopulationDelta", step)],
+        detail: { epidemicPopulationDelta: step.epidemicPopulationDelta },
+        includeSummaryText,
+        summary: `Epidemic pressure shifted population by ${step.epidemicPopulationDelta}.`,
+        sequence: nextSequence(),
+        localIndex: 0,
+    }));
+}
+function appendMetricDerivedEvents(target, worldSeed, step, metricsDelta, includeSummaryText, nextSequence) {
+    const metricFacts = [factRef("metrics", step)];
+    if (metricsDelta.totalPopulation !== 0) {
+        const severity = clampPercent(Math.floor(Math.abs(metricsDelta.totalPopulation) / 60));
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "polity",
+            severity,
+            significanceBoost: 7,
+            entityIds: [],
+            factRefs: metricFacts,
+            detail: { totalPopulationDelta: metricsDelta.totalPopulation },
+            includeSummaryText,
+            summary: `Aggregate polity population changed by ${metricsDelta.totalPopulation}.`,
+            sequence: nextSequence(),
+            localIndex: 0,
+        }));
+    }
+    if (metricsDelta.activeTreaties !== 0) {
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "diplomacy",
+            severity: clampPercent(25 + Math.abs(metricsDelta.activeTreaties) * 20),
+            significanceBoost: 6,
+            entityIds: [],
+            factRefs: metricFacts,
+            detail: { activeTreatiesDelta: metricsDelta.activeTreaties },
+            includeSummaryText,
+            summary: `Diplomatic treaty count shifted by ${metricsDelta.activeTreaties}.`,
+            sequence: nextSequence(),
+            localIndex: 1,
+        }));
+    }
+    if (metricsDelta.avgStability_Q !== 0) {
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "governance",
+            severity: clampPercent(Math.floor(Math.abs(metricsDelta.avgStability_Q) * 100 / SCALE.Q)),
+            significanceBoost: 4,
+            entityIds: [],
+            factRefs: metricFacts,
+            detail: { avgStabilityDelta_Q: metricsDelta.avgStability_Q },
+            includeSummaryText,
+            summary: `Governance stability shifted by ${metricsDelta.avgStability_Q}.`,
+            sequence: nextSequence(),
+            localIndex: 2,
+        }));
+    }
+    if (metricsDelta.viableTradeRoutes !== 0) {
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "infrastructure",
+            severity: clampPercent(20 + Math.abs(metricsDelta.viableTradeRoutes) * 15),
+            significanceBoost: 5,
+            entityIds: [],
+            factRefs: metricFacts,
+            detail: { viableTradeRoutesDelta: metricsDelta.viableTradeRoutes },
+            includeSummaryText,
+            summary: `Infrastructure connectivity changed by ${metricsDelta.viableTradeRoutes} viable routes.`,
+            sequence: nextSequence(),
+            localIndex: 3,
+        }));
+    }
+    if (metricsDelta.totalTreasury_cu !== 0 && step.trade.length === 0) {
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "economy",
+            severity: clampPercent(Math.floor(Math.abs(metricsDelta.totalTreasury_cu) / 500)),
+            significanceBoost: 3,
+            entityIds: [],
+            factRefs: metricFacts,
+            detail: { totalTreasuryDelta_cu: metricsDelta.totalTreasury_cu },
+            includeSummaryText,
+            summary: `Macro treasury shifted by ${metricsDelta.totalTreasury_cu} cu.`,
+            sequence: nextSequence(),
+            localIndex: 4,
+        }));
+    }
+    if (metricsDelta.avgMorale_Q !== 0) {
+        target.push(makeEvent({
+            worldSeed,
+            step,
+            category: "mythology_culture",
+            severity: clampPercent(Math.floor(Math.abs(metricsDelta.avgMorale_Q) * 100 / SCALE.Q)),
+            significanceBoost: 2,
+            entityIds: [],
+            factRefs: metricFacts,
+            detail: { avgMoraleDelta_Q: metricsDelta.avgMorale_Q },
+            includeSummaryText,
+            summary: `Cultural sentiment moved by ${metricsDelta.avgMorale_Q}.`,
+            sequence: nextSequence(),
+            localIndex: 5,
+        }));
+    }
+}
+function makeEvent(args) {
+    const fingerprint = JSON.stringify({
+        seed: args.worldSeed,
+        step: args.step.step,
+        tick: args.step.tick,
+        category: args.category,
+        index: args.localIndex,
+        entities: [...args.entityIds].sort((a, b) => a.localeCompare(b)),
+        detail: args.detail,
+        facts: args.factRefs.map((ref) => `${ref.subsystem}:${ref.step}:${ref.tick}:${ref.index ?? -1}`),
+    });
+    const hash = stableHashHex(fingerprint);
+    const significance = clampPercent(args.severity + CATEGORY_WEIGHT[args.category] + args.significanceBoost);
+    return {
+        id: `evo.${args.step.step}.${args.category}.${hash.slice(0, 12)}`,
+        hash,
+        step: args.step.step,
+        tick: args.step.tick,
+        category: args.category,
+        severity: args.severity,
+        significance,
+        entityIds: [...args.entityIds].sort((a, b) => a.localeCompare(b)),
+        factRefs: args.factRefs.map((ref) => ({ ...ref })),
+        ...(args.includeSummaryText ? { summary: args.summary } : {}),
+        sequence: args.sequence,
+    };
+}
+function factRef(subsystem, step, index) {
+    return {
+        subsystem,
+        step: step.step,
+        tick: step.tick,
+        ...(index != null ? { index } : {}),
+    };
+}
+function deriveMetricsDelta(prev, next) {
+    if (prev == null) {
+        return {
+            totalPopulation: next.totalPopulation,
+            totalTreasury_cu: next.totalTreasury_cu,
+            avgStability_Q: next.avgStability_Q,
+            avgMorale_Q: next.avgMorale_Q,
+            activeWars: next.activeWars,
+            activeTreaties: next.activeTreaties,
+            viableTradeRoutes: next.viableTradeRoutes,
+            activeEpidemics: next.activeEpidemics,
+            activeClimateEvents: next.activeClimateEvents,
+            migrationsThisStep: next.migrationsThisStep,
+            migrationsTotalPopulation: next.migrationsTotalPopulation,
+        };
+    }
+    return {
+        totalPopulation: next.totalPopulation - prev.totalPopulation,
+        totalTreasury_cu: next.totalTreasury_cu - prev.totalTreasury_cu,
+        avgStability_Q: next.avgStability_Q - prev.avgStability_Q,
+        avgMorale_Q: next.avgMorale_Q - prev.avgMorale_Q,
+        activeWars: next.activeWars - prev.activeWars,
+        activeTreaties: next.activeTreaties - prev.activeTreaties,
+        viableTradeRoutes: next.viableTradeRoutes - prev.viableTradeRoutes,
+        activeEpidemics: next.activeEpidemics - prev.activeEpidemics,
+        activeClimateEvents: next.activeClimateEvents - prev.activeClimateEvents,
+        migrationsThisStep: next.migrationsThisStep - prev.migrationsThisStep,
+        migrationsTotalPopulation: next.migrationsTotalPopulation - prev.migrationsTotalPopulation,
+    };
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Math.floor(value)));
+}
+function stableHashHex(input) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    const normalized = hash >>> 0;
+    return normalized.toString(16).padStart(8, "0");
+}

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

@@ -0,0 +1,138 @@
+import type { ActiveClimateEvent } from "../climate.js";
+import type { Treaty } from "../diplomacy.js";
+import type { PolityEpidemicState } from "../epidemic.js";
+import type { GovernanceState, LawCode } from "../governance.js";
+import type { MigrationFlow } from "../migration.js";
+import type { Polity, PolityPair, PolityTradeResult, PolityWarResult } from "../polity.js";
+import type { TradeRoute } from "../trade-routes.js";
+import type { DiseaseProfile } from "../sim/disease.js";
+import type { Q } from "../units.js";
+export declare const WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION: "ananke.world-evolution-backend.v1";
+export type WorldEvolutionRulesetId = "minimal_world_history" | "polity_dynamics" | "conflict_heavy" | "climate_and_migration" | "full_world_evolution" | "balanced" | "resilience" | "expansion";
+export interface EvolutionRulesetProfile {
+    id: WorldEvolutionRulesetId;
+    name: string;
+    description: string;
+    /**
+     * Explicit deterministic execution order for active subsystems.
+     * Hosts can inspect this to verify reproducible orchestration order.
+     */
+    pipelineOrder: readonly [
+        "polity",
+        "governance",
+        "diplomacy",
+        "trade",
+        "migration",
+        "climate",
+        "epidemic"
+    ];
+    polityDayEnabled: boolean;
+    governanceEnabled: boolean;
+    diplomacyEnabled: boolean;
+    tradeEnabled: boolean;
+    migrationEnabled: boolean;
+    epidemicEnabled: boolean;
+    climateEnabled: boolean;
+    governanceStabilityDaysPerStep: number;
+    treatyStrengthBoost_Q: Q;
+    routeEfficiencyBoost_Q: Q;
+    epidemicHealthBuffer_Q: Q;
+}
+export type WorldEvolutionRulesetProfile = EvolutionRulesetProfile;
+export interface WorldEvolutionSnapshot {
+    schemaVersion: typeof WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION;
+    worldSeed: number;
+    tick: number;
+    polities: Polity[];
+    pairs: PolityPair[];
+    activeWars: Array<[string, string]>;
+    treaties: Treaty[];
+    tradeRoutes: TradeRoute[];
+    governanceStates: GovernanceState[];
+    governanceLawRegistry: LawCode[];
+    epidemics: PolityEpidemicState[];
+    diseases: DiseaseProfile[];
+    climateByPolity: Array<{
+        polityId: string;
+        active: ActiveClimateEvent[];
+    }>;
+}
+export interface WorldEvolutionRunRequest {
+    snapshot: WorldEvolutionSnapshot;
+    steps: number;
+    profileId?: WorldEvolutionRulesetId;
+    profile?: WorldEvolutionRulesetProfile;
+    includeDeltas?: boolean;
+    checkpointInterval?: number;
+}
+export interface WorldEvolutionMetrics {
+    totalPopulation: number;
+    totalTreasury_cu: number;
+    avgStability_Q: Q;
+    avgMorale_Q: Q;
+    activeWars: number;
+    activeTreaties: number;
+    viableTradeRoutes: number;
+    activeEpidemics: number;
+    activeClimateEvents: number;
+    migrationsThisStep: number;
+    migrationsTotalPopulation: number;
+}
+export interface WorldEvolutionStepEvent {
+    step: number;
+    tick: number;
+    trade: PolityTradeResult[];
+    wars: PolityWarResult[];
+    migrations: MigrationFlow[];
+    climateEventIds: string[];
+    epidemicPopulationDelta: number;
+    metrics: WorldEvolutionMetrics;
+}
+export interface WorldEvolutionDelta {
+    step: number;
+    tick: number;
+    polityDeltas: Array<{
+        polityId: string;
+        populationDelta: number;
+        treasuryDelta_cu: number;
+        stabilityDelta_Q: number;
+        moraleDelta_Q: number;
+    }>;
+}
+export interface WorldEvolutionCheckpoint {
+    step: number;
+    tick: number;
+    snapshot: WorldEvolutionSnapshot;
+}
+export type EvolutionTimelineCategory = "polity" | "migration" | "conflict" | "diplomacy" | "economy" | "disease" | "climate" | "infrastructure" | "governance" | "mythology_culture";
+export interface EvolutionTimelineFactRef {
+    subsystem: "trade" | "wars" | "migrations" | "climateEventIds" | "epidemicPopulationDelta" | "metrics";
+    step: number;
+    tick: number;
+    index?: number;
+}
+export interface EvolutionTimelineEvent {
+    id: string;
+    hash: string;
+    step: number;
+    tick: number;
+    category: EvolutionTimelineCategory;
+    /** 0..100 host-friendly intensity score. */
+    severity: number;
+    /** 0..100 host-friendly relevance score for surfacing highlights. */
+    significance: number;
+    /** Stable timeline order in the normalized stream. */
+    sequence: number;
+    entityIds: string[];
+    factRefs: EvolutionTimelineFactRef[];
+    summary?: string;
+}
+export interface WorldEvolutionRunResult {
+    initialSnapshot: WorldEvolutionSnapshot;
+    finalSnapshot: WorldEvolutionSnapshot;
+    profile: WorldEvolutionRulesetProfile;
+    timeline: WorldEvolutionStepEvent[];
+    metrics: WorldEvolutionMetrics;
+    deltas?: WorldEvolutionDelta[];
+    checkpoints?: WorldEvolutionCheckpoint[];
+}

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

@@ -0,0 +1 @@
+export const WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION = "ananke.world-evolution-backend.v1";

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

@@ -0,0 +1,51 @@
+import { type EvolutionTimelineEvent, type HostAdapterContext, type OpenWorldHostInput, type WorldEvolutionInput, type WorldEvolutionRulesetId, type WorldEvolutionRulesetProfile, type WorldEvolutionRunResult, type EvolutionRunReproducibilityRecord } from "./world-evolution-backend/public.js";
+import { type CreateEvolutionBranchInput, type EvolutionBranch, type EvolutionCheckpoint, type EvolutionRequest, type EvolutionRunResult, type EvolutionSession, type ResumeEvolutionOptions } from "./world-evolution.js";
+/**
+ * Host-facing deterministic backend wrapper: adapt + validate + run + timeline projection.
+ *
+ * Stability boundary:
+ * - Additive API (non Tier-1) exposed only via `@.../world-evolution-host-backend`.
+ * - Reuses authoritative world-evolution backend + orchestration modules without replacing them.
+ */
+export interface HostDeterministicRunRequest {
+    input: WorldEvolutionInput | OpenWorldHostInput;
+    steps: number;
+    profileId?: WorldEvolutionRulesetId;
+    profile?: WorldEvolutionRulesetProfile;
+    includeDeltas?: boolean;
+    checkpointInterval?: number;
+    includeSummaryText?: boolean;
+}
+export interface HostDeterministicRunResult {
+    normalizedInput: WorldEvolutionInput;
+    adapterContext: HostAdapterContext;
+    run: WorldEvolutionRunResult;
+    history: EvolutionTimelineEvent[];
+}
+export interface HostDeterministicRunWithReplayProofResult extends HostDeterministicRunResult {
+    reproducibility: EvolutionRunReproducibilityRecord;
+}
+export interface HostOrchestrationSessionConfig {
+    input: WorldEvolutionInput | OpenWorldHostInput;
+    rulesetId?: WorldEvolutionRulesetId;
+    ruleset?: WorldEvolutionRulesetProfile;
+    checkpointInterval?: number;
+    includeDeltas?: boolean;
+    label?: string;
+}
+export interface HostOrchestrationRunRequest extends EvolutionRequest {
+}
+export interface HostOrchestrationRunResult {
+    session: EvolutionSession;
+    result: EvolutionRunResult;
+}
+export declare function runHostDeterministicEvolution(request: HostDeterministicRunRequest): HostDeterministicRunResult;
+export declare function createHostEvolutionSession(config: HostOrchestrationSessionConfig): EvolutionSession;
+export declare function runHostEvolutionSession(session: EvolutionSession, request: HostOrchestrationRunRequest): HostOrchestrationRunResult;
+export declare function resumeHostEvolutionSessionFromCheckpoint(checkpoint: EvolutionCheckpoint, request: HostOrchestrationRunRequest, options?: ResumeEvolutionOptions): HostOrchestrationRunResult;
+export declare function createHostEvolutionBranch(config: HostOrchestrationSessionConfig & {
+    metadata: CreateEvolutionBranchInput["metadata"];
+    baseStep?: number;
+}): EvolutionBranch;
+export declare function runHostEvolutionBranch(branch: EvolutionBranch, request: HostOrchestrationRunRequest): EvolutionRunResult;
+export declare function runHostDeterministicEvolutionWithReplayProof(request: HostDeterministicRunRequest): HostDeterministicRunWithReplayProofResult;

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

@@ -0,0 +1,97 @@
+import { buildEvolutionTimeline, mapOpenWorldHostToEvolutionInput, normalizeHostWorldInput, runWorldEvolution, toAnankeEvolutionState, toWorldEvolutionRunRequest, buildEvolutionRunReproducibilityRecord, } from "./world-evolution-backend/public.js";
+import { createEvolutionBranch, createEvolutionSession, resumeEvolutionSessionFromCheckpoint, runEvolution, runEvolutionOnBranch, } from "./world-evolution.js";
+export function runHostDeterministicEvolution(request) {
+    const hostInput = normalizeHostBackendInput(request.input);
+    const normalizedInput = normalizeHostWorldInput({
+        ...hostInput,
+        ...(request.profileId != null ? { profileId: request.profileId } : {}),
+    });
+    const adapterState = toAnankeEvolutionState(normalizedInput);
+    const runRequest = toWorldEvolutionRunRequest(normalizedInput, request.steps, {
+        ...(request.profileId != null ? { profileId: request.profileId } : {}),
+        ...(request.profile != null ? { profile: request.profile } : {}),
+        ...(request.includeDeltas != null ? { includeDeltas: request.includeDeltas } : {}),
+        ...(request.checkpointInterval != null ? { checkpointInterval: request.checkpointInterval } : {}),
+    });
+    const run = runWorldEvolution(runRequest);
+    const history = buildEvolutionTimeline(run, {
+        ...(request.includeSummaryText != null ? { includeSummaryText: request.includeSummaryText } : {}),
+    });
+    return {
+        normalizedInput,
+        adapterContext: adapterState.context,
+        run,
+        history,
+    };
+}
+export function createHostEvolutionSession(config) {
+    const hostInput = normalizeHostBackendInput(config.input);
+    const normalizedInput = normalizeHostWorldInput({
+        ...hostInput,
+        ...(config.rulesetId != null ? { profileId: config.rulesetId } : {}),
+    });
+    const runRequest = toWorldEvolutionRunRequest(normalizedInput, 0, {
+        ...(config.rulesetId != null ? { profileId: config.rulesetId } : {}),
+        ...(config.ruleset != null ? { profile: config.ruleset } : {}),
+        ...(config.checkpointInterval != null ? { checkpointInterval: config.checkpointInterval } : {}),
+        ...(config.includeDeltas != null ? { includeDeltas: config.includeDeltas } : {}),
+    });
+    return createEvolutionSession({
+        seed: runRequest.snapshot.worldSeed,
+        canonicalSnapshot: runRequest.snapshot,
+        ...(config.rulesetId != null ? { rulesetId: config.rulesetId } : {}),
+        ...(config.ruleset != null ? { ruleset: config.ruleset } : {}),
+        ...(config.checkpointInterval != null ? { checkpointInterval: config.checkpointInterval } : {}),
+        ...(config.includeDeltas != null ? { includeDeltas: config.includeDeltas } : {}),
+        ...(config.label != null ? { label: config.label } : {}),
+    });
+}
+export function runHostEvolutionSession(session, request) {
+    return {
+        session,
+        result: runEvolution(session, request),
+    };
+}
+export function resumeHostEvolutionSessionFromCheckpoint(checkpoint, request, options = {}) {
+    const resumedSession = resumeEvolutionSessionFromCheckpoint(checkpoint, options);
+    return {
+        session: resumedSession,
+        result: runEvolution(resumedSession, request),
+    };
+}
+export function createHostEvolutionBranch(config) {
+    const session = createHostEvolutionSession(config);
+    return createEvolutionBranch({
+        baseSnapshot: session.canonicalInitialSnapshot,
+        metadata: {
+            ...config.metadata,
+            rulesetProfile: config.metadata.rulesetProfile ?? session.ruleset,
+        },
+        ...(config.baseStep != null ? { baseStep: config.baseStep } : {}),
+    });
+}
+export function runHostEvolutionBranch(branch, request) {
+    return runEvolutionOnBranch(branch, request);
+}
+function normalizeHostBackendInput(input) {
+    if (isOpenWorldHostInput(input)) {
+        return mapOpenWorldHostToEvolutionInput(input).input;
+    }
+    return input;
+}
+function isOpenWorldHostInput(input) {
+    const candidate = input;
+    return Array.isArray(candidate.regions) && Array.isArray(candidate.settlements) && Array.isArray(candidate.factions);
+}
+export function runHostDeterministicEvolutionWithReplayProof(request) {
+    const result = runHostDeterministicEvolution(request);
+    return {
+        ...result,
+        reproducibility: buildEvolutionRunReproducibilityRecord(toWorldEvolutionRunRequest(result.normalizedInput, request.steps, {
+            ...(request.profileId != null ? { profileId: request.profileId } : {}),
+            ...(request.profile != null ? { profile: request.profile } : {}),
+            ...(request.includeDeltas != null ? { includeDeltas: request.includeDeltas } : {}),
+            ...(request.checkpointInterval != null ? { checkpointInterval: request.checkpointInterval } : {}),
+        }), result.run),
+    };
+}