@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-HDR72GB6.js

@@ -0,0 +1,188 @@
+'use strict';
+
+var chunkNZTKLY2W_js = require('./chunk-NZTKLY2W.js');
+
+// src/game/conformance/engine-platform.ts
+var FS_MODULE = "node:fs/promises";
+async function load(file) {
+  let bytes = await (await import(
+    /* @vite-ignore */
+    FS_MODULE
+  )).readFile(file);
+  return chunkNZTKLY2W_js.enginePlatformOf(await chunkNZTKLY2W_js.loadEngineRuntime(bytes));
+}
+function bytesFramePlatform(bytes) {
+  let platform = null;
+  return {
+    engine: () => (platform ?? (platform = chunkNZTKLY2W_js.loadEngineRuntime(bytes).then(chunkNZTKLY2W_js.enginePlatformOf)), platform)
+  };
+}
+function engineFramePlatform(file) {
+  let platform = null;
+  return {
+    engine: () => (platform ?? (platform = load(file)), platform)
+  };
+}
+
+// src/game/conformance/heap.ts
+var V8_MODULE = "node:v8", YOUNG_SPACE = "new_space", GC_ENTRY = "gc", SETTLE_DELAY_MS = 0, MEASURE_WINDOW_FRAMES = 500, MAX_REGULAR_OBJECT_BYTES = 131072, OBJECT_HEADER_BYTES = 64, CALIBRATION_ELEMENTS = 1024, ALIGNED_WINDOWS = 16, STEADY_BLOCKS = 8, STEADY_BLOCK_FRAMES = 2e3, alignmentSink = [];
+function elementBytes(young) {
+  let start = young(), probe = new Array((1024)).fill(0), filled = young(), empty = young();
+  return alignmentSink = probe, Math.max(1, Math.round((filled - start - (empty - filled)) / (1024)));
+}
+function isV8(value) {
+  return typeof value == "object" && value !== null && typeof Reflect.get(value, "getHeapSpaceStatistics") == "function";
+}
+async function createNodeHeapMeter() {
+  let v8;
+  try {
+    v8 = await import(
+      /* @vite-ignore */
+      V8_MODULE
+    );
+  } catch {
+    return null;
+  }
+  if (!isV8(v8)) return null;
+  let stats = v8, youngBytes = () => {
+    let spaces = stats.getHeapSpaceStatistics();
+    for (let i = 0; i < spaces.length; i++) if (spaces[i].space_name === YOUNG_SPACE) return spaces[i].space_used_size;
+    return 0;
+  }, halfPage = Math.floor(((131072) - (64)) / elementBytes(youngBytes)), Observer = Reflect.get(globalThis, "PerformanceObserver"), gcCount = 0, gcStarts = [], observer = null;
+  if (Observer) {
+    observer = new Observer((list) => {
+      let entries = list.getEntries();
+      gcCount += entries.length;
+      for (let i = 0; i < entries.length; i++) gcStarts.push(entries[i].startTime);
+    });
+    try {
+      observer.observe({ entryTypes: [GC_ENTRY] });
+    } catch {
+      observer = null;
+    }
+  }
+  return {
+    name: "v8-young-space",
+    youngBytes,
+    align() {
+      let first = new Array(halfPage).fill(0);
+      alignmentSink = new Array(halfPage).fill(0), alignmentSink[0] = first;
+    },
+    collections() {
+      return gcCount;
+    },
+    collectionsBetween(start, end) {
+      let count = 0;
+      for (let i = 0; i < gcStarts.length; i++) gcStarts[i] >= start && gcStarts[i] <= end && count++;
+      return count;
+    },
+    settle() {
+      return new Promise((resolve) => setTimeout(resolve, (0)));
+    },
+    dispose() {
+      observer?.disconnect();
+    }
+  };
+}
+var INSPECTOR_MODULE = "node:inspector/promises", SAMPLING_INTERVAL_BYTES = 16, DEFAULT_SITES = 8, FULL_COLLECTIONS = 2;
+function frameName(frame) {
+  let file = frame.url.slice(frame.url.lastIndexOf("/") + 1);
+  return `${frame.functionName || "(anonymous)"} ${file}:${frame.lineNumber + 1}`;
+}
+function collectSites(node, path, out) {
+  if (path.push(frameName(node.callFrame)), node.selfSize > 0) {
+    let key = path.slice(-4).join(" < ");
+    out.set(key, (out.get(key) ?? 0) + node.selfSize);
+  }
+  for (let child of node.children) collectSites(child, path, out);
+  path.pop();
+}
+async function collectGarbage() {
+  let Session;
+  try {
+    let inspector = await import(
+      /* @vite-ignore */
+      INSPECTOR_MODULE
+    );
+    Session = Reflect.get(inspector, "Session");
+  } catch {
+    return false;
+  }
+  let session = new Session();
+  session.connect();
+  try {
+    for (let i = 0; i < (2); i++) await session.post("HeapProfiler.collectGarbage");
+    return !0;
+  } finally {
+    session.disconnect();
+  }
+}
+function collectYoung() {
+  let gc = Reflect.get(globalThis, "gc");
+  return typeof gc != "function" ? false : (gc({ type: "minor", execution: "sync" }), true);
+}
+async function warmUp(frames, frame) {
+  let half = frames >> 1;
+  for (let i = 0; i < half; i++) frame(i);
+  await collectGarbage();
+  for (let i = half; i < frames; i++) frame(i);
+}
+async function profileAllocationSites(frames, frame, limit = (8)) {
+  let Session;
+  try {
+    let inspector = await import(
+      /* @vite-ignore */
+      INSPECTOR_MODULE
+    );
+    Session = Reflect.get(inspector, "Session");
+  } catch {
+    return null;
+  }
+  let session = new Session();
+  session.connect();
+  try {
+    await session.post("HeapProfiler.startSampling", {
+      samplingInterval: (16),
+      includeObjectsCollectedByMajorGC: !0,
+      includeObjectsCollectedByMinorGC: !0
+    });
+    for (let i = 0; i < frames; i++) frame(i);
+    let result = await session.post("HeapProfiler.stopSampling"), sites = /* @__PURE__ */ new Map();
+    return collectSites(result.profile.head, [], sites), [...sites.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([stack, bytes]) => ({ stack, bytes }));
+  } finally {
+    session.disconnect();
+  }
+}
+async function measureAllocations(meter, frames, frame) {
+  await meter.settle(), meter.align?.();
+  let gcBefore = meter.collections(), opened = performance.now(), bytes = 0, measured = 0, windows = 0;
+  for (let start = 0; start < frames; start += (500)) {
+    windows > 0 && windows % (16) === 0 && meter.align?.(), windows++;
+    let end = Math.min(frames, start + (500)), lead = meter.youngBytes(), before = meter.youngBytes();
+    for (let i = start; i < end; i++) frame(i);
+    let after = meter.youngBytes(), tail = meter.youngBytes(), leading = before - lead, trailing = tail - after, overhead = leading > trailing ? leading : trailing, delta = after - before - (overhead > 0 ? overhead : 0);
+    after < before || (bytes += delta > 0 ? delta : 0, measured += end - start);
+  }
+  let closed = performance.now();
+  await meter.settle();
+  let collections = meter.collectionsBetween ? meter.collectionsBetween(opened, closed) : meter.collections() - gcBefore, perFrame = measured > 0 ? bytes / measured : 0;
+  return { frames, bytes: perFrame * frames, bytesPerFrame: perFrame, collections };
+}
+async function measureSteadyAllocations(meter, frames, frame) {
+  let start = 0;
+  for (let block = 0; block < (8); block++) {
+    let from = start, settled = await measureAllocations(meter, (2e3), (i) => frame(from + i));
+    if (start += (2e3), settled.bytes === 0 && settled.collections === 0) break;
+  }
+  return measureAllocations(meter, frames, (i) => frame(start + i));
+}
+
+exports.bytesFramePlatform = bytesFramePlatform;
+exports.collectGarbage = collectGarbage;
+exports.collectYoung = collectYoung;
+exports.createNodeHeapMeter = createNodeHeapMeter;
+exports.engineFramePlatform = engineFramePlatform;
+exports.measureAllocations = measureAllocations;
+exports.measureSteadyAllocations = measureSteadyAllocations;
+exports.profileAllocationSites = profileAllocationSites;
+exports.warmUp = warmUp;

package/dist/chunk-HF5HPS4T.mjs

@@ -0,0 +1,40 @@
+import { settleDoubleFields, Vec3 } from './chunk-XPG3N5CF.mjs';
+
+// 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 Vec3();
+    this.direction = new 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;
+  }
+};
+settleDoubleFields(new RayQuery(), ["maxDistance"]);
+settleDoubleFields(new RayHit(), ["distance", "pointX", "pointY", "pointZ", "normalX", "normalY", "normalZ"]);
+settleDoubleFields(new CharacterMove(), ["x", "y", "z"]);
+
+export { CharacterMove, DEFAULT_CCD_SUBSTEPS, DEFAULT_PGS_ITERATIONS, DEFAULT_SLEEP_ANGULAR, DEFAULT_SLEEP_LINEAR, DEFAULT_SLEEP_SECONDS, DEFAULT_SOLVER_ITERATIONS, MAX_CCD_SUBSTEPS, MAX_PGS_ITERATIONS, MAX_SOLVER_ITERATIONS, RayHit, RayQuery };

package/dist/chunk-HK6LOFDS.js

@@ -0,0 +1,218 @@
+'use strict';
+
+// src/game/kit/frontier/protocol.ts
+var ACTION_BASE = 17920, ACTION = {
+  survey: 17921,
+  gather: 17922,
+  process: 17923,
+  craft: 17924,
+  learn: 17925,
+  place: 17926,
+  remove: 17927,
+  link: 17928,
+  unlink: 17929,
+  connect: 17930,
+  insert: 17931,
+  take: 17932,
+  logic: 17933,
+  enable: 17934,
+  till: 17935,
+  plant: 17936,
+  harvest: 17937,
+  water: 17938,
+  fertilise: 17939,
+  tame: 17940,
+  feed: 17941,
+  collect: 17942,
+  inventSubmit: 17943,
+  teach: 17945,
+  drop: 17946,
+  charge: 17949,
+  discharge: 17950,
+  vaccinate: 17951,
+  breed: 17952,
+  chemistrySubmit: 17953
+}, TRAIT = { growth: 0, yield: 1, drought: 2, cold: 3, heat: 4, fertility: 5, resistance: 6, size: 7, none: 255 }, PATHOGEN = { cattleFever: 0, leafBlight: 1 }, PROCESS = { heat: 1, press: 2, cut: 3, grind: 4, combine: 5, spin: 6 }, CHANNEL = { inputA: 0, inputB: 1, output: 2, power: 3, signal: 4 }, COMPARE = { pass: 0, greater: 1, less: 2, equal: 3, notEqual: 4, atLeast: 5, atMost: 6 }, NO_ITEM = 4294967295, NO_INVENTION = 65535, RUN_ID_BYTES = 16, MAX_COMMAND_BYTES = 256, FRONTIER_CHANNEL_SLOT = 62, INVENTION_FLAG = 2147483648, LITTLE = true, FACE_SHIFT_HIGH = 29, BAND_SHIFT_HIGH = 16, I_HIGH_SHIFT = 8, I_LOW_MASK = 255, I_LOW_SHIFT = 24, AXIS_MASK = 16777215, BAND_MASK = 8191, FACE_MASK = 7, HEX_RADIX = 16, HEX_PAIR = 2;
+function regionKey(face, band, i, j) {
+  let hi = ((face & (7)) << (29) | (band & (8191)) << (16) | (i & (16777215)) >>> (8)) >>> 0;
+  return { lo: ((i & (255)) << (24) | j & (16777215)) >>> 0, hi };
+}
+function regionFromBigInt(key) {
+  return { lo: Number(key & 0xffffffffn), hi: Number(key >> 32n & 0xffffffffn) };
+}
+function materialItem(id) {
+  return id >>> 0;
+}
+function inventionItem(id) {
+  return ((2147483648) | id) >>> 0;
+}
+function isInvention(item) {
+  return item !== (4294967295) && (item & (2147483648)) !== 0;
+}
+var CommandWriter = class {
+  constructor() {
+    this.bytes = new Uint8Array((256));
+    this.view = new DataView(this.bytes.buffer);
+    this.at = 0;
+  }
+  get length() {
+    return this.at;
+  }
+  reset() {
+    return this.at = 0, this;
+  }
+  u8(value) {
+    return this.view.setUint8(this.at, value), this.at += 1, this;
+  }
+  u16(value) {
+    return this.view.setUint16(this.at, value, (true)), this.at += 2, this;
+  }
+  u32(value) {
+    return this.view.setUint32(this.at, value >>> 0, (true)), this.at += 4, this;
+  }
+  i32(value) {
+    return this.view.setInt32(this.at, value | 0, (true)), this.at += 4, this;
+  }
+  region(region) {
+    return this.u32(region.lo).u32(region.hi);
+  }
+  spot(region, x, z) {
+    return this.region(region).u16(x).u16(z);
+  }
+  run(id) {
+    for (let i = 0; i < (16); i++) this.u8(id[i] ?? 0);
+    return this;
+  }
+};
+function actionOf(command) {
+  return ACTION[command.kind];
+}
+function encodeCommand(command, w) {
+  switch (w.reset(), command.kind) {
+    case "survey":
+      w.spot(command.region, command.x, command.z).u16(command.tool);
+      break;
+    case "gather":
+      w.u32(command.deposit).u16(command.amount);
+      break;
+    case "process":
+      w.u8(command.code).u16(command.param).u32(command.a).u32(command.b).u16(command.batches);
+      break;
+    case "craft":
+      w.u16(command.invention).u16(command.count);
+      break;
+    case "learn":
+      w.u16(command.invention);
+      break;
+    case "place":
+      w.u16(command.invention).spot(command.region, command.x, command.z);
+      break;
+    case "remove":
+      w.u32(command.machine);
+      break;
+    case "link":
+      w.u32(command.from).u32(command.to).u16(command.conveyor);
+      break;
+    case "unlink":
+      w.u32(command.link);
+      break;
+    case "connect":
+      w.u32(command.a).u32(command.b);
+      break;
+    case "insert":
+      w.u32(command.machine).u8(command.lane).u8(command.slot).u16(command.count);
+      break;
+    case "take":
+      w.u32(command.machine).u16(command.count);
+      break;
+    case "logic":
+      w.u32(command.machine).u32(command.source).u8(command.channel).u8(command.compare).i32(command.constant).u32(command.target);
+      break;
+    case "enable":
+      w.u32(command.machine).u8(command.on ? 1 : 0);
+      break;
+    case "till":
+      w.spot(command.region, command.x, command.z);
+      break;
+    case "plant":
+      w.u32(command.plot).u8(command.slot).u16(command.plants);
+      break;
+    case "harvest":
+      w.u32(command.plot);
+      break;
+    case "water":
+      w.u32(command.plot).u8(command.slot).u16(command.units);
+      break;
+    case "fertilise":
+      w.u32(command.plot).u8(command.slot);
+      break;
+    case "tame":
+    case "collect":
+      w.u32(command.herd);
+      break;
+    case "feed":
+      w.u32(command.herd).u8(command.slot).u16(command.count);
+      break;
+    case "inventSubmit":
+    case "chemistrySubmit":
+      w.run(command.run);
+      break;
+    case "teach":
+      w.u16(command.student);
+      break;
+    case "drop":
+      w.u8(command.slot).u16(command.count);
+      break;
+    case "charge":
+      w.u32(command.machine).u8(command.slot).u16(command.count);
+      break;
+    case "discharge":
+      w.u32(command.machine).u16(command.material).u16(command.count);
+      break;
+    case "vaccinate":
+      w.u32(command.herd).u8(command.pathogen);
+      break;
+    case "breed":
+      w.u32(command.herd).u8(command.trait).u8(command.upward ? 1 : 0);
+      break;
+  }
+  return w.length;
+}
+var AI_RUN_PREFIX = "air_", AI_RUN_BYTES = 12, HEX_DIGITS = /^[0-9a-f]+$/i;
+function runIdFromHex(hex) {
+  let out = new Uint8Array((16));
+  for (let i = 0; i < (16) && i * (2) + 1 < hex.length; i++)
+    out[i] = Number.parseInt(hex.slice(i * (2), i * (2) + (2)), (16));
+  return out;
+}
+function runIdFromAiRun(id) {
+  if (!id.startsWith(AI_RUN_PREFIX)) return null;
+  let hex = id.slice(AI_RUN_PREFIX.length);
+  return hex.length !== (12) * (2) || !HEX_DIGITS.test(hex) ? null : runIdFromHex(hex);
+}
+
+exports.ACTION = ACTION;
+exports.ACTION_BASE = (17920);
+exports.AI_RUN_BYTES = (12);
+exports.AI_RUN_PREFIX = AI_RUN_PREFIX;
+exports.CHANNEL = CHANNEL;
+exports.COMPARE = COMPARE;
+exports.CommandWriter = CommandWriter;
+exports.FRONTIER_CHANNEL_SLOT = (62);
+exports.INVENTION_FLAG = (2147483648);
+exports.MAX_COMMAND_BYTES = (256);
+exports.NO_INVENTION = (65535);
+exports.NO_ITEM = (4294967295);
+exports.PATHOGEN = PATHOGEN;
+exports.PROCESS = PROCESS;
+exports.RUN_ID_BYTES = (16);
+exports.TRAIT = TRAIT;
+exports.actionOf = actionOf;
+exports.encodeCommand = encodeCommand;
+exports.inventionItem = inventionItem;
+exports.isInvention = isInvention;
+exports.materialItem = materialItem;
+exports.regionFromBigInt = regionFromBigInt;
+exports.regionKey = regionKey;
+exports.runIdFromAiRun = runIdFromAiRun;
+exports.runIdFromHex = runIdFromHex;

package/dist/chunk-HMWYTXCY.mjs

@@ -0,0 +1,143 @@
+// src/game/input/dom.ts
+var POINTER_PHASES = {
+  pointerdown: "down",
+  pointermove: "move",
+  pointerup: "up",
+  pointercancel: "up"
+}, DOM_DELTA_LINE = 1, DOM_DELTA_PAGE = 2, WHEEL_LINE_PIXELS = 16, WHEEL_PAGE_PIXELS = 800, NO_BUTTONS = 0, PRIMARY_BUTTON = 1;
+function wheelPixels(delta, mode, pageHeight) {
+  return mode === (1) ? delta * (16) : mode === (2) ? delta * (pageHeight > 0 ? pageHeight : (800)) : delta;
+}
+var DomInputBridge = class {
+  constructor(input, surface, keyTarget, options) {
+    this.left = 0;
+    this.top = 0;
+    this.width = 1;
+    this.height = 1;
+    this.onPointer = (event) => this.pointer(event);
+    this.onKey = (event) => this.key(event);
+    this.onResize = () => this.measure();
+    this.onWheel = (event) => this.wheel(event);
+    this.onOrientation = (event) => this.orientation(event);
+    this.onContextMenu = (event) => event.preventDefault();
+    this.input = input, this.surface = surface, this.keyTarget = keyTarget, this.options = options;
+  }
+  attach() {
+    this.measure();
+    for (let type in POINTER_PHASES) this.surface.addEventListener(type, this.onPointer, { passive: true });
+    this.options.wheel !== false && this.surface.addEventListener("wheel", this.onWheel, { passive: this.options.preventWheel !== true }), this.options.preventContextMenu && this.surface.addEventListener("contextmenu", this.onContextMenu), this.options.orientation && this.keyTarget.addEventListener("deviceorientation", this.onOrientation), this.keyTarget.addEventListener("keydown", this.onKey), this.keyTarget.addEventListener("keyup", this.onKey), this.keyTarget.addEventListener("resize", this.onResize);
+  }
+  detach() {
+    for (let type in POINTER_PHASES) this.surface.removeEventListener(type, this.onPointer);
+    this.surface.removeEventListener("wheel", this.onWheel), this.surface.removeEventListener("contextmenu", this.onContextMenu), this.keyTarget.removeEventListener("deviceorientation", this.onOrientation), this.keyTarget.removeEventListener("keydown", this.onKey), this.keyTarget.removeEventListener("keyup", this.onKey), this.keyTarget.removeEventListener("resize", this.onResize);
+  }
+  measure() {
+    let rect = this.surface.getBoundingClientRect();
+    this.left = rect.left, this.top = rect.top, this.width = rect.width > 0 ? rect.width : 1, this.height = rect.height > 0 ? rect.height : 1;
+  }
+  pointer(event) {
+    let phase = POINTER_PHASES[event.type];
+    phase === "down" && this.measure();
+    let buttons = phase === "up" ? (0) : event.buttons === void 0 || event.buttons === 0 ? (1) : event.buttons;
+    this.input.pointerEvent(
+      phase,
+      event.pointerId,
+      (event.clientX - this.left) / this.width,
+      (event.clientY - this.top) / this.height,
+      event.timeStamp,
+      buttons
+    ), phase === "move" && (event.movementX || event.movementY) && this.input.motionEvent(event.movementX, event.movementY, event.timeStamp);
+  }
+  wheel(event) {
+    this.options.preventWheel && event.preventDefault();
+    let mode = event.deltaMode;
+    this.input.wheelEvent(
+      wheelPixels(event.deltaX, mode, this.height),
+      wheelPixels(event.deltaY, mode, this.height),
+      wheelPixels(event.deltaZ, mode, this.height),
+      (event.clientX - this.left) / this.width,
+      (event.clientY - this.top) / this.height,
+      event.timeStamp
+    );
+  }
+  orientation(event) {
+    event.alpha === null && event.beta === null && event.gamma === null || this.input.orientationEvent(event.alpha ?? 0, event.beta ?? 0, event.gamma ?? 0, event.timeStamp);
+  }
+  key(event) {
+    event.repeat || this.input.keyEvent(event.code, event.type === "keydown", event.timeStamp);
+  }
+};
+function attachDomInput(input, surface, keyTarget, options = {}) {
+  let bridge = new DomInputBridge(input, surface, keyTarget, options);
+  return bridge.attach(), () => bridge.detach();
+}
+async function requestPointerLock(target) {
+  try {
+    return await target.requestPointerLock(), !0;
+  } catch {
+    return false;
+  }
+}
+function exitPointerLock(doc) {
+  doc.pointerLockElement !== null && doc.exitPointerLock();
+}
+function isPointerLocked(doc, target) {
+  return doc.pointerLockElement !== null && doc.pointerLockElement === target;
+}
+async function requestOrientationPermission(source = globalThis.DeviceOrientationEvent) {
+  if (source == null) return false;
+  let request = source.requestPermission;
+  if (typeof request != "function") return true;
+  try {
+    return await request.call(source) === "granted";
+  } catch {
+    return false;
+  }
+}
+function screenOrientationDegrees(source = globalThis.screen) {
+  let angle = source?.orientation?.angle;
+  return typeof angle == "number" ? angle : 0;
+}
+var UNSEEN = Number.NaN;
+function ignore() {
+}
+var GamepadPoller = class {
+  constructor(source, index = 0) {
+    this.buttons = new Float32Array(32).fill(UNSEEN);
+    this.axes = new Float32Array(16).fill(UNSEEN);
+    this.connectedState = false;
+    this.source = source, this.index = index;
+  }
+  get connected() {
+    return this.connectedState;
+  }
+  poll(input, timeMs) {
+    let pad = this.pad();
+    if (this.connectedState = pad !== null, pad === null) return false;
+    let buttons = Math.min(pad.buttons.length, 32);
+    for (let i = 0; i < buttons; i++) {
+      let value = pad.buttons[i].value;
+      value !== this.buttons[i] && (this.buttons[i] = value, input.gamepadButtonEvent(i, value, timeMs));
+    }
+    let axes = Math.min(pad.axes.length, 16);
+    for (let i = 0; i < axes; i++) {
+      let value = pad.axes[i];
+      value !== this.axes[i] && (this.axes[i] = value, input.gamepadAxisEvent(i, value, timeMs));
+    }
+    return true;
+  }
+  rumble(strong, weak, durationMs) {
+    let actuator = this.pad()?.vibrationActuator;
+    return !actuator || typeof actuator.playEffect != "function" ? false : (actuator.playEffect("dual-rumble", {
+      duration: durationMs,
+      strongMagnitude: Math.max(0, Math.min(1, strong)),
+      weakMagnitude: Math.max(0, Math.min(1, weak))
+    }).catch(ignore), true);
+  }
+  pad() {
+    let pads = this.source.getGamepads(), pad = this.index < pads.length ? pads[this.index] : null;
+    return pad && pad.connected ? pad : null;
+  }
+};
+
+export { GamepadPoller, attachDomInput, exitPointerLock, isPointerLocked, requestOrientationPermission, requestPointerLock, screenOrientationDegrees, wheelPixels };

package/dist/chunk-HPCSRCMA.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/backends/engine/policy.ts
+var ENGINE_RAGDOLL_POLICY_EXPORT_NAMES = [
+  "engine_ragdoll_mjcf",
+  "engine_ragdoll_observe",
+  "engine_ragdoll_act",
+  "engine_ragdoll_policy_create",
+  "engine_ragdoll_policy_destroy",
+  "engine_ragdoll_policy_control"
+], RAGDOLL_POLICY_SPEC_VERSION = 1, POLICY_SPEC_VERSION_WORD = 0, POLICY_SPEC_MODE = 1, POLICY_SPEC_PRESET = 2, POLICY_SPEC_SUBSTEPS = 3, POLICY_SPEC_GOAL = 4, POLICY_SPEC_GROUND = 5, POLICY_SPEC_FOOT_COUNT = 6, POLICY_SPEC_FEET = 7, POLICY_MAX_FEET = 4, POLICY_MAX_HEADS = 4, POLICY_SPEC_WORDS = (7) + (4), POLICY_JOINT_OBSERVATIONS = 6, POLICY_ROOT_OBSERVATIONS = 11, POLICY_JOINT_ACTIONS = 3, POLICY_ACTION_MODES = ["orientation", "axes"], POLICY_DRIVE_PRESETS = ["soft", "firm", "stiff"], POLICY_NO_GROUND = 4294967295, POLICY_DEFAULT_SUBSTEPS = 2, NULL = 0, BYTE = 1;
+function engineRagdollPolicyExports(symbols) {
+  for (let name of ENGINE_RAGDOLL_POLICY_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+function writePolicySpec(out, spec) {
+  let feet = spec.feet ?? [];
+  if (feet.length > (4)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `a policy watches at most ${(4)} feet`);
+  out.fill(0, 0, POLICY_SPEC_WORDS), out[(0)] = (1), out[(1)] = POLICY_ACTION_MODES.indexOf(spec.mode ?? "axes"), out[(2)] = POLICY_DRIVE_PRESETS.indexOf(spec.preset ?? "firm"), out[(3)] = spec.substeps ?? (2), out[(4)] = spec.goal ?? 0, out[(5)] = spec.ground ?? (4294967295), out[(6)] = feet.length;
+  for (let k = 0; k < feet.length; k++) out[(7) + k] = feet[k];
+}
+function policyObservationSize(joints, spec) {
+  return joints * (6) + (11) + (spec.feet?.length ?? 0) + (spec.goal ?? 0);
+}
+function policyActionSize(joints) {
+  return joints * (3);
+}
+var RagdollPolicy = class {
+  constructor(session, exports, handle, goalSize) {
+    this.session = session;
+    this.exports = exports;
+    this.handle = handle;
+    this.closed = false;
+    this.goal = session.memory.allocate("f32", Math.max(goalSize, 1));
+  }
+  control(goal = []) {
+    if (this.closed) throw new chunk2V7IL4HC_js.GameError("unknown_resource", "this ragdoll policy was destroyed");
+    for (let k = 0; k < goal.length && k < this.goal.length; k++) this.goal[k] = goal[k];
+    let s = this.session;
+    s.flush(), s.check(this.exports.engine_ragdoll_policy_control(this.handle, s.require(), this.goal.byteOffset), "ragdoll policy");
+  }
+  destroy() {
+    this.closed || (this.closed = true, this.exports.engine_ragdoll_policy_destroy(this.handle));
+  }
+}, RagdollPolicies = class _RagdollPolicies {
+  constructor(session, exports) {
+    this.session = session;
+    this.exports = exports;
+    this.spec = session.memory.allocate("u32", POLICY_SPEC_WORDS);
+  }
+  static of(session) {
+    let exports = engineRagdollPolicyExports(session.symbols);
+    return exports ? new _RagdollPolicies(session, exports) : null;
+  }
+  world() {
+    return this.session.flush(), this.session.require();
+  }
+  mjcf(ragdoll, spec = {}) {
+    writePolicySpec(this.spec, spec);
+    let world = this.world(), length = this.session.check(this.exports.engine_ragdoll_mjcf(world, ragdoll.id, this.spec.byteOffset, (0), 0), "ragdoll mjcf"), out = this.session.memory.allocate("u8", Math.max(length, (1)));
+    return this.session.check(this.exports.engine_ragdoll_mjcf(world, ragdoll.id, this.spec.byteOffset, out.byteOffset, length), "ragdoll mjcf"), new TextDecoder().decode(out.subarray(0, length));
+  }
+  observe(ragdoll, spec, goal, out) {
+    return writePolicySpec(this.spec, spec), this.session.check(this.exports.engine_ragdoll_observe(this.world(), ragdoll.id, this.spec.byteOffset, goal.byteOffset, out.byteOffset, out.length), "ragdoll observe");
+  }
+  act(ragdoll, spec, action) {
+    writePolicySpec(this.spec, spec), this.session.check(this.exports.engine_ragdoll_act(this.world(), ragdoll.id, this.spec.byteOffset, action.byteOffset, action.length), "ragdoll act");
+  }
+  create(ragdoll, spec, heads) {
+    if (heads.length === 0 || heads.length > (4)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `a policy has 1 to ${(4)} heads`);
+    writePolicySpec(this.spec, spec);
+    let words = heads.reduce((sum, head) => sum + head.length + 1, 0), blobs = this.session.memory.allocate("u32", words), at = 0;
+    for (let head of heads)
+      blobs[at] = head.length, blobs.set(head, at + 1), at += head.length + 1;
+    let handle = this.exports.engine_ragdoll_policy_create(this.world(), ragdoll.id, this.spec.byteOffset, blobs.byteOffset, words, heads.length);
+    if (handle === (0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "the engine refused the policy for that ragdoll");
+    return new RagdollPolicy(this.session, this.exports, handle, spec.goal ?? 0);
+  }
+};
+
+exports.ENGINE_RAGDOLL_POLICY_EXPORT_NAMES = ENGINE_RAGDOLL_POLICY_EXPORT_NAMES;
+exports.POLICY_ACTION_MODES = POLICY_ACTION_MODES;
+exports.POLICY_DRIVE_PRESETS = POLICY_DRIVE_PRESETS;
+exports.RagdollPolicies = RagdollPolicies;
+exports.RagdollPolicy = RagdollPolicy;
+exports.policyActionSize = policyActionSize;
+exports.policyObservationSize = policyObservationSize;