@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-SAFJIGYB.mjs

@@ -0,0 +1,165 @@
+import { addSceneCamera, BoxBatch, BOX_Y, BOX_SX, BOX_SY, BOX_SZ, BOX_X, BOX_Z } from './chunk-QDYFLATW.mjs';
+import { templateFrameStamp, digestInts } from './chunk-KGHJH5KJ.mjs';
+import { FRAME_STEP_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/game/kit/templates/word.ts
+var word_exports = {};
+__export(word_exports, {
+  Mark: () => Mark,
+  WORD: () => WORD,
+  WORD_COUNT: () => WORD_COUNT,
+  WORD_LIST: () => WORD_LIST,
+  WordPuzzle: () => WordPuzzle,
+  consistent: () => consistent,
+  evaluate: () => evaluate,
+  wordPuzzleTemplate: () => wordPuzzleTemplate
+});
+var WORD = { length: 5, attempts: 6, alphabet: 26, nextRoundSeconds: 2 }, Mark = { None: 0, Absent: 1, Present: 2, Correct: 3 }, WORDS = "about above actor adapt adult agent agree alarm album alert alive apple award beach begin bench birth black blend bless bloom board boost brain brave bread break bring broad brown build cabin candy cargo carry chain chair charm chart cheap check chest child civic claim class clean clear climb clock cloud coach coast craft crowd dance dream drink drive early earth enjoy equal event faith field flame floor focus fresh fruit giant glass grace grain grand green group guest happy heart honey house juice knife laugh learn light lucky magic march market music night ocean offer party peace phone piano plant plate power price pride proud queen quick quiet radio raise ready river robot round royal salad scale scene score share shine smile solid sound space spice sport stage stand start steam stone storm story sugar sunny table taste teach thank tiger toast today touch tower trade train treat trust truth uncle under unity value video visit voice water whale wheat world young youth zebra", LETTER_BASE = 96;
+function encodeWords(text) {
+  let words = text.split(" ").filter((w) => w.length === WORD.length), out = new Uint8Array(words.length * WORD.length);
+  for (let i = 0; i < words.length; i++)
+    for (let j = 0; j < WORD.length; j++) out[i * WORD.length + j] = words[i].charCodeAt(j) - (96);
+  return out;
+}
+var WORD_LIST = encodeWords(WORDS), WORD_COUNT = WORD_LIST.length / WORD.length, LETTERS = ["", ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("")], counts = new Int8Array(WORD.alphabet + 1);
+function evaluate(guess, guessOffset, answer, answerOffset, out, outOffset) {
+  counts.fill(0);
+  let correct = 0;
+  for (let i = 0; i < WORD.length; i++) {
+    let g = guess[guessOffset + i], a = answer[answerOffset + i];
+    g === a ? (out[outOffset + i] = Mark.Correct, correct++) : (out[outOffset + i] = Mark.Absent, counts[a]++);
+  }
+  for (let i = 0; i < WORD.length; i++) {
+    if (out[outOffset + i] === Mark.Correct) continue;
+    let g = guess[guessOffset + i];
+    counts[g] > 0 && (counts[g]--, out[outOffset + i] = Mark.Present);
+  }
+  return correct === WORD.length;
+}
+var ENTER = 27, BACKSPACE = 28, KEY_CODES = [...LETTERS.slice(1).map((l) => `Key${l}`), "Enter", "Backspace"], TILE_RGB = [3359061, 4674921, 16096779, 1096065], EMPTY_RGB = 1976635, TILE_SIZE = 0.9, TILE_GAP = 1.05, CAMERA_HEIGHT = 9, CAMERA_FOV = 50, CAMERA_PITCH = -Math.PI / 2, WordPuzzle = class {
+  constructor(results = null, answerIndex = -1) {
+    this.name = "word-puzzle";
+    this.grid = new Uint8Array(WORD.attempts * WORD.length);
+    this.marks = new Uint8Array(WORD.attempts * WORD.length);
+    this.keyboard = new Uint8Array(WORD.alphabet + 1);
+    this.answer = new Uint8Array(WORD.length);
+    this.status = "playing";
+    this.row = 0;
+    this.col = 0;
+    this.rounds = 0;
+    this.wins = 0;
+    this.actions = [];
+    this.slots = [];
+    this.roundSlot = null;
+    this.tiles = null;
+    this.waitSeconds = 0;
+    this.results = results, this.fixedAnswer = answerIndex;
+  }
+  enter(game) {
+    addSceneCamera(game, 0, (9), 0, (50), CAMERA_PITCH);
+    for (let k = 0; k < KEY_CODES.length; k++)
+      this.actions.push(game.input.defineButton(KEY_CODES[k], [{ device: "key", code: KEY_CODES[k] }, { device: "virtual", control: KEY_CODES[k] }]));
+    for (let i = 0; i < WORD.attempts * WORD.length; i++) this.slots.push(game.ui.hudText(`tile${i}`));
+    this.roundSlot = game.ui.hudNumber("round"), this.tiles = new BoxBatch(game, WORD.attempts * WORD.length), this.newRound(game);
+  }
+  fixedUpdate(game) {
+    if (this.status !== "playing") {
+      this.waitSeconds -= game.loop.time.values[FRAME_STEP_SECONDS_SLOT], this.waitSeconds <= 0 && this.newRound(game);
+      return;
+    }
+    let input = game.input;
+    for (let k = 0; k < this.actions.length; k++)
+      input.justPressed(this.actions[k]) && (k + 1 === (27) ? this.submit(game) : k + 1 === (28) ? this.erase(game) : this.type(game, k + 1));
+  }
+  update() {
+    let tiles = this.tiles;
+    if (tiles === null) return;
+    let b = tiles.box;
+    tiles.begin(), b[BOX_Y] = 0, b[BOX_SX] = (0.9), b[BOX_SY] = 0.1, b[BOX_SZ] = (0.9);
+    for (let r = 0; r < WORD.attempts; r++)
+      for (let c = 0; c < WORD.length; c++) {
+        let i = r * WORD.length + c;
+        b[BOX_X] = (c - (WORD.length - 1) / 2) * (1.05), b[BOX_Z] = (r - (WORD.attempts - 1) / 2) * (1.05), tiles.add(this.grid[i] === 0 ? (1976635) : TILE_RGB[this.marks[i]]);
+      }
+    tiles.end();
+  }
+  type(game, letter) {
+    if (this.col >= WORD.length) return;
+    let i = this.row * WORD.length + this.col;
+    this.grid[i] = letter, game.ui.setText(this.slots[i], LETTERS[letter]), this.col++;
+  }
+  erase(game) {
+    if (this.col === 0) return;
+    this.col--;
+    let i = this.row * WORD.length + this.col;
+    this.grid[i] = 0, game.ui.setText(this.slots[i], LETTERS[0]);
+  }
+  submit(game) {
+    if (this.col < WORD.length) return;
+    let offset = this.row * WORD.length, won = evaluate(this.grid, offset, this.answer, 0, this.marks, offset);
+    for (let c = 0; c < WORD.length; c++) {
+      let letter = this.grid[offset + c];
+      this.marks[offset + c] > this.keyboard[letter] && (this.keyboard[letter] = this.marks[offset + c]);
+    }
+    this.row++, this.col = 0, (won || this.row === WORD.attempts) && this.finish(game, won);
+  }
+  finish(game, won) {
+    this.status = won ? "won" : "lost", this.rounds++, won && this.wins++, this.waitSeconds = WORD.nextRoundSeconds, game.ui.haptic(won ? "success" : "warning"), this.results?.roundEnded(won, this.row);
+  }
+  newRound(game) {
+    let index = this.fixedAnswer >= 0 ? this.fixedAnswer : game.random.int(0, WORD_COUNT - 1);
+    for (let j = 0; j < WORD.length; j++) this.answer[j] = WORD_LIST[index * WORD.length + j];
+    this.grid.fill(0), this.marks.fill(Mark.None), this.keyboard.fill(Mark.None);
+    for (let i = 0; i < this.slots.length; i++) game.ui.setText(this.slots[i], LETTERS[0]);
+    this.row = 0, this.col = 0, this.status = "playing", this.roundSlot !== null && game.ui.setNumber(this.roundSlot, this.rounds + 1);
+  }
+}, candidateMarks = new Uint8Array(WORD.length);
+function consistent(scene, candidate) {
+  for (let r = 0; r < scene.row; r++) {
+    evaluate(scene.grid, r * WORD.length, WORD_LIST, candidate * WORD.length, candidateMarks, 0);
+    for (let c = 0; c < WORD.length; c++) if (candidateMarks[c] !== scene.marks[r * WORD.length + c]) return false;
+  }
+  return true;
+}
+var BOT_HOLD_FRAMES = 2, WordBot = class {
+  constructor() {
+    this.held = -1;
+    this.holdFrames = 0;
+    this.target = -1;
+  }
+  drive(scene, game, frame) {
+    let t = templateFrameStamp(frame);
+    if (this.held >= 0) {
+      if (++this.holdFrames < (2)) return;
+      game.input.keyEvent(KEY_CODES[this.held], false, t), this.held = -1;
+      return;
+    }
+    if (scene.status !== "playing") {
+      this.target = -1;
+      return;
+    }
+    this.target < 0 && (this.target = this.pick(scene));
+    let key;
+    scene.col < WORD.length ? key = WORD_LIST[this.target * WORD.length + scene.col] - 1 : (key = (27) - 1, this.target = -1), game.input.keyEvent(KEY_CODES[key], true, t), this.held = key, this.holdFrames = 0;
+  }
+  pick(scene) {
+    for (let i = 0; i < WORD_COUNT; i++) if (consistent(scene, i)) return i;
+    return 0;
+  }
+}, digestScratch = new Int32Array(WORD.attempts * WORD.length + 3), wordPuzzleTemplate = {
+  id: "word-puzzle",
+  title: "Word puzzle",
+  sources: ["src/game/kit/templates/word.ts"],
+  economy: null,
+  scene: () => new WordPuzzle(),
+  bot: () => new WordBot(),
+  progress: (scene) => scene.wins,
+  digest(scene) {
+    let d = digestScratch;
+    for (let i = 0; i < scene.grid.length; i++) d[i] = scene.grid[i] * 4 + scene.marks[i];
+    return d[scene.grid.length] = scene.rounds, d[scene.grid.length + 1] = scene.wins, d[scene.grid.length + 2] = scene.row, digestInts(d, d.length);
+  }
+};
+
+export { Mark, WORD, WORD_COUNT, WORD_LIST, WordPuzzle, consistent, evaluate, wordPuzzleTemplate, word_exports };

package/dist/chunk-SKQFLBDD.js

@@ -0,0 +1,263 @@
+'use strict';
+
+var chunk7AAIAVAA_js = require('./chunk-7AAIAVAA.js');
+var chunk2O2CG465_js = require('./chunk-2O2CG465.js');
+var chunkPTRNO5UD_js = require('./chunk-PTRNO5UD.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/scenery/engine.ts
+var ENGINE_SPLAT_BODY_EXPORT_NAMES = ["engine_splat_edit", "engine_splat_bind", "engine_splat_hero_budget", "engine_splat_drape", "engine_splat_motion_rows", "engine_splat_motion"], ENGINE_SPLAT_EXPORT_NAMES = [
+  "engine_splat_open",
+  "engine_splat_close",
+  "engine_splat_provide",
+  "engine_splat_fail",
+  "engine_splat_update",
+  "engine_splat_requests",
+  "engine_splat_set_transform",
+  "engine_splat_registers"
+], NULL = 0, F32_BYTES = 4, EYE_OFFSET_BYTES = 0, TRANSFORM_OFFSET_BYTES = 16, BODY_OFFSET_BYTES = (16) + 8 * (4), BODY_WORDS = Math.max(3, 3, 14), SCRATCH_BYTES = BODY_OFFSET_BYTES + BODY_WORDS * (4);
+function refused(what, code) {
+  if (code < 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the ${what} (${code})`);
+}
+var EngineSceneryBodies = class {
+  constructor(exports, render, stage, stageOwned) {
+    this.exports = exports;
+    this.render = render;
+    this.stage = stage;
+    this.stageOwned = stageOwned;
+  }
+  edit(scene, region, values) {
+    refused("splat edit", this.exports.engine_splat_edit(scene, region, this.stage(values)));
+  }
+  bind(scene, root) {
+    refused("splat rig", this.exports.engine_splat_bind(scene, this.render(), root));
+  }
+  heroBudget(scene, caps) {
+    refused("hero budget", this.exports.engine_splat_hero_budget(scene, caps === null ? (0) : this.stage(caps)));
+  }
+  drape(scene, cloths, cloth, region, rest) {
+    let baked = rest === null ? (0) : this.stageOwned(new Uint8Array(rest.buffer, rest.byteOffset, rest.byteLength));
+    refused("splat drape", this.exports.engine_splat_drape(scene, cloths, cloth, region, baked, rest?.length ?? 0));
+  }
+  motionRows(scene) {
+    return this.exports.engine_splat_motion_rows(scene);
+  }
+  motion(scene, table, columns, reachMillimetres, mask) {
+    refused("splat motion", this.exports.engine_splat_motion(scene, table, columns === null ? (0) : this.stage(columns), reachMillimetres, mask));
+  }
+};
+function engineSplatExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_SPLAT_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineScenery = class {
+  constructor(runtime, exports, render) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.scratch = (0);
+    this.scratchBytes = 0;
+    this.live = 0;
+    this.buffer = null;
+    this.floats = new Float32Array(0);
+    this.words = new Uint32Array(0);
+    this.bytes = new Uint8Array(0);
+    let symbols = runtime.symbols;
+    this.bodies = ENGINE_SPLAT_BODY_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? new EngineSceneryBodies(symbols, render, (values) => this.stageBody(values), (values) => this.stage(values)) : null;
+  }
+  stageBody(values) {
+    let pointer = this.ensureScratch() + BODY_OFFSET_BYTES;
+    this.views();
+    let at = pointer >>> 2;
+    return values instanceof Float32Array ? this.floats.set(values, at) : this.words.set(values, at), pointer;
+  }
+  views() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.floats = new Float32Array(buffer), this.words = new Uint32Array(buffer), this.bytes = new Uint8Array(buffer));
+  }
+  ensureScratch() {
+    if (this.scratch !== (0)) return this.scratch;
+    let bytes = Math.max(SCRATCH_BYTES, chunk2O2CG465_js.COLUMN_ALIGN), pointer = this.runtime.exports.engine_alloc(bytes, chunk2O2CG465_js.COLUMN_ALIGN);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold scenery buffers");
+    return this.scratch = pointer, this.scratchBytes = bytes, pointer;
+  }
+  stage(source) {
+    let pointer = this.runtime.exports.engine_alloc(Math.max(source.byteLength, 1), chunk2O2CG465_js.COLUMN_ALIGN);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold scenery data");
+    return this.views(), this.bytes.set(source, pointer), pointer;
+  }
+  open(manifest) {
+    this.ensureScratch();
+    let scene = this.exports.engine_splat_open(this.render(), this.stage(manifest), manifest.byteLength);
+    if (scene === (0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "the engine refused the scenery manifest");
+    return this.live++, scene;
+  }
+  provide(scene, index, chunk) {
+    return this.exports.engine_splat_provide(scene, index, this.stage(chunk), chunk.byteLength);
+  }
+  fail(scene, index) {
+    return this.exports.engine_splat_fail(scene, index);
+  }
+  update(scene, eye, requests) {
+    let pointer = this.ensureScratch() + (0);
+    this.views();
+    let at = pointer >>> 2;
+    for (let i = 0; i < 3; i++) this.floats[at + i] = eye[i];
+    let n = this.exports.engine_splat_update(scene, this.render(), pointer);
+    if (n <= 0) return n;
+    let count = Math.min(n, requests.length), from = this.exports.engine_splat_requests(scene) >>> 2;
+    this.views();
+    for (let i = 0; i < count; i++) requests[i] = this.words[from + i];
+    return count;
+  }
+  setTransform(scene, transform) {
+    let pointer = this.ensureScratch() + (16);
+    this.views();
+    let at = pointer >>> 2;
+    for (let i = 0; i < 8; i++) this.floats[at + i] = transform[i];
+    let code = this.exports.engine_splat_set_transform(scene, pointer);
+    if (code < 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the scenery transform (${code})`);
+  }
+  registers(scene) {
+    let pointer = this.exports.engine_splat_registers(scene);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", "scenery is closed");
+    return this.views(), this.words.subarray(pointer >>> 2, (pointer >>> 2) + 20);
+  }
+  close(scene) {
+    this.exports.engine_splat_close(scene, this.render()), this.live--, !(this.live > 0 || this.scratch === (0)) && (this.runtime.exports.engine_free(this.scratch, this.scratchBytes, chunk2O2CG465_js.COLUMN_ALIGN), this.scratch = (0), this.scratchBytes = 0);
+  }
+};
+
+// src/game/world/engine.ts
+var ENGINE_STREAM_EXPORT_NAMES = [
+  "engine_stream_open",
+  "engine_stream_close",
+  "engine_stream_provide",
+  "engine_stream_update",
+  "engine_stream_registers",
+  "engine_stream_open_logic",
+  "engine_stream_step_logic",
+  "engine_stream_collider"
+], NULL2 = 0, FEATURE_NAME_BYTES = 64, LAZY_FEATURE = "world_lazy_packs_1", F32_BYTES2 = 4, U32_BYTES = 4;
+function engineStreamExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_STREAM_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineWorldStreaming = class {
+  constructor(runtime, exports, render) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.eye = { pointer: (0), bytes: 0 };
+    this.actors = { pointer: (0), bytes: 0 };
+    this.ops = { pointer: (0), bytes: 0 };
+    this.scratch = { pointer: (0), bytes: 0 };
+    this.buffer = null;
+    this.floats = new Float32Array(0);
+    this.words = new Uint32Array(0);
+    this.bytes = new Uint8Array(0);
+    this.lazySupport = null;
+  }
+  views() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.floats = new Float32Array(buffer), this.words = new Uint32Array(buffer), this.bytes = new Uint8Array(buffer));
+  }
+  ensure(block, bytes) {
+    if (block.bytes >= bytes) return block.pointer;
+    if (block.pointer !== (0) && this.runtime.exports.engine_free(block.pointer, block.bytes, chunk2O2CG465_js.COLUMN_ALIGN), block.bytes = Math.max(bytes, chunk2O2CG465_js.COLUMN_ALIGN), block.pointer = this.runtime.exports.engine_alloc(block.bytes, chunk2O2CG465_js.COLUMN_ALIGN), block.pointer === (0))
+      throw block.bytes = 0, new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold world streaming buffers");
+    return block.pointer;
+  }
+  stage(source) {
+    let pointer = this.runtime.exports.engine_alloc(Math.max(source.byteLength, 1), chunk2O2CG465_js.COLUMN_ALIGN);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold world data");
+    return this.views(), this.bytes.set(source, pointer), pointer;
+  }
+  lazyPacks() {
+    if (this.lazySupport !== null) return this.lazySupport;
+    this.lazySupport = false;
+    let symbols = this.runtime.symbols, count = symbols.engine_feature_count, name = symbols.engine_feature_name;
+    if (count === void 0 || name === void 0) return false;
+    let scratch = this.runtime.exports.engine_alloc((64), 1);
+    if (scratch === (0)) return false;
+    for (let i = 0; i < count() && !this.lazySupport; i++) {
+      let length = name(i, scratch, (64));
+      if (length !== LAZY_FEATURE.length) continue;
+      this.views();
+      let same = true;
+      for (let k = 0; k < length && same; k++) same = this.bytes[scratch + k] === LAZY_FEATURE.charCodeAt(k);
+      this.lazySupport = same;
+    }
+    return this.runtime.exports.engine_free(scratch, (64), 1), this.lazySupport;
+  }
+  open(world, materials, tier) {
+    let list = this.ensure(this.scratch, Math.max(materials.length, chunk7AAIAVAA_js.STREAM_COLLIDER_FLOATS) * (4)), pointer = this.stage(world);
+    this.views();
+    for (let i = 0; i < materials.length; i++) this.words[(list >>> 2) + i] = materials[i];
+    let stream = this.exports.engine_stream_open(this.render(), pointer, world.byteLength, list, materials.length, tier);
+    if (stream === (0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "the engine refused the world file");
+    return chunkPTRNO5UD_js.noteInspectorStream(stream), stream;
+  }
+  provide(stream, pack) {
+    let code = this.exports.engine_stream_provide(stream, this.stage(pack), pack.byteLength);
+    if (code === chunk7AAIAVAA_js.STREAM_PACK_CONTENDED) return code;
+    if (code < 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused a world pack (${code})`);
+    return code;
+  }
+  update(stream, eye) {
+    let pointer = this.ensure(this.eye, chunk7AAIAVAA_js.STREAM_EYE_FLOATS * (4));
+    this.views();
+    let at = pointer >>> 2;
+    for (let i = 0; i < chunk7AAIAVAA_js.STREAM_EYE_FLOATS; i++) this.floats[at + i] = eye[i];
+    this.exports.engine_stream_update(stream, this.render(), pointer);
+  }
+  registers(stream) {
+    let pointer = this.exports.engine_stream_registers(stream);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", "world stream is closed");
+    return this.views(), this.words.subarray(pointer >>> 2, (pointer >>> 2) + chunk7AAIAVAA_js.STREAM_REGISTER_BLOCK_WORDS);
+  }
+  openLogic(stream, stepSeconds, budget, actors) {
+    this.ensure(this.actors, Math.max(actors, 1) * chunk7AAIAVAA_js.STREAM_ACTOR_FLOATS * (4)), this.ensure(this.ops, Math.max(budget, 1) * (4));
+    let radius = this.exports.engine_stream_open_logic(stream, stepSeconds, budget, actors);
+    if (radius < 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused world colliders (${radius})`);
+    return radius;
+  }
+  stepLogic(stream, actors, count, ops) {
+    let actorPointer = this.ensure(this.actors, Math.max(count, 1) * chunk7AAIAVAA_js.STREAM_ACTOR_FLOATS * (4)), opsPointer = this.ensure(this.ops, Math.max(ops.length, 1) * (4));
+    this.views();
+    let at = actorPointer >>> 2, floats = count * chunk7AAIAVAA_js.STREAM_ACTOR_FLOATS;
+    for (let i = 0; i < floats; i++) this.floats[at + i] = actors[i];
+    let n = this.exports.engine_stream_step_logic(stream, actorPointer, count, opsPointer, ops.length);
+    if (n === chunk7AAIAVAA_js.STREAM_PACK_CONTENDED) return n;
+    if (n < 0) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `world collider step failed (${n})`);
+    this.views();
+    let from = opsPointer >>> 2;
+    for (let i = 0; i < n; i++) ops[i] = this.words[from + i];
+    return n;
+  }
+  collider(stream, index, out) {
+    let pointer = this.ensure(this.scratch, chunk7AAIAVAA_js.STREAM_COLLIDER_FLOATS * (4));
+    if (this.exports.engine_stream_collider(stream, index, pointer) < 0) throw new chunk2V7IL4HC_js.GameError("unknown_resource", `world collider ${index} does not exist`);
+    this.views();
+    let at = pointer >>> 2;
+    for (let i = 0; i < chunk7AAIAVAA_js.STREAM_COLLIDER_FLOATS; i++) out[i] = this.floats[at + i];
+  }
+  close(stream) {
+    chunkPTRNO5UD_js.noteInspectorStream((0)), this.exports.engine_stream_close(stream, this.render());
+    for (let block of [this.eye, this.actors, this.ops, this.scratch])
+      block.pointer !== (0) && this.runtime.exports.engine_free(block.pointer, block.bytes, chunk2O2CG465_js.COLUMN_ALIGN), block.pointer = (0), block.bytes = 0;
+  }
+};
+
+// src/game/physics/joints.ts
+var JOINT_AXES = { linX: 0, linY: 1, linZ: 2, angX: 3, angY: 4, angZ: 5 }, POSE_STRIDE = 10, NO_PARENT = -1;
+
+exports.ENGINE_SPLAT_EXPORT_NAMES = ENGINE_SPLAT_EXPORT_NAMES;
+exports.ENGINE_STREAM_EXPORT_NAMES = ENGINE_STREAM_EXPORT_NAMES;
+exports.EngineScenery = EngineScenery;
+exports.EngineWorldStreaming = EngineWorldStreaming;
+exports.JOINT_AXES = JOINT_AXES;
+exports.NO_PARENT = (-1);
+exports.POSE_STRIDE = (10);
+exports.engineSplatExports = engineSplatExports;
+exports.engineStreamExports = engineStreamExports;