@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-6PFNJPBJ.mjs

@@ -0,0 +1,820 @@
+import { addSceneCamera, BoxBatch, BOX_X, BOX_Y, BOX_Z, BOX_SX, BOX_SY, BOX_SZ } from './chunk-QDYFLATW.mjs';
+import { joinTickRoom } from './chunk-IRVFYAKP.mjs';
+import { yearOf, writeNature, writeConstitution, ratioQ16, percentQ16, encodeReviewedLaw, encodeDecree, bindGenesisEngine, TRIGGER, TIER, TERRAIN, START_MONTH, SINK, SELECTION, RUN_ID_BYTES, RIGHTS_ALL, RIGHT, REFUSED_SEAT, REFUSED_MALFORMED, REFUSED_FULL, REFUSED_DRAFT, Q16, PROPERTY, OP, NO_FAITH, NONE, MONTHS_PER_YEAR, MAX_FAITHS, MAX_DECREE_BYTES, LocalGenesis, HUMAN, GOVERNMENT, GIFTED, GENESIS_SETTLEMENT_WORDS, GENESIS_REFUSED, GENESIS_OPEN_WORDS, GENESIS_INDICATOR_WORDS, GENESIS_EXPORT_NAMES, GENESIS_CHANNEL_SLOT, GENESIS_ACTIVE_WORDS, FRAME, FORECAST_FAILED, FIELD, FACT_KINDS, ENVELOPE, DISASTER, DESTINY, DEFAULT_NATURE, DECREE_REFUSAL_BASE, DECREE_REFUSALS, CURSED, ByteWriter, BLESSED, ACTION } from './chunk-TM63CYGN.mjs';
+import { runIdFromAiRun } from './chunk-X6CN6KQF.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/game/kit/genesis/names.ts
+var MASK = (1n << 64n) - 1n, MIX_INCREMENT = 0x9e3779b97f4a7c15n, MIX_MUL_A = 0xbf58476d1ce4e5b9n, MIX_MUL_B = 0x94d049bb133111ebn, PURPOSE_CULTURE = 0x43554c54n, ONSETS = ["k", "t", "v", "s", "r", "m", "n", "d", "l", "z", "th", "br", "gr", "sh", "f", "h", "j", "p", "b", "y", "dr", "kh", "tl", "w"], NUCLEI = ["a", "e", "i", "o", "u", "ae", "ei", "ou", "ya", "ai", "eo", "u"], CODAS = ["", "", "n", "r", "s", "th", "l", "m", "k", "sh", "nd", "x"], ONSETS_PER_CULTURE = 9, NUCLEI_PER_CULTURE = 6, CODAS_PER_CULTURE = 6, CULTURE_SHIFT = 24, SEED_MASK = 16777215, MAX_RETRIES = 8, FALLBACK_SALT = 0x5eedn;
+function finalize(value) {
+  let z = value & MASK;
+  return z = (z ^ z >> 30n) * MIX_MUL_A & MASK, z = (z ^ z >> 27n) * MIX_MUL_B & MASK, z ^ z >> 31n;
+}
+function mix(seed, domain, a, b, c) {
+  let h = finalize(seed + MIX_INCREMENT & MASK ^ domain);
+  return h = finalize(h + MIX_INCREMENT & MASK ^ a), h = finalize(h + MIX_INCREMENT & MASK ^ b), finalize(h + MIX_INCREMENT & MASK ^ c);
+}
+function phonology(worldSeed, culture) {
+  let pick = (salt, table, k) => table[Number(mix(worldSeed, PURPOSE_CULTURE, BigInt(culture), salt, BigInt(k)) % BigInt(table.length))];
+  return {
+    onsets: Array.from({ length: (9) }, (_, k) => pick(1n, ONSETS, k)),
+    nuclei: Array.from({ length: (6) }, (_, k) => pick(2n, NUCLEI, k)),
+    codas: Array.from({ length: (6) }, (_, k) => pick(3n, CODAS, k))
+  };
+}
+function word(p, seed) {
+  let h = finalize(seed), syllables = 2n + h % 2n, out = "";
+  for (let k = 0n; k < syllables; k++)
+    h = finalize(h + k & MASK), out += p.onsets[Number(h % BigInt((9)))], out += p.nuclei[Number((h >> 8n) % BigInt((6)))], k + 1n === syllables && (out += p.codas[Number((h >> 16n) % BigInt((6)))]);
+  return out.length === 0 ? out : out[0].toUpperCase() + out.slice(1);
+}
+var RELIGIOUS_TERMS = [
+  "christ",
+  "jesus",
+  "allah",
+  "islam",
+  "muslim",
+  "muhammad",
+  "mohammed",
+  "quran",
+  "koran",
+  "bible",
+  "torah",
+  "judaism",
+  "jewish",
+  "yahweh",
+  "jehovah",
+  "buddha",
+  "buddhis",
+  "hindu",
+  "krishna",
+  "vishnu",
+  "shiva",
+  "brahma",
+  "sikh",
+  "guru nanak",
+  "jainis",
+  "zoroast",
+  "shinto",
+  "taois",
+  "confuci",
+  "orisha",
+  "yoruba ifa",
+  "sango",
+  "ogun",
+  "obatala",
+  "vodun",
+  "voodoo",
+  "baha'i",
+  "mormon",
+  "pope",
+  "vatican"
+], MAX_NAME_CHARS = 40;
+function screenName(name) {
+  let trimmed = name.trim();
+  if (trimmed.length === 0) return "empty";
+  if ([...trimmed].length > (40)) return "too_long";
+  let folded = [...trimmed.toLowerCase()].filter((c) => /[\p{L}\p{N} ']/u.test(c)).join(""), squashed = folded.replace(/\s+/g, "");
+  return ((terms) => terms.some((t) => folded.includes(t) || squashed.includes(t.replace(/ /g, ""))))(RELIGIOUS_TERMS) ? "real_religion" : null;
+}
+function nameOf(worldSeed, packed) {
+  let culture = packed >>> (24), seed = BigInt(packed & (16777215)), p = phonology(worldSeed, culture);
+  for (let retry = 0n; retry < BigInt((8)); retry++) {
+    let w = word(p, seed ^ retry << 32n);
+    if (screenName(w) === null) return w;
+  }
+  return word(p, seed ^ FALLBACK_SALT);
+}
+
+// src/game/kit/genesis/ai.ts
+var CONSTITUTION_PROMPT = "constitution_draft", CONSTITUTION_SCHEMA_NAME = "genesis_constitution", CHRONICLE_PROMPT = "chronicle_era", MAX_WORLD_CHARS = 200, MAX_FACT_CHARS = 200, FACT_SLOTS = 8, FACT_SLOT_NAMES = Array.from({ length: (8) }, (_, k) => `facts${k}`), CHRONICLE_MAX_UNITS = 400, AI_CAPABILITY = "Write laws and chronicles for your world in your own words", RIGHTS = ["speak", "worship", "assemble", "move", "own_land", "trade", "bear_arms", "marry", "leave"], CONSTITUTION_SCHEMA = {
+  title: CONSTITUTION_SCHEMA_NAME,
+  type: "object",
+  additionalProperties: false,
+  required: ["government", "property", "rights", "offices", "rules"],
+  properties: {
+    government: { enum: ["chiefdom", "monarchy", "oligarchy", "republic", "direct_democracy", "theocracy", "elders", "technocracy", "anarchy", "custom"] },
+    property: { enum: ["common", "first_tiller", "feudal", "freehold", "state"] },
+    rights: { type: "array", maxItems: 9, items: { enum: RIGHTS } },
+    offices: {
+      type: "array",
+      maxItems: 8,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "seats", "selection", "term_years"],
+        properties: {
+          name: { type: "string", minLength: 1, maxLength: 24 },
+          seats: { type: "integer", minimum: 1, maximum: 16 },
+          selection: { enum: ["heredity", "election", "appointment", "lot", "merit", "divine"] },
+          term_years: { type: "integer", minimum: 0, maximum: 100 }
+        }
+      }
+    },
+    rules: {
+      type: "array",
+      maxItems: 64,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["when", "who", "effect"],
+        properties: {
+          when: { enum: ["monthly", "year_end", "birth", "coming_of_age"] },
+          who: {
+            type: "array",
+            maxItems: 3,
+            items: {
+              type: "array",
+              maxItems: 4,
+              items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["field", "op", "value"],
+                properties: {
+                  field: { enum: ["age", "sex", "faith", "devotion", "place", "occupation", "wealth", "status", "notable", "realm"] },
+                  op: { enum: ["=", "!=", "<", "<=", ">", ">="] },
+                  value: { type: ["integer", "string"] }
+                }
+              }
+            }
+          },
+          effect: {
+            type: "object",
+            additionalProperties: false,
+            required: ["kind"],
+            properties: {
+              kind: { enum: ["transfer_share", "grant", "grant_rights", "revoke_rights", "set_status", "set_faith", "adjust_devotion", "modify_hazard", "migrate", "set_occupation"] },
+              percent: { type: "number", minimum: 0, maximum: 100 },
+              amount: { type: "integer", minimum: 0, maximum: 1e5 },
+              to: { enum: ["treasury", "temple"] },
+              rights: { type: "array", items: { enum: RIGHTS } },
+              status: { enum: ["free", "imprisoned", "exiled", "outlawed"] },
+              faith: { type: "string" },
+              delta: { type: "integer", minimum: -255, maximum: 255 },
+              death_rate: { type: "number", minimum: 0.01, maximum: 8 },
+              birth_rate: { type: "number", minimum: 0, maximum: 8 },
+              place: { type: "string" },
+              occupation: { enum: ["farmer", "crafter", "trader", "priest", "soldier", "scholar", "official"] }
+            }
+          },
+          priority: { type: "integer", minimum: 0, maximum: 255 }
+        }
+      }
+    },
+    unexpressed: { type: "array", maxItems: 8, items: { type: "string", maxLength: 200 } }
+  }
+}, CONSTITUTION_TEMPLATE = "You turn a god's words into the constitution of a fictional realm in a world-building game. Governments: chiefdom, monarchy, oligarchy, republic, direct democracy, theocracy, council of elders, technocracy, anarchy, custom. Answer only with the genesis_constitution structure. Use only faiths and places named in the world context. Put anything the structure cannot express in unexpressed. Never name or depict a real religion, deity, prophet, scripture, place, nation, party or public figure; every name must be fictional. World context: {{world}}.", CHRONICLE_TEMPLATE = "You are the chronicler of a fictional world in a god game. Write a short era chronicle (at most 180 words) and an era title from these recorded facts, in order, without inventing events that contradict them: {{facts0}}{{facts1}}{{facts2}}{{facts3}}{{facts4}}{{facts5}}{{facts6}}{{facts7}}. Realm: {{realm}}. Depict hardship abstractly. Never name or depict a real religion, deity, prophet, scripture, place, nation or public figure.", BARE_KEY = /^[A-Za-z0-9_-]+$/;
+function toml(value) {
+  return typeof value == "string" ? JSON.stringify(value) : typeof value == "number" || typeof value == "boolean" ? String(value) : Array.isArray(value) ? `[${value.map(toml).join(", ")}]` : `{ ${Object.entries(value).map(([k, v]) => `${BARE_KEY.test(k) ? k : JSON.stringify(k)} = ${toml(v)}`).join(", ")} }`;
+}
+function genesisAiToml() {
+  return `[capabilities]
+ai = ${JSON.stringify(AI_CAPABILITY)}
+
+${genesisAiSection()}`;
+}
+function genesisAiSection() {
+  return `[ai]
+payer = "creator"
+languages = ["en"]
+per_player_daily_units = 20000
+per_session_units = 10000
+per_interactive_monthly_units = 2000000
+
+[[ai.prompts]]
+name = "${CONSTITUTION_PROMPT}"
+template = ${JSON.stringify(CONSTITUTION_TEMPLATE)}
+output = "structured"
+schema = "${CONSTITUTION_SCHEMA_NAME}"
+quality = "standard"
+cache = "none"
+player_text = true
+
+[[ai.prompts.slots]]
+name = "world"
+kind = "text"
+max_chars = ${(200)}
+
+[[ai.prompts]]
+name = "${CHRONICLE_PROMPT}"
+template = ${JSON.stringify(CHRONICLE_TEMPLATE)}
+output = "text"
+quality = "standard"
+cache = "interactive"
+player_text = false
+
+${FACT_SLOT_NAMES.map((name) => `[[ai.prompts.slots]]
+name = "${name}"
+kind = "text"
+max_chars = ${(200)}
+`).join(`
+`)}
+[[ai.prompts.slots]]
+name = "realm"
+kind = "text"
+max_chars = ${(200)}
+
+[[ai.schemas]]
+name = "${CONSTITUTION_SCHEMA_NAME}"
+schema = ${toml(CONSTITUTION_SCHEMA)}
+`;
+}
+function clip(text, max) {
+  return text.length <= max ? text : text.slice(0, max);
+}
+function constitutionRequest(request) {
+  return {
+    audience: { kind: "requester" },
+    output: { kind: "structured", schema: CONSTITUTION_SCHEMA_NAME },
+    player_text: request.words.trim(),
+    prompt: CONSTITUTION_PROMPT,
+    request_key: request.requestKey,
+    slots: [{ kind: "text", name: "world", value: clip(request.world, (200)) }],
+    stream: false,
+    variant: 0
+  };
+}
+async function requestConstitution(ai, request) {
+  let run = await ai.generate(constitutionRequest(request)), id = runIdFromAiRun(run.run_id);
+  if (id === null) throw new RangeError(`unexpected ai run id ${run.run_id}`);
+  return id;
+}
+function factsText(seed, facts, placeName) {
+  let parts = [];
+  for (let f of facts) {
+    let year = Math.floor((f.month - START_MONTH) / MONTHS_PER_YEAR), place = nameOf(seed, placeName(f.settlement));
+    parts.push(`year ${year}: ${FACT_KINDS[f.kind] ?? "event"} at ${place} (${f.a}, ${f.b})`);
+  }
+  return parts.join("; ");
+}
+function chronicleRequest(request) {
+  return {
+    audience: { kind: "requester" },
+    output: { kind: "text", max_units: (400) },
+    prompt: CHRONICLE_PROMPT,
+    request_key: request.requestKey,
+    slots: [
+      ...FACT_SLOT_NAMES.map((name, k) => ({ kind: "text", name, value: request.facts.slice(k * (200), (k + 1) * (200)) })),
+      { kind: "text", name: "realm", value: clip(request.realm, (200)) }
+    ],
+    stream: false,
+    variant: 0
+  };
+}
+async function requestChronicle(ai, request) {
+  return ai.generate(chronicleRequest(request));
+}
+
+// src/game/kit/genesis/link.ts
+var FRAME_RING = 512, FRAME_BYTES = 1200, TickGenesisLink = class {
+  constructor(transport) {
+    this.frames = new Uint8Array((512) * (1200));
+    this.lengths = new Int32Array((512));
+    this.head = 0;
+    this.count = 0;
+    this.dropped = 0;
+    this.transport = transport, transport.tap(GENESIS_CHANNEL_SLOT, (view, offset, length) => this.push(view, offset, length));
+  }
+  push(view, offset, length) {
+    if (this.count === (512) || length > (1200)) {
+      this.dropped++;
+      return;
+    }
+    let slot = (this.head + this.count) % (512), base = slot * (1200);
+    for (let i = 0; i < length; i++) this.frames[base + i] = view.getUint8(offset + i);
+    this.lengths[slot] = length, this.count++;
+  }
+  command(action, payload, length) {
+    this.transport.client.sendCommand(action, payload, length);
+  }
+  pump(mirror) {
+    let applied = 0;
+    for (; this.count > 0; )
+      mirror.apply(this.frames, this.head * (1200), this.lengths[this.head]), this.head = (this.head + 1) % (512), this.count--, applied++;
+    return applied;
+  }
+  close() {
+    this.transport.tap(GENESIS_CHANNEL_SLOT, null);
+  }
+}, ReplayGenesisLink = class {
+  constructor(frames, perPump = Number.POSITIVE_INFINITY) {
+    this.sent = [];
+    this.next = 0;
+    this.frames = frames, this.perPump = perPump;
+  }
+  get remaining() {
+    return this.frames.length - this.next;
+  }
+  command(action, payload, length) {
+    this.sent.push({ action, bytes: payload.slice(0, length) });
+  }
+  pump(mirror) {
+    let applied = 0;
+    for (; this.next < this.frames.length && applied < this.perPump; )
+      mirror.apply(this.frames[this.next++]), applied++;
+    return applied;
+  }
+}, GenesisCommands = class {
+  constructor(link) {
+    this.w = new ByteWriter();
+    this.link = link;
+  }
+  decree(decree) {
+    let length = encodeDecree(decree, this.w);
+    this.link.command(ACTION.decree, this.w.bytes, length);
+  }
+  enact(review) {
+    let length = encodeReviewedLaw(review.polity, review.constitution, this.w);
+    this.link.command(ACTION.decree, this.w.bytes, length);
+  }
+  interest(settlement, tier) {
+    this.w.reset().u16(settlement).u8(tier), this.flush(ACTION.interest);
+  }
+  time(monthsPerMinute, paused) {
+    this.w.reset().u32(monthsPerMinute).u8(paused ? 1 : 0), this.flush(ACTION.time);
+  }
+  draft(run, polity) {
+    if (run.length !== RUN_ID_BYTES) throw new RangeError("a run id is 16 bytes");
+    this.w.reset().raw(run).u16(polity), this.flush(ACTION.draft);
+  }
+  era(fromMonth, toMonth) {
+    this.w.reset().u32(fromMonth).u32(toMonth), this.flush(ACTION.era);
+  }
+  follow(person) {
+    this.w.reset().u32(person), this.flush(ACTION.follow);
+  }
+  flush(action) {
+    this.link.command(action, this.w.bytes, this.w.length);
+  }
+};
+
+// src/game/kit/genesis/mirror.ts
+var MAX_SETTLEMENTS = 4096, FACT_RING = 1024, EDIT_RING = 256, LAT_BANDS_MAX = 64, LITTLE = true, FOOD_MASK = 15, PLAGUE_SHIFT = 4, DECODER = new TextDecoder(), Cursor = class {
+  constructor(view, at, end) {
+    this.view = view, this.at = at, this.end = end;
+  }
+  need(n) {
+    if (this.at + n > this.end) throw new RangeError("genesis frame is truncated");
+  }
+  u8() {
+    return this.need(1), this.view.getUint8(this.at++);
+  }
+  i8() {
+    return this.need(1), this.view.getInt8(this.at++);
+  }
+  u16() {
+    this.need(2);
+    let v = this.view.getUint16(this.at, (true));
+    return this.at += 2, v;
+  }
+  i16() {
+    this.need(2);
+    let v = this.view.getInt16(this.at, (true));
+    return this.at += 2, v;
+  }
+  u32() {
+    this.need(4);
+    let v = this.view.getUint32(this.at, (true));
+    return this.at += 4, v;
+  }
+  i32() {
+    this.need(4);
+    let v = this.view.getInt32(this.at, (true));
+    return this.at += 4, v;
+  }
+  f32() {
+    this.need(4);
+    let v = this.view.getFloat32(this.at, (true));
+    return this.at += 4, v;
+  }
+  u64() {
+    this.need(8);
+    let v = this.view.getBigUint64(this.at, (true));
+    return this.at += 8, v;
+  }
+  i64() {
+    this.need(8);
+    let v = this.view.getBigInt64(this.at, (true));
+    return this.at += 8, v;
+  }
+  bytes(n) {
+    this.need(n);
+    let out = new Uint8Array(this.view.buffer, this.view.byteOffset + this.at, n).slice();
+    return this.at += n, out;
+  }
+  text() {
+    let n = this.u16();
+    return DECODER.decode(this.bytes(n));
+  }
+}, GenesisMirror = class {
+  constructor() {
+    this.state = {
+      month: 0,
+      tick: 0n,
+      population: 0n,
+      individuals: 0,
+      births: 0,
+      deaths: 0,
+      conversions: 0,
+      migrants: 0,
+      fedPermille: 0,
+      meanAgeTenths: 0,
+      wealth: 0n,
+      treasury: 0n,
+      natureDigest: 0n,
+      ledgerDigest: 0n,
+      rateMilli: 0n,
+      paused: false,
+      faithCount: 0
+    };
+    this.faithPopulation = new Float64Array(MAX_FAITHS);
+    this.nature = {
+      digest: 0n,
+      seed: 0n,
+      gravity: [0, -9.81, 0],
+      timeScale: 1,
+      airDensity: 1.225,
+      waterDensity: 1e3,
+      scaleHeightM: 8e3,
+      rayleigh: [58e-7, 13558e-9, 331e-7],
+      mie: 3996e-9,
+      ozone: 65e-8,
+      radiusM: 6371e3,
+      daySeconds: 1440,
+      tiltDegrees: 23.44,
+      daysPerYear: 48,
+      ticksPerHour: 600,
+      seaLevelPermille: 180,
+      bands: 0
+    };
+    this.bandTempC10 = new Int16Array((64));
+    this.bandRain = new Uint16Array((64));
+    this.bandBiome = new Uint8Array((64));
+    this.settlementCount = 0;
+    this.tier = new Uint8Array((4096));
+    this.food = new Uint8Array((4096));
+    this.plague = new Uint8Array((4096));
+    this.population = new Uint32Array((4096));
+    this.faith = new Uint8Array((4096));
+    this.faithShare = new Uint16Array((4096));
+    this.x = new Int32Array((4096));
+    this.z = new Int32Array((4096));
+    this.name = new Uint32Array((4096));
+    this.polity = new Uint16Array((4096));
+    this.band = new Uint8Array((4096));
+    this.tempC = new Int8Array((4096));
+    this.rain = new Uint16Array((4096));
+    this.price = new Uint16Array((4096));
+    this.facts = [];
+    this.factsSeen = 0;
+    this.edits = [];
+    this.editsSeen = 0;
+    this.faiths = [];
+    this.review = null;
+    this.era = null;
+    this.forecast = null;
+    this.people = /* @__PURE__ */ new Map();
+    this.refusals = 0;
+    this.lastRefusal = null;
+    this.framesApplied = 0;
+    this.natureChanges = 0;
+  }
+  apply(frame, offset = 0, length = frame.length - offset) {
+    let view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength), c = new Cursor(view, offset, offset + length);
+    switch (c.u8()) {
+      case FRAME.state:
+        this.applyState(c);
+        break;
+      case FRAME.settlements:
+        this.applySettlements(c);
+        break;
+      case FRAME.facts:
+        this.applyFacts(c);
+        break;
+      case FRAME.edits:
+        this.applyEdits(c);
+        break;
+      case FRAME.nature:
+        this.applyNature(c);
+        break;
+      case FRAME.review:
+        this.applyReview(c);
+        break;
+      case FRAME.era:
+        this.applyEra(c);
+        break;
+      case FRAME.refused:
+        this.lastRefusal = { action: c.u16(), code: c.u8() }, this.refusals++;
+        break;
+      case FRAME.faiths:
+        this.applyFaiths(c);
+        break;
+      case FRAME.person:
+        this.applyPerson(c);
+        break;
+      case FRAME.forecast:
+        this.applyForecast(c);
+        break;
+      default:
+        return;
+    }
+    this.framesApplied++;
+  }
+  applyState(c) {
+    let s = this.state;
+    s.month = c.u32(), s.tick = c.u64(), s.population = c.u64(), s.individuals = c.u32(), s.births = c.u32(), s.deaths = c.u32(), s.conversions = c.u32(), s.migrants = c.u32(), s.fedPermille = c.u16(), s.meanAgeTenths = c.u16(), s.wealth = c.i64(), s.treasury = c.i64(), s.natureDigest = c.u64(), s.ledgerDigest = c.u64(), s.rateMilli = c.u64(), s.paused = c.u8() !== 0, s.faithCount = Math.min(c.u8(), MAX_FAITHS), this.faithPopulation.fill(0);
+    for (let f = 0; f < s.faithCount; f++) this.faithPopulation[f] = Number(c.u64());
+  }
+  applySettlements(c) {
+    let count = c.u16();
+    for (let k = 0; k < count; k++) {
+      let s = c.u16();
+      if (s >= (4096)) throw new RangeError("settlement id out of range");
+      this.tier[s] = c.u8();
+      let packed = c.u8();
+      this.food[s] = packed & (15), this.plague[s] = packed >> (4), this.population[s] = c.u32(), this.faith[s] = c.u8(), this.faithShare[s] = c.u16(), this.x[s] = c.i32(), this.z[s] = c.i32(), this.name[s] = c.u32(), this.polity[s] = c.u16(), this.band[s] = c.u8(), this.tempC[s] = c.i8(), this.rain[s] = c.u16(), this.price[s] = c.u16(), s + 1 > this.settlementCount && (this.settlementCount = s + 1);
+    }
+  }
+  readFact(c) {
+    return { month: c.u32(), kind: c.u8(), settlement: c.u16(), a: c.u32(), b: c.u32() };
+  }
+  applyFacts(c) {
+    let count = c.u16();
+    for (let k = 0; k < count; k++)
+      this.facts.push(this.readFact(c)), this.factsSeen++;
+    this.facts.length > (1024) && this.facts.splice(0, this.facts.length - (1024));
+  }
+  applyEdits(c) {
+    let count = c.u16();
+    for (let k = 0; k < count; k++)
+      this.edits.push({ month: c.u32(), settlement: c.u16(), address: c.u64(), xM: c.i32(), zM: c.i32(), radiusM: c.u16(), depthCm: c.i32(), kind: c.u8() }), this.editsSeen++;
+    this.edits.length > (256) && this.edits.splice(0, this.edits.length - (256));
+  }
+  applyNature(c) {
+    let n = this.nature;
+    n.digest = c.u64(), n.seed = c.u64(), n.gravity = [c.f32(), c.f32(), c.f32()], n.timeScale = c.f32(), n.airDensity = c.f32(), n.waterDensity = c.f32(), n.scaleHeightM = c.f32(), n.rayleigh = [c.f32(), c.f32(), c.f32()], n.mie = c.f32(), n.ozone = c.f32(), n.radiusM = c.f32(), n.daySeconds = c.f32(), n.tiltDegrees = c.f32(), n.daysPerYear = c.u32(), n.ticksPerHour = c.u32(), n.seaLevelPermille = c.u16(), n.bands = Math.min(c.u8(), (64));
+    for (let b = 0; b < n.bands; b++)
+      this.bandTempC10[b] = c.i16(), this.bandRain[b] = c.u16(), this.bandBiome[b] = c.u8();
+    this.natureChanges++;
+  }
+  applyReview(c) {
+    let polity = c.u16(), problems = [], n = c.u8();
+    for (let k = 0; k < n; k++) problems.push({ code: c.u8(), text: c.text() });
+    let lines = [], m = c.u16();
+    for (let k = 0; k < m; k++) lines.push(c.text());
+    let constitution = c.bytes(c.u16());
+    this.review = { polity, problems, lines, constitution };
+  }
+  applyEra(c) {
+    let from = c.u32(), to = c.u32(), digest = c.u64(), startPopulation = c.u64(), endPopulation = c.u64(), n = c.u8(), facts = [];
+    for (let k = 0; k < n; k++) facts.push(this.readFact(c));
+    this.era = { from, to, digest, startPopulation, endPopulation, facts };
+  }
+  applyForecast(c) {
+    let polity = c.u16(), count = c.u16(), failed = count === FORECAST_FAILED, years = [];
+    for (let k = 0; k < (failed ? 0 : count); k++)
+      years.push({
+        population: [c.u64(), c.u64()],
+        births: [c.u32(), c.u32()],
+        deaths: [c.u32(), c.u32()],
+        fedPermille: [c.u16(), c.u16()],
+        wealth: [c.i64(), c.i64()]
+      });
+    this.forecast = { polity, failed, years };
+  }
+  applyFaiths(c) {
+    let n = Math.min(c.u8(), MAX_FAITHS), list = [];
+    for (let k = 0; k < n; k++) list.push({ name: c.u32(), parent: c.u8(), founder: c.u32(), founded: c.u32(), symbol: c.u32() });
+    this.faiths = list;
+  }
+  applyPerson(c) {
+    let p = {
+      id: c.u32(),
+      generation: c.u32(),
+      flags: c.u8(),
+      birth: c.u32(),
+      settlement: c.u16(),
+      occupation: c.u8(),
+      health: c.u8(),
+      faith: c.u8(),
+      devotion: c.u8(),
+      status: c.u8(),
+      hazard: c.u16(),
+      partner: c.u32(),
+      mother: c.u32(),
+      father: c.u32(),
+      wealth: c.i32(),
+      name: c.u32(),
+      destiny: c.u16(),
+      values: c.u64()
+    };
+    this.people.set(p.id, p);
+  }
+  totalPopulation() {
+    return Number(this.state.population);
+  }
+};
+
+// src/game/kit/genesis/genesis.ts
+var BOX_CAPACITY = 8192, MAP_SCALE = 1 / 400, CAMERA_HEIGHT = 70, CAMERA_BACK = 80, CAMERA_FOV = 50, CAMERA_PITCH = -0.85, GROUND_RGB = 3100463, GROUND_SIZE = 220, GROUND_HEIGHT = 0.4, FAMINE_RGB = 4139549, PLAGUE_RGB = 12131356, SELECT_RGB = 16448250, FAITH_RGB = [11051678, 16096779, 3718648, 10980346, 3462041, 16020150, 16436245, 6333946, 16478597, 4906624, 12616956, 3003583, 16628340, 9684477, 14285213, 15235577], MIN_SIZE = 0.8, SIZE_PER_ROOT = 0.06, HEIGHT_PER_ROOT = 0.12, SELECT_RING = 1.4, HALF = 0.5, FAMINE_BAND = 3, SPEEDS = [0, 6, 12, 60, 240, 1200], DEFAULT_SPEED = 2, SLOT_YEAR = 0, SLOT_PEOPLE = 1, SLOT_FAITHS = 2, SLOT_FED = 3, SLOT_PLACE = 4, BLESS_MORTALITY = Math.floor(Q16 * 0.7), BLESS_FERTILITY = Math.floor(Q16 * 1.3), CURSE_MORTALITY = Math.floor(Q16 * 1.6), CURSE_FERTILITY = Math.floor(Q16 * 0.6), BLESS_MONTHS = 24, RAIN_TEMP_C10 = -10, RAIN_PERMILLE = 1600, DROUGHT_PERMILLE = 150, WEATHER_MONTHS = 6, QUAKE_MAGNITUDE = 6, PLAGUE_BETA = Q16 * 2, PLAGUE_LETHALITY = Math.floor(Q16 / 12), PLAGUE_MONTHS = 18, MIRACLE_FOOD = 2e5, MIRACLE_DEVOTION = 40, PROPHET_TRANSMISSIBILITY = Math.floor(Q16 / 6), EARTH_RAYLEIGH_BLUE = 331e-7, EARTH_AIR = 1.225, BASE_TURBIDITY = 2;
+function applyNature(game, nature) {
+  game.physics.setGravity({ x: nature.gravity[0], y: nature.gravity[1], z: nature.gravity[2] });
+  let blue = nature.rayleigh[2] / (331e-7);
+  game.graphics.setEnvironment({
+    sky: {
+      rayleigh: Math.max(0, blue * (nature.airDensity / (1.225))),
+      mie: nature.mie / 3996e-9 * 5e-3,
+      turbidity: (2) * Math.max(0.2, nature.airDensity / (1.225))
+    }
+  });
+}
+var GenesisWorld = class {
+  constructor(options) {
+    this.name = "genesis-world";
+    this.mirror = new GenesisMirror();
+    this.selected = 0;
+    this.speed = (2);
+    this.paused = false;
+    this.framesApplied = 0;
+    this.decreesSent = 0;
+    this.hud = [];
+    this.boxes = null;
+    this.natureSeen = 0;
+    this.actions = /* @__PURE__ */ new Map();
+    this.options = options, this.commands = new GenesisCommands(options.link);
+  }
+  enter(game) {
+    addSceneCamera(game, 0, (70), (80), (50), (-0.85)), this.boxes = new BoxBatch(game, (8192)), this.hud[(0)] = game.ui.hudNumber("year"), this.hud[(1)] = game.ui.hudNumber("people"), this.hud[(2)] = game.ui.hudNumber("faiths"), this.hud[(3)] = game.ui.hudNumber("fed %"), this.hud[(4)] = game.ui.hudText("place");
+    let bind = (name, code) => {
+      this.actions.set(name, game.input.defineButton(name, [{ device: "key", code }, { device: "virtual", control: name }]));
+    };
+    bind("next", "BracketRight"), bind("previous", "BracketLeft"), bind("bless", "KeyB"), bind("curse", "KeyC"), bind("rain", "KeyR"), bind("drought", "KeyD"), bind("quake", "KeyQ"), bind("plague", "KeyP"), bind("miracle", "KeyM"), bind("prophet", "KeyF"), bind("focus", "KeyE"), bind("faster", "Equal"), bind("slower", "Minus"), bind("pause", "Space"), bind("law", "KeyL"), bind("chronicle", "KeyH");
+  }
+  pressed(game, name) {
+    let id = this.actions.get(name);
+    return id !== void 0 && game.input.justPressed(id);
+  }
+  fixedUpdate(game) {
+    this.framesApplied += this.options.link.pump(this.mirror);
+    let m = this.mirror;
+    m.natureChanges !== this.natureSeen && (this.natureSeen = m.natureChanges, applyNature(game, m.nature));
+    let count = m.settlementCount;
+    count > 0 && (this.pressed(game, "next") && (this.selected = (this.selected + 1) % count), this.pressed(game, "previous") && (this.selected = (this.selected + count - 1) % count)), this.options.god !== false && count > 0 && this.godInput(game);
+    let ui = game.ui;
+    ui.setNumber(this.hud[(0)], Math.max(0, yearOf(m.state.month))), ui.setNumber(this.hud[(1)], m.totalPopulation()), ui.setNumber(this.hud[(2)], m.state.faithCount), ui.setNumber(this.hud[(3)], Math.round(m.state.fedPermille / 10)), ui.setText(this.hud[(4)], count > 0 ? this.placeName(this.selected) : "");
+  }
+  godInput(game) {
+    let s = this.selected, at = { kind: "settlement", settlement: s }, send = (decree) => {
+      this.commands.decree(decree), this.decreesSent++;
+    };
+    if (this.pressed(game, "bless") && send({ target: at, power: { kind: "bless", mortalityQ16: BLESS_MORTALITY, fertilityQ16: BLESS_FERTILITY, months: (24) } }), this.pressed(game, "curse") && send({ target: at, power: { kind: "curse", mortalityQ16: CURSE_MORTALITY, fertilityQ16: CURSE_FERTILITY, months: (24) } }), this.pressed(game, "rain") && send({ target: at, power: { kind: "weather", tempC10: (-10), rainPermille: (1600), months: (6) } }), this.pressed(game, "drought") && send({ target: at, power: { kind: "weather", tempC10: 0, rainPermille: (150), months: (6) } }), this.pressed(game, "quake") && send({ target: at, power: { kind: "disaster", disaster: DISASTER.earthquake, magnitude: (6) } }), this.pressed(game, "plague") && send({ target: at, power: { kind: "plague", betaQ16: PLAGUE_BETA, lethalityQ16: PLAGUE_LETHALITY, months: (18) } }), this.pressed(game, "miracle") && send({ target: at, power: { kind: "miracle", food: (2e5), devotion: (40) } }), this.pressed(game, "prophet")) {
+      let name = this.mirror.state.month * 7919 + s * 104729 & 16777215;
+      send({ target: at, power: { kind: "prophet", faithName: name, values: BigInt(name), transmissibilityQ16: PROPHET_TRANSMISSIBILITY } });
+    }
+    if (this.pressed(game, "focus")) {
+      let tier = this.mirror.tier[s] === TIER.cohort ? TIER.active : TIER.cohort;
+      this.commands.interest(s, tier);
+    }
+    this.pressed(game, "faster") && this.setSpeed(Math.min(this.speed + 1, SPEEDS.length - 1)), this.pressed(game, "slower") && this.setSpeed(Math.max(this.speed - 1, 1)), this.pressed(game, "pause") && (this.paused = !this.paused, this.commands.time(SPEEDS[this.speed], this.paused)), this.pressed(game, "law") && this.options.onLaw?.(this), this.pressed(game, "chronicle") && this.options.onChronicle?.(this);
+  }
+  setSpeed(speed) {
+    this.speed = speed, this.commands.time(SPEEDS[speed], this.paused);
+  }
+  placeName(s) {
+    return nameOf(this.mirror.nature.seed, this.mirror.name[s]);
+  }
+  faithName(f) {
+    if (f === 0 || f === NO_FAITH) return "the old ways";
+    let record = this.mirror.faiths[f];
+    return record === void 0 ? `faith ${f}` : `the ${nameOf(this.mirror.nature.seed, record.name)} faith`;
+  }
+  worldContext() {
+    let m = this.mirror, faiths = [];
+    for (let f = 0; f < m.faiths.length; f++) faiths.push(this.faithName(f));
+    let places = [];
+    for (let s = 0; s < Math.min(m.settlementCount, 32); s++) places.push(this.placeName(s));
+    return `faiths: ${faiths.join(", ")}; places: ${places.join(", ")}`;
+  }
+  update(_game) {
+    let boxes = this.boxes;
+    if (boxes === null) return;
+    let b = boxes.box, m = this.mirror;
+    boxes.begin(), b[BOX_X] = 0, b[BOX_Y] = -(0.4) * (0.5), b[BOX_Z] = 0, b[BOX_SX] = (220), b[BOX_SY] = (0.4), b[BOX_SZ] = (220), boxes.add((3100463));
+    for (let s = 0; s < m.settlementCount; s++) {
+      let root = Math.sqrt(m.population[s]), size = (0.8) + root * (0.06), height = (0.8) + root * (0.12), rgb = m.plague[s] !== 0 ? (12131356) : m.food[s] >= (3) ? (4139549) : FAITH_RGB[m.faith[s] % FAITH_RGB.length];
+      b[BOX_X] = m.x[s] * MAP_SCALE, b[BOX_Y] = height * (0.5), b[BOX_Z] = m.z[s] * MAP_SCALE, b[BOX_SX] = size, b[BOX_SY] = height, b[BOX_SZ] = size, boxes.add(rgb), s === this.selected && (b[BOX_Y] = (0.4), b[BOX_SX] = size * (1.4), b[BOX_SY] = (0.4), b[BOX_SZ] = size * (1.4), boxes.add((16448250)));
+    }
+    boxes.end();
+  }
+};
+async function joinGenesisWorld(ctx, request, hooks = {}) {
+  let session = await ctx.join_world(request);
+  if (session.realtime === null)
+    return { scene: new GenesisWorld({ link: new ReplayGenesisLink([]), ...hooks }), transport: null, onFrame() {
+    } };
+  let transport = joinTickRoom({ realtime: session.realtime }), scene = new GenesisWorld({ link: new TickGenesisLink(transport), ...hooks }), started = false;
+  return {
+    scene,
+    transport,
+    onFrame(nowMs) {
+      started || (transport.start(nowMs), started = true), transport.update(nowMs);
+    }
+  };
+}
+
+// src/game/kit/genesis/index.ts
+var genesis_exports = {};
+__export(genesis_exports, {
+  ACTION: () => ACTION,
+  AI_CAPABILITY: () => AI_CAPABILITY,
+  BLESSED: () => BLESSED,
+  BOX_CAPACITY: () => (8192),
+  ByteWriter: () => ByteWriter,
+  CHRONICLE_MAX_UNITS: () => (400),
+  CHRONICLE_PROMPT: () => CHRONICLE_PROMPT,
+  CHRONICLE_TEMPLATE: () => CHRONICLE_TEMPLATE,
+  CONSTITUTION_PROMPT: () => CONSTITUTION_PROMPT,
+  CONSTITUTION_SCHEMA: () => CONSTITUTION_SCHEMA,
+  CONSTITUTION_SCHEMA_NAME: () => CONSTITUTION_SCHEMA_NAME,
+  CONSTITUTION_TEMPLATE: () => CONSTITUTION_TEMPLATE,
+  CURSED: () => CURSED,
+  DECREE_REFUSALS: () => DECREE_REFUSALS,
+  DECREE_REFUSAL_BASE: () => DECREE_REFUSAL_BASE,
+  DEFAULT_NATURE: () => DEFAULT_NATURE,
+  DESTINY: () => DESTINY,
+  DISASTER: () => DISASTER,
+  EDIT_RING: () => (256),
+  ENVELOPE: () => ENVELOPE,
+  FACT_KINDS: () => FACT_KINDS,
+  FACT_RING: () => (1024),
+  FACT_SLOTS: () => (8),
+  FIELD: () => FIELD,
+  FORECAST_FAILED: () => FORECAST_FAILED,
+  FRAME: () => FRAME,
+  GENESIS_ACTIVE_WORDS: () => GENESIS_ACTIVE_WORDS,
+  GENESIS_CHANNEL_SLOT: () => GENESIS_CHANNEL_SLOT,
+  GENESIS_EXPORT_NAMES: () => GENESIS_EXPORT_NAMES,
+  GENESIS_INDICATOR_WORDS: () => GENESIS_INDICATOR_WORDS,
+  GENESIS_OPEN_WORDS: () => GENESIS_OPEN_WORDS,
+  GENESIS_REFUSED: () => GENESIS_REFUSED,
+  GENESIS_SETTLEMENT_WORDS: () => GENESIS_SETTLEMENT_WORDS,
+  GIFTED: () => GIFTED,
+  GOVERNMENT: () => GOVERNMENT,
+  GenesisCommands: () => GenesisCommands,
+  GenesisMirror: () => GenesisMirror,
+  GenesisWorld: () => GenesisWorld,
+  HUMAN: () => HUMAN,
+  LAT_BANDS_MAX: () => (64),
+  LocalGenesis: () => LocalGenesis,
+  MAX_DECREE_BYTES: () => MAX_DECREE_BYTES,
+  MAX_FACT_CHARS: () => (200),
+  MAX_FAITHS: () => MAX_FAITHS,
+  MAX_NAME_CHARS: () => (40),
+  MAX_SETTLEMENTS: () => (4096),
+  MAX_WORLD_CHARS: () => (200),
+  MONTHS_PER_YEAR: () => MONTHS_PER_YEAR,
+  NONE: () => NONE,
+  NO_FAITH: () => NO_FAITH,
+  OP: () => OP,
+  PROPERTY: () => PROPERTY,
+  Q16: () => Q16,
+  REFUSED_DRAFT: () => REFUSED_DRAFT,
+  REFUSED_FULL: () => REFUSED_FULL,
+  REFUSED_MALFORMED: () => REFUSED_MALFORMED,
+  REFUSED_SEAT: () => REFUSED_SEAT,
+  RIGHT: () => RIGHT,
+  RIGHTS_ALL: () => RIGHTS_ALL,
+  RUN_ID_BYTES: () => RUN_ID_BYTES,
+  ReplayGenesisLink: () => ReplayGenesisLink,
+  SELECTION: () => SELECTION,
+  SINK: () => SINK,
+  START_MONTH: () => START_MONTH,
+  TERRAIN: () => TERRAIN,
+  TIER: () => TIER,
+  TRIGGER: () => TRIGGER,
+  TickGenesisLink: () => TickGenesisLink,
+  applyNature: () => applyNature,
+  bindGenesisEngine: () => bindGenesisEngine,
+  chronicleRequest: () => chronicleRequest,
+  constitutionRequest: () => constitutionRequest,
+  encodeDecree: () => encodeDecree,
+  encodeReviewedLaw: () => encodeReviewedLaw,
+  factsText: () => factsText,
+  finalize: () => finalize,
+  genesisAiSection: () => genesisAiSection,
+  genesisAiToml: () => genesisAiToml,
+  joinGenesisWorld: () => joinGenesisWorld,
+  mix: () => mix,
+  nameOf: () => nameOf,
+  percentQ16: () => percentQ16,
+  ratioQ16: () => ratioQ16,
+  requestChronicle: () => requestChronicle,
+  requestConstitution: () => requestConstitution,
+  runIdFromAiRun: () => runIdFromAiRun,
+  screenName: () => screenName,
+  writeConstitution: () => writeConstitution,
+  writeNature: () => writeNature,
+  yearOf: () => yearOf
+});
+
+export { AI_CAPABILITY, BOX_CAPACITY, CHRONICLE_MAX_UNITS, CHRONICLE_PROMPT, CHRONICLE_TEMPLATE, CONSTITUTION_PROMPT, CONSTITUTION_SCHEMA, CONSTITUTION_SCHEMA_NAME, CONSTITUTION_TEMPLATE, EDIT_RING, FACT_RING, FACT_SLOTS, GenesisCommands, GenesisMirror, GenesisWorld, LAT_BANDS_MAX, MAX_FACT_CHARS, MAX_NAME_CHARS, MAX_SETTLEMENTS, MAX_WORLD_CHARS, ReplayGenesisLink, TickGenesisLink, applyNature, chronicleRequest, constitutionRequest, factsText, finalize, genesisAiSection, genesisAiToml, genesis_exports, joinGenesisWorld, mix, nameOf, requestChronicle, requestConstitution, screenName };