@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-R56P64LB.mjs

@@ -0,0 +1,208 @@
+// src/game/profile.ts
+var GAME_API_PROFILE = "game_api", DIRECT_ENGINE_PREFIX = "direct_engine:", ENGINE_FAMILIES = [
+  { engine: "three", modules: ["three"], prefixes: ["three/"] },
+  { engine: "phaser", modules: ["phaser", "phaser3", "phaser4"], prefixes: ["phaser/"] },
+  {
+    engine: "rapier",
+    modules: [],
+    prefixes: ["@dimforge/rapier2d", "@dimforge/rapier3d"]
+  },
+  { engine: "babylon", modules: ["babylonjs"], prefixes: ["@babylonjs/", "babylonjs/"] },
+  { engine: "playcanvas", modules: ["playcanvas"], prefixes: ["playcanvas/"] },
+  { engine: "pixi", modules: ["pixi.js"], prefixes: ["@pixi/", "pixi.js/"] },
+  { engine: "matter", modules: ["matter-js"], prefixes: [] },
+  { engine: "cannon", modules: ["cannon", "cannon-es"], prefixes: [] },
+  { engine: "ammo", modules: ["ammo.js"], prefixes: [] },
+  { engine: "react-three-fiber", modules: [], prefixes: ["@react-three/"] }
+], ENGINE_ADDONS = {
+  three: ["three", "rapier"],
+  phaser: ["phaser", "rapier"]
+}, BACKEND_PREFIX = "@cimplify/sdk/game/", PUBLIC_GAME_ENTRIES = [
+  "@cimplify/sdk/game",
+  "@cimplify/sdk/game/kit",
+  "@cimplify/sdk/game/kit/canvas",
+  "@cimplify/sdk/game/kit/slots",
+  "@cimplify/sdk/game/kit/engine",
+  "@cimplify/sdk/game/kit/shootout",
+  "@cimplify/sdk/game/kit/runner",
+  "@cimplify/sdk/game/kit/five-a-side",
+  "@cimplify/sdk/game/kit/ludo",
+  "@cimplify/sdk/game/kit/word",
+  "@cimplify/sdk/game/kit/tycoon",
+  "@cimplify/sdk/game/kit/danfo",
+  "@cimplify/sdk/game/kit/courier",
+  "@cimplify/sdk/game/kit/worlds"
+];
+function parseGameProfile(value) {
+  if (value === GAME_API_PROFILE) return { ok: true, profile: { kind: "game_api" }, error: null };
+  if (value.startsWith(DIRECT_ENGINE_PREFIX)) {
+    let engine = value.slice(DIRECT_ENGINE_PREFIX.length);
+    return engine === "three" || engine === "phaser" ? { ok: true, profile: { kind: "direct_engine", engine }, error: null } : { ok: false, profile: null, error: `engine ${engine} is not an admitted engine profile` };
+  }
+  return { ok: false, profile: null, error: `profile must be ${GAME_API_PROFILE} or ${DIRECT_ENGINE_PREFIX}<engine>` };
+}
+function engineOf(specifier) {
+  for (let family of ENGINE_FAMILIES) {
+    if (family.modules.indexOf(specifier) >= 0) return family.engine;
+    for (let prefix of family.prefixes) if (specifier.startsWith(prefix)) return family.engine;
+  }
+  return null;
+}
+function checkGameSources(manifest, files) {
+  let parsed = parseGameProfile(manifest.profile);
+  if (!parsed.ok || !parsed.profile)
+    return { ok: false, profile: null, violations: [], error: parsed.error };
+  let profile = parsed.profile, violations = [];
+  for (let file of files)
+    for (let found of scanImports(file.source)) {
+      let violation = judge(profile, found.specifier, found.dynamic);
+      violation && violations.push({ path: file.path, line: found.line, specifier: found.specifier, reason: violation.reason, engine: violation.engine });
+    }
+  return { ok: violations.length === 0, profile, violations, error: null };
+}
+function judge(profile, specifier, dynamic) {
+  if (specifier === null)
+    return dynamic ? { reason: "dynamic_import", engine: null } : null;
+  if (specifier.startsWith(BACKEND_PREFIX) && PUBLIC_GAME_ENTRIES.indexOf(specifier) < 0)
+    return { reason: "backend_import", engine: null };
+  let engine = engineOf(specifier);
+  return engine === null ? null : profile.kind === "game_api" ? { reason: "engine_import", engine } : ENGINE_ADDONS[profile.engine].indexOf(engine) >= 0 ? null : { reason: "foreign_engine_import", engine };
+}
+var IDENT_START = /[A-Za-z_$]/, IDENT_PART = /[A-Za-z0-9_$]/, REGEX_PRECEDERS = /* @__PURE__ */ new Set(["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";", "+", "-", "*", "%", "<", ">", "~", "^", "return", "typeof", "case", "do", "else", "in", "of", "new", "delete", "void", "throw", "yield", "await", ""]);
+function scanImports(source) {
+  let tokens = tokenize(source), found = [];
+  for (let i = 0; i < tokens.length; i++) {
+    let t = tokens[i];
+    if (t.kind !== "ident") continue;
+    let prev = i > 0 ? tokens[i - 1] : null;
+    if (!(prev && prev.kind === "punct" && prev.value === ".")) {
+      if (t.value === "import") {
+        let next = tokens[i + 1];
+        if (next && next.kind === "punct" && next.value === "(") {
+          found.push(callArgument(tokens, i + 2, t.line, true));
+          continue;
+        }
+        if (next && next.kind === "punct" && next.value === ".") continue;
+        if (next && next.kind === "string") {
+          found.push({ specifier: next.value, line: t.line, dynamic: false });
+          continue;
+        }
+        let from = findFrom(tokens, i + 1);
+        from && found.push({ specifier: from.value, line: t.line, dynamic: false });
+      } else if (t.value === "export") {
+        let from = findFrom(tokens, i + 1);
+        from && found.push({ specifier: from.value, line: t.line, dynamic: false });
+      } else if (t.value === "require") {
+        let next = tokens[i + 1];
+        next && next.kind === "punct" && next.value === "(" && found.push(callArgument(tokens, i + 2, t.line, true));
+      }
+    }
+  }
+  return found;
+}
+function callArgument(tokens, index, line, dynamic) {
+  let arg = tokens[index], close = tokens[index + 1];
+  return arg && arg.kind === "string" && close && close.kind === "punct" && (close.value === ")" || close.value === ",") ? { specifier: arg.value, line, dynamic } : { specifier: null, line, dynamic };
+}
+function findFrom(tokens, start) {
+  for (let i = start; i < tokens.length; i++) {
+    let t = tokens[i];
+    if (t.kind === "punct" && t.value === ";") return null;
+    if (t.kind === "ident" && t.value === "from") {
+      let next = tokens[i + 1];
+      return next && next.kind === "string" ? { value: next.value } : null;
+    }
+    if (t.kind === "ident" && (t.value === "import" || t.value === "export") && i > start || t.kind === "punct" && t.value === "=") return null;
+  }
+  return null;
+}
+function tokenize(source) {
+  let tokens = [], braceStack = [], line = 1, i = 0, n = source.length, lastSignificant = () => {
+    let t = tokens[tokens.length - 1];
+    return t ? t.kind === "punct" || t.kind === "ident" ? t.value : "value" : "";
+  };
+  for (; i < n; ) {
+    let c = source[i];
+    if (c === `
+`) {
+      line++, i++;
+      continue;
+    }
+    if (c === " " || c === "	" || c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === "/" && source[i + 1] === "/") {
+      for (; i < n && source[i] !== `
+`; ) i++;
+      continue;
+    }
+    if (c === "/" && source[i + 1] === "*") {
+      for (i += 2; i < n && !(source[i] === "*" && source[i + 1] === "/"); )
+        source[i] === `
+` && line++, i++;
+      i += 2;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      let start = line, value = "";
+      for (i++; i < n && source[i] !== c; ) {
+        if (source[i] === "\\") {
+          value += source[i + 1] ?? "", i += 2;
+          continue;
+        }
+        source[i] === `
+` && line++, value += source[i], i++;
+      }
+      i++, tokens.push({ kind: "string", value, line: start });
+      continue;
+    }
+    if (c === "`" || c === "}" && braceStack.length > 0 && braceStack[braceStack.length - 1] === 0) {
+      c === "}" && braceStack.pop();
+      let start = line;
+      for (i++; i < n && source[i] !== "`"; ) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === "$" && source[i + 1] === "{") {
+          braceStack.push(0), i += 2;
+          break;
+        }
+        source[i] === `
+` && line++, i++;
+      }
+      source[i] === "`" && i++, tokens.push({ kind: "template", line: start });
+      continue;
+    }
+    if (c === "/" && REGEX_PRECEDERS.has(lastSignificant())) {
+      i++;
+      let inClass = false;
+      for (; i < n && source[i] !== `
+`; ) {
+        let r = source[i];
+        if (r === "\\") {
+          i += 2;
+          continue;
+        }
+        if (r === "[") inClass = true;
+        else if (r === "]") inClass = false;
+        else if (r === "/" && !inClass) break;
+        i++;
+      }
+      for (i++; i < n && IDENT_PART.test(source[i]); ) i++;
+      tokens.push({ kind: "template", line });
+      continue;
+    }
+    if (IDENT_START.test(c)) {
+      let j = i + 1;
+      for (; j < n && IDENT_PART.test(source[j]); ) j++;
+      tokens.push({ kind: "ident", value: source.slice(i, j), line }), i = j;
+      continue;
+    }
+    c === "{" ? braceStack.length > 0 && braceStack[braceStack.length - 1]++ : c === "}" && braceStack.length > 0 && braceStack[braceStack.length - 1]--, tokens.push({ kind: "punct", value: c, line }), i++;
+  }
+  return tokens;
+}
+
+export { DIRECT_ENGINE_PREFIX, GAME_API_PROFILE, checkGameSources, engineOf, parseGameProfile, scanImports };

package/dist/chunk-RCQ2MPBV.js

@@ -0,0 +1,428 @@
+'use strict';
+
+var chunkAZ5BGWHB_js = require('./chunk-AZ5BGWHB.js');
+
+// 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 chunkAZ5BGWHB_js.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 chunkAZ5BGWHB_js.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"]);
+
+exports.Quat = Quat;
+exports.SOA_EXPORT_NAMES = SOA_EXPORT_NAMES;
+exports.ShapeCastQuery = ShapeCastQuery;
+exports.Vec2 = Vec2;
+exports.Vec3 = Vec3;
+exports.Vec4 = Vec4;
+exports.bindSoaEngine = bindSoaEngine;
+exports.castShapeCode = castShapeCode;
+exports.columnBytes = columnBytes;
+exports.kindBytes = kindBytes;
+exports.settleDoubleFields = settleDoubleFields;
+exports.strideFor = strideFor;