@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-TJI3K6RP.js

@@ -0,0 +1,137 @@
+'use strict';
+
+// src/interactives/runtime/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), INITIAL = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), SHA256_BYTES = 32, BLOCK_BYTES = 64, LENGTH_BYTES = 8, PAD_MARKER = 128, TWO_32 = 4294967296, words = new Uint32Array(64), state = new Uint32Array(8), tail = new Uint8Array((64) * 2), tailView = new DataView(tail.buffer);
+function rotr(x, n) {
+  return x >>> n | x << 32 - n;
+}
+function compress(view, offset) {
+  for (let i = 0; i < 16; i++) words[i] = view.getUint32(offset + i * 4, false);
+  rounds();
+}
+function compressBytes(bytes, offset) {
+  for (let i = 0; i < 16; i++) {
+    let at = offset + i * 4;
+    words[i] = bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3];
+  }
+  rounds();
+}
+function rounds() {
+  for (let i = 16; i < 64; i++) {
+    let a2 = words[i - 15], b2 = words[i - 2], s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3, s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+    words[i] = words[i - 16] + s0 + words[i - 7] + s1 | 0;
+  }
+  let a = state[0], b = state[1], c = state[2], d = state[3], e = state[4], f = state[5], g = state[6], h = state[7];
+  for (let i = 0; i < 64; i++) {
+    let t1 = h + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[i] + words[i] | 0, t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+    h = g, g = f, f = e, e = d + t1 | 0, d = c, c = b, b = a, a = t1 + t2 | 0;
+  }
+  state[0] += a, state[1] += b, state[2] += c, state[3] += d, state[4] += e, state[5] += f, state[6] += g, state[7] += h;
+}
+function sha256Into(input, out) {
+  state.set(INITIAL);
+  let view = new DataView(input.buffer, input.byteOffset, input.byteLength), whole = input.length - input.length % (64);
+  for (let offset = 0; offset < whole; offset += (64)) compress(view, offset);
+  let rest = input.length - whole;
+  tail.fill(0), tail.set(input.subarray(whole), 0), tail[rest] = (128);
+  let blocks = rest + 1 + (8) > (64) ? 2 : 1, bits = input.length * 8, end = blocks * (64);
+  tailView.setUint32(end - 8, Math.floor(bits / (4294967296)), false), tailView.setUint32(end - 4, bits >>> 0, false);
+  for (let block = 0; block < blocks; block++) compress(tailView, block * (64));
+  let outView = new DataView(out.buffer, out.byteOffset, (32));
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, state[i], false);
+}
+function sha256Matches(input, expected, at) {
+  state.set(INITIAL);
+  let whole = input.length - input.length % (64);
+  for (let offset = 0; offset < whole; offset += (64)) compressBytes(input, offset);
+  let rest = input.length - whole;
+  tail.fill(0);
+  for (let i = 0; i < rest; i++) tail[i] = input[whole + i];
+  tail[rest] = (128);
+  let blocks = rest + 1 + (8) > (64) ? 2 : 1, bits = input.length * 8, end = blocks * (64);
+  tailView.setUint32(end - 8, Math.floor(bits / (4294967296)), false), tailView.setUint32(end - 4, bits >>> 0, false);
+  for (let block = 0; block < blocks; block++) compress(tailView, block * (64));
+  for (let i = 0; i < 8; i++) {
+    let word = state[i], p = at + i * 4;
+    if (expected[p] !== word >>> 24 || expected[p + 1] !== (word >>> 16 & 255) || expected[p + 2] !== (word >>> 8 & 255) || expected[p + 3] !== (word & 255)) return false;
+  }
+  return true;
+}
+
+exports.SHA256_BYTES = (32);
+exports.sha256Into = sha256Into;
+exports.sha256Matches = sha256Matches;

package/dist/chunk-TL2SVO4P.mjs

@@ -0,0 +1,55 @@
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/render/types.ts
+function createPickHit() {
+  return {
+    node: 0,
+    instance: 0,
+    triangle: 0,
+    distance: 0,
+    point: new Float32Array(3),
+    barycentric: new Float32Array(2),
+    uv: new Float32Array(2)
+  };
+}
+var UNTINTED = { tintable: false, mask: void 0 };
+function materialTint(desc) {
+  if (!("tintable" in desc || "tintMask" in desc)) return UNTINTED;
+  let mask = desc.tintMask;
+  if (mask === void 0 && desc.tintable !== true) return UNTINTED;
+  if (mask !== void 0 && desc.kind === "physical" && ((desc.transmission ?? 0) > 0 || desc.transmissionMap !== void 0))
+    throw new GameError("invalid_argument", "a tint mask shares the transmission texture slot; drop transmission or the tint mask");
+  return { tintable: true, mask };
+}
+var SH_COEFFICIENT_FLOATS = 27, GPU_PASS_NAMES = [
+  "cull",
+  "particles",
+  "shadow",
+  "main",
+  "overlay",
+  "post",
+  "targets",
+  "gi",
+  "rt",
+  "volumetrics"
+];
+function createGpuStats() {
+  return {
+    gpuLastNs: 0,
+    gpuP50Ns: 0,
+    gpuP95Ns: 0,
+    gpuBytes: 0,
+    thermalTier: 0,
+    particlesAlive: 0,
+    rawDispatches: 0,
+    rawGpuNs: 0,
+    rawDisabled: 0,
+    transparentSorted: 0,
+    textGlyphs: 0,
+    drawCalls: 0,
+    triangles: 0,
+    passNs: new Float64Array(GPU_PASS_NAMES.length)
+  };
+}
+
+export { GPU_PASS_NAMES, SH_COEFFICIENT_FLOATS, createGpuStats, createPickHit, materialTint };

package/dist/chunk-TM63CYGN.mjs

@@ -0,0 +1,399 @@
+// src/game/kit/genesis/protocol.ts
+var GENESIS_CHANNEL_SLOT = 61, RUN_ID_BYTES = 16, MAX_DECREE_BYTES = 1024, Q16 = 65536, START_MONTH = 1536, MONTHS_PER_YEAR = 12, MAX_FAITHS = 16, NONE = 4294967295, NO_FAITH = 255, ACTION = {
+  decree: 18177,
+  interest: 18178,
+  time: 18179,
+  draft: 18180,
+  era: 18181,
+  follow: 18182
+}, FRAME = {
+  state: 1,
+  settlements: 2,
+  facts: 3,
+  edits: 4,
+  nature: 5,
+  review: 6,
+  era: 7,
+  refused: 8,
+  faiths: 9,
+  person: 10,
+  forecast: 11
+}, FORECAST_FAILED = 65535, TIER = { embodied: 0, active: 1, ledger: 2, cohort: 3 }, FIELD = { age: 0, sex: 1, faith: 2, devotion: 3, settlement: 4, occupation: 5, wealthBand: 6, status: 7, notable: 8, polity: 9 }, OP = { eq: 0, ne: 1, lt: 2, le: 3, gt: 4, ge: 5 }, TRIGGER = { monthly: 0, yearEnd: 1, birth: 2, comingOfAge: 3 }, SINK = { treasury: 0, temple: 1 }, GOVERNMENT = { chiefdom: 0, monarchy: 1, oligarchy: 2, republic: 3, directDemocracy: 4, theocracy: 5, elders: 6, technocracy: 7, anarchy: 8, custom: 9 }, SELECTION = { heredity: 0, election: 1, appointment: 2, lot: 3, merit: 4, divine: 5 }, PROPERTY = { common: 0, firstTiller: 1, feudal: 2, freehold: 3, state: 4 }, TERRAIN = { raise: 0, lower: 1, crater: 2, flatten: 3, cone: 4 }, DISASTER = { earthquake: 0, flood: 1, volcano: 2, drought: 3, storm: 4, meteor: 5 }, DESTINY = { none: 0, rule: 1, foundFaith: 2, discover: 3, wander: 4, serve: 5 }, RIGHT = { speak: 1, worship: 2, assemble: 4, move: 8, ownLand: 16, trade: 32, bearArms: 64, marry: 128, leave: 256 }, RIGHTS_ALL = 511, GIFTED = 16, BLESSED = 4, CURSED = 8, FACT_KINDS = [
+  "world_began",
+  "settlement_founded",
+  "notable_born",
+  "notable_died",
+  "office_filled",
+  "law_passed",
+  "nature_changed",
+  "plague_began",
+  "plague_ended",
+  "famine",
+  "miracle",
+  "disaster",
+  "faith_founded",
+  "schism",
+  "prophet_rose",
+  "destiny_fulfilled",
+  "migration",
+  "population_record",
+  "blessing",
+  "curse",
+  "weather_worked",
+  "terrain_shaped",
+  "gifted_births"
+], DECREE_REFUSALS = [
+  "",
+  "the decree queue is full",
+  "no such place",
+  "no such realm",
+  "no such faith",
+  "no such person",
+  "no decree may single out a player",
+  "magnitude must be 1 to 10",
+  "duration must be 1 to 1,200 months",
+  "births must number 1 to 100,000",
+  "this world holds no more faiths",
+  "this world holds no more places",
+  "that nature is outside the stability envelope",
+  "that constitution does not validate",
+  "not enough divine power",
+  "that moment has passed",
+  "that power needs a different target"
+], REFUSED_SEAT = 1, REFUSED_MALFORMED = 2, REFUSED_FULL = 3, REFUSED_DRAFT = 4, DECREE_REFUSAL_BASE = 32, HUMAN = {
+  lifespanYears: 100,
+  maturityYears: 16,
+  fertileEndYears: 45,
+  gestationMonths: 9,
+  litter: 1,
+  fertilityPermille: 260,
+  infantPermille: 60,
+  adultPermille: 3,
+  senescenceDoublingYears: 8,
+  foodPerMonth: 30
+}, DEFAULT_NATURE = {
+  radiusM: 6371e3,
+  gravityMmS2: 9810,
+  daySeconds: 1440,
+  yearDays: 48,
+  tiltMdeg: 23440,
+  eccentricityPermille: 17,
+  moons: 1,
+  seaLevelPermille: 180,
+  recipe: 0,
+  physicalScalePermille: 1e3,
+  historyDaysPerSecondMilli: 1e3,
+  airDensityGM3: 1225,
+  scaleHeightM: 8e3,
+  rayleighPerMm: [5802, 13558, 33100],
+  miePerMm: 3996,
+  ozonePerMm: 650,
+  breathable: true,
+  waterDensityKgM3: 1e3,
+  viscosityMicroPaS: 1002,
+  freezeK10: 2731,
+  boilK10: 3731,
+  salinityPermille: 35,
+  solarWM2: 1361,
+  greenhousePermille: 1e3,
+  albedoPermille: 300,
+  iceAlbedoPermille: 620,
+  transportPermille: 400,
+  precipitationPermille: 1e3,
+  stormPermille: 60,
+  seasonPermille: 1e3,
+  species: [HUMAN],
+  conservativeMass: true,
+  conservativeEnergy: true,
+  createdEnergyPerTickJ: 0n,
+  gravityEnvelopeMmS2: 50000n,
+  energyBudgetPerTickJ: 1000000n,
+  costBudgetUnits: 1000000n
+}, ENVELOPE = {
+  gravityMaxMmS2: 5e4,
+  scaleMinPermille: 100,
+  scaleMaxPermille: 4e3,
+  dayMinSeconds: 60,
+  airMaxGM3: 50 * 1225,
+  tiltMaxMdeg: 9e4,
+  yearMinDays: 12,
+  yearMaxDays: 1e5,
+  lifespanMaxYears: 127
+}, LITTLE = true, ByteWriter = class {
+  constructor(capacity = (1024)) {
+    this.length = 0;
+    this.bytes = new Uint8Array(capacity), this.view = new DataView(this.bytes.buffer);
+  }
+  reset() {
+    return this.length = 0, this;
+  }
+  room(n) {
+    if (this.length + n > this.bytes.length) throw new RangeError("genesis command is larger than its buffer");
+    let at = this.length;
+    return this.length += n, at;
+  }
+  u8(v) {
+    return this.view.setUint8(this.room(1), v & 255), this;
+  }
+  u16(v) {
+    return this.view.setUint16(this.room(2), v & 65535, (true)), this;
+  }
+  u32(v) {
+    return this.view.setUint32(this.room(4), v >>> 0, (true)), this;
+  }
+  i32(v) {
+    return this.view.setInt32(this.room(4), v | 0, (true)), this;
+  }
+  u64(v) {
+    return this.view.setBigUint64(this.room(8), BigInt.asUintN(64, v), (true)), this;
+  }
+  raw(src) {
+    let at = this.room(src.length);
+    return this.bytes.set(src, at), this;
+  }
+  slice() {
+    return this.bytes.slice(0, this.length);
+  }
+};
+function writeFilter(w, filter) {
+  w.u8(filter.length);
+  for (let clause of filter) {
+    w.u8(clause.length);
+    for (let p of clause) w.u8(p.field).u8(p.op).u32(p.value);
+  }
+}
+var EFFECT_CODE = {
+  transferShare: 0,
+  grant: 1,
+  grantRights: 2,
+  revokeRights: 3,
+  setStatus: 4,
+  setFaith: 5,
+  adjustDevotion: 6,
+  modifyHazard: 7,
+  migrate: 8,
+  setOccupation: 9
+};
+function writeEffect(w, e) {
+  switch (w.u8(EFFECT_CODE[e.kind]), e.kind) {
+    case "transferShare":
+      w.u32(e.shareQ16).u8(e.to);
+      return;
+    case "grant":
+      w.u32(e.amount).u8(e.from);
+      return;
+    case "grantRights":
+    case "revokeRights":
+      w.u16(e.bits);
+      return;
+    case "setStatus":
+      w.u8(e.status);
+      return;
+    case "setFaith":
+      w.u8(e.faith);
+      return;
+    case "adjustDevotion":
+      w.u8(e.delta & 255);
+      return;
+    case "modifyHazard":
+      w.u32(e.mortalityQ16).u32(e.fertilityQ16);
+      return;
+    case "migrate":
+      w.u16(e.to);
+      return;
+    case "setOccupation":
+      w.u8(e.occupation);
+      return;
+  }
+}
+function writeConstitution(w, c) {
+  w.u16(c.polity).u8(c.government).u8(c.property).u16(c.rights), w.u8(c.offices.length);
+  for (let o of c.offices) w.u32(o.name).u8(o.seats).u8(o.selection).u8(o.termYears);
+  w.u8(c.rules.length);
+  for (let r of c.rules)
+    w.u16(r.id).u8(r.trigger).u8(r.priority), writeFilter(w, r.filter), writeEffect(w, r.effect);
+}
+function writeNature(w, n) {
+  w.u32(n.radiusM).u32(n.gravityMmS2).u32(n.daySeconds).u32(n.yearDays).i32(n.tiltMdeg).u16(n.eccentricityPermille).u8(n.moons).u16(n.seaLevelPermille).u32(n.recipe), w.u32(n.physicalScalePermille).u32(n.historyDaysPerSecondMilli), w.u32(n.airDensityGM3).u32(n.scaleHeightM).u32(n.rayleighPerMm[0]).u32(n.rayleighPerMm[1]).u32(n.rayleighPerMm[2]).u32(n.miePerMm).u32(n.ozonePerMm).u8(n.breathable ? 1 : 0), w.u32(n.waterDensityKgM3).u32(n.viscosityMicroPaS).u32(n.freezeK10).u32(n.boilK10).u16(n.salinityPermille), w.u32(n.solarWM2).u32(n.greenhousePermille).u32(n.albedoPermille).u32(n.iceAlbedoPermille).u32(n.transportPermille).u32(n.precipitationPermille).u32(n.stormPermille).u32(n.seasonPermille), w.u8(n.species.length);
+  for (let s of n.species)
+    w.u8(s.lifespanYears).u8(s.maturityYears).u8(s.fertileEndYears).u8(s.gestationMonths).u8(s.litter), w.u16(s.fertilityPermille).u16(s.infantPermille).u16(s.adultPermille).u8(s.senescenceDoublingYears).u32(s.foodPerMonth);
+  w.u8((n.conservativeMass ? 1 : 0) | (n.conservativeEnergy ? 2 : 0)), w.u64(n.createdEnergyPerTickJ).u64(n.gravityEnvelopeMmS2).u64(n.energyBudgetPerTickJ).u64(n.costBudgetUnits);
+}
+function writeTarget(w, t) {
+  switch (t.kind) {
+    case "world":
+      w.u8(0);
+      return;
+    case "settlement":
+      w.u8(1).u16(t.settlement);
+      return;
+    case "polity":
+      w.u8(2).u16(t.polity);
+      return;
+    case "faith":
+      w.u8(3).u8(t.faith);
+      return;
+    case "filter":
+      w.u8(4), writeFilter(w, t.filter);
+      return;
+    case "person":
+      w.u8(5).u32(t.person);
+      return;
+    case "births":
+      w.u8(6).u16(t.settlement).u32(t.count);
+      return;
+  }
+}
+var POWER_CODE = {
+  weather: 1,
+  terrain: 2,
+  bless: 3,
+  curse: 4,
+  disaster: 5,
+  plague: 6,
+  miracle: 7,
+  prophet: 8,
+  fate: 9,
+  found: 10,
+  law: 11,
+  nature: 12
+};
+function writePower(w, p) {
+  switch (w.u8(POWER_CODE[p.kind]), p.kind) {
+    case "weather":
+      w.u16(p.tempC10 & 65535).u16(p.rainPermille).u16(p.months);
+      return;
+    case "terrain":
+      w.u8(p.terrain).u16(p.radiusM).i32(p.depthCm);
+      return;
+    case "bless":
+    case "curse":
+      w.u32(p.mortalityQ16).u32(p.fertilityQ16).u16(p.months);
+      return;
+    case "disaster":
+      w.u8(p.disaster).u8(p.magnitude);
+      return;
+    case "plague":
+      w.u32(p.betaQ16).u32(p.lethalityQ16).u16(p.months);
+      return;
+    case "miracle":
+      w.u32(p.food).u8(p.devotion & 255);
+      return;
+    case "prophet":
+      w.u32(p.faithName).u64(p.values).u32(p.transmissibilityQ16);
+      return;
+    case "fate":
+      w.u16(p.gift).u8(p.faith).u16(p.destiny);
+      return;
+    case "found": {
+      let f = p.found;
+      w.u32(f.name).u16(f.polity).u8(f.culture).u64(f.address).i32(f.latMdeg).u16(f.elevationPermille).i32(f.xM).i32(f.zM).u32(f.land), w.u32(p.founders).u8(p.faith);
+      return;
+    }
+    case "law":
+      writeConstitution(w, p.constitution);
+      return;
+    case "nature":
+      writeNature(w, p.nature);
+      return;
+  }
+}
+function encodeDecree(d, w) {
+  return w.reset(), w.u32(0).u16(0).u32(0).u32(d.effectiveMonth ?? 0).u64(d.key ?? 0n), writeTarget(w, d.target), writePower(w, d.power), w.length;
+}
+function encodeReviewedLaw(polity, constitution, w, key = 0n) {
+  return w.reset(), w.u32(0).u16(0).u32(0).u32(0).u64(key), w.u8(2).u16(polity), w.u8(POWER_CODE.law).raw(constitution), w.length;
+}
+function percentQ16(percentTenths) {
+  return Math.floor(percentTenths * (65536) / 1e3);
+}
+function ratioQ16(ratio) {
+  return Math.floor(Math.round(ratio * 1e3) * (65536) / 1e3);
+}
+function yearOf(month) {
+  return Math.floor((month - (1536)) / (12));
+}
+
+// src/game/kit/genesis/engine.ts
+var GENESIS_EXPORT_NAMES = [
+  "engine_genesis_open",
+  "engine_genesis_load",
+  "engine_genesis_close",
+  "engine_genesis_step_months",
+  "engine_genesis_advance",
+  "engine_genesis_interest",
+  "engine_genesis_decree",
+  "engine_genesis_indicators",
+  "engine_genesis_settlements",
+  "engine_genesis_active",
+  "engine_genesis_save",
+  "engine_genesis_saved"
+], GENESIS_OPEN_WORDS = 6, GENESIS_INDICATOR_WORDS = 16 + (16) * 2, GENESIS_SETTLEMENT_WORDS = 8, GENESIS_ACTIVE_WORDS = 4, GENESIS_REFUSED = 65536, WORD = 4, ALIGN = 8, HALF = 4294967296, MAX_ROWS = 4096;
+function bindGenesisEngine(symbols, memory) {
+  for (let name of GENESIS_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return typeof symbols.engine_alloc != "function" || typeof symbols.engine_free != "function" ? null : { exports: symbols, memory };
+}
+var LocalGenesis = class _LocalGenesis {
+  constructor(engine, handle) {
+    this.writer = new ByteWriter();
+    this.engine = engine, this.handle = handle, this.scratchBytes = (4096) * (8) * (4), this.scratch = engine.exports.engine_alloc(this.scratchBytes, (8));
+  }
+  static open(engine, start) {
+    let e = engine.exports, desc = e.engine_alloc((6) * (4), (8)), words = new Uint32Array(engine.memory.buffer, desc, (6));
+    words[0] = Number(start.seed & 0xffffffffn), words[1] = Number(start.seed >> 32n & 0xffffffffn), words[2] = start.people ?? 0, words[3] = start.settlements ?? 0, words[4] = start.active ?? 0, words[5] = start.city === true ? 1 : 0;
+    let handle = e.engine_genesis_open(desc);
+    return e.engine_free(desc, (6) * (4), (8)), handle === 0 ? null : new _LocalGenesis(engine, handle);
+  }
+  stepMonths(months) {
+    return this.engine.exports.engine_genesis_step_months(this.handle, months);
+  }
+  advance(ticks) {
+    return this.engine.exports.engine_genesis_advance(this.handle, ticks);
+  }
+  interest(settlement, tier) {
+    return this.engine.exports.engine_genesis_interest(this.handle, settlement, tier) === 0;
+  }
+  decree(decree) {
+    let length = encodeDecree(decree, this.writer), e = this.engine.exports, pointer = e.engine_alloc(length, (8));
+    new Uint8Array(this.engine.memory.buffer, pointer, length).set(this.writer.bytes.subarray(0, length));
+    let result = e.engine_genesis_decree(this.handle, pointer, length);
+    return e.engine_free(pointer, length, (8)), result;
+  }
+  indicators() {
+    this.engine.exports.engine_genesis_indicators(this.handle, this.scratch);
+    let w = new Uint32Array(this.engine.memory.buffer, this.scratch, GENESIS_INDICATOR_WORDS), faithPopulation = [];
+    for (let f = 0; f < (16); f++) faithPopulation.push(w[16 + f * 2] + w[17 + f * 2] * (4294967296));
+    return {
+      month: w[0],
+      population: w[1] + w[2] * (4294967296),
+      individuals: w[3],
+      births: w[4],
+      deaths: w[5],
+      conversions: w[6],
+      migrants: w[7],
+      fedPermille: w[8],
+      faiths: w[10],
+      settlements: w[11],
+      active: w[12],
+      digest: BigInt(w[13]) | BigInt(w[14]) << 32n,
+      faithPopulation
+    };
+  }
+  settlements(from = 0, max = (4096)) {
+    let count = this.engine.exports.engine_genesis_settlements(this.handle, from, this.scratch, Math.min(max, (4096)));
+    return new Uint32Array(this.engine.memory.buffer, this.scratch, Math.max(0, count) * (8)).slice();
+  }
+  active(max = (4096) * 2) {
+    let rows = Math.min(max, this.scratchBytes / (4) / (4) | 0), count = this.engine.exports.engine_genesis_active(this.handle, this.scratch, rows);
+    return new Uint32Array(this.engine.memory.buffer, this.scratch, Math.max(0, count) * (4)).slice();
+  }
+  save() {
+    let e = this.engine.exports, length = e.engine_genesis_save(this.handle);
+    return length <= 0 ? new Uint8Array(0) : new Uint8Array(this.engine.memory.buffer, e.engine_genesis_saved(this.handle), length).slice();
+  }
+  close() {
+    this.handle !== 0 && (this.engine.exports.engine_genesis_close(this.handle), this.engine.exports.engine_free(this.scratch, this.scratchBytes, (8)), this.handle = 0);
+  }
+};
+
+export { ACTION, BLESSED, ByteWriter, CURSED, DECREE_REFUSALS, DECREE_REFUSAL_BASE, DEFAULT_NATURE, DESTINY, DISASTER, ENVELOPE, FACT_KINDS, FIELD, FORECAST_FAILED, FRAME, GENESIS_ACTIVE_WORDS, GENESIS_CHANNEL_SLOT, GENESIS_EXPORT_NAMES, GENESIS_INDICATOR_WORDS, GENESIS_OPEN_WORDS, GENESIS_REFUSED, GENESIS_SETTLEMENT_WORDS, GIFTED, GOVERNMENT, HUMAN, LocalGenesis, MAX_DECREE_BYTES, MAX_FAITHS, MONTHS_PER_YEAR, NONE, NO_FAITH, OP, PROPERTY, Q16, REFUSED_DRAFT, REFUSED_FULL, REFUSED_MALFORMED, REFUSED_SEAT, RIGHT, RIGHTS_ALL, RUN_ID_BYTES, SELECTION, SINK, START_MONTH, TERRAIN, TIER, TRIGGER, bindGenesisEngine, encodeDecree, encodeReviewedLaw, percentQ16, ratioQ16, writeConstitution, writeNature, yearOf };

package/dist/chunk-TU5RYTYU.mjs

@@ -0,0 +1,13 @@
+import { QUANTISATION, FRAME_FLAGS, MAX_DATAGRAM_BYTES } from './chunk-SPCRQ6NO.mjs';
+
+// src/interactives/rooms/constants.ts
+var SNAPSHOT_STREAM_SLOT = 65535, MOVE_APPLIED_SLOT = 65534, MOVE_DURABLE_SLOT = 65533, COMMAND_DURABLE_SLOT = 65532, WATCHER_SLOT = 65535, CAMERA_ACTION = 65535, ROOM_LAYER = 0, Lane = {
+  Datagram: 0,
+  Reliable: 1
+}, JOIN_VERSION = 1, JOIN_VERSION_DELTA = 2, JOIN_TICKET = 1, JOIN_RESUME = 2, JOIN_HEADER_BYTES = 4, JOIN_REPLY_BYTES = 36, RESUME_TOKEN_BYTES = 16, LANE_LENGTH_BYTES = 2, MAX_JOIN_BYTES = 2048, PACKET_BYTES = MAX_DATAGRAM_BYTES, OUTBOUND_POOL_SLOTS = 16, INBOUND_POOL_SLOTS = 64, STREAM_BUFFER_BYTES = 8192, ENTITY_CAPACITY = 128, SNAPSHOT_RING = 32, SEEN_TICKS = 64, ACK_HISTORY_BITS = 32, SPECTATOR_ACK_EVERY = 4, APPLIED_RING = 16, SHORT_TICK_MASK = 65535, U32_RANGE = 4294967296, U16_RANGE = 65536, INPUT_LOG_CAPACITY = 256, MAX_INPUTS_PER_PACKET = 32, INPUT_BUFFER_TARGET = 2, SUBTICKS_PER_TICK = 256, MAX_SUBTICK = (256) - 1, TIMING_BUFFERED_MASK = 255, TIMING_PACE_SHIFT = 8, TIMING_TICK_SHIFT = 16, Pace = {
+  Steady: 0,
+  Faster: 1,
+  Slower: 2
+}, PACE_FASTER_SCALE = 0.95, PACE_SLOWER_SCALE = 1.05, MAX_CATCH_UP_TICKS = 5, MS_PER_SECOND = 1e3, NANOS_PER_SECOND = 1e9, DEFAULT_SUBSTEPS = 2, RTT_WINDOW = 16, RTT_SMOOTHING = 0.125, OFFSET_WINDOW = 64, JITTER_SMOOTHING = 0.0625, JITTER_MULTIPLIER = 2, INTERPOLATION_SEND_INTERVALS = 2, DELAY_SMOOTHING = 0.1, MAX_INTERPOLATION_DELAY_MS = 400, EXTRAPOLATION_CAP_MS = 250, HIGH_LATENCY_ENTER_MS = 220, HIGH_LATENCY_LEAVE_MS = 200, SMOOTHING_TIME_CONSTANT_MS = 100, SETTLED_OFFSET_UNITS = 0.5, REMOTE_HISTORY = 32, FALLBACK_AFTER_MS = 1500, CONNECT_TIMEOUT_MS = 1e4, RETRY_AFTER_MS = 2e3, RESUME_GRACE_MS = 3e4, NETWORK_MEMORY_TTL_MS = 864e5, NETWORK_MEMORY_PREFIX = "cimplify.rooms.transport.", DEFAULT_NETWORK = "default", CAMERA_PAYLOAD_BYTES = 6, CAMERA_RESEND_MS = 500, MAX_SEND_STRIDE = (32) / 4, SEND_RECOVER_MS = 250, CELL_MAX_UNITS = 65535, SPAWN_ORIGIN_UNITS = 32767, SPAWN_SPACING_UNITS = 512, SPAWN_ROW = 16, AXIS_LIMIT = QUANTISATION.axis_scale, VELOCITY_FRACTION = 1 << 24, WALK_UNITS_PER_SECOND = 6 * QUANTISATION.position_units_per_metre, SPRINT_UNITS_PER_SECOND = 10 * QUANTISATION.position_units_per_metre, BUTTON_SPRINT = FRAME_FLAGS.move_input.sprint, KEYFRAME_FLAG = FRAME_FLAGS.presence_tick.keyframe, YAW_UNITS_PER_TURN = QUANTISATION.yaw_units_per_turn, HALF_YAW_UNITS = YAW_UNITS_PER_TURN / 2;
+
+export { ACK_HISTORY_BITS, APPLIED_RING, AXIS_LIMIT, BUTTON_SPRINT, CAMERA_ACTION, CAMERA_PAYLOAD_BYTES, CAMERA_RESEND_MS, CELL_MAX_UNITS, COMMAND_DURABLE_SLOT, CONNECT_TIMEOUT_MS, DEFAULT_NETWORK, DEFAULT_SUBSTEPS, DELAY_SMOOTHING, ENTITY_CAPACITY, EXTRAPOLATION_CAP_MS, FALLBACK_AFTER_MS, HALF_YAW_UNITS, HIGH_LATENCY_ENTER_MS, HIGH_LATENCY_LEAVE_MS, INBOUND_POOL_SLOTS, INPUT_BUFFER_TARGET, INPUT_LOG_CAPACITY, INTERPOLATION_SEND_INTERVALS, JITTER_MULTIPLIER, JITTER_SMOOTHING, JOIN_HEADER_BYTES, JOIN_REPLY_BYTES, JOIN_RESUME, JOIN_TICKET, JOIN_VERSION, JOIN_VERSION_DELTA, KEYFRAME_FLAG, LANE_LENGTH_BYTES, Lane, MAX_CATCH_UP_TICKS, MAX_INPUTS_PER_PACKET, MAX_INTERPOLATION_DELAY_MS, MAX_JOIN_BYTES, MAX_SEND_STRIDE, MAX_SUBTICK, MOVE_APPLIED_SLOT, MOVE_DURABLE_SLOT, MS_PER_SECOND, NANOS_PER_SECOND, NETWORK_MEMORY_PREFIX, NETWORK_MEMORY_TTL_MS, OFFSET_WINDOW, OUTBOUND_POOL_SLOTS, PACE_FASTER_SCALE, PACE_SLOWER_SCALE, PACKET_BYTES, Pace, REMOTE_HISTORY, RESUME_GRACE_MS, RESUME_TOKEN_BYTES, RETRY_AFTER_MS, ROOM_LAYER, RTT_SMOOTHING, RTT_WINDOW, SEEN_TICKS, SEND_RECOVER_MS, SETTLED_OFFSET_UNITS, SHORT_TICK_MASK, SMOOTHING_TIME_CONSTANT_MS, SNAPSHOT_RING, SNAPSHOT_STREAM_SLOT, SPAWN_ORIGIN_UNITS, SPAWN_ROW, SPAWN_SPACING_UNITS, SPECTATOR_ACK_EVERY, SPRINT_UNITS_PER_SECOND, STREAM_BUFFER_BYTES, SUBTICKS_PER_TICK, TIMING_BUFFERED_MASK, TIMING_PACE_SHIFT, TIMING_TICK_SHIFT, U16_RANGE, U32_RANGE, VELOCITY_FRACTION, WALK_UNITS_PER_SECOND, WATCHER_SLOT, YAW_UNITS_PER_TURN };