@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-XYP45OLE.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var chunkZXREOYOW_js = require('./chunk-ZXREOYOW.js');
+var chunkWWKMOA76_js = require('./chunk-WWKMOA76.js');
+
+// src/interactives/runtime/web-face-colours.ts
+var RED_SHIFT = 16, GREEN_SHIFT = 8;
+function packColour(colour) {
+  return colour === null ? chunkZXREOYOW_js.NO_FACE_COLOUR : (colour[0] & 255) << (16) | (colour[1] & 255) << (8) | colour[2] & 255;
+}
+function packColours(colours) {
+  return { skin: packColour(colours.skin), hair: packColour(colours.hair), eye: packColour(colours.eye) };
+}
+var STRIDE = chunkWWKMOA76_js.FACE_LAYOUT.landmark_stride, CHANNELS = 4, LEVELS = 256, BYTE = 255, LUMA_R = 0.2126, LUMA_G = 0.7152, LUMA_B = 0.0722, SKIN_PATCH = 0.06, HAIR_PATCH = 0.08, HAIR_LIFT = 0.16, IRIS_PATCH = 0.14, MIN_HAIR_CONTRAST = 0.06, HAIR_SPREAD = [-0.35, 0, 0.35], MID = 0.5, POINT = {
+  rightEyeOuter: 33,
+  rightEyeInner: 133,
+  leftEyeInner: 362,
+  leftEyeOuter: 263,
+  forehead: 10,
+  chin: 152,
+  rightEyeBottom: 145,
+  leftEyeBottom: 374,
+  mouthRight: 61,
+  mouthLeft: 291,
+  rightBrowMid: 105,
+  leftBrowMid: 334
+}, SKIN_PAIRS = [
+  [POINT.rightEyeBottom, POINT.mouthRight],
+  [POINT.leftEyeBottom, POINT.mouthLeft],
+  [POINT.rightBrowMid, POINT.forehead],
+  [POINT.leftBrowMid, POINT.forehead]
+], IRIS_PAIRS = [
+  [POINT.rightEyeOuter, POINT.rightEyeInner],
+  [POINT.leftEyeInner, POINT.leftEyeOuter]
+], FaceColourSampler = class {
+  constructor() {
+    this.bins = new Uint32Array((256) * 3);
+    this.count = 0;
+  }
+  sample(source, landmarks) {
+    let w = source.width, h = source.height, px = (i) => landmarks[i * STRIDE] * w, py = (i) => landmarks[i * STRIDE + 1] * h, ex = px(POINT.leftEyeOuter) - px(POINT.rightEyeOuter), ey = py(POINT.leftEyeOuter) - py(POINT.rightEyeOuter), span = Math.sqrt(ex * ex + ey * ey);
+    this.reset();
+    for (let [a, b] of SKIN_PAIRS) this.patch(source, px(a) + (px(b) - px(a)) * (0.5), py(a) + (py(b) - py(a)) * (0.5), span * (0.06), (255) + 1);
+    let skin = this.median() ?? [(255) >> 1, (255) >> 1, (255) >> 1], upX = px(POINT.forehead) - px(POINT.chin), upY = py(POINT.forehead) - py(POINT.chin);
+    this.reset();
+    for (let side of HAIR_SPREAD)
+      this.patch(source, px(POINT.forehead) + upX * (0.16) + ex * side, py(POINT.forehead) + upY * (0.16) + ey * side, span * (0.08), (255) + 1);
+    let hairRaw = this.median(), hair = hairRaw !== null && Math.abs(luma(hairRaw) - luma(skin)) >= (0.06) ? hairRaw : null;
+    this.reset();
+    let below = luma(skin) * (255);
+    for (let [a, b] of IRIS_PAIRS) {
+      let dx = px(b) - px(a), dy = py(b) - py(a);
+      this.patch(source, (px(a) + px(b)) / 2, (py(a) + py(b)) / 2, Math.sqrt(dx * dx + dy * dy) * (0.14), below);
+    }
+    return { skin, hair, eye: this.median() };
+  }
+  reset() {
+    this.bins.fill(0), this.count = 0;
+  }
+  patch(source, cx, cy, half, lumaBelow) {
+    let x0 = Math.max(0, Math.floor(cx - half)), x1 = Math.min(source.width - 1, Math.ceil(cx + half)), y0 = Math.max(0, Math.floor(cy - half)), y1 = Math.min(source.height - 1, Math.ceil(cy + half));
+    if (x1 < x0 || y1 < y0) return;
+    let width = x1 - x0 + 1, pixels = source.read(x0, y0, width, y1 - y0 + 1);
+    for (let i = 0; i < pixels.length; i += (4)) {
+      let r = pixels[i], g = pixels[i + 1], b = pixels[i + 2];
+      (0.2126) * r + (0.7152) * g + (0.0722) * b >= lumaBelow || (this.bins[r]++, this.bins[(256) + g]++, this.bins[(256) * 2 + b]++, this.count++);
+    }
+  }
+  median() {
+    if (this.count === 0) return null;
+    let half = this.count + 1 >> 1, out = [0, 0, 0];
+    for (let c = 0; c < 3; c++) {
+      let seen = 0, level = 0;
+      for (; level < (256) && (seen += this.bins[c * (256) + level], !(seen >= half)); level++)
+        ;
+      out[c] = level;
+    }
+    return [out[0], out[1], out[2]];
+  }
+};
+function luma(c) {
+  return ((0.2126) * c[0] + (0.7152) * c[1] + (0.0722) * c[2]) / (255);
+}
+function landmarksPresent(landmarks) {
+  let a = POINT.rightEyeOuter * STRIDE, b = POINT.leftEyeOuter * STRIDE;
+  return landmarks[a] !== landmarks[b] || landmarks[a + 1] !== landmarks[b + 1];
+}
+var VideoPixelSource = class {
+  constructor(video) {
+    this.video = video;
+    this.context = null;
+    this.canvas = null;
+    this.width = 0;
+    this.height = 0;
+  }
+  capture() {
+    return this.width = this.video.videoWidth, this.height = this.video.videoHeight, this.width === 0 || this.height === 0 || ((this.canvas === null || this.canvas.width !== this.width || this.canvas.height !== this.height) && (this.canvas = new OffscreenCanvas(this.width, this.height), this.context = this.canvas.getContext("2d", { willReadFrequently: true })), this.context === null) ? false : (this.context.drawImage(this.video, 0, 0, this.width, this.height), true);
+  }
+  read(x, y, width, height) {
+    return this.context === null ? new Uint8ClampedArray(0) : this.context.getImageData(x, y, width, height).data;
+  }
+}, WebFaceColours = class {
+  constructor(video) {
+    this.sampler = new FaceColourSampler();
+    this.source = new VideoPixelSource(video);
+  }
+  sample(landmarks) {
+    return !landmarksPresent(landmarks) || !this.source.capture() ? null : packColours(this.sampler.sample(this.source, landmarks));
+  }
+};
+
+exports.FaceColourSampler = FaceColourSampler;
+exports.VideoPixelSource = VideoPixelSource;
+exports.WebFaceColours = WebFaceColours;
+exports.landmarksPresent = landmarksPresent;
+exports.packColour = packColour;
+exports.packColours = packColours;

package/dist/chunk-XZSDGZX6.mjs

@@ -0,0 +1,301 @@
+import { ODDS_TOTAL_PPM } from './chunk-3DAD2LDF.mjs';
+
+// src/game/kit/economy/real-money.ts
+var ISO_4217 = "aed afn all amd ang aoa ars aud awg azn bam bbd bdt bgn bhd bif bmd bnd bob brl bsd btn bwp byn bzd cad cdf chf clp cny cop crc cuc cup cve czk djf dkk dop dzd egp ern etb eur fjd fkp gbp gel ghs gip gmd gnf gtq gyd hkd hnl htg huf idr ils inr iqd irr isk jmd jod jpy kes kgs khr kmf kpw krw kwd kyd kzt lak lbp lkr lrd lsl lyd mad mdl mga mkd mmk mnt mop mru mur mvr mwk mxn myr mzn nad ngn nio nok npr nzd omr pab pen pgk php pkr pln pyg qar ron rsd rub rwf sar sbd scr sdg sek sgd shp sle sll sos srd ssp stn svc syp szl thb tjs tmt tnd top try ttd twd tzs uah ugx usd uyu uzs ves vnd vuv wst xaf xcd xof xpf yer zar zmw zwl", MONEY_WORDS = [
+  "dollar",
+  "cent",
+  "euro",
+  "eurocent",
+  "pound",
+  "sterling",
+  "penny",
+  "pennies",
+  "pence",
+  "yen",
+  "yuan",
+  "renminbi",
+  "rupee",
+  "paisa",
+  "naira",
+  "kobo",
+  "cedi",
+  "pesewa",
+  "shilling",
+  "rand",
+  "franc",
+  "cfa",
+  "dirham",
+  "dinar",
+  "riyal",
+  "rial",
+  "peso",
+  "centavo",
+  "reais",
+  "ruble",
+  "rouble",
+  "kopek",
+  "kwacha",
+  "ngwee",
+  "birr",
+  "leone",
+  "dalasi",
+  "ouguiya",
+  "kwanza",
+  "metical",
+  "meticais",
+  "pula",
+  "thebe",
+  "loti",
+  "maloti",
+  "lilangeni",
+  "emalangeni",
+  "ariary",
+  "lira",
+  "kurus",
+  "baht",
+  "ringgit",
+  "rupiah",
+  "zloty",
+  "krona",
+  "krone",
+  "kronor",
+  "kroner",
+  "forint",
+  "koruna",
+  "hryvnia",
+  "taka",
+  "afghani",
+  "ngultrum",
+  "kyat",
+  "tugrik",
+  "tenge",
+  "manat",
+  "lari",
+  "shekel",
+  "sheqel",
+  "guarani",
+  "boliviano",
+  "cordoba",
+  "quetzal",
+  "lempira",
+  "balboa",
+  "gourde",
+  "bitcoin",
+  "satoshi",
+  "usdt",
+  "usdc",
+  "stablecoin"
+], MONEY_PHRASES = ["cfa franc", "pound sterling", "brazilian real", "south african rand", "us dollar"], MONEY_SYMBOLS = [
+  "\u20A6",
+  "\u20B5",
+  "$",
+  "\u20AC",
+  "\xA3",
+  "\xA5",
+  "\u20B9",
+  "\u20A9",
+  "\u20BD",
+  "\u20BA",
+  "\u20B1",
+  "\u20AB",
+  "\u20AD",
+  "\u20AE",
+  "\u20B4",
+  "\u20B8",
+  "\u20BC",
+  "\u20BE",
+  "\u20BF",
+  "\xA2",
+  "\u0E3F",
+  "\u20AA",
+  "\uFDFC",
+  "\u20A1",
+  "\u20B2",
+  "\u20A3",
+  "\u20A5",
+  "\u09F3",
+  "\u17DB"
+], LETTER_SYMBOLS = /* @__PURE__ */ new Set(["R", "KSh", "Ksh", "TSh", "Tsh", "USh", "Ush", "Rs", "Rp", "RM", "CFA", "FCFA"]), CODES = new Set(ISO_4217.split(" ")), WORDS = new Set(MONEY_WORDS), PLURAL_SUFFIXES = ["", "s", "es"], TOKEN = /[\p{L}\p{N}]+/gu, CODE_LENGTH = 3, REAL_MONEY_SUGGESTION = "currencies can't use real money names or symbols; try something like 'Jollof Coins' or 'Danfo Tokens', or mark a soft currency in_world in a game with no shopping";
+function singular(token) {
+  for (let suffix of PLURAL_SUFFIXES) {
+    if (!token.endsWith(suffix)) continue;
+    let stem = token.slice(0, token.length - suffix.length);
+    if (WORDS.has(stem)) return stem;
+  }
+  return null;
+}
+function realMoneyIn(text) {
+  for (let symbol of MONEY_SYMBOLS) if (text.includes(symbol)) return { kind: "symbol", found: symbol };
+  let original = text.match(TOKEN) ?? [];
+  for (let token of original) if (LETTER_SYMBOLS.has(token)) return { kind: "symbol", found: token };
+  let lower = original.map((t) => t.toLowerCase());
+  for (let token of lower) {
+    let word = singular(token);
+    if (word !== null) return { kind: "name", found: word };
+  }
+  let spaced = ` ${lower.join(" ")} `;
+  for (let phrase of MONEY_PHRASES) if (spaced.includes(` ${phrase} `) || spaced.includes(` ${phrase}s `)) return { kind: "name", found: phrase };
+  let compact = lower.join(""), whole = singular(compact);
+  if (whole !== null) return { kind: "name", found: whole };
+  if (CODES.has(compact)) return { kind: "code", found: compact.toUpperCase() };
+  for (let token of original)
+    if (token.length === (3) && token === token.toUpperCase() && CODES.has(token.toLowerCase())) return { kind: "code", found: token };
+  return null;
+}
+var IN_WORLD_CATEGORY = "games", COMMERCE_CAPABILITIES = ["services.cart", "services.orders", "services.purchase_intents", "services.delivery"];
+function inWorldRefusal(currency, context) {
+  if (context.category !== IN_WORLD_CATEGORY)
+    return `currency ${currency} is in_world, which only a game may declare; points named like real money in an everyday Interactive could be taken for the real thing`;
+  let commerce = context.capabilities.filter((c) => COMMERCE_CAPABILITIES.indexOf(c) >= 0);
+  return commerce.length > 0 ? `currency ${currency} is in_world, so this game cannot also request ${commerce.join(", ")}; real and pretend money never meet in one experience` : null;
+}
+
+// src/game/kit/economy/audit.ts
+var ECONOMY_IDENTIFIER = /^[a-z][a-z0-9_-]{0,62}$/, VALUE_CLASSES = ["soft", "premium"], Auditor = class {
+  constructor(decl, context) {
+    this.violations = [];
+    this.ids = /* @__PURE__ */ new Set();
+    this.values = /* @__PURE__ */ new Map();
+    this.decl = decl, this.context = context;
+  }
+  run() {
+    let d = this.decl;
+    for (let i = 0; i < d.currencies.length; i++) this.declareValue(d.currencies[i]);
+    for (let i = 0; i < d.items.length; i++) {
+      let item = d.items[i];
+      this.declareValue(item), item.class === "soft" && item.sellsFor !== null && this.expectValue(item.sellsFor, item.id, "soft");
+    }
+    let faucets = d.faucets ?? [];
+    for (let i = 0; i < faucets.length; i++) this.rule(faucets[i].id, faucets[i].value, faucets[i].maxQuantity);
+    let sinks = d.sinks ?? [];
+    for (let i = 0; i < sinks.length; i++) this.rule(sinks[i].id, sinks[i].value, sinks[i].maxQuantity);
+    let exchanges = d.exchanges ?? [];
+    for (let i = 0; i < exchanges.length; i++) {
+      let ex = exchanges[i];
+      if (this.claim(ex.id), this.legs(ex.id, ex.pay, ex.class === "soft" ? "soft" : "premium"), this.legs(ex.id, ex.receive, ex.class === "soft" ? "soft" : "premium"), ex.class === "premium")
+        for (let j = 0; j < ex.receive.length; j++)
+          ex.receive[j].value.kind !== "item" && this.add("one_way_money", ex.id, `premium exchange ${ex.id} may only yield premium items`);
+    }
+    let offers = d.offers ?? [];
+    for (let i = 0; i < offers.length; i++) {
+      let offer = offers[i];
+      if (this.claim(offer.id), this.price(offer.id, offer.priceCimples), offer.kind === "fixed") {
+        offer.grants.length === 0 && this.add("quantity", offer.id, `offer ${offer.id} grants nothing`);
+        for (let j = 0; j < offer.grants.length; j++) this.cimplesGrant(offer.id, offer.grants[j]);
+      } else
+        this.odds(offer.id, offer.odds, null);
+    }
+    let randoms = d.randomExchanges ?? [];
+    for (let i = 0; i < randoms.length; i++) {
+      let r = randoms[i];
+      this.claim(r.id), this.leg(r.id, r.pay, "premium"), this.odds(r.id, r.odds, "premium");
+    }
+    return this.violations;
+  }
+  add(code, subject, message) {
+    this.violations.push({ code, subject, message });
+  }
+  claim(id) {
+    ECONOMY_IDENTIFIER.test(id) || this.add("identifier", id, `'${id}' must be lowercase letters, digits, '-' or '_', starting with a letter`), this.ids.has(id) && this.add("duplicate_id", id, `'${id}' is declared more than once`), this.ids.add(id);
+  }
+  declareValue(value) {
+    if (this.claim(value.id), VALUE_CLASSES.indexOf(value.class) < 0 && this.add("currency_class", value.id, `${value.id} has class '${String(value.class)}'; it must be soft or premium`), value.kind === "currency" && !(value.maxBalance > 0) && this.add("quantity", value.id, `${value.id} needs a positive maximum balance`), value.kind === "currency") {
+      let inWorld = value.class === "soft" && value.inWorld === true, money = inWorld ? null : realMoneyIn(value.name) ?? realMoneyIn(value.id);
+      money !== null && this.add("real_money_name", value.id, `currency ${value.id} uses '${money.found}'; ${REAL_MONEY_SUGGESTION}`);
+      let refusal = inWorld && this.context !== null ? inWorldRefusal(value.id, this.context) : null;
+      refusal !== null && this.add("in_world_context", value.id, refusal);
+    }
+    this.values.set(value.id, value);
+  }
+  expectValue(value, subject, cls) {
+    let declared = this.values.get(value.id);
+    if (declared === void 0 || declared.kind !== value.kind) {
+      this.add("unknown_reference", subject, `${subject} refers to ${value.id}, which is not declared`);
+      return;
+    }
+    if (declared.class !== value.class) {
+      this.add("class_mismatch", subject, `${subject} uses ${value.id} as ${value.class} but it is declared ${declared.class}`);
+      return;
+    }
+    cls !== null && value.class !== cls && this.add("one_way_money", subject, `${subject} moves ${value.class} value ${value.id} where only ${cls} value may go`);
+  }
+  rule(id, value, maxQuantity) {
+    this.claim(id), this.expectValue(value, id, "soft"), (!Number.isInteger(maxQuantity) || maxQuantity <= 0) && this.add("quantity", id, `${id} needs a positive whole maximum quantity`);
+  }
+  leg(subject, leg, cls) {
+    this.expectValue(leg.value, subject, cls), (!Number.isInteger(leg.quantity) || leg.quantity <= 0) && this.add("quantity", subject, `${subject} moves a non-positive quantity`);
+  }
+  legs(subject, legs, cls) {
+    legs.length === 0 && this.add("quantity", subject, `${subject} has an empty side`);
+    for (let i = 0; i < legs.length; i++) this.leg(subject, legs[i], cls);
+  }
+  price(subject, price) {
+    (!Number.isInteger(price) || price <= 0) && this.add("price", subject, `${subject} needs a positive whole Cimples price`);
+  }
+  cimplesGrant(subject, g) {
+    g.kind === "value" && this.leg(subject, g, null);
+  }
+  odds(subject, odds, cls) {
+    if (!odds || odds.length === 0) {
+      this.add("odds_missing", subject, `${subject} is a paid random reward without disclosed odds`);
+      return;
+    }
+    let total = 0;
+    for (let i = 0; i < odds.length; i++) {
+      let o = odds[i];
+      (!Number.isInteger(o.partsPerMillion) || o.partsPerMillion <= 0) && this.add("odds_outcome", subject, `${subject} has an outcome with invalid odds`), cls === "premium" && (o.value.kind !== "item" || o.value.class !== "premium") ? this.add("one_way_money", subject, `${subject} spends premium currency, so it may only yield premium items, not ${o.value.id}`) : this.expectValue(o.value, subject, cls), (!Number.isInteger(o.quantity) || o.quantity <= 0) && this.add("quantity", subject, `${subject} has an outcome with a non-positive quantity`), total += o.partsPerMillion;
+    }
+    total !== ODDS_TOTAL_PPM && this.add("odds_total", subject, `${subject} odds add up to ${total} parts per million, not ${ODDS_TOTAL_PPM}`);
+  }
+};
+function auditEconomy(decl, context = null) {
+  return new Auditor(decl, context).run();
+}
+
+// src/game/kit/gates/gates.ts
+function auditManifestEconomy(manifest, context = null) {
+  let out = [];
+  for (let c of manifest.currencies) {
+    c.class !== "soft" && c.class !== "premium" && out.push({ code: "currency_class", subject: c.id, message: `currency ${c.id} has class '${c.class}'; it must be soft or premium` });
+    let inWorld = c.class === "soft" && c.inWorld === true, money = inWorld ? null : (c.name === void 0 ? null : realMoneyIn(c.name)) ?? realMoneyIn(c.id);
+    money !== null && out.push({ code: "real_money_name", subject: c.id, message: `currency ${c.id} uses '${money.found}'; ${REAL_MONEY_SUGGESTION}` }), c.inWorld === true && c.class !== "soft" && out.push({ code: "in_world_context", subject: c.id, message: `currency ${c.id} is in_world, which only a soft currency may be` });
+    let refusal = inWorld && context !== null ? inWorldRefusal(c.id, context) : null;
+    refusal !== null && out.push({ code: "in_world_context", subject: c.id, message: refusal });
+  }
+  let odds = new Map(manifest.odds.map((o) => [o.item, o]));
+  for (let item of manifest.items) {
+    let disclosed = odds.get(item.id);
+    if (!(item.random === true || disclosed !== void 0)) continue;
+    if (disclosed === void 0) {
+      out.push({ code: "odds_missing", subject: item.id, message: `${item.id} is a random reward without disclosed odds` });
+      continue;
+    }
+    let total = 0;
+    for (let o of disclosed.outcomes) total += o.partsPerMillion;
+    total !== ODDS_TOTAL_PPM && out.push({ code: "odds_total", subject: item.id, message: `${item.id} odds add up to ${total} parts per million, not ${ODDS_TOTAL_PPM}` });
+  }
+  return out;
+}
+var GATE_CODES = [
+  ["currency classes", ["currency_class", "class_mismatch", "real_money_name", "in_world_context"]],
+  ["odds disclosure", ["odds_missing", "odds_total", "odds_outcome"]],
+  ["one-way money", ["one_way_money"]],
+  ["economy declaration", ["identifier", "duplicate_id", "unknown_reference", "quantity", "price"]]
+], PASS_DETAIL = {
+  "currency classes": "every currency and item is soft or premium, and only an in_world game currency, away from shopping, is named as real money",
+  "odds disclosure": "every paid random reward discloses odds that add up",
+  "one-way money": "no value leaves the game: nothing turns into premium value, Cimples or money",
+  "economy declaration": "declarations are complete and consistent"
+};
+function judgeEconomy(violations) {
+  return GATE_CODES.map(([name, codes]) => {
+    let found = violations.filter((v) => codes.indexOf(v.code) >= 0);
+    return found.length === 0 ? { name, passed: true, detail: PASS_DETAIL[name] } : { name, passed: false, detail: found.map((v) => v.message).join("; ") };
+  });
+}
+function kitPublicationGates(economy, manifest = null, context = null) {
+  let violations = [];
+  return economy !== null && violations.push(...auditEconomy(economy, context)), manifest !== null && violations.push(...auditManifestEconomy(manifest, context)), judgeEconomy(violations);
+}
+
+export { COMMERCE_CAPABILITIES, ECONOMY_IDENTIFIER, IN_WORLD_CATEGORY, REAL_MONEY_SUGGESTION, auditEconomy, auditManifestEconomy, inWorldRefusal, judgeEconomy, kitPublicationGates, realMoneyIn };

package/dist/chunk-Y2EMGN4T.mjs

@@ -0,0 +1,120 @@
+import { detExp } from './chunk-2LHLG4OB.mjs';
+import { RayHit } from './chunk-HF5HPS4T.mjs';
+import { ShapeCastQuery } from './chunk-XPG3N5CF.mjs';
+import { FRAME_ALPHA_SLOT } from './chunk-IDLW4NWA.mjs';
+
+// 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 - 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 ShapeCastQuery();
+    this.hit = new 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[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)));
+  }
+};
+
+export { BOOM_DISTANCE, BOOM_DX, BOOM_DY, BOOM_DZ, BOOM_FREE, BOOM_IO_WORDS, BOOM_OX, BOOM_OY, BOOM_OZ, CameraBoom, DEFAULT_BOOM_RADIUS, LensDriver, POSE_PITCH, POSE_X, POSE_Y, POSE_YAW, POSE_Z, TWO_PI, atan2Into, clamp, dampFactor, interpolatedPosition, placeCamera, wrapAngle, wrapAt, yawInto, yawOfQuat };