@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-NXKQOQ6L.js

@@ -0,0 +1,76 @@
+'use strict';
+
+// src/game/math/deterministic.ts
+var view = new DataView(new ArrayBuffer(8)), TWO_OVER_PI = 0.6366197723675814, PIO2_HI = 1.5707963267341256, PIO2_LO = 6077100506506192e-26, S1 = -0.16666666666666632, S2 = 0.00833333333332249, S3 = -1984126982985795e-19, S4 = 27557313707070068e-22, S5 = -2.5050760253406863e-8, S6 = 158969099521155e-24, C1 = 0.0416666666666666, C2 = -0.001388888888887411, C3 = 2480158728947673e-20, C4 = -2.7557314351390663e-7, C5 = 2087572321298175e-24, C6 = -11359647557788195e-27, LN2_HI = 0.6931471803691238, LN2_LO = 19082149292705877e-26, INV_LN2 = 1.4426950408889634, LG1 = 0.6666666666666735, LG2 = 0.3999999999940942, LG3 = 0.2857142874366239, LG4 = 0.22222198432149784, LG5 = 0.1818357216161805, LG6 = 0.15313837699209373, LG7 = 0.14798198605116586, P1 = 0.16666666666666602, P2 = -0.0027777777777015593, P3 = 6613756321437934e-20, P4 = -16533902205465252e-22, P5 = 41381367970572385e-24, TWO54 = 18014398509481984, EXP_OVERFLOW = 709.782712893384, EXP_UNDERFLOW = -745.1332191019411, EXPONENT_BIAS = 1023, EXPONENT_SHIFT = 20, EXPONENT_MASK = 2047, MANTISSA_HIGH_MASK = 1048575, SQRT_HALF_MANTISSA = 614244, ONE_HIGH = 1072693248, HALF_HIGH = 1071644672, EXPONENT_MIN = -1022, EXPONENT_MAX = 1023;
+function sinKernel(x) {
+  let z = x * x, r = (0.00833333333332249) + z * ((-1984126982985795e-19) + z * ((27557313707070068e-22) + z * ((-2.5050760253406863e-8) + z * (158969099521155e-24))));
+  return x + z * x * ((-0.16666666666666632) + z * r);
+}
+function cosKernel(x) {
+  let z = x * x, r = z * ((0.0416666666666666) + z * ((-0.001388888888887411) + z * ((2480158728947673e-20) + z * ((-2.7557314351390663e-7) + z * ((2087572321298175e-24) + z * (-11359647557788195e-27))))));
+  return 1 - (0.5 * z - z * r);
+}
+function quadrant(x) {
+  return Math.round(x * (0.6366197723675814));
+}
+function reduce(x, n) {
+  return x - n * (1.5707963267341256) - n * (6077100506506192e-26);
+}
+function detSin(x) {
+  if (!Number.isFinite(x)) return Number.NaN;
+  let n = quadrant(x), r = reduce(x, n);
+  switch ((n % 4 + 4) % 4) {
+    case 0:
+      return sinKernel(r);
+    case 1:
+      return cosKernel(r);
+    case 2:
+      return -sinKernel(r);
+    default:
+      return -cosKernel(r);
+  }
+}
+function detCos(x) {
+  if (!Number.isFinite(x)) return Number.NaN;
+  let n = quadrant(x), r = reduce(x, n);
+  switch ((n % 4 + 4) % 4) {
+    case 0:
+      return cosKernel(r);
+    case 1:
+      return -sinKernel(r);
+    case 2:
+      return -cosKernel(r);
+    default:
+      return sinKernel(r);
+  }
+}
+function detLog(x) {
+  if (Number.isNaN(x) || x < 0) return Number.NaN;
+  if (x === 0) return Number.NEGATIVE_INFINITY;
+  if (x === Number.POSITIVE_INFINITY) return x;
+  let k = 0, m = x;
+  view.setFloat64(0, m), view.getUint32(0) >>> (20) || (m *= (18014398509481984), k -= 54, view.setFloat64(0, m));
+  let high = view.getUint32(0);
+  k += (high >>> (20)) - (1023);
+  let mantissa = high & (1048575), lift = mantissa + (614244) >= (1048575) + 1 ? 1 : 0;
+  view.setUint32(0, mantissa | (lift === 1 ? (1071644672) : (1072693248))), k += lift;
+  let f = view.getFloat64(0) - 1, s = f / (2 + f), z = s * s, w = z * z, t1 = w * ((0.3999999999940942) + w * ((0.22222198432149784) + w * (0.15313837699209373))), r = z * ((0.6666666666666735) + w * ((0.2857142874366239) + w * ((0.1818357216161805) + w * (0.14798198605116586)))) + t1, half = 0.5 * f * f;
+  return k * (0.6931471803691238) - (half - (s * (half + r) + k * (19082149292705877e-26)) - f);
+}
+function power2(k) {
+  return view.setUint32(0, (k + (1023) & (2047)) << (20)), view.setUint32(4, 0), view.getFloat64(0);
+}
+function detExp(x) {
+  if (Number.isNaN(x)) return x;
+  if (x > (709.782712893384)) return Number.POSITIVE_INFINITY;
+  if (x < (-745.1332191019411)) return 0;
+  let k = Math.round(x * (1.4426950408889634)), hi = x - k * (0.6931471803691238), lo = k * (19082149292705877e-26), r = hi - lo, t = r * r, c = r - t * ((0.16666666666666602) + t * ((-0.0027777777777015593) + t * ((6613756321437934e-20) + t * ((-16533902205465252e-22) + t * (41381367970572385e-24))))), y = 1 - (lo - r * c / (2 - c) - hi);
+  if (k >= (-1022) && k <= (1023)) return y * power2(k);
+  let first = k < 0 ? (-1022) : (1023);
+  return y * power2(first) * power2(k - first);
+}
+
+exports.detCos = detCos;
+exports.detExp = detExp;
+exports.detLog = detLog;
+exports.detSin = detSin;

package/dist/chunk-NXLAZIJZ.js

@@ -0,0 +1,309 @@
+'use strict';
+
+var chunkKZJRSXHK_js = require('./chunk-KZJRSXHK.js');
+
+// 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: chunkKZJRSXHK_js.STORAGE_F32, i32: chunkKZJRSXHK_js.STORAGE_I32, u32: chunkKZJRSXHK_js.STORAGE_U32, f64: (4), vec2: chunkKZJRSXHK_js.STORAGE_F32, vec3: chunkKZJRSXHK_js.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 = chunkKZJRSXHK_js.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 chunkKZJRSXHK_js.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);
+}
+
+exports.COMMAND_AREA_BYTES = (4096);
+exports.GUEST_HEAP_BYTES = (67108864);
+exports.LOCKSTEP_STORAGE_U64_HI = (5);
+exports.LOCKSTEP_STORAGE_U64_LO = (4);
+exports.LOCKSTEP_TABLE_ALIGN = (8);
+exports.LockstepKernel = LockstepKernel;
+exports.LockstepTable = LockstepTable;
+exports.MAX_COMMAND_PAYLOAD_BYTES = (512);
+exports.MAX_STATE_BYTES = (262144);
+exports.TICK_DEADLINE_MS = (4);
+exports.TickRoomError = TickRoomError;
+exports.aligned = aligned;
+exports.defineTickRoom = defineTickRoom;
+exports.defineTickState = defineTickState;
+exports.describeRegion = describeRegion;
+exports.lockstepKernel = lockstepKernel;
+exports.lockstepKernelHost = lockstepKernelHost;
+exports.lockstepTable = lockstepTable;
+exports.setLockstepKernelHost = setLockstepKernelHost;
+exports.tickLayout = tickLayout;

package/dist/chunk-NYWNA5CF.js

@@ -0,0 +1,148 @@
+'use strict';
+
+var chunkNXKQOQ6L_js = require('./chunk-NXKQOQ6L.js');
+var chunkG3EEC44R_js = require('./chunk-G3EEC44R.js');
+var chunkRCQ2MPBV_js = require('./chunk-RCQ2MPBV.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+
+// src/game/math/frame-math.ts
+var PI = 3.141592653589793, PI_LO = 12246467991473532e-32, PI_OVER_2 = 1.5707963267948966, PI_OVER_4 = 0.7853981633974483, ONE_HIGH = 1072693248, ABS_MASK = 2147483647, INFINITY_HIGH = 2146435072, EXPONENT_SHIFT = 20, RATIO_LIMIT = 60, SIGN_SHIFT = 31, QUADRANT_SHIFT = 30, WORD_LOW = 0, WORD_HIGH = 1, bits = new Float64Array(1), words = new Uint32Array(bits.buffer);
+function atan2Into(io, at) {
+  let y = io[at], x = io[at + 1];
+  if (x !== x || y !== y) {
+    io[at] = x + y;
+    return;
+  }
+  bits[0] = x;
+  let lx = words[(0)], ix = words[(1)];
+  bits[0] = y;
+  let ly = words[(0)], iy = words[(1)];
+  if ((ix - (1072693248) | lx) === 0) {
+    io[at] = Math.atan(y);
+    return;
+  }
+  let m = iy >>> (31) & 1 | ix >>> (30) & 2;
+  if (ix &= (2147483647), iy &= (2147483647), (iy | ly) === 0) {
+    io[at] = m < 2 ? y : m === 2 ? (3.141592653589793) : -(3.141592653589793);
+    return;
+  }
+  if ((ix | lx) === 0) {
+    io[at] = (m & 1) !== 0 ? -(1.5707963267948966) : (1.5707963267948966);
+    return;
+  }
+  if (ix === (2146435072)) {
+    iy === (2146435072) ? io[at] = m === 0 ? (0.7853981633974483) : m === 1 ? -(0.7853981633974483) : m === 2 ? 3 * (0.7853981633974483) : -3 * (0.7853981633974483) : io[at] = m === 0 ? 0 : m === 1 ? -0 : m === 2 ? (3.141592653589793) : -(3.141592653589793);
+    return;
+  }
+  if (iy === (2146435072)) {
+    io[at] = (m & 1) !== 0 ? -(1.5707963267948966) : (1.5707963267948966);
+    return;
+  }
+  let k = iy - ix >> (20), z;
+  k > (60) ? (z = (1.5707963267948966) + 0.5 * (12246467991473532e-32), m &= 1) : (m & 2) !== 0 && k < -(60) ? z = 0 : z = Math.atan(Math.abs(y / x)), io[at] = m === 0 ? z : m === 1 ? -z : m === 2 ? (3.141592653589793) - (z - (12246467991473532e-32)) : z - (12246467991473532e-32) - (3.141592653589793);
+}
+
+// src/game/kit/character/math.ts
+var TWO_PI = Math.PI * 2;
+function wrapAngle(angle) {
+  let a = angle % TWO_PI;
+  return a > Math.PI ? a -= TWO_PI : a < -Math.PI && (a += TWO_PI), a;
+}
+function wrapAt(values, index) {
+  let a = values[index] % TWO_PI;
+  a > Math.PI ? a -= TWO_PI : a < -Math.PI && (a += TWO_PI), values[index] = a;
+}
+function dampFactor(sharpness, dt) {
+  return sharpness <= 0 ? 0 : 1 - chunkNXKQOQ6L_js.detExp(-sharpness * dt);
+}
+function clamp(value, lo, hi) {
+  return value < lo ? lo : value > hi ? hi : value;
+}
+function yawOfQuat(rotation, at) {
+  let x = rotation[at], y = rotation[at + 1], z = rotation[at + 2], w = rotation[at + 3];
+  return Math.atan2(2 * (w * y + x * z), 1 - 2 * (x * x + y * y));
+}
+var yawPair = new Float64Array(2);
+function yawInto(rotation, at, out, index) {
+  let x = rotation[at], y = rotation[at + 1], z = rotation[at + 2], w = rotation[at + 3];
+  yawPair[0] = 2 * (w * y + x * z), yawPair[1] = 1 - 2 * (x * x + y * y), atan2Into(yawPair, 0), out[index] = yawPair[0];
+}
+function writeYawPitch(rotation, at, angles, yawIndex, pitchIndex) {
+  let yaw = angles[yawIndex], pitch = angles[pitchIndex], sy = Math.sin(yaw / 2), cy = Math.cos(yaw / 2), sp = Math.sin(pitch / 2), cp = Math.cos(pitch / 2);
+  rotation[at] = cy * sp, rotation[at + 1] = sy * cp, rotation[at + 2] = -sy * sp, rotation[at + 3] = cy * cp;
+}
+
+// src/game/kit/camera/boom.ts
+var BOOM_OX = 0, BOOM_OY = 1, BOOM_OZ = 2, BOOM_DX = 3, BOOM_DY = 4, BOOM_DZ = 5, BOOM_DISTANCE = 6, BOOM_FREE = 7, BOOM_IO_WORDS = 8, POSE_X = 0, POSE_Y = 1, POSE_Z = 2, POSE_YAW = 3, POSE_PITCH = 4, DEFAULT_BOOM_RADIUS = 0.22, DEFAULT_BOOM_MARGIN = 0.06, FOV_EPSILON = 0.01, LENS_FOV = 0, LENS_NEAR = 1, LENS_FAR = 2, LENS_WORDS = 3, PICK_OPEN = 0, PICK_BLOCKED = 1, PICK_FREE = 2, PICK_WORDS = 3, CameraBoom = class {
+  constructor(physics, options = {}) {
+    this.query = new chunkRCQ2MPBV_js.ShapeCastQuery();
+    this.hit = new chunkG3EEC44R_js.RayHit();
+    this.pick = new Float64Array((3));
+    this.physics = physics, this.radius = options.radius ?? (0.22), this.margin = options.margin ?? (0.06), this.query.ball(this.radius);
+  }
+  cast(io, at, excludeBody) {
+    let distance = io[at + (6)];
+    if (distance <= 0) {
+      io[at + (7)] = 0;
+      return;
+    }
+    let q = this.query, origin = q.origin;
+    origin.x = io[at + (0)], origin.y = io[at + (1)], origin.z = io[at + (2)];
+    let direction = q.direction;
+    direction.x = io[at + (3)], direction.y = io[at + (4)], direction.z = io[at + (5)], q.maxDistance = distance + this.margin, q.excludeBody = excludeBody;
+    let hit = this.physics.castShape(q, this.hit), pick = this.pick;
+    pick[(0)] = distance, pick[(1)] = 0, pick[(2)] = this.hit.distance - this.margin;
+    let beyond = !(pick[(2)] < distance), blocked = pick[(2)] <= 0, choice = hit && !beyond ? blocked ? (1) : (2) : (0);
+    io[at + (7)] = pick[choice];
+  }
+};
+function interpolatedPosition(transforms, entity, clock, out, offset) {
+  let f = transforms.store.fields, o = transforms.row(entity) * 3, alpha = clock[chunkYXGZQPUD_js.FRAME_ALPHA_SLOT], now = f.position, before = f.previousPosition;
+  out[offset] = before[o] + (now[o] - before[o]) * alpha, out[offset + 1] = before[o + 1] + (now[o + 1] - before[o + 1]) * alpha, out[offset + 2] = before[o + 2] + (now[o + 2] - before[o + 2]) * alpha;
+}
+function placeCamera(transforms, camera, pose, at) {
+  let row = transforms.row(camera), f = transforms.store.fields, p = row * 3, q = row * 4;
+  f.position[p] = pose[at + (0)], f.position[p + 1] = pose[at + (1)], f.position[p + 2] = pose[at + (2)], writeYawPitch(f.rotation, q, pose, at + (3), at + (4));
+  for (let i = 0; i < 3; i++) f.previousPosition[p + i] = f.position[p + i];
+  for (let i = 0; i < 4; i++) f.previousRotation[q + i] = f.rotation[q + i];
+}
+var LensDriver = class {
+  constructor(lens) {
+    this.projection = new Float64Array((3)).fill(Number.NaN);
+    this.lens = lens, lens !== null && (this.projection[(1)] = lens.near, this.projection[(2)] = lens.far);
+  }
+  apply(values, index) {
+    let lens = this.lens;
+    if (lens === null) return;
+    let p = this.projection, fov = values[index], shown = p[(0)];
+    shown === shown && Math.abs(shown - fov) < (0.01) || (p[(0)] = fov, lens.graphics.setPerspectiveFrom(lens.node, p, (0)));
+  }
+};
+
+exports.BOOM_DISTANCE = (6);
+exports.BOOM_DX = (3);
+exports.BOOM_DY = (4);
+exports.BOOM_DZ = (5);
+exports.BOOM_FREE = (7);
+exports.BOOM_IO_WORDS = (8);
+exports.BOOM_OX = (0);
+exports.BOOM_OY = (1);
+exports.BOOM_OZ = (2);
+exports.CameraBoom = CameraBoom;
+exports.DEFAULT_BOOM_RADIUS = (0.22);
+exports.LensDriver = LensDriver;
+exports.POSE_PITCH = (4);
+exports.POSE_X = (0);
+exports.POSE_Y = (1);
+exports.POSE_YAW = (3);
+exports.POSE_Z = (2);
+exports.TWO_PI = TWO_PI;
+exports.atan2Into = atan2Into;
+exports.clamp = clamp;
+exports.dampFactor = dampFactor;
+exports.interpolatedPosition = interpolatedPosition;
+exports.placeCamera = placeCamera;
+exports.wrapAngle = wrapAngle;
+exports.wrapAt = wrapAt;
+exports.yawInto = yawInto;
+exports.yawOfQuat = yawOfQuat;