@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-J6KQZ4FO.mjs

@@ -0,0 +1,821 @@
+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 { runIdFromHex, runIdFromAiRun, regionKey, regionFromBigInt, materialItem, isInvention, inventionItem, encodeCommand, actionOf, TRAIT, RUN_ID_BYTES, PROCESS, PATHOGEN, NO_ITEM, NO_INVENTION, MAX_COMMAND_BYTES, INVENTION_FLAG, FRONTIER_CHANNEL_SLOT, CommandWriter, COMPARE, CHANNEL, AI_RUN_PREFIX, AI_RUN_BYTES, ACTION } from './chunk-X6CN6KQF.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/game/kit/frontier/invent.ts
+var INVENT_PROMPT = "frontier_invent", INVENT_SCHEMA = "frontier_invention", MAX_KNOWN_CHARS = 200, MAX_NAME_CHARS = 32, MAX_INGREDIENTS = 6, MAX_STEPS = 4, MAX_BEHAVIOURS = 6, MAX_QUANTITY = 999, MAX_PARAM = 4294967295, MAX_STEP_VALUE = 65535, MAX_MATERIAL_CHARS = 48, VERBS = [
+  "store",
+  "generate",
+  "solar",
+  "battery",
+  "heat",
+  "press",
+  "cut",
+  "grind",
+  "combine",
+  "mine",
+  "pump",
+  "irrigate",
+  "fertilise",
+  "harvest",
+  "grow_boost",
+  "transport",
+  "light",
+  "sense",
+  "logic",
+  "vehicle",
+  "shelter",
+  "feed",
+  "survey",
+  "spin"
+], KINDS = ["tool", "machine", "structure", "consumable"], PROCESSES = ["heat", "press", "cut", "grind", "combine", "spin"], INVENTION_SCHEMA = {
+  title: INVENT_SCHEMA,
+  type: "object",
+  additionalProperties: false,
+  required: ["name", "kind", "ingredients", "behaviours"],
+  properties: {
+    name: { type: "string", minLength: 1, maxLength: (32) },
+    kind: { enum: KINDS },
+    ingredients: {
+      type: "array",
+      minItems: 1,
+      maxItems: (6),
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["quantity"],
+        properties: {
+          material: { type: "string", maxLength: (48) },
+          invention: { type: "string", maxLength: (32) },
+          family: { type: "boolean" },
+          quantity: { type: "integer", minimum: 1, maximum: (999) }
+        }
+      }
+    },
+    steps: {
+      type: "array",
+      maxItems: (4),
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["process"],
+        properties: {
+          process: { enum: PROCESSES },
+          value: { type: "integer", minimum: 0, maximum: (65535) }
+        }
+      }
+    },
+    behaviours: {
+      type: "array",
+      minItems: 1,
+      maxItems: (6),
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["verb"],
+        properties: {
+          verb: { enum: VERBS },
+          a: { type: "integer", minimum: 0, maximum: (4294967295) },
+          b: { type: "integer", minimum: 0, maximum: (4294967295) }
+        }
+      }
+    },
+    claims: { type: "object", additionalProperties: { type: "integer", minimum: 0, maximum: (65535) } }
+  }
+}, INVENT_TEMPLATE = "You design one invention for a survival planet game from the player's description that follows. Known materials: {{materials}}. Known techs: {{techs}}. Answer only with the frontier_invention structure, using only known materials, at most six ingredients and six behaviours from the verb list. Behaviour parameters: heat a = kelvin and b = 1 when it burns its own fuel; press a = MPa; cut and mine a = hardness in Mohs times 100, mine b = depth in metres; generate a = watts and b = efficiency per mille; solar a = watts; battery a = kilojoules; store a = slots; transport a = items per minute; pump a = litres per minute; irrigate, harvest, feed and light a = radius in metres; grow_boost a = per mille boost and b = radius; vehicle a = centimetres per second; survey a = range and b = depth in metres. Never describe weapons, harm to players, money or anything outside the game world.", 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(", ")} }`;
+}
+var AI_CAPABILITY = "Describe an invention and the planet's rules decide whether it works";
+function frontierAiToml() {
+  return `[capabilities]
+ai = ${JSON.stringify(AI_CAPABILITY)}
+
+${frontierAiSection()}`;
+}
+function frontierAiSection() {
+  return `[ai]
+payer = "creator"
+languages = ["en"]
+per_player_daily_units = 20000
+per_session_units = 10000
+per_interactive_monthly_units = 2000000
+
+[[ai.prompts]]
+name = "${INVENT_PROMPT}"
+template = ${JSON.stringify(INVENT_TEMPLATE)}
+output = "structured"
+schema = "${INVENT_SCHEMA}"
+quality = "standard"
+cache = "none"
+player_text = true
+
+[[ai.prompts.slots]]
+name = "materials"
+kind = "text"
+max_chars = ${(200)}
+
+[[ai.prompts.slots]]
+name = "techs"
+kind = "text"
+max_chars = ${(200)}
+
+[[ai.schemas]]
+name = "${INVENT_SCHEMA}"
+schema = ${toml(INVENTION_SCHEMA)}
+`;
+}
+function clip(text, max) {
+  return text.length <= max ? text : text.slice(0, max);
+}
+function inventionRequest(request) {
+  return {
+    audience: { kind: "requester" },
+    output: { kind: "structured", schema: INVENT_SCHEMA },
+    player_text: request.description.trim(),
+    prompt: INVENT_PROMPT,
+    request_key: request.requestKey,
+    slots: [
+      { kind: "text", name: "materials", value: clip(request.materials.join(", "), (200)) },
+      { kind: "text", name: "techs", value: clip(request.techs.join(", "), (200)) }
+    ],
+    stream: false,
+    variant: 0
+  };
+}
+async function requestInvention(ai, request) {
+  let run = await ai.generate(inventionRequest(request)), id = runIdFromAiRun(run.run_id);
+  if (id === null) throw new RangeError(`unexpected ai run id ${run.run_id}`);
+  return id;
+}
+
+// src/game/kit/frontier/chemistry.ts
+var CHEMISTRY_PROMPT = "frontier_chemistry", CHEMISTRY_SCHEMA_NAME = "frontier_chemistry", MAX_CHEMISTRY_NAME = 32, MAX_TERMS = 4, MAX_COUNT = 16, MAX_KELVIN = 8e3, MAX_ENTHALPY = 4e6, MAX_LATENT = 2e6, MAX_HEAT_CAPACITY = 400, MAX_DENSITY = 3e4, MAX_ACTIVATION = 1e6, MAX_RATE_MILLI = 1e6, MAX_GROUPS = 8, MAX_GROUP_CHARS = 16, MAX_HARDNESS = 1e3, CHEMISTRY_GROUPS = [
+  "fuel",
+  "oxidiser",
+  "acid",
+  "base",
+  "metal",
+  "salt",
+  "ore",
+  "oxide",
+  "organic",
+  "aqueous",
+  "powder",
+  "catalyst",
+  "explosive",
+  "inert",
+  "solvent",
+  "carbonate",
+  "polymer",
+  "sugar",
+  "living",
+  "reducer",
+  "toxic",
+  "mineral",
+  "atmosphere",
+  "custom"
+], KELVIN = { type: "integer", minimum: 0, maximum: (8e3) }, NAME = { type: "string", minLength: 1, maxLength: (32) }, TERM = {
+  type: "object",
+  additionalProperties: false,
+  required: ["species"],
+  properties: {
+    species: NAME,
+    count: { type: "integer", minimum: 1, maximum: (16) },
+    phases: { type: "string", pattern: "^[slg]{1,3}$" }
+  }
+}, CHEMISTRY_SCHEMA = {
+  title: CHEMISTRY_SCHEMA_NAME,
+  type: "object",
+  additionalProperties: false,
+  required: ["kind", "name"],
+  properties: {
+    kind: { enum: ["species", "reaction"] },
+    name: NAME,
+    formula: { type: "string", maxLength: (32) },
+    formation_enthalpy_j_per_mol: { type: "integer", minimum: -(4e6), maximum: (4e6) },
+    melt_k: KELVIN,
+    melt_latent_j_per_mol: { type: "integer", minimum: 0, maximum: (2e6) },
+    boil_k: KELVIN,
+    boil_latent_j_per_mol: { type: "integer", minimum: 0, maximum: (2e6) },
+    heat_capacity_j_per_mol_k: { type: "array", minItems: 3, maxItems: 3, items: { type: "integer", minimum: 1, maximum: (400) } },
+    density_kg_m3: { type: "array", minItems: 2, maxItems: 2, items: { type: "integer", minimum: 1, maximum: (3e4) } },
+    groups: { type: "array", maxItems: (8), items: { enum: CHEMISTRY_GROUPS } },
+    ignition_k: KELVIN,
+    hardness: { type: "integer", minimum: 0, maximum: (1e3) },
+    reactants: { type: "array", maxItems: (4), items: TERM },
+    products: { type: "array", maxItems: (4), items: TERM },
+    activation_j_per_mol: { type: "integer", minimum: 0, maximum: (1e6) },
+    rate_at_k: { type: "integer", minimum: 1, maximum: (8e3) },
+    rate_per_second_milli: { type: "integer", minimum: 1, maximum: (1e6) },
+    above_k: KELVIN,
+    below_k: KELVIN,
+    catalyst: { type: "string", maxLength: (32) },
+    reaction_enthalpy_j: { type: "integer", minimum: -(4e6), maximum: (4e6) }
+  }
+}, CHEMISTRY_TEMPLATE = "You define one new substance or one new reaction for a planet game from the player's description that follows. Known substances: {{substances}}. Answer only with the frontier_chemistry structure. A species needs a chemical formula with real elements, a formation enthalpy in joules per mole, melting and boiling points in kelvin with latent heats, heat capacities for solid, liquid and gas, and densities. A reaction lists at most four reactants and four products by known substance names; atoms must balance and the energy must follow the formation enthalpies. Never describe weapons, harm to players, money or anything outside the game world.", BARE_KEY2 = /^[A-Za-z0-9_-]+$/;
+function toml2(value) {
+  return typeof value == "string" ? JSON.stringify(value) : typeof value == "number" || typeof value == "boolean" ? String(value) : Array.isArray(value) ? `[${value.map(toml2).join(", ")}]` : `{ ${Object.entries(value).map(([k, v]) => `${BARE_KEY2.test(k) ? k : JSON.stringify(k)} = ${toml2(v)}`).join(", ")} }`;
+}
+function frontierChemistryAiSection() {
+  return `[[ai.prompts]]
+name = "${CHEMISTRY_PROMPT}"
+template = ${JSON.stringify(CHEMISTRY_TEMPLATE)}
+output = "structured"
+schema = "${CHEMISTRY_SCHEMA_NAME}"
+quality = "standard"
+cache = "none"
+player_text = true
+
+[[ai.prompts.slots]]
+name = "substances"
+kind = "text"
+max_chars = ${(200)}
+
+[[ai.schemas]]
+name = "${CHEMISTRY_SCHEMA_NAME}"
+schema = ${toml2(CHEMISTRY_SCHEMA)}
+`;
+}
+function chemistryRequest(request) {
+  let known = request.substances.join(", ");
+  return {
+    audience: { kind: "requester" },
+    output: { kind: "structured", schema: CHEMISTRY_SCHEMA_NAME },
+    player_text: request.description.trim(),
+    prompt: CHEMISTRY_PROMPT,
+    request_key: request.requestKey,
+    slots: [{ kind: "text", name: "substances", value: known.length <= (200) ? known : known.slice(0, (200)) }],
+    stream: false,
+    variant: 0
+  };
+}
+async function requestChemistry(ai, request) {
+  let run = await ai.generate(chemistryRequest(request)), id = runIdFromAiRun(run.run_id);
+  if (id === null) throw new RangeError(`unexpected ai run id ${run.run_id}`);
+  return id;
+}
+
+// src/game/kit/frontier/link.ts
+var FRAME_RING = 256, FRAME_BYTES = 1200, TickFrontierLink = class {
+  constructor(transport) {
+    this.frames = new Uint8Array((256) * (1200));
+    this.lengths = new Int32Array((256));
+    this.head = 0;
+    this.count = 0;
+    this.dropped = 0;
+    this.transport = transport, transport.tap(FRONTIER_CHANNEL_SLOT, (view, offset, length) => this.push(view, offset, length));
+  }
+  push(view, offset, length) {
+    if (this.count === (256) || length > (1200)) {
+      this.dropped++;
+      return;
+    }
+    let slot = (this.head + this.count) % (256), 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) % (256), this.count--, applied++;
+    return applied;
+  }
+  close() {
+    this.transport.tap(FRONTIER_CHANNEL_SLOT, null);
+  }
+}, ReplayFrontierLink = 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;
+  }
+}, FrontierCommands = class {
+  constructor(link) {
+    this.w = new CommandWriter();
+    this.link = link;
+  }
+  send(command) {
+    let length = encodeCommand(command, this.w);
+    this.link.command(actionOf(command), this.w.bytes, length);
+  }
+  survey(region, x, z, tool) {
+    this.w.reset().spot(region, x, z).u16(tool), this.flush(ACTION.survey);
+  }
+  gather(deposit, amount) {
+    this.w.reset().u32(deposit).u16(amount), this.flush(ACTION.gather);
+  }
+  place(invention, region, x, z) {
+    this.w.reset().u16(invention).spot(region, x, z), this.flush(ACTION.place);
+  }
+  craft(invention, count) {
+    this.w.reset().u16(invention).u16(count), this.flush(ACTION.craft);
+  }
+  learn(invention) {
+    this.w.reset().u16(invention), this.flush(ACTION.learn);
+  }
+  insert(machine, lane, slot, count) {
+    this.w.reset().u32(machine).u8(lane).u8(slot).u16(count), this.flush(ACTION.insert);
+  }
+  take(machine, count) {
+    this.w.reset().u32(machine).u16(count), this.flush(ACTION.take);
+  }
+  till(region, x, z) {
+    this.w.reset().spot(region, x, z), this.flush(ACTION.till);
+  }
+  harvest(plot) {
+    this.w.reset().u32(plot), this.flush(ACTION.harvest);
+  }
+  charge(machine, slot, count) {
+    this.w.reset().u32(machine).u8(slot).u16(count), this.flush(ACTION.charge);
+  }
+  discharge(machine, material, count) {
+    this.w.reset().u32(machine).u16(material).u16(count), this.flush(ACTION.discharge);
+  }
+  vaccinate(herd, pathogen) {
+    this.w.reset().u32(herd).u8(pathogen), this.flush(ACTION.vaccinate);
+  }
+  breed(herd, trait, upward) {
+    this.w.reset().u32(herd).u8(trait).u8(upward ? 1 : 0), this.flush(ACTION.breed);
+  }
+  chemistry(run) {
+    this.w.reset().run(run), this.flush(ACTION.chemistrySubmit);
+  }
+  invent(run) {
+    this.w.reset().run(run), this.flush(ACTION.inventSubmit);
+  }
+  flush(action) {
+    this.link.command(action, this.w.bytes, this.w.length);
+  }
+};
+
+// src/game/kit/frontier/mirror.ts
+var FRAME_MAGIC = 245, FRAME_VERSION = 1, HEADER_BYTES = 9, LAYER = { machines: 1, deposits: 2, plots: 3, herds: 4, inventory: 5, events: 6, herdHealth: 7, plotHealth: 8, reactors: 9 }, HEALTH_FIELDS = 5, HERD_HEALTH = { sick: 0, immune: 1, resistance: 2, fertility: 3, yield: 4 }, PLOT_HEALTH = { blight: 0, immune: 1, growth: 2, yield: 3, drought: 4 }, REACTOR_SLOTS = 8, REACTOR_FIELDS = 3 + (8) * 2, REACTOR = { machine: 0, kelvin: 1, slots: 2, contents: 3 }, FIELD = { placement: 1, laneA: 2, laneB: 4, out: 8, progress: 16, signal: 32 }, MACHINE_FLAG = { alive: 1, enabled: 2, working: 4, logicOff: 8, starved: 16, blocked: 32, unpowered: 64 }, EVENT = {
+  refused: 1,
+  techDiscovered: 2,
+  inventionAccepted: 3,
+  inventionRejected: 4,
+  surveyHit: 5,
+  materialDerived: 6,
+  produced: 7,
+  inventionRequested: 8,
+  chemistryRequested: 9,
+  chemistryAccepted: 10,
+  chemistryRejected: 11
+}, LANES = 6, PLOT_FIELDS = 9, HERD_FIELDS = 11, EVENT_WORDS = 6, EVENT_KIND = 0, EVENT_PLAYER = 1, EVENT_A = 2, EVENT_B = 3, EVENT_C_LOW = 4, EVENT_C_HIGH = 5, MIRROR_EVENTS = 256, PLOT = { region: 0, x: 1, z: 2, crop: 3, stage: 4, health: 5, moisture: 6, fertility: 7, plants: 8 }, HERD = { species: 0, region: 1, x: 2, z: 3, females: 4, males: 5, young: 6, hunger: 7, thirst: 8, produce: 9, owner: 10 }, SLOT_FIELDS = 3, LANE_BITS = [FIELD.laneA, FIELD.laneB, FIELD.out], NO_CODE = 0, CODE_BASE = 2, CODE_INVENTION = 1, INVENTION_FLAG2 = 2147483648, VARINT_MORE = 128, VARINT_MASK = 127, VARINT_SHIFT = 7, MAX_SHIFT = 64, LOW_BITS = 32, TWO_POW_32 = 4294967296, INITIAL_ROWS = 64, GROWTH = 2, FNV_OFFSET = 0xcbf29ce484222325n, FNV_PRIME = 0x100000001b3n, U64 = 0xffffffffffffffffn, U32_MASK = 0xffffffffn;
+function itemFromCode(code) {
+  if (code === (0)) return NO_ITEM;
+  let index = code - (2) >>> 1;
+  return (code & (1)) === 0 ? index : ((2147483648) | index) >>> 0;
+}
+var Reader = class {
+  constructor() {
+    this.bytes = new Uint8Array(0);
+    this.at = 0;
+    this.end = 0;
+    this.low = 0;
+    this.high = 0;
+  }
+  byte() {
+    if (this.at >= this.end) throw new RangeError("frontier frame ends early");
+    return this.bytes[this.at++];
+  }
+  wide() {
+    let low = 0, high = 0, shift = 0;
+    for (; ; ) {
+      let b = this.byte(), bits = b & (127);
+      if (shift < (32) ? (low = (low | bits << shift) >>> 0, shift + (7) > (32) && (high = (high | bits >>> (32) - shift) >>> 0)) : high = (high | bits << shift - (32)) >>> 0, (b & (128)) === 0) break;
+      if (shift += (7), shift >= (64)) throw new RangeError("frontier varint too long");
+    }
+    this.low = low, this.high = high;
+  }
+  varint() {
+    return this.wide(), this.high * (4294967296) + this.low;
+  }
+  zigzag() {
+    return this.wide(), this.low >>> 1 ^ -(this.low & 1);
+  }
+};
+function grow(array, rows, stride, make) {
+  if (array.length >= rows * stride) return array;
+  let capacity = Math.max((64), array.length / stride);
+  for (; capacity < rows; ) capacity *= (2);
+  let next = make(capacity * stride);
+  return next.set(array), next;
+}
+var FrontierMirror = class {
+  constructor() {
+    this.tick = 0;
+    this.machines = 0;
+    this.deposits = 0;
+    this.plotCount = 0;
+    this.herdCount = 0;
+    this.players = 0;
+    this.machineSpec = new Uint32Array((64));
+    this.machineFlags = new Uint8Array((64));
+    this.machineRegion = new Uint32Array((64));
+    this.machineX = new Uint32Array((64));
+    this.machineZ = new Uint32Array((64));
+    this.machineOwner = new Uint32Array((64));
+    this.machineLanes = new Uint32Array((64) * (6));
+    this.machineProgress = new Uint8Array((64));
+    this.machineSignal = new Int32Array((64));
+    this.depositAmount = new Float64Array((64));
+    this.plots = new Uint32Array((64) * (9));
+    this.herds = new Uint32Array((64) * (11));
+    this.techs = [];
+    this.inventory = [];
+    this.inventoryUsed = [];
+    this.herdHealthCount = 0;
+    this.plotHealthCount = 0;
+    this.reactorCount = 0;
+    this.herdHealth = new Uint32Array((64) * (5));
+    this.plotHealth = new Uint32Array((64) * (5));
+    this.reactors = new Uint32Array((64) * REACTOR_FIELDS);
+    this.events = new Uint32Array((256) * (6));
+    this.eventHead = 0;
+    this.eventCount = 0;
+    this.eventsSeen = 0;
+    this.reader = new Reader();
+  }
+  apply(frame, offset = 0, length = frame.length - offset) {
+    if (length < (9) || frame[offset] !== (245) || frame[offset + 1] !== (1))
+      throw new RangeError("not a frontier frame");
+    let layer = frame[offset + 2];
+    this.tick = (frame[offset + 3] | frame[offset + 4] << 8 | frame[offset + 5] << 16 | frame[offset + 6] << 24) >>> 0;
+    let rows = frame[offset + 7] | frame[offset + 8] << 8, r = this.reader;
+    r.bytes = frame, r.at = offset + (9), r.end = offset + length;
+    let index = -1;
+    for (let k = 0; k < rows; k++) {
+      let delta = r.varint();
+      switch (index = index < 0 ? delta : index + 1 + delta, layer) {
+        case LAYER.machines:
+          this.machine(index);
+          break;
+        case LAYER.deposits:
+          this.ensureDeposits(index + 1), this.depositAmount[index] = r.varint(), r.varint();
+          break;
+        case LAYER.plots:
+          this.plot(index);
+          break;
+        case LAYER.herds:
+          this.herd(index);
+          break;
+        case LAYER.inventory:
+          this.slots(index);
+          break;
+        case LAYER.events:
+          this.pushEvent();
+          break;
+        case LAYER.herdHealth:
+          index + 1 > this.herdHealthCount && (this.herdHealth = grow(this.herdHealth, index + 1, (5), (n) => new Uint32Array(n)), this.herdHealthCount = index + 1);
+          for (let f = 0; f < (5); f++) this.herdHealth[index * (5) + f] = r.varint();
+          break;
+        case LAYER.plotHealth:
+          index + 1 > this.plotHealthCount && (this.plotHealth = grow(this.plotHealth, index + 1, (5), (n) => new Uint32Array(n)), this.plotHealthCount = index + 1);
+          for (let f = 0; f < (5); f++) this.plotHealth[index * (5) + f] = r.varint();
+          break;
+        case LAYER.reactors:
+          this.reactor(index);
+          break;
+        default:
+          throw new RangeError(`unknown frontier layer ${layer}`);
+      }
+    }
+    if (r.at !== r.end) throw new RangeError("frontier frame has trailing bytes");
+  }
+  ensureMachines(rows) {
+    rows <= this.machines || (this.machineSpec = grow(this.machineSpec, rows, 1, (n) => new Uint32Array(n)), this.machineFlags = grow(this.machineFlags, rows, 1, (n) => new Uint8Array(n)), this.machineRegion = grow(this.machineRegion, rows, 1, (n) => new Uint32Array(n)), this.machineX = grow(this.machineX, rows, 1, (n) => new Uint32Array(n)), this.machineZ = grow(this.machineZ, rows, 1, (n) => new Uint32Array(n)), this.machineOwner = grow(this.machineOwner, rows, 1, (n) => new Uint32Array(n)), this.machineLanes = grow(this.machineLanes, rows, (6), (n) => new Uint32Array(n)), this.machineProgress = grow(this.machineProgress, rows, 1, (n) => new Uint8Array(n)), this.machineSignal = grow(this.machineSignal, rows, 1, (n) => new Int32Array(n)), this.machines = rows);
+  }
+  ensureDeposits(rows) {
+    rows <= this.deposits || (this.depositAmount = grow(this.depositAmount, rows, 1, (n) => new Float64Array(n)), this.deposits = rows);
+  }
+  machine(i) {
+    let r = this.reader;
+    this.ensureMachines(i + 1);
+    let mask = r.byte();
+    this.machineFlags[i] = r.byte(), (mask & FIELD.placement) !== 0 && (this.machineSpec[i] = r.varint(), this.machineRegion[i] = r.varint(), this.machineX[i] = r.varint(), this.machineZ[i] = r.varint(), this.machineOwner[i] = r.varint());
+    let base = i * (6);
+    for (let k = 0; k < LANE_BITS.length; k++)
+      (mask & LANE_BITS[k]) !== 0 ? (this.machineLanes[base + k * 2] = itemFromCode(r.varint()), this.machineLanes[base + k * 2 + 1] = r.varint()) : (this.machineLanes[base + k * 2] = NO_ITEM, this.machineLanes[base + k * 2 + 1] = 0);
+    this.machineProgress[i] = (mask & FIELD.progress) !== 0 ? r.byte() : 0, this.machineSignal[i] = (mask & FIELD.signal) !== 0 ? r.zigzag() : 0;
+  }
+  plot(i) {
+    let r = this.reader;
+    i + 1 > this.plotCount && (this.plots = grow(this.plots, i + 1, (9), (n) => new Uint32Array(n)), this.plotCount = i + 1);
+    let base = i * (9);
+    this.plots[base + PLOT.region] = r.varint(), this.plots[base + PLOT.x] = r.varint(), this.plots[base + PLOT.z] = r.varint(), this.plots[base + PLOT.crop] = r.byte(), this.plots[base + PLOT.stage] = r.byte();
+    for (let f = PLOT.health; f < (9); f++) this.plots[base + f] = r.varint();
+  }
+  herd(i) {
+    let r = this.reader;
+    i + 1 > this.herdCount && (this.herds = grow(this.herds, i + 1, (11), (n) => new Uint32Array(n)), this.herdCount = i + 1);
+    let base = i * (11);
+    this.herds[base] = r.byte();
+    for (let f = 1; f < (11); f++) this.herds[base + f] = r.varint();
+  }
+  reactor(i) {
+    let r = this.reader;
+    i + 1 > this.reactorCount && (this.reactors = grow(this.reactors, i + 1, REACTOR_FIELDS, (n) => new Uint32Array(n)), this.reactorCount = i + 1);
+    let base = i * REACTOR_FIELDS;
+    this.reactors[base + REACTOR.machine] = r.varint(), this.reactors[base + REACTOR.kelvin] = r.varint();
+    let slots = r.byte();
+    if (slots > (8)) throw new RangeError("frontier reactor row has too many slots");
+    this.reactors[base + REACTOR.slots] = slots;
+    for (let k = 0; k < slots * 2; k++) this.reactors[base + REACTOR.contents + k] = r.varint();
+  }
+  herdHealthField(herd, field) {
+    return this.herdHealth[herd * (5) + field];
+  }
+  plotHealthField(plot, field) {
+    return this.plotHealth[plot * (5) + field];
+  }
+  reactorKelvin(reactor) {
+    return this.reactors[reactor * REACTOR_FIELDS + REACTOR.kelvin];
+  }
+  slots(player) {
+    let r = this.reader;
+    for (; this.inventory.length <= player; )
+      this.inventory.push(new Uint32Array(0)), this.inventoryUsed.push(0), this.techs.push(0n);
+    this.players = Math.max(this.players, player + 1), r.wide(), this.techs[player] = BigInt(r.high) << 32n | BigInt(r.low);
+    let used = r.byte(), slots = this.inventory[player];
+    slots.length < used * (3) && (slots = new Uint32Array(used * (3)), this.inventory[player] = slots);
+    for (let k = 0; k < used; k++)
+      slots[k * (3)] = r.byte(), slots[k * (3) + 1] = itemFromCode(r.varint()), slots[k * (3) + 2] = r.varint();
+    this.inventoryUsed[player] = used;
+  }
+  pushEvent() {
+    let r = this.reader, at = (this.eventHead + this.eventCount) % (256) * (6);
+    this.events[at + (0)] = r.byte(), this.events[at + (1)] = r.varint(), this.events[at + (2)] = r.varint(), this.events[at + (3)] = r.varint(), r.wide(), this.events[at + (4)] = r.low, this.events[at + (5)] = r.high, this.eventCount === (256) ? this.eventHead = (this.eventHead + 1) % (256) : this.eventCount++, this.eventsSeen++;
+  }
+  event(at, word) {
+    return this.events[(this.eventHead + at) % (256) * (6) + word];
+  }
+  machineLane(machine, lane) {
+    return this.machineLanes[machine * (6) + lane];
+  }
+  plotField(plot, field) {
+    return this.plots[plot * (9) + field];
+  }
+  herdField(herd, field) {
+    return this.herds[herd * (11) + field];
+  }
+  digest() {
+    let h = FNV_OFFSET, word = (value) => {
+      h = (h ^ value) * FNV_PRIME & U64;
+    }, words = (values, count) => {
+      for (let i = 0; i < count; i++) word(BigInt(values[i]));
+    };
+    word(BigInt(this.tick)), words(this.machineSpec, this.machines), words(this.machineFlags, this.machines), words(this.machineRegion, this.machines), words(this.machineX, this.machines), words(this.machineZ, this.machines), words(this.machineLanes, this.machines * (6)), words(this.machineProgress, this.machines);
+    for (let i = 0; i < this.machines; i++) word(BigInt(this.machineSignal[i]) & U32_MASK);
+    words(this.depositAmount, this.deposits), words(this.plots, this.plotCount * (9)), words(this.herds, this.herdCount * (11));
+    for (let p = 0; p < this.inventory.length; p++) {
+      word(BigInt(p));
+      let slots = this.inventory[p];
+      for (let k = 0; k < this.inventoryUsed[p] * (3); k++) word(BigInt(slots[k]));
+    }
+    for (let t of this.techs) word(t);
+    for (let e = 0; e < this.eventCount; e++) {
+      for (let f = (0); f <= (3); f++) word(BigInt(this.event(e, f)));
+      word(BigInt(this.event(e, (5))) << 32n | BigInt(this.event(e, (4))));
+    }
+    words(this.herdHealth, this.herdHealthCount * (5)), words(this.plotHealth, this.plotHealthCount * (5));
+    for (let i = 0; i < this.reactorCount; i++) {
+      let base = i * REACTOR_FIELDS;
+      word(BigInt(this.reactors[base + REACTOR.machine])), word(BigInt(this.reactors[base + REACTOR.kelvin]));
+      for (let k = 0; k < this.reactors[base + REACTOR.slots] * 2; k++) word(BigInt(this.reactors[base + REACTOR.contents + k]));
+    }
+    return h.toString(16).padStart(16, "0");
+  }
+};
+
+// src/game/kit/frontier/frontier.ts
+var REGION_METRES = 256, MAX_SURVEYED = 64, BOX_CAPACITY = 4096, SCALE = 0.25, CAMERA_HEIGHT = 40, CAMERA_BACK = 50, CAMERA_FOV = 55, CAMERA_PITCH = -0.8, GROUND_RGB = 4152874, MACHINE_IDLE_RGB = 7041664, MACHINE_WORKING_RGB = 16096779, MACHINE_STARVED_RGB = 10265519, PLOT_RGB = 8145438, CROP_RGB = 8702998, HERD_RGB = 16119284, DEPOSIT_RGB = 6333946, MACHINE_SIZE = 1.2, PLOT_SIZE = 2, STAGE_HEIGHT = 0.3, HERD_UNIT = 0.15, DEPOSIT_SIZE = 0.6, GATHER_AMOUNT = 20, SURVEY_KIND_MASK = 65535, SURVEY_X_SHIFT = 0, SURVEY_Z_SHIFT = 16, SLOT_TECHS = 0, SLOT_MACHINES = 1, SLOT_PLOTS = 2, SLOT_ANIMALS = 3, HALF = 0.5, PROGRESS_STEPS = 255, GROUND_HEIGHT = 0.2, PLOT_HEIGHT = 0.1, CROP_BASE = 0.05, FrontierPlanet = class {
+  constructor(options) {
+    this.name = "frontier-planet";
+    this.mirror = new FrontierMirror();
+    this.surveyed = new Uint32Array((64) * 3);
+    this.surveyedCount = 0;
+    this.framesApplied = 0;
+    this.techsKnown = 0;
+    this.hud = [];
+    this.boxes = null;
+    this.eventsRead = 0;
+    this.x = 0;
+    this.z = 0;
+    this.surveyAction = null;
+    this.gatherAction = null;
+    this.tillAction = null;
+    this.harvestAction = null;
+    this.inventAction = null;
+    this.options = options, this.commands = new FrontierCommands(options.link), this.x = options.spawn?.x ?? (256) / 2, this.z = options.spawn?.z ?? (256) / 2;
+  }
+  enter(game) {
+    addSceneCamera(game, 0, (40), (50), (55), (-0.8)), this.boxes = new BoxBatch(game, (4096)), this.hud[(0)] = game.ui.hudNumber("techs"), this.hud[(1)] = game.ui.hudNumber("machines"), this.hud[(2)] = game.ui.hudNumber("fields"), this.hud[(3)] = game.ui.hudNumber("animals"), this.surveyAction = game.input.defineButton("survey", [{ device: "key", code: "KeyQ" }, { device: "virtual", control: "survey" }]), this.gatherAction = game.input.defineButton("gather", [{ device: "key", code: "KeyG" }, { device: "virtual", control: "gather" }]), this.tillAction = game.input.defineButton("till", [{ device: "key", code: "KeyT" }, { device: "virtual", control: "till" }]), this.harvestAction = game.input.defineButton("harvest", [{ device: "key", code: "KeyH" }, { device: "virtual", control: "harvest" }]), this.inventAction = game.input.defineButton("invent", [{ device: "key", code: "KeyI" }, { device: "virtual", control: "invent" }]);
+  }
+  fixedUpdate(game) {
+    this.framesApplied += this.options.link.pump(this.mirror), this.readEvents();
+    let input = game.input, region = this.options.region;
+    if (this.surveyAction !== null && input.justPressed(this.surveyAction) && this.commands.survey(region, this.x, this.z, NO_INVENTION), this.gatherAction !== null && input.justPressed(this.gatherAction) && this.surveyedCount > 0 && this.commands.gather(this.surveyed[0], (20)), this.tillAction !== null && input.justPressed(this.tillAction) && this.commands.till(region, this.x, this.z), this.harvestAction !== null && input.justPressed(this.harvestAction))
+      for (let p = 0; p < this.mirror.plotCount; p++) this.commands.harvest(p);
+    this.inventAction !== null && input.justPressed(this.inventAction) && this.options.onInvent && this.options.onInvent();
+    let ui = game.ui;
+    ui.setNumber(this.hud[(0)], this.techsKnown), ui.setNumber(this.hud[(1)], this.aliveMachines()), ui.setNumber(this.hud[(2)], this.mirror.plotCount), ui.setNumber(this.hud[(3)], this.animals());
+  }
+  readEvents() {
+    let m = this.mirror, fresh = Math.min(m.eventsSeen - this.eventsRead, m.eventCount);
+    for (let e = m.eventCount - fresh; e < m.eventCount; e++) {
+      if (m.event(e, (1)) !== this.options.player) continue;
+      let kind = m.event(e, (0));
+      if (kind === EVENT.techDiscovered && this.techsKnown++, kind === EVENT.surveyHit && this.surveyedCount < (64)) {
+        let at = this.surveyedCount * 3;
+        this.surveyed[at] = m.event(e, (2)), this.surveyed[at + 1] = m.event(e, (5)) >>> (0) & (65535), this.surveyed[at + 2] = m.event(e, (5)) >>> (16) & (65535), this.surveyedCount++;
+      }
+    }
+    this.eventsRead = m.eventsSeen;
+  }
+  aliveMachines() {
+    let n = 0;
+    for (let i = 0; i < this.mirror.machines; i++) (this.mirror.machineFlags[i] & MACHINE_FLAG.alive) !== 0 && n++;
+    return n;
+  }
+  animals() {
+    let n = 0;
+    for (let h = 0; h < this.mirror.herdCount; h++)
+      n += this.mirror.herdField(h, HERD.females) + this.mirror.herdField(h, HERD.males) + this.mirror.herdField(h, HERD.young);
+    return n;
+  }
+  progress() {
+    return this.framesApplied + this.aliveMachines() + this.mirror.plotCount + this.techsKnown;
+  }
+  update(_game) {
+    let boxes = this.boxes;
+    if (boxes === null) return;
+    let b = boxes.box, m = this.mirror, half = (256) * (0.25) * (0.5);
+    boxes.begin(), b[BOX_X] = 0, b[BOX_Y] = -(0.2) * (0.5), b[BOX_Z] = 0, b[BOX_SX] = (256) * (0.25), b[BOX_SY] = (0.2), b[BOX_SZ] = (256) * (0.25), boxes.add((4152874));
+    for (let i = 0; i < m.machines; i++) {
+      let flags = m.machineFlags[i];
+      if ((flags & MACHINE_FLAG.alive) === 0) continue;
+      let rgb = (flags & MACHINE_FLAG.working) !== 0 ? (16096779) : (flags & MACHINE_FLAG.starved) !== 0 ? (10265519) : (7041664);
+      b[BOX_X] = m.machineX[i] * (0.25) - half, b[BOX_Y] = (1.2) * (0.5), b[BOX_Z] = m.machineZ[i] * (0.25) - half, b[BOX_SX] = (1.2), b[BOX_SY] = (1.2) * (1 + m.machineProgress[i] / (255)), b[BOX_SZ] = (1.2), boxes.add(rgb);
+    }
+    for (let p = 0; p < m.plotCount; p++) {
+      let stage = m.plotField(p, PLOT.stage);
+      b[BOX_X] = m.plotField(p, PLOT.x) * (0.25) - half, b[BOX_Y] = (0.1) * (0.5), b[BOX_Z] = m.plotField(p, PLOT.z) * (0.25) - half, b[BOX_SX] = (2), b[BOX_SY] = (0.1), b[BOX_SZ] = (2), boxes.add((8145438)), m.plotField(p, PLOT.plants) > 0 && (b[BOX_Y] = stage * (0.3) * (0.5) + (0.1), b[BOX_SX] = (2) * (0.5), b[BOX_SY] = stage * (0.3) + (0.05), b[BOX_SZ] = (2) * (0.5), boxes.add((8702998)));
+    }
+    for (let h = 0; h < m.herdCount; h++) {
+      let count = m.herdField(h, HERD.females) + m.herdField(h, HERD.males) + m.herdField(h, HERD.young);
+      if (count === 0) continue;
+      let size = (0.15) * Math.sqrt(count) + (0.15);
+      b[BOX_X] = m.herdField(h, HERD.x) * (0.25) - half, b[BOX_Y] = size * (0.5), b[BOX_Z] = m.herdField(h, HERD.z) * (0.25) - half, b[BOX_SX] = size, b[BOX_SY] = size, b[BOX_SZ] = size, boxes.add((16119284));
+    }
+    b[BOX_Y] = (0.6) * (0.5), b[BOX_SX] = (0.6), b[BOX_SY] = (0.6), b[BOX_SZ] = (0.6);
+    for (let s = 0; s < this.surveyedCount; s++)
+      b[BOX_X] = this.surveyed[s * 3 + 1] * (0.25) - half, b[BOX_Z] = this.surveyed[s * 3 + 2] * (0.25) - half, boxes.add((6333946));
+    boxes.end();
+  }
+  moveTo(x, z) {
+    this.x = x, this.z = z;
+  }
+};
+async function joinFrontierPlanet(ctx, request, onInvent) {
+  let session = await ctx.join_world(request), region = regionKey(0, 0, 0, 0);
+  if (session.realtime === null)
+    return { scene: new FrontierPlanet({ link: new ReplayFrontierLink([]), region, player: 0, onInvent }), transport: null, onFrame() {
+    } };
+  let transport = joinTickRoom({ realtime: session.realtime }), scene = new FrontierPlanet({ link: new TickFrontierLink(transport), region, player: transport.participant, onInvent }), started = false;
+  return {
+    scene,
+    transport,
+    onFrame(nowMs) {
+      started || (transport.start(nowMs), started = true), transport.update(nowMs);
+    }
+  };
+}
+
+// src/game/kit/frontier/index.ts
+var frontier_exports = {};
+__export(frontier_exports, {
+  ACTION: () => ACTION,
+  ACTION_BASE: () => ACTION_BASE,
+  AI_CAPABILITY: () => AI_CAPABILITY,
+  AI_RUN_BYTES: () => AI_RUN_BYTES,
+  AI_RUN_PREFIX: () => AI_RUN_PREFIX,
+  BOX_CAPACITY: () => (4096),
+  CHANNEL: () => CHANNEL,
+  CHEMISTRY_GROUPS: () => CHEMISTRY_GROUPS,
+  CHEMISTRY_PROMPT: () => CHEMISTRY_PROMPT,
+  CHEMISTRY_SCHEMA: () => CHEMISTRY_SCHEMA,
+  CHEMISTRY_SCHEMA_NAME: () => CHEMISTRY_SCHEMA_NAME,
+  CHEMISTRY_TEMPLATE: () => CHEMISTRY_TEMPLATE,
+  COMPARE: () => COMPARE,
+  CommandWriter: () => CommandWriter,
+  EVENT: () => EVENT,
+  EVENT_A: () => (2),
+  EVENT_B: () => (3),
+  EVENT_C_HIGH: () => (5),
+  EVENT_C_LOW: () => (4),
+  EVENT_KIND: () => (0),
+  EVENT_PLAYER: () => (1),
+  EVENT_WORDS: () => (6),
+  FIELD: () => FIELD,
+  FRAME_MAGIC: () => (245),
+  FRAME_VERSION: () => (1),
+  FRONTIER_CHANNEL_SLOT: () => FRONTIER_CHANNEL_SLOT,
+  FrontierCommands: () => FrontierCommands,
+  FrontierMirror: () => FrontierMirror,
+  FrontierPlanet: () => FrontierPlanet,
+  HEADER_BYTES: () => (9),
+  HEALTH_FIELDS: () => (5),
+  HERD: () => HERD,
+  HERD_FIELDS: () => (11),
+  HERD_HEALTH: () => HERD_HEALTH,
+  INVENTION_FLAG: () => INVENTION_FLAG,
+  INVENTION_SCHEMA: () => INVENTION_SCHEMA,
+  INVENT_PROMPT: () => INVENT_PROMPT,
+  INVENT_SCHEMA: () => INVENT_SCHEMA,
+  INVENT_TEMPLATE: () => INVENT_TEMPLATE,
+  KINDS: () => KINDS,
+  LANES: () => (6),
+  LAYER: () => LAYER,
+  MACHINE_FLAG: () => MACHINE_FLAG,
+  MAX_ACTIVATION: () => (1e6),
+  MAX_BEHAVIOURS: () => (6),
+  MAX_CHEMISTRY_NAME: () => (32),
+  MAX_COMMAND_BYTES: () => MAX_COMMAND_BYTES,
+  MAX_COUNT: () => (16),
+  MAX_DENSITY: () => (3e4),
+  MAX_ENTHALPY: () => (4e6),
+  MAX_GROUPS: () => (8),
+  MAX_GROUP_CHARS: () => (16),
+  MAX_HARDNESS: () => (1e3),
+  MAX_HEAT_CAPACITY: () => (400),
+  MAX_INGREDIENTS: () => (6),
+  MAX_KELVIN: () => (8e3),
+  MAX_KNOWN_CHARS: () => (200),
+  MAX_LATENT: () => (2e6),
+  MAX_MATERIAL_CHARS: () => (48),
+  MAX_NAME_CHARS: () => (32),
+  MAX_PARAM: () => (4294967295),
+  MAX_QUANTITY: () => (999),
+  MAX_RATE_MILLI: () => (1e6),
+  MAX_STEPS: () => (4),
+  MAX_STEP_VALUE: () => (65535),
+  MAX_SURVEYED: () => (64),
+  MAX_TERMS: () => (4),
+  MIRROR_EVENTS: () => (256),
+  NO_INVENTION: () => NO_INVENTION,
+  NO_ITEM: () => NO_ITEM,
+  PATHOGEN: () => PATHOGEN,
+  PLOT: () => PLOT,
+  PLOT_FIELDS: () => (9),
+  PLOT_HEALTH: () => PLOT_HEALTH,
+  PROCESS: () => PROCESS,
+  PROCESSES: () => PROCESSES,
+  REACTOR: () => REACTOR,
+  REACTOR_FIELDS: () => REACTOR_FIELDS,
+  REACTOR_SLOTS: () => (8),
+  REGION_METRES: () => (256),
+  RUN_ID_BYTES: () => RUN_ID_BYTES,
+  ReplayFrontierLink: () => ReplayFrontierLink,
+  SLOT_FIELDS: () => (3),
+  TRAIT: () => TRAIT,
+  TickFrontierLink: () => TickFrontierLink,
+  VERBS: () => VERBS,
+  actionOf: () => actionOf,
+  chemistryRequest: () => chemistryRequest,
+  encodeCommand: () => encodeCommand,
+  frontierAiSection: () => frontierAiSection,
+  frontierAiToml: () => frontierAiToml,
+  frontierChemistryAiSection: () => frontierChemistryAiSection,
+  inventionItem: () => inventionItem,
+  inventionRequest: () => inventionRequest,
+  isInvention: () => isInvention,
+  itemFromCode: () => itemFromCode,
+  joinFrontierPlanet: () => joinFrontierPlanet,
+  materialItem: () => materialItem,
+  regionFromBigInt: () => regionFromBigInt,
+  regionKey: () => regionKey,
+  requestChemistry: () => requestChemistry,
+  requestInvention: () => requestInvention,
+  runIdFromAiRun: () => runIdFromAiRun,
+  runIdFromHex: () => runIdFromHex
+});
+
+export { AI_CAPABILITY, BOX_CAPACITY, CHEMISTRY_GROUPS, CHEMISTRY_PROMPT, CHEMISTRY_SCHEMA, CHEMISTRY_SCHEMA_NAME, CHEMISTRY_TEMPLATE, EVENT, EVENT_A, EVENT_B, EVENT_C_HIGH, EVENT_C_LOW, EVENT_KIND, EVENT_PLAYER, EVENT_WORDS, FIELD, FRAME_MAGIC, FRAME_VERSION, FrontierCommands, FrontierMirror, FrontierPlanet, HEADER_BYTES, HEALTH_FIELDS, HERD, HERD_FIELDS, HERD_HEALTH, INVENTION_SCHEMA, INVENT_PROMPT, INVENT_SCHEMA, INVENT_TEMPLATE, KINDS, LANES, LAYER, MACHINE_FLAG, MAX_ACTIVATION, MAX_BEHAVIOURS, MAX_CHEMISTRY_NAME, MAX_COUNT, MAX_DENSITY, MAX_ENTHALPY, MAX_GROUPS, MAX_GROUP_CHARS, MAX_HARDNESS, MAX_HEAT_CAPACITY, MAX_INGREDIENTS, MAX_KELVIN, MAX_KNOWN_CHARS, MAX_LATENT, MAX_MATERIAL_CHARS, MAX_NAME_CHARS, MAX_PARAM, MAX_QUANTITY, MAX_RATE_MILLI, MAX_STEPS, MAX_STEP_VALUE, MAX_SURVEYED, MAX_TERMS, MIRROR_EVENTS, PLOT, PLOT_FIELDS, PLOT_HEALTH, PROCESSES, REACTOR, REACTOR_FIELDS, REACTOR_SLOTS, REGION_METRES, ReplayFrontierLink, SLOT_FIELDS, TickFrontierLink, VERBS, chemistryRequest, frontierAiSection, frontierAiToml, frontierChemistryAiSection, frontier_exports, inventionRequest, itemFromCode, joinFrontierPlanet, requestChemistry, requestInvention };