@its-not-rocket-science/ananke 0.1.68 → 0.5.1

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

@@ -0,0 +1,208 @@
+import { SCALE } from "../units.js";
+import { toAnankeEvolutionState, } from "./host-schema.js";
+export const OPEN_WORLD_HOST_ADAPTER_SCHEMA_VERSION = "ananke.open-world-host-adapter.v1";
+export function canonicalizeOpenWorldInput(input) {
+    const environment = input.environment == null ? undefined : {
+        ...(input.environment.climateByRegionId != null ? { climateByRegionId: canonicalizeStringRecord(input.environment.climateByRegionId) } : {}),
+        ...(input.environment.climateByPolity != null ? {
+            climateByPolity: [...input.environment.climateByPolity]
+                .map((entry) => ({ polityId: entry.polityId, active: [...entry.active] }))
+                .sort((a, b) => a.polityId.localeCompare(b.polityId)),
+        } : {}),
+        ...withOptional("metadata", canonicalizeMetadataBuckets(input.environment.metadata)),
+    };
+    const lore = input.lore == null ? undefined : {
+        ...withOptional("summary", input.lore.summary),
+        ...(input.lore.tags != null ? { tags: [...input.lore.tags].sort((a, b) => a.localeCompare(b)) } : {}),
+        ...withOptional("metadata", canonicalizeMetadataBuckets(input.lore.metadata)),
+    };
+    return {
+        schemaVersion: OPEN_WORLD_HOST_ADAPTER_SCHEMA_VERSION,
+        worldSeed: Math.floor(input.worldSeed),
+        tick: Math.max(0, Math.floor(input.tick ?? 0)),
+        regions: [...input.regions]
+            .map((region) => ({ ...region, ...withOptional("metadata", canonicalizeMetadataBuckets(region.metadata)) }))
+            .sort((a, b) => a.id.localeCompare(b.id)),
+        settlements: [...input.settlements]
+            .map((settlement) => ({ ...settlement, ...withOptional("metadata", canonicalizeMetadataBuckets(settlement.metadata)) }))
+            .sort((a, b) => a.id.localeCompare(b.id)),
+        factions: [...input.factions]
+            .map((faction) => ({ ...faction, ...withOptional("metadata", canonicalizeMetadataBuckets(faction.metadata)) }))
+            .sort((a, b) => a.id.localeCompare(b.id)),
+        ...(input.resources != null ? {
+            resources: [...input.resources]
+                .map((resource) => ({ ...resource, ...withOptional("metadata", canonicalizeMetadataBuckets(resource.metadata)) }))
+                .sort((a, b) => a.id.localeCompare(b.id)),
+        } : {}),
+        ...(input.tradeLinks != null ? {
+            tradeLinks: [...input.tradeLinks]
+                .map((tradeLink) => ({ ...tradeLink, ...withOptional("metadata", canonicalizeMetadataBuckets(tradeLink.metadata)) }))
+                .sort((a, b) => a.id.localeCompare(b.id)),
+        } : {}),
+        ...withOptional("environment", environment),
+        ...withOptional("lore", lore),
+        ...withOptional("metadata", canonicalizeMetadataBuckets(input.metadata)),
+    };
+}
+export function mapOpenWorldHostToEvolutionInput(input, options = {}) {
+    const canonical = canonicalizeOpenWorldInput(input);
+    const mapEntityMetadata = options.entityMetadataTransform ?? metadataToPassthrough;
+    const mapRelationshipMetadata = options.relationshipMetadataTransform ?? metadataToPassthrough;
+    const factionByPolityId = {};
+    const entities = [
+        ...canonical.factions.map((faction) => {
+            const polityId = faction.polityId ?? `p.${faction.id}`;
+            factionByPolityId[polityId] = faction.id;
+            return {
+                kind: "polity",
+                id: polityId,
+                name: faction.name,
+                factionId: faction.id,
+                ...withOptional("population", faction.population),
+                ...withOptional("treasury_cu", faction.treasury_cu),
+                ...withOptional("stabilityQ", faction.stabilityQ),
+                ...withOptional("moraleQ", faction.moraleQ),
+                ...withOptional("metadata", mapEntityMetadata(faction.metadata)),
+            };
+        }),
+        ...canonical.regions.map((region) => ({
+            kind: "region",
+            id: region.id,
+            name: region.name,
+            ...withOptional("polityId", region.polityId),
+            ...withOptional("population", region.population),
+            ...withOptional("biome", region.climateTag),
+            ...withOptional("metadata", mapEntityMetadata(region.metadata)),
+        })),
+        ...canonical.settlements.map((settlement) => ({
+            kind: "settlement",
+            id: settlement.id,
+            name: settlement.name,
+            ...withOptional("polityId", settlement.polityId),
+            regionId: settlement.regionId,
+            ...withOptional("population", settlement.population),
+            ...withOptional("metadata", mapEntityMetadata(settlement.metadata)),
+        })),
+    ];
+    const relationships = [];
+    for (const link of canonical.tradeLinks ?? []) {
+        const sourceId = resolvePolityId(canonical.factions, link.sourceFactionId);
+        const targetId = resolvePolityId(canonical.factions, link.targetFactionId);
+        const routeQualityQ = clampQ(link.routeQualityQ ?? SCALE.Q);
+        const metadata = mapRelationshipMetadata(link.metadata);
+        if (link.sharedBorderCount != null) {
+            relationships.push({
+                id: `${link.id}:border`, kind: "border", sourceId, targetId,
+                sharedBorderCount: Math.max(0, Math.floor(link.sharedBorderCount)),
+                routeQualityQ,
+                ...withOptional("metadata", metadata),
+            });
+        }
+        if (link.baseVolume_cu != null) {
+            relationships.push({
+                id: `${link.id}:trade`, kind: "trade_route", sourceId, targetId,
+                baseVolume_cu: Math.max(0, Math.floor(link.baseVolume_cu)),
+                routeQualityQ,
+                ...withOptional("metadata", metadata),
+            });
+        }
+        if (link.treatyType != null) {
+            relationships.push({
+                id: `${link.id}:treaty`, kind: "treaty", sourceId, targetId,
+                treatyType: link.treatyType,
+                treatyStrength_Q: clampQ(link.treatyStrength_Q ?? SCALE.Q),
+                ...withOptional("metadata", metadata),
+            });
+        }
+        if (link.war === true) {
+            relationships.push({ id: `${link.id}:war`, kind: "war", sourceId, targetId, ...withOptional("metadata", metadata) });
+        }
+    }
+    const resources = (canonical.resources ?? []).map((resource) => ({
+        id: resource.id,
+        resourceType: resource.resourceType,
+        ...withOptional("stock", resource.stock),
+        ...withOptional("regionId", resource.regionId),
+        ...withOptional("settlementId", resource.settlementId),
+        ...withOptional("polityId", resource.factionId == null ? undefined : resolvePolityId(canonical.factions, resource.factionId)),
+        ...withOptional("metadata", metadataToPassthrough(resource.metadata)),
+    }));
+    const hostMetadata = canonicalizeRecord({
+        openWorld: {
+            environment: canonical.environment,
+            lore: canonical.lore,
+            topLevelMetadata: canonical.metadata,
+            ...(options.topLevelOpaqueMerge ?? {}),
+        },
+    }) ?? {};
+    return {
+        input: {
+            schemaVersion: OPEN_WORLD_HOST_ADAPTER_SCHEMA_VERSION,
+            worldSeed: canonical.worldSeed,
+            tick: canonical.tick ?? 0,
+            entities,
+            relationships,
+            resources,
+            hostMetadata,
+            ...(canonical.environment?.climateByPolity != null ? { simulationState: { climateByPolity: canonical.environment.climateByPolity } } : {}),
+        },
+        context: {
+            schemaVersion: OPEN_WORLD_HOST_ADAPTER_SCHEMA_VERSION,
+            metadataPassthrough: hostMetadata,
+            factionByPolityId,
+        },
+    };
+}
+export function toAnankeEvolutionStateFromOpenWorld(input, options = {}) {
+    return toAnankeEvolutionState(mapOpenWorldHostToEvolutionInput(input, options).input);
+}
+function resolvePolityId(factions, factionId) {
+    const faction = factions.find((candidate) => candidate.id === factionId);
+    return faction?.polityId ?? `p.${factionId}`;
+}
+function clampQ(value) {
+    return Math.max(0, Math.min(SCALE.Q, Math.floor(value)));
+}
+function metadataToPassthrough(metadata) {
+    if (metadata == null)
+        return undefined;
+    return canonicalizeRecord({
+        ...withOptional("simulation", canonicalizeRecord(metadata.simulation)),
+        ...withOptional("descriptive", canonicalizeRecord(metadata.descriptive)),
+        ...withOptional("opaque", canonicalizeRecord(metadata.opaque)),
+    });
+}
+function canonicalizeMetadataBuckets(metadata) {
+    if (metadata == null)
+        return undefined;
+    return {
+        ...withOptional("simulation", canonicalizeRecord(metadata.simulation)),
+        ...withOptional("descriptive", canonicalizeRecord(metadata.descriptive)),
+        ...withOptional("opaque", canonicalizeRecord(metadata.opaque)),
+    };
+}
+function canonicalizeStringRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+function canonicalizeRecord(record) {
+    if (record == null)
+        return undefined;
+    return Object.fromEntries(Object.entries(record)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, value]) => [key, canonicalizeUnknown(value)]));
+}
+function canonicalizeUnknown(value) {
+    if (Array.isArray(value))
+        return value.map((entry) => canonicalizeUnknown(entry));
+    if (value != null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => [key, canonicalizeUnknown(entry)]));
+    }
+    return value;
+}
+function withOptional(key, value) {
+    if (value === undefined)
+        return {};
+    return { [key]: value };
+}

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

@@ -0,0 +1,4 @@
+import type { WorldEvolutionRulesetId, WorldEvolutionRulesetProfile } from "./types.js";
+export declare function listWorldEvolutionProfiles(): WorldEvolutionRulesetProfile[];
+export declare function resolveWorldEvolutionProfile(id?: WorldEvolutionRulesetId): WorldEvolutionRulesetProfile;
+export declare function mergeWorldEvolutionProfileWithOverrides(profileId: WorldEvolutionRulesetId | undefined, overrides: Partial<WorldEvolutionRulesetProfile> | undefined): WorldEvolutionRulesetProfile;

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

@@ -0,0 +1,136 @@
+import { q } from "../units.js";
+const DEFAULT_PIPELINE_ORDER = [
+    "polity",
+    "governance",
+    "diplomacy",
+    "trade",
+    "migration",
+    "climate",
+    "epidemic",
+];
+const PROFILES_BY_CANONICAL_ID = {
+    minimal_world_history: {
+        id: "minimal_world_history",
+        name: "Minimal World History",
+        description: "Low-cost long-horizon baseline: polity core only, all other subsystems disabled.",
+        pipelineOrder: DEFAULT_PIPELINE_ORDER,
+        polityDayEnabled: true,
+        governanceEnabled: false,
+        diplomacyEnabled: false,
+        tradeEnabled: false,
+        migrationEnabled: false,
+        epidemicEnabled: false,
+        climateEnabled: false,
+        governanceStabilityDaysPerStep: 0,
+        treatyStrengthBoost_Q: 0,
+        routeEfficiencyBoost_Q: 0,
+        epidemicHealthBuffer_Q: 0,
+    },
+    polity_dynamics: {
+        id: "polity_dynamics",
+        name: "Polity Dynamics",
+        description: "Political-economy focus: governance, diplomacy, and trade enabled without climate or epidemic load.",
+        pipelineOrder: DEFAULT_PIPELINE_ORDER,
+        polityDayEnabled: true,
+        governanceEnabled: true,
+        diplomacyEnabled: true,
+        tradeEnabled: true,
+        migrationEnabled: false,
+        epidemicEnabled: false,
+        climateEnabled: false,
+        governanceStabilityDaysPerStep: 1,
+        treatyStrengthBoost_Q: 0,
+        routeEfficiencyBoost_Q: q(0.0005),
+        epidemicHealthBuffer_Q: 0,
+    },
+    conflict_heavy: {
+        id: "conflict_heavy",
+        name: "Conflict Heavy",
+        description: "Conflict-forward settings with weaker diplomatic/trade stabilization and no climate/epidemic overhead.",
+        pipelineOrder: DEFAULT_PIPELINE_ORDER,
+        polityDayEnabled: true,
+        governanceEnabled: true,
+        diplomacyEnabled: true,
+        tradeEnabled: true,
+        migrationEnabled: true,
+        epidemicEnabled: false,
+        climateEnabled: false,
+        governanceStabilityDaysPerStep: 1,
+        treatyStrengthBoost_Q: 0,
+        routeEfficiencyBoost_Q: 0,
+        epidemicHealthBuffer_Q: 0,
+    },
+    climate_and_migration: {
+        id: "climate_and_migration",
+        name: "Climate + Migration",
+        description: "Environment and movement focus: climate + migration + epidemic pressure with lighter diplomatic/economic mechanics.",
+        pipelineOrder: DEFAULT_PIPELINE_ORDER,
+        polityDayEnabled: true,
+        governanceEnabled: false,
+        diplomacyEnabled: false,
+        tradeEnabled: false,
+        migrationEnabled: true,
+        epidemicEnabled: true,
+        climateEnabled: true,
+        governanceStabilityDaysPerStep: 0,
+        treatyStrengthBoost_Q: 0,
+        routeEfficiencyBoost_Q: 0,
+        epidemicHealthBuffer_Q: q(0.02),
+    },
+    full_world_evolution: {
+        id: "full_world_evolution",
+        name: "Full World Evolution",
+        description: "Maximal backend composition: all currently integrated world-scale subsystems enabled.",
+        pipelineOrder: DEFAULT_PIPELINE_ORDER,
+        polityDayEnabled: true,
+        governanceEnabled: true,
+        diplomacyEnabled: true,
+        tradeEnabled: true,
+        migrationEnabled: true,
+        epidemicEnabled: true,
+        climateEnabled: true,
+        governanceStabilityDaysPerStep: 1,
+        treatyStrengthBoost_Q: 0,
+        routeEfficiencyBoost_Q: 0,
+        epidemicHealthBuffer_Q: 0,
+    },
+};
+const LEGACY_ALIAS_TO_CANONICAL = {
+    balanced: "full_world_evolution",
+    resilience: "full_world_evolution",
+    expansion: "full_world_evolution",
+};
+export function listWorldEvolutionProfiles() {
+    return [
+        PROFILES_BY_CANONICAL_ID.minimal_world_history,
+        PROFILES_BY_CANONICAL_ID.polity_dynamics,
+        PROFILES_BY_CANONICAL_ID.conflict_heavy,
+        PROFILES_BY_CANONICAL_ID.climate_and_migration,
+        PROFILES_BY_CANONICAL_ID.full_world_evolution,
+    ].map(cloneProfile);
+}
+export function resolveWorldEvolutionProfile(id = "full_world_evolution") {
+    const canonicalId = (id in LEGACY_ALIAS_TO_CANONICAL)
+        ? LEGACY_ALIAS_TO_CANONICAL[id]
+        : id;
+    return cloneProfile(PROFILES_BY_CANONICAL_ID[canonicalId]);
+}
+export function mergeWorldEvolutionProfileWithOverrides(profileId, overrides) {
+    const base = resolveWorldEvolutionProfile(profileId ?? "full_world_evolution");
+    if (!overrides)
+        return base;
+    return cloneProfile({
+        ...base,
+        ...overrides,
+        id: base.id,
+        name: overrides.name ?? `${base.name} (host override)`,
+        description: overrides.description ?? `${base.description} Host overrides applied deterministically.`,
+        pipelineOrder: DEFAULT_PIPELINE_ORDER,
+    });
+}
+function cloneProfile(profile) {
+    return {
+        ...profile,
+        pipelineOrder: [...profile.pipelineOrder],
+    };
+}

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

@@ -0,0 +1,11 @@
+export { runWorldEvolution, createWorldEvolutionSnapshot, listAvailableWorldEvolutionProfiles, } from "./engine.js";
+export { resolveWorldEvolutionProfile, listWorldEvolutionProfiles, mergeWorldEvolutionProfileWithOverrides, } from "./profiles.js";
+export { WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION, } from "./types.js";
+export type { EvolutionRulesetProfile, WorldEvolutionRulesetId, WorldEvolutionRulesetProfile, WorldEvolutionSnapshot, WorldEvolutionRunRequest, WorldEvolutionRunResult, WorldEvolutionStepEvent, WorldEvolutionDelta, WorldEvolutionCheckpoint, WorldEvolutionMetrics, EvolutionTimelineCategory, EvolutionTimelineFactRef, EvolutionTimelineEvent, } from "./types.js";
+export { buildEvolutionTimeline, sortTimelineEventsBySignificance, } from "./timeline.js";
+export { HOST_WORLD_EVOLUTION_SCHEMA_VERSION, normalizeHostWorldInput, validateWorldEvolutionInput, toAnankeEvolutionState, fromAnankeEvolutionState, toWorldEvolutionRunRequest, fromWorldEvolutionRunResult, } from "./host-schema.js";
+export type { WorldEvolutionInput, NormalizedWorldEvolutionInput, HostWorldEntity, HostPolity, HostSettlement, HostRegion, HostRelationship, HostResourceNode, HostRuleOverrides, HostDiseaseProfile, HostEpidemicState, ValidationError, HostAdapterContext, AnankeEvolutionAdapterState, } from "./host-schema.js";
+export { OPEN_WORLD_HOST_ADAPTER_SCHEMA_VERSION, canonicalizeOpenWorldInput, mapOpenWorldHostToEvolutionInput, toAnankeEvolutionStateFromOpenWorld, } from "./open-world-host-adapter.js";
+export type { MetadataBuckets, OpenWorldHostInput, OpenWorldRegion, OpenWorldSettlement, OpenWorldFaction, OpenWorldResource, OpenWorldTradeLink, OpenWorldEnvironment, OpenWorldLoreMetadata, OpenWorldHostAdapterOptions, OpenWorldAdapterContext, OpenWorldMappedState, } from "./open-world-host-adapter.js";
+export { computeWorldEvolutionRunRequestFingerprint, computeWorldEvolutionRunResultDigest, buildEvolutionRunReproducibilityRecord, } from "./reproducibility.js";
+export type { EvolutionRunReproducibilityRecord, } from "./reproducibility.js";

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

@@ -0,0 +1,7 @@
+export { runWorldEvolution, createWorldEvolutionSnapshot, listAvailableWorldEvolutionProfiles, } from "./engine.js";
+export { resolveWorldEvolutionProfile, listWorldEvolutionProfiles, mergeWorldEvolutionProfileWithOverrides, } from "./profiles.js";
+export { WORLD_EVOLUTION_BACKEND_SCHEMA_VERSION, } from "./types.js";
+export { buildEvolutionTimeline, sortTimelineEventsBySignificance, } from "./timeline.js";
+export { HOST_WORLD_EVOLUTION_SCHEMA_VERSION, normalizeHostWorldInput, validateWorldEvolutionInput, toAnankeEvolutionState, fromAnankeEvolutionState, toWorldEvolutionRunRequest, fromWorldEvolutionRunResult, } from "./host-schema.js";
+export { OPEN_WORLD_HOST_ADAPTER_SCHEMA_VERSION, canonicalizeOpenWorldInput, mapOpenWorldHostToEvolutionInput, toAnankeEvolutionStateFromOpenWorld, } from "./open-world-host-adapter.js";
+export { computeWorldEvolutionRunRequestFingerprint, computeWorldEvolutionRunResultDigest, buildEvolutionRunReproducibilityRecord, } from "./reproducibility.js";

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

@@ -0,0 +1,8 @@
+import type { WorldEvolutionRunRequest, WorldEvolutionRunResult } from "./types.js";
+export interface EvolutionRunReproducibilityRecord {
+    requestFingerprint: string;
+    outputDigest: string;
+}
+export declare function computeWorldEvolutionRunRequestFingerprint(request: WorldEvolutionRunRequest): string;
+export declare function computeWorldEvolutionRunResultDigest(result: WorldEvolutionRunResult): string;
+export declare function buildEvolutionRunReproducibilityRecord(request: WorldEvolutionRunRequest, result: WorldEvolutionRunResult): EvolutionRunReproducibilityRecord;

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

@@ -0,0 +1,35 @@
+export function computeWorldEvolutionRunRequestFingerprint(request) {
+    return stableHashHex(stableJsonStringify(request));
+}
+export function computeWorldEvolutionRunResultDigest(result) {
+    return stableHashHex(stableJsonStringify(result));
+}
+export function buildEvolutionRunReproducibilityRecord(request, result) {
+    return {
+        requestFingerprint: computeWorldEvolutionRunRequestFingerprint(request),
+        outputDigest: computeWorldEvolutionRunResultDigest(result),
+    };
+}
+function stableJsonStringify(value) {
+    return JSON.stringify(stableJson(value));
+}
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => stableJson(entry));
+    }
+    if (value != null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => [key, stableJson(entry)]));
+    }
+    return 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/timeline.d.ts

@@ -0,0 +1,6 @@
+import type { EvolutionTimelineEvent, WorldEvolutionRunResult } from "./types.js";
+export interface BuildEvolutionTimelineOptions {
+    includeSummaryText?: boolean;
+}
+export declare function buildEvolutionTimeline(result: Pick<WorldEvolutionRunResult, "initialSnapshot" | "timeline">, options?: BuildEvolutionTimelineOptions): EvolutionTimelineEvent[];
+export declare function sortTimelineEventsBySignificance(events: readonly EvolutionTimelineEvent[]): EvolutionTimelineEvent[];