@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-OXMIBOD4.js

@@ -0,0 +1,337 @@
+'use strict';
+
+var chunkAZ5BGWHB_js = require('./chunk-AZ5BGWHB.js');
+var chunkTVJZ4GPS_js = require('./chunk-TVJZ4GPS.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/net/codec.ts
+var KIND_UNSIGNED = 0, KIND_SIGNED = 1, KIND_F32 = 2, KIND_F64 = 3, KIND_QUANTIZED = 4, HEADER_BITS = 8, BITS_PER_BYTE = 8, WORD_BITS = 32, MAX_MESSAGE_TYPES = 256, scratchF32 = new Float32Array(1), scratchF32Bits = new Uint32Array(scratchF32.buffer), scratchF64 = new Float64Array(1), scratchF64Bits = new Uint32Array(scratchF64.buffer);
+function describe(field) {
+  if (typeof field != "string") {
+    if (field.bits < 1 || field.bits > 32 || !(field.max > field.min))
+      throw new chunk2V7IL4HC_js.GameError("invalid_argument", "quantized fields need 1..32 bits and max > min");
+    return { kind: (4), bits: field.bits };
+  }
+  switch (field) {
+    case "bool":
+      return { kind: (0), bits: 1 };
+    case "u8":
+      return { kind: (0), bits: 8 };
+    case "u16":
+      return { kind: (0), bits: 16 };
+    case "u32":
+      return { kind: (0), bits: 32 };
+    case "i8":
+      return { kind: (1), bits: 8 };
+    case "i16":
+      return { kind: (1), bits: 16 };
+    case "i32":
+      return { kind: (1), bits: 32 };
+    case "f32":
+      return { kind: (2), bits: 32 };
+    case "f64":
+      return { kind: (3), bits: 64 };
+  }
+}
+var MessageType = class {
+  constructor(id, name, schema) {
+    this.names = /* @__PURE__ */ new Map();
+    if (id < 0 || id >= (256)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "message id out of range");
+    this.id = id, this.name = name;
+    let keys = Object.keys(schema);
+    this.fieldKind = new Uint8Array(keys.length), this.fieldBits = new Uint8Array(keys.length), this.fieldOffset = new Uint32Array(keys.length), this.fieldMin = new Float64Array(keys.length), this.fieldScale = new Float64Array(keys.length), this.fieldMax = new Float64Array(keys.length);
+    let offset = (8);
+    for (let i = 0; i < keys.length; i++) {
+      let field = schema[keys[i]], { kind, bits } = describe(field);
+      if (this.fieldKind[i] = kind, this.fieldBits[i] = bits, this.fieldOffset[i] = offset, typeof field != "string") {
+        let steps = Math.pow(2, field.bits) - 1;
+        this.fieldMin[i] = field.min, this.fieldMax[i] = steps, this.fieldScale[i] = steps / (field.max - field.min);
+      }
+      this.names.set(keys[i], i), offset += bits;
+    }
+    this.bytes = Math.ceil(offset / (8));
+  }
+  field(name) {
+    let index = this.names.get(name);
+    if (index === void 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `message ${this.name} has no field ${name}`);
+    return index;
+  }
+}, wire = new Uint32Array(1);
+function writeBits(buffer, bitOffset, bits) {
+  let remaining = bits, offset = bitOffset, v = wire[0];
+  for (; remaining > 0; ) {
+    let byte = offset >>> 3, shift = offset & 7, take = Math.min((8) - shift, remaining), mask = (1 << take) - 1 << shift;
+    buffer[byte] = buffer[byte] & ~mask | v << shift & mask, v >>>= take, offset += take, remaining -= take;
+  }
+}
+function readBits(buffer, base, bitOffset, bits) {
+  let result = 0, written = 0, offset = bitOffset;
+  for (; written < bits; ) {
+    let byte = base + (offset >>> 3), shift = offset & 7, take = Math.min((8) - shift, bits - written), chunk = buffer[byte] >>> shift & (1 << take) - 1;
+    result |= chunk << written, written += take, offset += take;
+  }
+  wire[0] = result;
+}
+var MessageWriter = class {
+  constructor(capacity = 1200) {
+    this.type = null;
+    this.buffer = new Uint8Array(capacity);
+  }
+  get length() {
+    return this.type ? this.type.bytes : 0;
+  }
+  get messageType() {
+    return this.type;
+  }
+  begin(type) {
+    if (type.bytes > this.buffer.length) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "message exceeds writer");
+    return this.type = type, this.buffer.fill(0, 0, type.bytes), this.buffer[0] = type.id, this;
+  }
+  set(field, value) {
+    return scratchF64[0] = value, this.encode(field), this;
+  }
+  setFrom(field, source, index) {
+    return scratchF64[0] = source[index], this.encode(field), this;
+  }
+  setBool(field, value) {
+    return scratchF64[0] = value ? 1 : 0, this.encode(field), this;
+  }
+  setVec3(fieldX, fieldY, fieldZ, value) {
+    return scratchF64[0] = value.x, this.encode(fieldX), scratchF64[0] = value.y, this.encode(fieldY), scratchF64[0] = value.z, this.encode(fieldZ), this;
+  }
+  encode(field) {
+    let type = this.type, offset = type.fieldOffset[field], bits = type.fieldBits[field], value = scratchF64[0];
+    switch (type.fieldKind[field]) {
+      case (0):
+      case (1):
+        wire[0] = value, writeBits(this.buffer, offset, bits);
+        return;
+      case (2):
+        scratchF32[0] = value, wire[0] = scratchF32Bits[0], writeBits(this.buffer, offset, (32));
+        return;
+      case (3):
+        wire[0] = scratchF64Bits[0], writeBits(this.buffer, offset, (32)), wire[0] = scratchF64Bits[1], writeBits(this.buffer, offset + (32), (32));
+        return;
+      default: {
+        let max = type.fieldMax[field], q = Math.round((value - type.fieldMin[field]) * type.fieldScale[field]);
+        wire[0] = q < 0 ? 0 : q > max ? max : q, writeBits(this.buffer, offset, bits);
+      }
+    }
+  }
+}, MessageReader = class {
+  constructor(types) {
+    this.bytes = new Uint8Array(0);
+    this.base = 0;
+    this.size = 0;
+    this.type = null;
+    this.types = types;
+  }
+  get messageType() {
+    return this.type;
+  }
+  get length() {
+    return this.size;
+  }
+  bind(bytes, base, length) {
+    this.bytes = bytes, this.base = base, this.size = length;
+    let type = length > 0 ? this.types[bytes[base]] : null;
+    return this.type = type && type.bytes <= length ? type : null, this.type !== null;
+  }
+  is(type) {
+    return this.type === type;
+  }
+  get(field) {
+    return this.decode(field), scratchF64[0];
+  }
+  getInto(field, out, index) {
+    this.decode(field), out[index] = scratchF64[0];
+  }
+  getBool(field) {
+    return this.decode(field), scratchF64[0] !== 0;
+  }
+  getVec3(fieldX, fieldY, fieldZ, out) {
+    return this.decode(fieldX), out.x = scratchF64[0], this.decode(fieldY), out.y = scratchF64[0], this.decode(fieldZ), out.z = scratchF64[0], out;
+  }
+  decode(field) {
+    let type = this.type, offset = type.fieldOffset[field], bits = type.fieldBits[field];
+    switch (type.fieldKind[field]) {
+      case (0):
+        readBits(this.bytes, this.base, offset, bits), scratchF64[0] = wire[0];
+        return;
+      case (1): {
+        readBits(this.bytes, this.base, offset, bits);
+        let raw = wire[0] | 0;
+        scratchF64[0] = bits === (32) ? raw : raw << (32) - bits >> (32) - bits;
+        return;
+      }
+      case (2):
+        readBits(this.bytes, this.base, offset, (32)), scratchF32Bits[0] = wire[0], scratchF64[0] = scratchF32[0];
+        return;
+      case (3):
+        readBits(this.bytes, this.base, offset, (32)), scratchF64Bits[0] = wire[0], readBits(this.bytes, this.base, offset + (32), (32)), scratchF64Bits[1] = wire[0];
+        return;
+      default:
+        readBits(this.bytes, this.base, offset, bits), scratchF64[0] = wire[0] / type.fieldScale[field] + type.fieldMin[field];
+    }
+  }
+};
+function quantized(min, max, bits) {
+  return { kind: "quantized", min, max, bits };
+}
+var MESSAGE_TYPE_LIMIT = (256);
+
+// src/game/net/room.ts
+var Channel = class {
+  constructor(transport, name, delivery) {
+    this.transport = transport, this.name = name, this.delivery = delivery, this.id = transport.open(name, delivery);
+  }
+  send(writer) {
+    if (writer.length === 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "writer holds no message");
+    this.transport.send(this.id, writer.buffer, writer.length);
+  }
+  receive(reader) {
+    return this.transport.receive(this.id, reader);
+  }
+}, GameNet = class {
+  constructor() {
+    this.types = Array.from({ length: MESSAGE_TYPE_LIMIT }, () => null);
+    this.typeCount = 0;
+    this.transport = null;
+    this.joinedRoom = null;
+  }
+  joinRoom(options, nowMs) {
+    this.joinedRoom?.close();
+    let room = new chunkTVJZ4GPS_js.RoomClient(options);
+    return room.start(nowMs), this.joinedRoom = room, room;
+  }
+  get room() {
+    return this.joinedRoom;
+  }
+  defineMessage(name, schema) {
+    let type = new MessageType(this.typeCount, name, schema);
+    return this.types[this.typeCount++] = type, type;
+  }
+  reader() {
+    return new MessageReader(this.types);
+  }
+  connect(transport) {
+    this.transport = transport;
+  }
+  get connected() {
+    return this.transport !== null;
+  }
+  get participant() {
+    return this.requireTransport().participant;
+  }
+  channel(name, delivery) {
+    return new Channel(this.requireTransport(), name, delivery);
+  }
+  disconnect() {
+    this.transport?.close(), this.transport = null, this.joinedRoom?.close(), this.joinedRoom = null;
+  }
+  requireTransport() {
+    if (!this.transport) throw new chunk2V7IL4HC_js.GameError("not_initialized", "no room transport is connected");
+    return this.transport;
+  }
+}, ChannelQueue = class {
+  constructor(latest, slots, slotBytes) {
+    this.head = 0;
+    this.count = 0;
+    this.dropped = 0;
+    this.latest = latest, this.capacity = latest ? 1 : slots, this.slotBytes = slotBytes, this.slots = new Uint8Array(this.capacity * slotBytes), this.lengths = new Int32Array(this.capacity);
+  }
+  reserve(length) {
+    if (length > this.slotBytes) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "message exceeds channel slot size");
+    let slot;
+    if (this.latest)
+      slot = 0, this.count = 1;
+    else {
+      if (this.count >= this.capacity)
+        return this.dropped++, -1;
+      slot = (this.head + this.count) % this.capacity, this.count++;
+    }
+    return this.lengths[slot] = length, slot * this.slotBytes;
+  }
+  pop(reader) {
+    if (this.count === 0) return false;
+    let slot = this.head;
+    return this.count--, this.latest || (this.head = slot + 1 === this.capacity ? 0 : slot + 1), reader.bind(this.slots, slot * this.slotBytes, this.lengths[slot]);
+  }
+}, LoopbackTransport = class _LoopbackTransport {
+  constructor(participant, options) {
+    this.peer = null;
+    this.names = /* @__PURE__ */ new Map();
+    this.queues = [];
+    this.participant = participant, this.slots = options.slots ?? 64, this.slotBytes = options.slotBytes ?? 1200;
+  }
+  static pair(options = {}) {
+    let a = new _LoopbackTransport(0, options), b = new _LoopbackTransport(1, options);
+    return a.peer = b, b.peer = a, [a, b];
+  }
+  open(channel, delivery) {
+    let existing = this.names.get(channel);
+    if (existing !== void 0) return existing;
+    let id = this.queues.length;
+    return this.queues.push(new ChannelQueue(delivery === "latest", this.slots, this.slotBytes)), this.names.set(channel, id), id;
+  }
+  send(channel, bytes, length) {
+    let peer = this.peer;
+    if (!peer) throw new chunk2V7IL4HC_js.GameError("not_initialized", "loopback transport is closed");
+    let queue = peer.queues[channel];
+    if (!queue) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `peer has not opened channel ${channel}`);
+    let base = queue.reserve(length);
+    if (base < 0) return;
+    let slots = queue.slots;
+    for (let i = 0; i < length; i++) slots[base + i] = bytes[i];
+  }
+  receive(channel, reader) {
+    let queue = this.queues[channel];
+    return queue !== void 0 && queue.pop(reader);
+  }
+  dropped(channel) {
+    return this.queues[channel]?.dropped ?? 0;
+  }
+  close() {
+    this.peer && (this.peer.peer = null), this.peer = null;
+  }
+}, NO_TICK = -1, SnapshotBuffer = class {
+  constructor(entities, history = 32) {
+    this.weight = new Float64Array(1);
+    this.entities = entities, this.history = history, this.ticks = new Float64Array(entities * history).fill((-1)), this.positions = new Float32Array(entities * history * 3), this.rotations = new Float32Array(entities * history * 4), this.heads = new Int32Array(entities), this.counts = new Int32Array(entities);
+  }
+  push(slot, tick, positions, po, rotations, ro) {
+    let head = this.heads[slot], i = slot * this.history + head;
+    this.ticks[i] = tick;
+    let p = i * 3;
+    for (let k = 0; k < 3; k++) this.positions[p + k] = positions[po + k];
+    let q = i * 4;
+    for (let k = 0; k < 4; k++) this.rotations[q + k] = rotations[ro + k];
+    this.heads[slot] = head + 1 === this.history ? 0 : head + 1, this.counts[slot] < this.history && this.counts[slot]++;
+  }
+  sample(slot, tick, outPosition, positionOffset, outRotation, rotationOffset) {
+    let count = this.counts[slot];
+    if (count === 0) return false;
+    let base = slot * this.history, before = -1, after = -1;
+    for (let k = 0; k < count; k++) {
+      let i = base + (this.heads[slot] - 1 - k + this.history) % this.history, t = this.ticks[i];
+      t <= tick && (before < 0 || t > this.ticks[before]) && (before = i), t >= tick && (after < 0 || t < this.ticks[after]) && (after = i);
+    }
+    before < 0 && (before = after), after < 0 && (after = before);
+    let span = this.ticks[after] - this.ticks[before], alpha = span > 0 ? (tick - this.ticks[before]) / span : 0;
+    this.weight[0] = alpha;
+    let pa = before * 3, pb = after * 3;
+    for (let c = 0; c < 3; c++)
+      outPosition[positionOffset + c] = this.positions[pa + c] + (this.positions[pb + c] - this.positions[pa + c]) * alpha;
+    return chunkAZ5BGWHB_js.quatSlerpArrays(outRotation, rotationOffset, this.rotations, before * 4, this.rotations, after * 4, this.weight, 0), true;
+  }
+};
+
+exports.Channel = Channel;
+exports.ChannelQueue = ChannelQueue;
+exports.GameNet = GameNet;
+exports.LoopbackTransport = LoopbackTransport;
+exports.MessageReader = MessageReader;
+exports.MessageType = MessageType;
+exports.MessageWriter = MessageWriter;
+exports.SnapshotBuffer = SnapshotBuffer;
+exports.quantized = quantized;

package/dist/chunk-PBL6YL5L.mjs

@@ -0,0 +1,288 @@
+import { parseProgram, KernelVm, STORAGE_F32, STORAGE_U32, STORAGE_I32 } from './chunk-MOBSBXVE.mjs';
+
+// src/interactives/tick/layout.ts
+var COMMAND_AREA_BYTES = 4096, MAX_COMMAND_PAYLOAD_BYTES = 512, MAX_STATE_BYTES = 262144;
+var TICK_DEADLINE_MS = 4, GUEST_HEAP_BYTES = 67108864;
+function aligned(bytes) {
+  return bytes + 8 - 1 & -8;
+}
+function tickLayout(seats, stateBytes) {
+  let x = aligned(128 + seats), y = aligned(x + seats * 4), z = aligned(y + seats * 4), yaw = aligned(z + seats * 4), axisX = aligned(yaw + seats * 2), axisZ = aligned(axisX + seats * 2), buttons = aligned(axisZ + seats * 2), animation = aligned(buttons + seats), flags = aligned(animation + seats), commands = aligned(flags + seats), state = commands + 4096, total = aligned(state + stateBytes);
+  return { seats, stateBytes, alive: 128, x, y, z, yaw, axisX, axisZ, buttons, animation, flags, commands, state, total };
+}
+function describeRegion(header, layout, stepNs, random) {
+  header[4] = layout.seats, header[7] = layout.stateBytes, header[12] = stepNs;
+  for (let i = 0; i < 4; i++) header[8 + i] = random[i];
+  header[16] = layout.alive, header[17] = layout.x, header[18] = layout.y, header[19] = layout.z, header[20] = layout.yaw, header[21] = layout.axisX, header[22] = layout.axisZ, header[23] = layout.buttons, header[24] = layout.animation, header[25] = layout.flags, header[26] = layout.commands, header[27] = layout.state, header[28] = layout.total;
+}
+
+// src/interactives/tick/room.ts
+var TickRoomError = class extends Error {
+  constructor(code, message) {
+    super(message), this.name = "TickRoomError", this.code = code;
+  }
+}, TYPE_BYTES = { i8: 1, u8: 1, i16: 2, u16: 2, i32: 4, u32: 4, f32: 4, f64: 8 };
+function readField(view, type, at) {
+  switch (type) {
+    case "i8":
+      return view.getInt8(at);
+    case "u8":
+      return view.getUint8(at);
+    case "i16":
+      return view.getInt16(at, true);
+    case "u16":
+      return view.getUint16(at, true);
+    case "i32":
+      return view.getInt32(at, true);
+    case "u32":
+      return view.getUint32(at, true);
+    case "f32":
+      return view.getFloat32(at, true);
+    case "f64":
+      return view.getFloat64(at, true);
+  }
+}
+function writeField(view, type, at, value) {
+  switch (type) {
+    case "i8":
+      return view.setInt8(at, value);
+    case "u8":
+      return view.setUint8(at, value);
+    case "i16":
+      return view.setInt16(at, value, true);
+    case "u16":
+      return view.setUint16(at, value, true);
+    case "i32":
+      return view.setInt32(at, value, true);
+    case "u32":
+      return view.setUint32(at, value, true);
+    case "f32":
+      return view.setFloat32(at, value, true);
+    case "f64":
+      return view.setFloat64(at, value, true);
+  }
+}
+function defineTickState(schema, options = {}) {
+  let at = {}, replicated = options.replicated ?? Object.keys(schema);
+  for (let name of replicated)
+    if (!(name in schema)) throw new TickRoomError("invalid_state_field", `replicated field ${name} is not in the state schema`);
+  let ordered = [...replicated, ...Object.keys(schema).filter((name) => !replicated.includes(name))], offset = 0, replicatedBytes = 0;
+  for (let index = 0; index < ordered.length; index++) {
+    let name = ordered[index], type = schema[name], size = TYPE_BYTES[type];
+    if (size === void 0) throw new TickRoomError("invalid_state_field", `state field ${name} has unknown type ${String(type)}`);
+    offset = offset + size - 1 & ~(size - 1), at[name] = offset, offset += size, index < replicated.length && (replicatedBytes = offset);
+  }
+  if (offset > 262144) throw new TickRoomError("state_bytes_exceeded", `the state schema needs ${offset} bytes, above ${262144}`);
+  let offsets = at;
+  return {
+    bytes: offset,
+    replicatedBytes,
+    at: offsets,
+    types: schema,
+    get: (view, field) => readField(view, schema[field], offsets[field]),
+    set: (view, field, value) => writeField(view, schema[field], offsets[field], value)
+  };
+}
+var registered = false;
+function stateBytesOf(definition) {
+  if (definition.state !== void 0 && definition.stateBytes !== void 0 && definition.stateBytes !== definition.state.bytes)
+    throw new TickRoomError("invalid_state_bytes", `stateBytes ${definition.stateBytes} disagrees with the state schema's ${definition.state.bytes} bytes`);
+  let bytes = definition.state?.bytes ?? definition.stateBytes ?? 0;
+  if (!Number.isInteger(bytes) || bytes < 0) throw new TickRoomError("invalid_state_bytes", `stateBytes must be a whole number of bytes, got ${String(bytes)}`);
+  if (bytes > 262144) throw new TickRoomError("state_bytes_exceeded", `stateBytes ${bytes} is above the ${262144} byte limit`);
+  return bytes;
+}
+function tickHost() {
+  let host = globalThis.registerTickRoom;
+  return typeof host == "function" ? host : null;
+}
+function defineTickRoom(definition) {
+  if (definition === null || typeof definition != "object" || typeof definition.step != "function")
+    throw new TickRoomError("missing_step", "a tick room needs a step(ctx) function");
+  let stateBytes = stateBytesOf(definition), replicatedBytes = definition.replicate === true ? definition.state?.replicatedBytes ?? stateBytes : 0, init = typeof definition.init == "function" ? (ctx) => definition.init?.(ctx) : null, step = (ctx) => definition.step(ctx), host = tickHost();
+  if (host !== null) {
+    if (registered) throw new TickRoomError("already_registered", "a tick bundle registers exactly one room");
+    host(init === null ? { stateBytes, replicatedBytes, step } : { stateBytes, replicatedBytes, init, step }), registered = true;
+  }
+  return { stateBytes, replicatedBytes, state: definition.state ?? null, init, step, onTick: host !== null };
+}
+
+// src/interactives/tick/kernels.ts
+var LOCKSTEP_STORAGE_U64_LO = 4, LOCKSTEP_STORAGE_U64_HI = 5, LOCKSTEP_TABLE_ALIGN = 8, HALVES_PER_F64 = 2, WIDTH = { f32: 1, i32: 1, u32: 1, f64: 1, vec2: 2, vec3: 3 }, ELEMENT_BYTES = { f32: 4, i32: 4, u32: 4, f64: 8, vec2: 4, vec3: 4 }, STORAGE = { f32: STORAGE_F32, i32: STORAGE_I32, u32: STORAGE_U32, f64: (4), vec2: STORAGE_F32, vec3: STORAGE_F32 }, AXES = ["x", "y", "z"], TRUE_BITS = 4294967295, BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", PAD = "=", DESCRIPTOR_WORDS = 2, TRANSCENDENTAL = /\bMath\s*\.\s*(sin|cos|tan|asin|acos|atan|atan2|sinh|cosh|tanh|asinh|acosh|atanh|exp|expm1|log|log2|log10|log1p|pow|cbrt|hypot)\b|\*\*/, NO_KERNEL = -1;
+function refereeHost() {
+  let g = globalThis, load = g.__cimplify_kernel_load, run = g.__cimplify_kernel_run;
+  return typeof load != "function" || typeof run != "function" ? null : { load: (program) => load(program), run: (kernel, buffer, columns, count, rows, args) => run(kernel, buffer, columns, count, rows, args) };
+}
+var installed = null;
+function setLockstepKernelHost(host) {
+  installed = host;
+}
+function lockstepKernelHost() {
+  return installed;
+}
+function decodeBase64(text) {
+  let clean = text.endsWith(PAD + PAD) ? text.slice(0, -2) : text.endsWith(PAD) ? text.slice(0, -1) : text, out = new Uint8Array(Math.floor(clean.length * 3 / 4)), bits = 0, value = 0, at = 0;
+  for (let k = 0; k < clean.length; k++) {
+    let digit = BASE64.indexOf(clean[k]);
+    if (digit < 0) throw new TickRoomError("invalid_lockstep", "a compiled lockstep kernel carries invalid base64");
+    value = (value << 6 | digit) & 16777215, bits += 6, bits >= 8 && (bits -= 8, out[at++] = value >> bits & 255);
+  }
+  return out.subarray(0, at);
+}
+var LockstepKernel = class {
+  constructor(fn, compiled) {
+    this.hostId = (-1);
+    this.hostOwner = null;
+    if (this.fn = fn, this.name = fn.name.length > 0 ? fn.name : "lockstepKernel", this.transcendental = TRANSCENDENTAL.test(String(fn)), compiled === void 0)
+      this.meta = null, this.program = null, this.parsed = null, this.args = new Uint32Array(0);
+    else {
+      let payload = JSON.parse(compiled);
+      this.meta = payload.meta, this.program = decodeBase64(payload.program), this.parsed = parseProgram(this.program);
+      for (let slot of payload.meta.slots)
+        if (slot.scratch === true || slot.spawn === true) throw new TickRoomError("invalid_lockstep", `lockstep kernel ${payload.meta.name} spawns or keeps scratch rows; a lockstep kernel may only read and write its table`);
+      if (this.parsed.calls.length > 0 || this.parsed.channels.length > 0)
+        throw new TickRoomError("invalid_lockstep", `lockstep kernel ${payload.meta.name} calls engine services or emits events; a lockstep kernel may only read and write its table`);
+      this.args = new Uint32Array(payload.meta.argWords);
+    }
+    this.floats = new Float32Array(this.args.buffer);
+  }
+  get compiled() {
+    return this.program !== null;
+  }
+};
+function lockstepKernel(fn, compiled) {
+  if (typeof fn != "function") throw new TickRoomError("invalid_lockstep", "lockstepKernel() takes a function");
+  return new LockstepKernel(fn, compiled);
+}
+function packArgs(meta, words, floats, args) {
+  let at = 0;
+  for (let k = 0; k < meta.length; k++) {
+    let arg = meta[k], value = args[k];
+    if (arg.width > 1) {
+      let v = value;
+      for (let c = 0; c < arg.width; c++) floats[at++] = v[AXES[c]];
+    } else arg.kind === "f32" ? floats[at++] = value : arg.kind === "bool" ? words[at++] = value === true ? (4294967295) : 0 : words[at++] = value >>> 0;
+  }
+}
+var LockstepTable = class {
+  constructor(schema, options) {
+    this.keys = [];
+    this.offsets = [];
+    this.types = [];
+    this.index = /* @__PURE__ */ new Map();
+    this.views = /* @__PURE__ */ new WeakMap();
+    this.referee = refereeHost();
+    this.entity = {};
+    this.row = 0;
+    this.current = { columns: [] };
+    let { at, rows } = options;
+    if (!Number.isInteger(at) || at < 0 || at % (8) !== 0) throw new TickRoomError("invalid_lockstep", `a lockstep table starts at a multiple of ${(8)} bytes, got ${String(at)}`);
+    if (!Number.isInteger(rows) || rows < 1) throw new TickRoomError("invalid_lockstep", `a lockstep table holds at least one row, got ${String(rows)}`);
+    this.schema = schema, this.at = at, this.rows = rows;
+    let offset = 0;
+    for (let field of Object.keys(schema)) {
+      let type = schema[field], element = ELEMENT_BYTES[type];
+      if (element === void 0) throw new TickRoomError("invalid_lockstep", `lockstep table field ${field} has unknown type ${String(type)}`);
+      for (let c = 0; c < WIDTH[type]; c++)
+        offset = Math.ceil(offset / element) * element, this.index.set(`${field}:${c}`, this.keys.length), this.keys.push(field), this.offsets.push(offset), this.types.push(type), offset += rows * element;
+    }
+    this.bytes = Math.ceil(offset / (8)) * (8), this.defineEntity();
+  }
+  get end() {
+    return this.at + this.bytes;
+  }
+  column(state, field, component = 0) {
+    let k = this.index.get(`${field}:${component}`);
+    if (k === void 0) throw new TickRoomError("invalid_lockstep", `lockstep table has no column ${field}[${component}]`);
+    return this.viewsOf(state).columns[k];
+  }
+  run(kernel, state, count, ...args) {
+    if (!Number.isInteger(count) || count < 0 || count > this.rows) throw new TickRoomError("invalid_lockstep", `a lockstep kernel runs over 0 to ${this.rows} rows, got ${String(count)}`);
+    let views = this.viewsOf(state);
+    if (kernel.meta === null || kernel.parsed === null || kernel.program === null) {
+      this.runSource(kernel, views, count, args);
+      return;
+    }
+    let binding = this.bind(kernel, views, state);
+    packArgs(kernel.meta.args, kernel.args, kernel.floats, args);
+    let host = this.referee ?? installed;
+    if (host !== null) {
+      kernel.hostOwner !== host && (kernel.hostId = host.load(kernel.program), kernel.hostOwner = host), host.run(kernel.hostId, state.buffer, binding.descriptor, count, this.rows, kernel.args);
+      return;
+    }
+    binding.vm === null && (binding.vm = new KernelVm(kernel.parsed, this.rows)), binding.vm.run(binding.columns, count, null, kernel.args);
+  }
+  viewsOf(state) {
+    let views = this.views.get(state);
+    if (views !== void 0) return views;
+    if (this.at + this.bytes > state.byteLength) throw new TickRoomError("invalid_lockstep", `a lockstep table of ${this.bytes} bytes at ${this.at} does not fit ${state.byteLength} state bytes`);
+    let base = state.byteOffset + this.at;
+    if (base % (8) !== 0) throw new TickRoomError("invalid_lockstep", `lockstep state must start on a ${(8)}-byte boundary`);
+    return views = { columns: this.types.map((type, k) => {
+      let at = base + this.offsets[k];
+      return type === "f64" ? new Float64Array(state.buffer, at, this.rows) : type === "i32" ? new Int32Array(state.buffer, at, this.rows) : type === "u32" ? new Uint32Array(state.buffer, at, this.rows) : new Float32Array(state.buffer, at, this.rows);
+    }), bindings: /* @__PURE__ */ new Map() }, this.views.set(state, views), views;
+  }
+  bind(kernel, views, state) {
+    let known = views.bindings.get(kernel);
+    if (known !== void 0) return known;
+    let meta = kernel.meta, columns = [], descriptor = new Uint32Array(meta.slots.length * (2));
+    meta.slots.forEach((slot, s) => {
+      let k = this.index.get(`${slot.field}:${slot.component}`);
+      if (k === void 0) throw new TickRoomError("invalid_lockstep", `lockstep kernel ${meta.name} reads ${slot.field}, which this table does not have`);
+      let wide = this.types[k] === "f64", storage = wide ? slot.high === true ? (5) : (4) : STORAGE[this.types[k]], column = views.columns[k], values = wide ? new Uint32Array(column.buffer, column.byteOffset, this.rows * (2)) : column;
+      columns.push({ values, storage }), descriptor[s * (2)] = state.byteOffset + this.at + this.offsets[k], descriptor[s * (2) + 1] = storage;
+    });
+    let binding = { columns, descriptor, vm: null };
+    return views.bindings.set(kernel, binding), binding;
+  }
+  defineEntity() {
+    let table = this, current = { columns: [] };
+    this.current = current;
+    for (let field of Object.keys(this.schema)) {
+      let type = this.schema[field], first = this.index.get(`${field}:0`);
+      if (WIDTH[type] === 1) {
+        Object.defineProperty(this.entity, field, {
+          enumerable: true,
+          get: () => current.columns[first][table.row],
+          set: (v) => {
+            current.columns[first][table.row] = v;
+          }
+        });
+        continue;
+      }
+      let vector = {};
+      for (let c = 0; c < WIDTH[type]; c++)
+        Object.defineProperty(vector, AXES[c], {
+          enumerable: true,
+          get: () => current.columns[first + c][table.row],
+          set: (v) => {
+            current.columns[first + c][table.row] = v;
+          }
+        });
+      Object.defineProperty(this.entity, field, {
+        enumerable: true,
+        get: () => vector,
+        set: (v) => {
+          for (let c = 0; c < WIDTH[type]; c++) current.columns[first + c][table.row] = v[AXES[c]];
+        }
+      });
+    }
+  }
+  runSource(kernel, views, count, args) {
+    if (kernel.transcendental)
+      throw new TickRoomError(
+        "invalid_lockstep",
+        `lockstep kernel ${kernel.name} uses transcendental maths (Math.sin, Math.pow, ** and the like); it must run compiled on every peer and the referee, so build it with the cimplify CLI instead of running its source`
+      );
+    this.current.columns = views.columns;
+    let entity = this.entity;
+    for (let row = 0; row < count; row++)
+      this.row = row, kernel.fn(entity, ...args);
+  }
+};
+function lockstepTable(schema, options) {
+  return new LockstepTable(schema, options);
+}
+
+export { COMMAND_AREA_BYTES, GUEST_HEAP_BYTES, LOCKSTEP_STORAGE_U64_HI, LOCKSTEP_STORAGE_U64_LO, LOCKSTEP_TABLE_ALIGN, LockstepKernel, LockstepTable, MAX_COMMAND_PAYLOAD_BYTES, MAX_STATE_BYTES, TICK_DEADLINE_MS, TickRoomError, aligned, defineTickRoom, defineTickState, describeRegion, lockstepKernel, lockstepKernelHost, lockstepTable, setLockstepKernelHost, tickLayout };