@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-XK6UDWJS.js

@@ -0,0 +1,203 @@
+'use strict';
+
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
+
+// src/interactives/runtime/studio.ts
+var STUDIO_GRANT_TOPIC = "studio.grant", STUDIO_FRAME_HEADER_BYTES = 9, STUDIO_PART_BYTES = 1 << 20, STUDIO_MESSAGE_MAX_BYTES = 16 << 20, STUDIO_MAX_PARTS = STUDIO_MESSAGE_MAX_BYTES / STUDIO_PART_BYTES, STUDIO_MAX_TOPIC_BYTES = 64, STUDIO_HELD_MESSAGES = 8, SEQ_OFFSET = 1, INDEX_OFFSET = 5, COUNT_OFFSET = 7, TOPIC_LENGTH_BYTES = 1, JSON_LENGTH_BYTES = 4, PAYLOAD_HEAD_BYTES = (1) + (4), NULL_JSON = "null", STUDIO_CHANNEL_KEY = "__cimplify_studio", encoder = new TextEncoder(), decoder = new TextDecoder(), StudioFrameError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "StudioFrameError";
+  }
+};
+function studioPayload(message) {
+  let topic = encoder.encode(message.topic);
+  if (topic.length === 0 || topic.length > (64))
+    throw new StudioFrameError(`a studio topic is 1 to ${(64)} bytes`);
+  let json = encoder.encode(
+    message.json ?? (message.body === void 0 ? NULL_JSON : JSON.stringify(message.body))
+  ), bytes = message.bytes ?? null, size = PAYLOAD_HEAD_BYTES + topic.length + json.length + (bytes?.length ?? 0);
+  if (size > STUDIO_MESSAGE_MAX_BYTES)
+    throw new StudioFrameError(`a studio message is at most ${STUDIO_MESSAGE_MAX_BYTES} bytes`);
+  let payload = new Uint8Array(size), view = new DataView(payload.buffer);
+  return payload[0] = topic.length, payload.set(topic, (1)), view.setUint32((1) + topic.length, json.length, true), payload.set(json, PAYLOAD_HEAD_BYTES + topic.length), bytes !== null && payload.set(bytes, PAYLOAD_HEAD_BYTES + topic.length + json.length), payload;
+}
+function studioFrames(tag, seq, payload) {
+  let count = Math.max(1, Math.ceil(payload.length / STUDIO_PART_BYTES));
+  if (count > STUDIO_MAX_PARTS)
+    throw new StudioFrameError(`a studio message is at most ${STUDIO_MESSAGE_MAX_BYTES} bytes`);
+  let frames = [];
+  for (let index = 0; index < count; index++) {
+    let part = payload.subarray(
+      index * STUDIO_PART_BYTES,
+      Math.min(payload.length, (index + 1) * STUDIO_PART_BYTES)
+    ), frame = new Uint8Array((9) + part.length), view = new DataView(frame.buffer);
+    frame[0] = tag, view.setUint32((1), seq >>> 0, true), view.setUint16((5), index, true), view.setUint16((7), count, true), frame.set(part, (9)), frames.push(frame);
+  }
+  return frames;
+}
+function readStudioPayload(payload) {
+  if (payload.length < PAYLOAD_HEAD_BYTES)
+    throw new StudioFrameError("a studio message is cut short");
+  let topicLength = payload[0];
+  if (topicLength === 0 || topicLength > (64) || payload.length < PAYLOAD_HEAD_BYTES + topicLength)
+    throw new StudioFrameError("a studio message has no readable topic");
+  let jsonLength = new DataView(payload.buffer, payload.byteOffset, payload.byteLength).getUint32((1) + topicLength, true), jsonStart = PAYLOAD_HEAD_BYTES + topicLength;
+  if (jsonStart + jsonLength > payload.length)
+    throw new StudioFrameError("a studio message body runs past its end");
+  let topic = decoder.decode(
+    payload.subarray((1), (1) + topicLength)
+  ), body;
+  try {
+    body = JSON.parse(decoder.decode(payload.subarray(jsonStart, jsonStart + jsonLength)));
+  } catch {
+    throw new StudioFrameError("a studio message body is not JSON");
+  }
+  let rest = jsonStart + jsonLength;
+  return { topic, body, bytes: rest < payload.length ? payload.slice(rest) : null };
+}
+var StudioAssembler = class {
+  constructor() {
+    this.seq = -1;
+    this.count = 0;
+    this.next = 0;
+    this.size = 0;
+    this.parts = [];
+  }
+  get pending() {
+    return this.next > 0;
+  }
+  reset() {
+    this.seq = -1, this.count = 0, this.next = 0, this.size = 0, this.parts = [];
+  }
+  accept(frame) {
+    try {
+      return this.take(frame);
+    } catch (error) {
+      throw this.reset(), error;
+    }
+  }
+  take(frame) {
+    if (frame.length < (9))
+      throw new StudioFrameError("a studio frame is cut short");
+    let view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength), seq = view.getUint32((1), true), index = view.getUint16((5), true), count = view.getUint16((7), true);
+    if (count === 0 || count > STUDIO_MAX_PARTS || index >= count)
+      throw new StudioFrameError("a studio frame has an impossible part count");
+    if (index === 0)
+      this.reset(), this.seq = seq, this.count = count;
+    else if (seq !== this.seq || count !== this.count || index !== this.next)
+      throw new StudioFrameError("a studio frame arrived out of order");
+    let part = frame.subarray((9));
+    if (part.length > STUDIO_PART_BYTES)
+      throw new StudioFrameError("a studio frame is over its part size");
+    if (this.size += part.length, this.size > STUDIO_MESSAGE_MAX_BYTES)
+      throw new StudioFrameError("a studio message is over its size");
+    if (this.next = index + 1, count === 1)
+      return this.reset(), readStudioPayload(part);
+    if (this.parts.push(part.slice()), this.next < count) return null;
+    let payload = new Uint8Array(this.size), at = 0;
+    for (let piece of this.parts)
+      payload.set(piece, at), at += piece.length;
+    return this.reset(), readStudioPayload(payload);
+  }
+}, StudioSender = class {
+  constructor(tag, send) {
+    this.tag = tag;
+    this.send = send;
+    this.seq = 0;
+  }
+  post(message) {
+    let frames = studioFrames(this.tag, this.seq, studioPayload(message));
+    this.seq = this.seq + 1 >>> 0;
+    for (let frame of frames) this.send(frame);
+  }
+}, sealedChannel = null;
+function channel() {
+  let scope = globalThis, existing = scope[STUDIO_CHANNEL_KEY] ?? sealedChannel;
+  if (existing != null) return existing;
+  let fresh = { sink: null, listeners: /* @__PURE__ */ new Set(), held: [] };
+  return Object.isExtensible(scope) ? scope[STUDIO_CHANNEL_KEY] = fresh : sealedChannel = fresh, fresh;
+}
+function openStudioChannel(sink) {
+  let studio = channel();
+  studio.sink = sink, sink === null && (studio.held.length = 0);
+}
+function sendToStudio(message) {
+  let sink = channel().sink;
+  return sink === null ? false : (sink(message), true);
+}
+function deliverStudio(message) {
+  let studio = channel();
+  if (!(studio.sink === null || message.topic === STUDIO_GRANT_TOPIC)) {
+    if (studio.listeners.size === 0) {
+      studio.held.length < (8) && studio.held.push(message);
+      return;
+    }
+    for (let listener of studio.listeners) listener(message);
+  }
+}
+function onStudio(listener) {
+  let studio = channel();
+  studio.listeners.add(listener);
+  let held = studio.held.splice(0);
+  for (let message of held) listener(message);
+  return () => {
+    studio.listeners.delete(listener);
+  };
+}
+chunk4ZDR72SG_js.MessageTag.studio; chunk4ZDR72SG_js.MessageTag.studio_report;
+
+// src/interactives/meters/channel.ts
+var METERS_OFF = { on: false, tier: "high", pin: false }, METER_REPORT_FRAMES = 30, METER_CHANNEL_KEY = "__cimplify_meters", sealedChannel2 = null;
+function channel2() {
+  let scope = globalThis, existing = scope[METER_CHANNEL_KEY] ?? sealedChannel2;
+  if (existing != null) return existing;
+  let fresh = {
+    request: METERS_OFF,
+    sink: null,
+    scriptHeap: null,
+    listeners: /* @__PURE__ */ new Set()
+  };
+  return Object.isExtensible(scope) ? scope[METER_CHANNEL_KEY] = fresh : sealedChannel2 = fresh, fresh;
+}
+function requestMeters(request) {
+  let meters = channel2(), was = meters.request;
+  if (!(was.on === request.on && was.tier === request.tier && was.pin === request.pin)) {
+    meters.request = request;
+    for (let listener of meters.listeners) listener(request);
+  }
+}
+function metersRequested() {
+  return channel2().request;
+}
+function watchMeters(listener) {
+  let meters = channel2();
+  return meters.listeners.add(listener), meters.request.on && listener(meters.request), () => {
+    meters.listeners.delete(listener);
+  };
+}
+function reportMetersTo(sink, scriptHeap = null) {
+  let meters = channel2();
+  meters.sink = sink, meters.scriptHeap = scriptHeap;
+}
+function meterScriptHeap() {
+  return channel2().scriptHeap?.() ?? 0;
+}
+function reportMeters(live) {
+  channel2().sink?.(live);
+}
+
+exports.METERS_OFF = METERS_OFF;
+exports.METER_REPORT_FRAMES = (30);
+exports.STUDIO_GRANT_TOPIC = STUDIO_GRANT_TOPIC;
+exports.STUDIO_MESSAGE_MAX_BYTES = STUDIO_MESSAGE_MAX_BYTES;
+exports.StudioAssembler = StudioAssembler;
+exports.StudioSender = StudioSender;
+exports.deliverStudio = deliverStudio;
+exports.meterScriptHeap = meterScriptHeap;
+exports.metersRequested = metersRequested;
+exports.onStudio = onStudio;
+exports.openStudioChannel = openStudioChannel;
+exports.reportMeters = reportMeters;
+exports.reportMetersTo = reportMetersTo;
+exports.requestMeters = requestMeters;
+exports.sendToStudio = sendToStudio;
+exports.watchMeters = watchMeters;

package/dist/chunk-XPG3N5CF.mjs

@@ -0,0 +1,415 @@
+import { quatFromRotationColumns } from './chunk-KIZOA5LX.mjs';
+
+// src/game/soa/layout.ts
+function kindBytes(kind) {
+  return kind === 3 ? 1 : 4;
+}
+function strideFor(capacity) {
+  return Math.ceil(capacity / 16) * 16;
+}
+function columnBytes(kind, stride) {
+  return Math.ceil(stride * kindBytes(kind) / 64) * 64;
+}
+var SOA_EXPORT_NAMES = [
+  "engine_soa_create",
+  "engine_soa_destroy",
+  "engine_soa_generations",
+  "engine_soa_header",
+  "engine_soa_turn",
+  "engine_soa_remove",
+  "engine_soa_map",
+  "engine_soa_vec",
+  "engine_soa_select",
+  "engine_soa_reduce",
+  "engine_soa_sort",
+  "engine_soa_grid",
+  "engine_soa_near",
+  "engine_soa_nearest"
+], SOA_BULK_EXPORT_NAMES = [
+  "engine_soa_inventory",
+  "engine_soa_effect",
+  "engine_soa_raycast",
+  "engine_soa_paths",
+  "engine_soa_pick",
+  "engine_soa_flow",
+  "engine_flow_create",
+  "engine_flow_destroy",
+  "engine_flow_registers",
+  "engine_flow_costs",
+  "engine_flow_rasterize",
+  "engine_flow_build"
+];
+function bindSoaEngine(symbols, memory) {
+  for (let name of SOA_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  if (typeof symbols.engine_alloc != "function" || typeof symbols.engine_free != "function") return null;
+  let bulk = {};
+  for (let name of SOA_BULK_EXPORT_NAMES) {
+    let fn = symbols[name];
+    typeof fn == "function" && (bulk[name] = fn);
+  }
+  return { exports: symbols, memory, bulk };
+}
+
+// src/game/math/shape.ts
+function settleDoubleFields(instance, fields) {
+  for (let i = 0; i < fields.length; i++) {
+    let field = fields[i], value = instance[field];
+    Reflect.set(instance, field, 0.5), Reflect.set(instance, field, value);
+  }
+}
+
+// src/game/math/vec.ts
+var Vec2 = class {
+  constructor(x = 0, y = 0) {
+    this.x = x, this.y = y;
+  }
+  set(x, y) {
+    return this.x = x, this.y = y, this;
+  }
+  copy(v) {
+    return this.x = v.x, this.y = v.y, this;
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  add(v) {
+    return this.x += v.x, this.y += v.y, this;
+  }
+  sub(v) {
+    return this.x -= v.x, this.y -= v.y, this;
+  }
+  scale(s) {
+    return this.x *= s, this.y *= s, this;
+  }
+  dot(v) {
+    return this.x * v.x + this.y * v.y;
+  }
+  cross(v) {
+    return this.x * v.y - this.y * v.x;
+  }
+  normalize() {
+    let len = this.length();
+    return len > 1e-6 && this.scale(1 / len), this;
+  }
+  distanceTo(v) {
+    return Math.hypot(this.x - v.x, this.y - v.y);
+  }
+  lerp(a, b, t) {
+    return this.x = a.x + (b.x - a.x) * t, this.y = a.y + (b.y - a.y) * t, this;
+  }
+  angle() {
+    return Math.atan2(-this.y, -this.x) + Math.PI;
+  }
+  rotateAround(center, radians) {
+    let c = Math.cos(radians), s = Math.sin(radians), x = this.x - center.x, y = this.y - center.y;
+    return this.x = x * c - y * s + center.x, this.y = x * s + y * c + center.y, this;
+  }
+}, Vec4 = class {
+  constructor(x = 0, y = 0, z = 0, w = 1) {
+    this.x = x, this.y = y, this.z = z, this.w = w;
+  }
+  set(x, y, z, w) {
+    return this.x = x, this.y = y, this.z = z, this.w = w, this;
+  }
+  copy(v) {
+    return this.set(v.x, v.y, v.z, v.w);
+  }
+  dot(v) {
+    return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+  }
+  length() {
+    return Math.sqrt(this.dot(this));
+  }
+  scale(s) {
+    return this.set(this.x * s, this.y * s, this.z * s, this.w * s);
+  }
+  lerp(a, b, t) {
+    return this.set(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
+  }
+  applyMat4(m, o) {
+    let { x, y, z, w } = this;
+    return this.set(
+      m[o] * x + m[o + 4] * y + m[o + 8] * z + m[o + 12] * w,
+      m[o + 1] * x + m[o + 5] * y + m[o + 9] * z + m[o + 13] * w,
+      m[o + 2] * x + m[o + 6] * y + m[o + 10] * z + m[o + 14] * w,
+      m[o + 3] * x + m[o + 7] * y + m[o + 11] * z + m[o + 15] * w
+    );
+  }
+  readFrom(array, offset) {
+    return this.set(array[offset], array[offset + 1], array[offset + 2], array[offset + 3]);
+  }
+  writeTo(array, offset) {
+    array[offset] = this.x, array[offset + 1] = this.y, array[offset + 2] = this.z, array[offset + 3] = this.w;
+  }
+}, Vec3 = class {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x, this.y = y, this.z = z;
+  }
+  set(x, y, z) {
+    return this.x = x, this.y = y, this.z = z, this;
+  }
+  copy(v) {
+    return this.x = v.x, this.y = v.y, this.z = v.z, this;
+  }
+  add(v) {
+    return this.x += v.x, this.y += v.y, this.z += v.z, this;
+  }
+  sub(v) {
+    return this.x -= v.x, this.y -= v.y, this.z -= v.z, this;
+  }
+  scale(s) {
+    return this.x *= s, this.y *= s, this.z *= s, this;
+  }
+  addScaled(v, s) {
+    return this.x += v.x * s, this.y += v.y * s, this.z += v.z * s, this;
+  }
+  dot(v) {
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+  }
+  cross(a, b) {
+    let x = a.y * b.z - a.z * b.y, y = a.z * b.x - a.x * b.z, z = a.x * b.y - a.y * b.x;
+    return this.x = x, this.y = y, this.z = z, this;
+  }
+  lengthSq() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  length() {
+    return Math.sqrt(this.lengthSq());
+  }
+  normalize() {
+    let len = this.length();
+    return len > 1e-6 && this.scale(1 / len), this;
+  }
+  lerp(a, b, t) {
+    return this.x = a.x + (b.x - a.x) * t, this.y = a.y + (b.y - a.y) * t, this.z = a.z + (b.z - a.z) * t, this;
+  }
+  distanceTo(v) {
+    return Math.sqrt(this.distanceToSquared(v));
+  }
+  distanceToSquared(v) {
+    let dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+    return dx * dx + dy * dy + dz * dz;
+  }
+  negate() {
+    return this.set(-this.x, -this.y, -this.z);
+  }
+  min(v) {
+    return this.set(Math.min(this.x, v.x), Math.min(this.y, v.y), Math.min(this.z, v.z));
+  }
+  max(v) {
+    return this.set(Math.max(this.x, v.x), Math.max(this.y, v.y), Math.max(this.z, v.z));
+  }
+  clamp(lo, hi) {
+    return this.set(
+      Math.max(lo.x, Math.min(hi.x, this.x)),
+      Math.max(lo.y, Math.min(hi.y, this.y)),
+      Math.max(lo.z, Math.min(hi.z, this.z))
+    );
+  }
+  clampLength(min, max) {
+    let len = this.length();
+    return len < 1e-6 ? this : this.scale(Math.max(min, Math.min(max, len)) / len);
+  }
+  subVectors(a, b) {
+    return this.set(a.x - b.x, a.y - b.y, a.z - b.z);
+  }
+  addVectors(a, b) {
+    return this.set(a.x + b.x, a.y + b.y, a.z + b.z);
+  }
+  applyQuat(q) {
+    return q.rotate(this), this;
+  }
+  applyMat4(m, o) {
+    let x = this.x, y = this.y, z = this.z, w = m[o + 3] * x + m[o + 7] * y + m[o + 11] * z + m[o + 15], inv = Math.abs(w) > 1e-6 ? 1 / w : 1;
+    return this.set(
+      (m[o] * x + m[o + 4] * y + m[o + 8] * z + m[o + 12]) * inv,
+      (m[o + 1] * x + m[o + 5] * y + m[o + 9] * z + m[o + 13]) * inv,
+      (m[o + 2] * x + m[o + 6] * y + m[o + 10] * z + m[o + 14]) * inv
+    );
+  }
+  transformDirection(m, o) {
+    let x = this.x, y = this.y, z = this.z;
+    return this.set(m[o] * x + m[o + 4] * y + m[o + 8] * z, m[o + 1] * x + m[o + 5] * y + m[o + 9] * z, m[o + 2] * x + m[o + 6] * y + m[o + 10] * z), this.normalize();
+  }
+  projectOnVector(v) {
+    let denominator = v.x * v.x + v.y * v.y + v.z * v.z;
+    if (denominator < 1e-6) return this.set(0, 0, 0);
+    let s = this.dot(v) / denominator;
+    return this.set(v.x * s, v.y * s, v.z * s);
+  }
+  projectOnPlane(normal) {
+    let d = this.dot(normal);
+    return this.set(this.x - normal.x * d, this.y - normal.y * d, this.z - normal.z * d);
+  }
+  reflect(normal) {
+    let d = 2 * this.dot(normal);
+    return this.set(this.x - normal.x * d, this.y - normal.y * d, this.z - normal.z * d);
+  }
+  angleTo(v) {
+    let denominator = Math.sqrt(this.lengthSq() * (v.x * v.x + v.y * v.y + v.z * v.z));
+    return denominator < 1e-6 ? Math.PI / 2 : Math.acos(Math.max(-1, Math.min(1, this.dot(v) / denominator)));
+  }
+  setFromSpherical(radius, polar, azimuth) {
+    let s = Math.sin(polar) * radius;
+    return this.set(s * Math.sin(azimuth), Math.cos(polar) * radius, s * Math.cos(azimuth));
+  }
+  setFromMatrixColumn(m, o, column) {
+    return this.readFrom(m, o + column * 4);
+  }
+  equals(v, tolerance = 0) {
+    return Math.abs(this.x - v.x) <= tolerance && Math.abs(this.y - v.y) <= tolerance && Math.abs(this.z - v.z) <= tolerance;
+  }
+  readFrom(array, offset) {
+    return this.x = array[offset], this.y = array[offset + 1], this.z = array[offset + 2], this;
+  }
+  writeTo(array, offset) {
+    array[offset] = this.x, array[offset + 1] = this.y, array[offset + 2] = this.z;
+  }
+}, Quat = class {
+  constructor(x = 0, y = 0, z = 0, w = 1) {
+    this.x = x, this.y = y, this.z = z, this.w = w;
+  }
+  set(x, y, z, w) {
+    return this.x = x, this.y = y, this.z = z, this.w = w, this;
+  }
+  identity() {
+    return this.set(0, 0, 0, 1);
+  }
+  copy(q) {
+    return this.set(q.x, q.y, q.z, q.w);
+  }
+  setAxisAngle(axis, radians) {
+    let half = radians * 0.5, s = Math.sin(half);
+    return this.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(half));
+  }
+  setEuler(x, y, z) {
+    let cx = Math.cos(x * 0.5), sx = Math.sin(x * 0.5), cy = Math.cos(y * 0.5), sy = Math.sin(y * 0.5), cz = Math.cos(z * 0.5), sz = Math.sin(z * 0.5);
+    return this.set(
+      sx * cy * cz + cx * sy * sz,
+      cx * sy * cz - sx * cy * sz,
+      cx * cy * sz + sx * sy * cz,
+      cx * cy * cz - sx * sy * sz
+    );
+  }
+  multiply(a, b) {
+    return this.set(
+      a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+      a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+      a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+      a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+    );
+  }
+  normalize() {
+    let len = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    if (len < 1e-6) return this.identity();
+    let inv = 1 / len;
+    return this.set(this.x * inv, this.y * inv, this.z * inv, this.w * inv);
+  }
+  rotate(v) {
+    let { x, y, z, w } = this, ix = w * v.x + y * v.z - z * v.y, iy = w * v.y + z * v.x - x * v.z, iz = w * v.z + x * v.y - y * v.x, iw = -x * v.x - y * v.y - z * v.z;
+    return v.set(
+      ix * w + iw * -x + iy * -z - iz * -y,
+      iy * w + iw * -y + iz * -x - ix * -z,
+      iz * w + iw * -z + ix * -y - iy * -x
+    );
+  }
+  dot(q) {
+    return this.x * q.x + this.y * q.y + this.z * q.z + this.w * q.w;
+  }
+  conjugate() {
+    return this.set(-this.x, -this.y, -this.z, this.w);
+  }
+  invert() {
+    let lenSq = this.dot(this);
+    if (lenSq < 1e-6) return this.identity();
+    let inv = 1 / lenSq;
+    return this.set(-this.x * inv, -this.y * inv, -this.z * inv, this.w * inv);
+  }
+  premultiply(q) {
+    return this.multiply(q, this);
+  }
+  slerp(a, b, t) {
+    let bx = b.x, by = b.y, bz = b.z, bw = b.w, cos = a.x * bx + a.y * by + a.z * bz + a.w * bw;
+    cos < 0 && (cos = -cos, bx = -bx, by = -by, bz = -bz, bw = -bw);
+    let wa = 1 - t, wb = t;
+    if (cos <= 0.9995) {
+      let angle = Math.acos(cos), sin = Math.sin(angle);
+      wa = Math.sin((1 - t) * angle) / sin, wb = Math.sin(t * angle) / sin;
+    }
+    return this.set(a.x * wa + bx * wb, a.y * wa + by * wb, a.z * wa + bz * wb, a.w * wa + bw * wb), this.normalize();
+  }
+  rotateTowards(target, maxRadians) {
+    let angle = this.angleTo(target);
+    return angle < 1e-6 ? this : this.slerp(this, target, Math.min(1, maxRadians / angle));
+  }
+  angleTo(q) {
+    return 2 * Math.acos(Math.min(1, Math.abs(this.dot(q))));
+  }
+  setFromUnitVectors(from, to) {
+    let r = from.x * to.x + from.y * to.y + from.z * to.z + 1;
+    return r < 1e-6 ? (r = 0, Math.abs(from.x) > Math.abs(from.z) ? this.set(-from.y, from.x, 0, r).normalize() : this.set(0, -from.z, from.y, r).normalize()) : this.set(
+      from.y * to.z - from.z * to.y,
+      from.z * to.x - from.x * to.z,
+      from.x * to.y - from.y * to.x,
+      r
+    ).normalize();
+  }
+  setFromRotationMatrix(m, o) {
+    return quatFromRotationColumns(QUAT_SCRATCH, 0, m[o], m[o + 1], m[o + 2], m[o + 4], m[o + 5], m[o + 6], m[o + 8], m[o + 9], m[o + 10]), this.set(QUAT_SCRATCH[0], QUAT_SCRATCH[1], QUAT_SCRATCH[2], QUAT_SCRATCH[3]);
+  }
+  lookRotation(forwardX, forwardY, forwardZ, upX = 0, upY = 1, upZ = 0) {
+    let zx = -forwardX, zy = -forwardY, zz = -forwardZ, len = Math.sqrt(zx * zx + zy * zy + zz * zz);
+    if (len < 1e-6) return this.identity();
+    zx /= len, zy /= len, zz /= len;
+    let xx = upY * zz - upZ * zy, xy = upZ * zx - upX * zz, xz = upX * zy - upY * zx;
+    len = Math.sqrt(xx * xx + xy * xy + xz * xz), len < 1e-6 && (xx = 1, xy = 0, xz = 0, len = 1), xx /= len, xy /= len, xz /= len;
+    let yx = zy * xz - zz * xy, yy = zz * xx - zx * xz, yz = zx * xy - zy * xx;
+    return quatFromRotationColumns(QUAT_SCRATCH, 0, xx, xy, xz, yx, yy, yz, zx, zy, zz), this.set(QUAT_SCRATCH[0], QUAT_SCRATCH[1], QUAT_SCRATCH[2], QUAT_SCRATCH[3]);
+  }
+  toEuler(out) {
+    let { x, y, z, w } = this, m11 = 1 - 2 * (y * y + z * z), m12 = 2 * (x * y - w * z), m13 = 2 * (x * z + w * y), m22 = 1 - 2 * (x * x + z * z), m23 = 2 * (y * z - w * x), m32 = 2 * (y * z + w * x), m33 = 1 - 2 * (x * x + y * y), ey = Math.asin(Math.max(-1, Math.min(1, m13)));
+    return Math.abs(m13) < 1 - 1e-6 ? out.set(Math.atan2(-m23, m33), ey, Math.atan2(-m12, m11)) : out.set(Math.atan2(m32, m22), ey, 0);
+  }
+  readFrom(array, offset) {
+    return this.set(array[offset], array[offset + 1], array[offset + 2], array[offset + 3]);
+  }
+  writeTo(array, offset) {
+    array[offset] = this.x, array[offset + 1] = this.y, array[offset + 2] = this.z, array[offset + 3] = this.w;
+  }
+}, QUAT_SCRATCH = new Float64Array(4);
+settleDoubleFields(new Vec2(), ["x", "y"]);
+settleDoubleFields(new Vec4(), ["x", "y", "z", "w"]);
+settleDoubleFields(new Vec3(), ["x", "y", "z"]);
+settleDoubleFields(new Quat(), ["x", "y", "z", "w"]);
+
+// src/game/physics/queries.ts
+var CAST_BALL = 0, CAST_CUBOID = 1, CAST_CAPSULE = 2, CAST_CYLINDER = 3, ShapeCastQuery = class {
+  constructor() {
+    this.kind = "ball";
+    this.params = new Vec3(0.5, 0, 0);
+    this.origin = new Vec3();
+    this.rotation = new Float32Array([0, 0, 0, 1]);
+    this.direction = new Vec3(0, -1, 0);
+    this.maxDistance = Number.MAX_VALUE;
+    this.includeSensors = false;
+    this.excludeBody = -1;
+  }
+  ball(radius) {
+    return this.kind = "ball", this.params.set(radius, 0, 0), this;
+  }
+  cuboid(hx, hy, hz) {
+    return this.kind = "cuboid", this.params.set(hx, hy, hz), this;
+  }
+  capsule(halfHeight, radius) {
+    return this.kind = "capsule", this.params.set(halfHeight, radius, 0), this;
+  }
+  cylinder(halfHeight, radius) {
+    return this.kind = "cylinder", this.params.set(halfHeight, radius, 0), this;
+  }
+};
+function castShapeCode(kind) {
+  return kind === "ball" ? (0) : kind === "cuboid" ? (1) : kind === "capsule" ? (2) : (3);
+}
+settleDoubleFields(new ShapeCastQuery(), ["maxDistance"]);
+
+export { Quat, SOA_EXPORT_NAMES, ShapeCastQuery, Vec2, Vec3, Vec4, bindSoaEngine, castShapeCode, columnBytes, kindBytes, settleDoubleFields, strideFor };

package/dist/chunk-XVZ2NKSU.mjs

@@ -0,0 +1,74 @@
+// src/interactives/hosts/chrome/consents.ts
+var CONSENT_KINDS = ["camera", "clip_camera", "microphone", "location", "notifications", "friends", "personal_data", "tracking"], STORAGE_PREFIX = "cimplify.interactives.consents.";
+function memoryStore() {
+  let values = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => values.get(key) ?? null,
+    set: (key, value) => {
+      values.set(key, value);
+    }
+  };
+}
+function browserStore() {
+  let fallback = memoryStore();
+  return {
+    get(key) {
+      try {
+        return globalThis.localStorage?.getItem(key) ?? fallback.get(key);
+      } catch {
+        return fallback.get(key);
+      }
+    },
+    set(key, value) {
+      fallback.set(key, value);
+      try {
+        globalThis.localStorage?.setItem(key, value);
+      } catch {
+        return;
+      }
+    }
+  };
+}
+var ConsentStore = class {
+  constructor(storage = browserStore()) {
+    this.storage = storage;
+    this.cache = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.versionValue = 0;
+    this.version = () => this.versionValue;
+    this.subscribe = (listener) => (this.listeners.add(listener), () => this.listeners.delete(listener));
+  }
+  decisions(interactive_id) {
+    let cached = this.cache.get(interactive_id);
+    if (cached !== void 0) return cached;
+    let parsed = { granted: [], denied: [] }, raw = this.storage.get(STORAGE_PREFIX + interactive_id);
+    if (raw !== null)
+      try {
+        let value = JSON.parse(raw);
+        parsed = { granted: known(value.granted), denied: known(value.denied) };
+      } catch {
+        parsed = { granted: [], denied: [] };
+      }
+    return this.cache.set(interactive_id, parsed), parsed;
+  }
+  granted(interactive_id) {
+    return this.decisions(interactive_id).granted;
+  }
+  state(interactive_id, kind) {
+    let decisions = this.decisions(interactive_id);
+    return decisions.granted.includes(kind) ? "granted" : decisions.denied.includes(kind) ? "denied" : "undecided";
+  }
+  decide(interactive_id, kind, granted) {
+    let current = this.decisions(interactive_id), next = {
+      granted: granted ? [...current.granted.filter((k) => k !== kind), kind] : current.granted.filter((k) => k !== kind),
+      denied: granted ? current.denied.filter((k) => k !== kind) : [...current.denied.filter((k) => k !== kind), kind]
+    };
+    this.cache.set(interactive_id, next), this.storage.set(STORAGE_PREFIX + interactive_id, JSON.stringify(next)), this.versionValue++;
+    for (let listener of this.listeners) listener(interactive_id);
+  }
+};
+function known(values) {
+  return Array.isArray(values) ? values.filter((value) => CONSENT_KINDS.includes(value)) : [];
+}
+
+export { CONSENT_KINDS, ConsentStore, browserStore, memoryStore };