@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-FQBFWJBS.mjs

@@ -0,0 +1,110 @@
+import { NO_FACE_COLOUR } from './chunk-5C3C7VDM.mjs';
+import { FACE_LAYOUT } from './chunk-SPCRQ6NO.mjs';
+
+// src/interactives/runtime/web-face-colours.ts
+var RED_SHIFT = 16, GREEN_SHIFT = 8;
+function packColour(colour) {
+  return colour === null ? 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 = 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));
+  }
+};
+
+export { FaceColourSampler, VideoPixelSource, WebFaceColours, landmarksPresent, packColour, packColours };

package/dist/chunk-FXVJ2HFU.js

@@ -0,0 +1,26 @@
+'use strict';
+
+// src/game/backends/engine/wasi.ts
+var WASI_IMPORTS = "wasi_snapshot_preview1", REACTOR_INITIALIZE = "_initialize";
+function wasiStubs(memory) {
+  return {
+    clock_time_get(_id, _precision, out) {
+      return new DataView(memory().buffer).setBigUint64(out, 0n, true), 0;
+    },
+    fd_close: () => 8,
+    fd_seek: () => 8,
+    fd_write: () => 8
+  };
+}
+function importsWasi(module) {
+  return WebAssembly.Module.imports(module).some((entry) => entry.module === WASI_IMPORTS);
+}
+function initializeReactor(exports) {
+  let initialize = exports[REACTOR_INITIALIZE];
+  typeof initialize == "function" && initialize();
+}
+
+exports.WASI_IMPORTS = WASI_IMPORTS;
+exports.importsWasi = importsWasi;
+exports.initializeReactor = initializeReactor;
+exports.wasiStubs = wasiStubs;

package/dist/chunk-FZMQMQBW.js

@@ -0,0 +1,312 @@
+'use strict';
+
+var chunkA2MAX6S4_js = require('./chunk-A2MAX6S4.js');
+
+// 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 !== chunkA2MAX6S4_js.ODDS_TOTAL_PPM && this.add("odds_total", subject, `${subject} odds add up to ${total} parts per million, not ${chunkA2MAX6S4_js.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 !== chunkA2MAX6S4_js.ODDS_TOTAL_PPM && out.push({ code: "odds_total", subject: item.id, message: `${item.id} odds add up to ${total} parts per million, not ${chunkA2MAX6S4_js.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);
+}
+
+exports.COMMERCE_CAPABILITIES = COMMERCE_CAPABILITIES;
+exports.ECONOMY_IDENTIFIER = ECONOMY_IDENTIFIER;
+exports.IN_WORLD_CATEGORY = IN_WORLD_CATEGORY;
+exports.REAL_MONEY_SUGGESTION = REAL_MONEY_SUGGESTION;
+exports.auditEconomy = auditEconomy;
+exports.auditManifestEconomy = auditManifestEconomy;
+exports.inWorldRefusal = inWorldRefusal;
+exports.judgeEconomy = judgeEconomy;
+exports.kitPublicationGates = kitPublicationGates;
+exports.realMoneyIn = realMoneyIn;

package/dist/chunk-G3EEC44R.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var chunkRCQ2MPBV_js = require('./chunk-RCQ2MPBV.js');
+
+// src/game/physics/types.ts
+var DEFAULT_SOLVER_ITERATIONS = 4, DEFAULT_PGS_ITERATIONS = 1, DEFAULT_CCD_SUBSTEPS = 1, MAX_SOLVER_ITERATIONS = 64, MAX_PGS_ITERATIONS = 16, MAX_CCD_SUBSTEPS = 16, DEFAULT_SLEEP_LINEAR = 0.05, DEFAULT_SLEEP_ANGULAR = 0.5, DEFAULT_SLEEP_SECONDS = 0.5, RayQuery = class {
+  constructor() {
+    this.origin = new chunkRCQ2MPBV_js.Vec3();
+    this.direction = new chunkRCQ2MPBV_js.Vec3(0, -1, 0);
+    this.maxDistance = Number.MAX_VALUE;
+    this.solid = true;
+    this.includeSensors = false;
+    this.excludeCollider = -1;
+  }
+  set(ox, oy, oz, dx, dy, dz, maxDistance) {
+    return this.origin.set(ox, oy, oz), this.direction.set(dx, dy, dz), this.maxDistance = maxDistance, this;
+  }
+}, RayHit = class {
+  constructor() {
+    this.hit = false;
+    this.collider = -1;
+    this.distance = 0;
+    this.pointX = 0;
+    this.pointY = 0;
+    this.pointZ = 0;
+    this.normalX = 0;
+    this.normalY = 0;
+    this.normalZ = 0;
+  }
+}, CharacterMove = class {
+  constructor() {
+    this.grounded = false;
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+  }
+};
+chunkRCQ2MPBV_js.settleDoubleFields(new RayQuery(), ["maxDistance"]);
+chunkRCQ2MPBV_js.settleDoubleFields(new RayHit(), ["distance", "pointX", "pointY", "pointZ", "normalX", "normalY", "normalZ"]);
+chunkRCQ2MPBV_js.settleDoubleFields(new CharacterMove(), ["x", "y", "z"]);
+
+exports.CharacterMove = CharacterMove;
+exports.DEFAULT_CCD_SUBSTEPS = (1);
+exports.DEFAULT_PGS_ITERATIONS = (1);
+exports.DEFAULT_SLEEP_ANGULAR = (0.5);
+exports.DEFAULT_SLEEP_LINEAR = (0.05);
+exports.DEFAULT_SLEEP_SECONDS = (0.5);
+exports.DEFAULT_SOLVER_ITERATIONS = (4);
+exports.MAX_CCD_SUBSTEPS = (16);
+exports.MAX_PGS_ITERATIONS = (16);
+exports.MAX_SOLVER_ITERATIONS = (64);
+exports.RayHit = RayHit;
+exports.RayQuery = RayQuery;