@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-Y65LXQGA.mjs

@@ -0,0 +1,3164 @@
+import { bakeRate, propertySize, INTERPOLATION_CODES, LOOP_CODES, SYNC_MODE_CODES, checkSyncMarkers, HUMAN_BONES, BLEND_SPACE_CODES, IK_CODES, DEFAULT_IK_ITERATIONS, DEFAULT_IK_TOLERANCE, animationLodInterval, ROOT_MOTION_WORDS, emptyClipEvent, CLIP_EVENT_KINDS } from './chunk-7ARSJPV3.mjs';
+import { createWithDescriptor, EngineFeatures, refuseUndrawnPhysicalFields, MATERIAL_KINDS, writeMaterialExtension, extraTextures, writeMaterialFeatures, materialFeatureFlags, writeMaterialTint, writeCharacterWords, writeTextureTransforms, writePlanes, materialSlotIndex, writeMaterialState, LIGHT_KINDS, writeNodeFeatures, OWNER_STAGING, writeSky, writeTintWords, WebAudioPort, HeadlessAudio, WorkletAudio, engineTerrainExports, EngineTerrain, CAP_CUSTOM_PROJECTION, CAP_POINT_SHADOWS, SHADOW_TYPES, floatBits } from './chunk-7BHW5GTC.mjs';
+import { bindKernelEngine, engineStoryExports, EngineStory, checkColliderClass, packContactRuleHeader, writeContactRulePayload, DEFAULT_EXTENTS, VEHICLE_DESC_WORDS, INPUT_STRIDE, STATE_STRIDE, ENGINE_AI_EXPORT_NAMES, ENGINE_AI_WORLD_STEP, MAX_WAVES, SEA_STATES, WATER_SAMPLE_WORDS } from './chunk-RUVGVNOF.mjs';
+import { bindSoaEngine, castShapeCode } from './chunk-XPG3N5CF.mjs';
+import { writeMediumDesc } from './chunk-ATAWRACV.mjs';
+import { FRAME_SECONDS_SLOT, FRAME_NOW_MS_SLOT, FRAME_ALPHA_SLOT } from './chunk-IDLW4NWA.mjs';
+import { engineVectorSurfaceExports, EngineVectorSurfaces, ENGINE_AUDIO_WORKLET_EXPORTS, ENGINE_AUDIO_EXPORT_NAMES, EngineAudioPort, EngineMemory, WorldSnapshots, DEFAULT_ROLLBACK_FRAMES, hasRollback, ROLLBACK_CONFIG_WORDS, writeRollbackConfig, releaseEngineArena, engineJoints } from './chunk-GXKI64OT.mjs';
+import { engineStreamExports, EngineWorldStreaming, engineSplatExports, EngineScenery } from './chunk-NHJUGZUR.mjs';
+import { BLEND_FACTORS, BUFFER_OWNER_CAPABILITIES, TEXTURE_KIND_EXTERNAL, TEXTURE_FORMAT_RGBA32I, TEXTURE_FORMAT_R32I, TEXTURE_FORMAT_RGBA32UI, TEXTURE_FORMAT_RGBA16UI, TEXTURE_FORMAT_RGBA8UI, TEXTURE_FORMAT_RG32UI, TEXTURE_FORMAT_R32UI, TEXTURE_FORMAT_R16UI, TEXTURE_FORMAT_R8UI, TEXTURE_FORMAT_RG32F, TEXTURE_FORMAT_R32F, TEXTURE_FORMAT_RG16F, TEXTURE_FORMAT_R16F, TEXTURE_FORMAT_RG8, TEXTURE_FORMAT_R8, TEXTURE_KIND_2D_ARRAY, TEXTURE_KIND_3D, TEXTURE_ENCODE_ASTC_4X4, TEXTURE_ENCODE_BC7, TEXTURE_ENCODE_AUTO, OP_MARK_TEXTURE_REGION, MATERIAL_SLOTS, OP_SET_MATERIAL_WORD, OP_MARK_EMITTER, OP_EMIT, OP_SET_EMITTER_RATE, OP_CLEAR_EMITTER, OP_DESTROY_EMITTER, OP_SET_RENDER_ORDER, OP_SET_SHADOW, STAT_THERMAL_TIER, NODE_POSE_FLOATS, MEDIA_VOLUME_FEATURE, FOG_MODES, TONE_MAPPINGS, ENV_TONE_CURVE, ENV_GI, GI_MODES, ENV_GI_INTENSITY, ENV_GI_SPACING, ENV_GI_SUN_ANGLE, OP_SET_VOLUMETRICS, TARGET_KIND_CUBE, TARGET_KIND_ARRAY, TARGET_KIND_2D, TARGET_KIND, TARGET_LAYERS, TARGET_SAMPLED_DEPTH, TARGET_COLORS, TARGET_TEXTURES, TARGET_MAX_COLORS, MAX_CHAIN_EFFECTS, EFFECT_LENS_FLARE, OP_SET_EFFECT, POST_EFFECT_TEXTURES, OP_SET_EFFECT_TEXTURE, OP_SET_WEATHER, OP_SET_TIME_OF_DAY, PASS_SLICE, PASS_FLAGS, PASS_FLAG_CUBE_FACE, PASS_FLAG_REFLECT, PASS_FLAG_ONCE, PASS_PLANE, useTransformEngine, bindTransformEngine, bindChemistryEngine, engineSmokeExports, EngineSmoke, engineReactiveExports, EngineReactive, engineFluidExports, EngineFluids, engineDestructionExports, EngineDestruction, RENDER_CORE_EXPORTS, RENDER_FEATURE_EXPORTS, OP_ANIMATION, ANIM_SET_TIME, ANIM_SET_SPEED, ANIM_SET_LOOP, ANIM_SET_PAUSED, ANIM_SET_RANGE, ANIM_SET_SYNC, ANIM_SET_SYNC_MODE, ANIM_SET_SYNC_MARKERS, ANIM_INERTIALIZE, ANIM_BAKE_RETARGET, ANIM_SET_EVENTS, OP_SET_CLIP_ADDITIVE, ANIM_CROSSFADE, ANIM_FADE, ANIM_CREATE_MASK, OP_SET_CLIP_MASK, ANIM_DESTROY, ANIM_KIND_MASK, ANIM_SET_CLIP_EVENTS, ANIM_CLIP_INFO, ANIM_CREATE_BLEND, ANIM_SET_BLEND, ANIM_KIND_BLEND, ANIM_CREATE_IK, ANIM_SET_IK_TARGET, ANIM_SET_IK_POLE, ANIM_KIND_IK, ANIM_HUMANOID, ANIM_RETARGET, ANIM_KIND_RETARGET, ANIM_SET_LOD, ROOT_MOTION_XZ, ROOT_MOTION_Y, ROOT_MOTION_YAW, ROOT_MOTION_APPLY, ANIM_ROOT_MOTION, ANIM_KIND_ROOT_MOTION, ANIMATION_BUFFER_ROOT_MOTION, ANIMATION_BUFFER_ACTIONS, ANIM_ACTION_RUNNING, ANIM_ACTION_PAUSED, ANIM_ACTION_FINISHED, ANIMATION_BUFFER_EVENTS, ANIM_MAX_EVENTS, EMITTER_SHAPES, EMITTER_COLLISIONS, OP_RAW_MARK_BUFFER, OP_RAW_MARK_TEXTURE, OP_RAW_COPY_TEXTURE, OP_RAW_DESTROY_TEXTURE, OP_RAW_DISPATCH, OP_RAW_DRAW, OP_RAW_COPY, OP_RAW_DESTROY_BUFFER, ANIM_ACTION_WORDS, ANIM_EVENT_WORDS, RENDER_KERNEL_INSTANCES_FEATURE, RENDER_FEED_POSE_FEATURE } from './chunk-E65WCTIG.mjs';
+import { engineClothExports, EngineCloths, engineSoftBodyExports, EngineSoftBodies, SOFT_BODY_FEATURE, CRUMPLE_IMPACT_FLOATS } from './chunk-5YFBGGCK.mjs';
+import { engineSessionFailure, hasPhysics, requireEngineMemoryHeld } from './chunk-GHS6MIL6.mjs';
+import { COLUMN_ALIGN, ERROR_INVALID_ARGUMENT, WORD_BYTES, ERROR_UNSUPPORTED, ERROR_UNKNOWN_RESOURCE, ERROR_DEAD_ENTITY, ERROR_CAPACITY_EXCEEDED, DESC_WORDS, WORLD_GRAVITY, WORLD_STEP_SECONDS, WORLD_MAX_BODIES, WORLD_MAX_COLLIDERS, WORLD_MAX_JOINTS, WORLD_MAX_CONTACTS, WORLD_MAX_CONTROLLERS, DEFAULT_MAX_COMMANDS, WORLD_MAX_COMMANDS, REGISTER_WORDS, COMMAND_WORDS, COMMAND_OP, COMMAND_BODY, COMMAND_PAYLOAD, LAYOUT_POSITION, LAYOUT_ROTATION, LAYOUT_SCALE, LAYOUT_PREVIOUS_POSITION, LAYOUT_PREVIOUS_ROTATION, LAYOUT_PREVIOUS_SCALE, LAYOUT_PARENT, LAYOUT_RENDER, LAYOUT_ENTITIES, LAYOUT_SPARSE, LAYOUT_CAPACITY, LAYOUT_SPARSE_LEN, OP_SET_GRAVITY, BODY_KIND_DYNAMIC, BODY_KIND_KINEMATIC, BODY_KIND_FIXED, BODY_KIND, BODY_LINEAR_DAMPING, BODY_ANGULAR_DAMPING, BODY_GRAVITY_SCALE, BODY_FLAGS, BODY_FLAG_CCD, BODY_FLAG_CAN_SLEEP, BODY_DOMINANCE, COLLIDER_SHAPE, COLLIDER_DATA_A, COLLIDER_DATA_A_LEN, COLLIDER_ROWS, COLLIDER_COLUMNS, COLLIDER_PARAMS, COLLIDER_DATA_B, COLLIDER_DATA_B_LEN, COLLIDER_BORDER, COLLIDER_OFFSET, COLLIDER_ROTATION, COLLIDER_DENSITY, COLLIDER_MASS, COLLIDER_FRICTION, COLLIDER_RESTITUTION, COLLIDER_FLAGS, COLLIDER_FLAG_SENSOR, COLLIDER_FLAG_EVENTS, COLLIDER_FLAG_GROUPS, COLLISION_GROUP_ALL, COLLIDER_MEMBERSHIP, COLLIDER_FILTER, JOINT_ANCHOR_A, JOINT_ANCHOR_B, JOINT_SIX_DOF, JOINT_KIND, JOINT_CONE, JOINT_AXIS, JOINT_SWING, JOINT_LIMITS, JOINT_SPRING, JOINT_LENGTH, JOINT_STIFFNESS, JOINT_DAMPING, JOINT_ROPE, JOINT_REVOLUTE, JOINT_PRISMATIC, JOINT_HAS_LIMITS, JOINT_SPHERICAL, JOINT_FIXED, REGISTER_MOTOR_VELOCITY, REGISTER_MOTOR_MAX_FORCE, OP_SET_BODY_POSE, OP_SET_LINEAR_VELOCITY, OP_SET_ANGULAR_VELOCITY, OP_APPLY_IMPULSE, OP_APPLY_TORQUE_IMPULSE, OP_ADD_FORCE, OP_APPLY_IMPULSE_AT_POINT, OP_ADD_FORCE_AT_POINT, OP_ADD_TORQUE, VECTOR_OUT, MOTOR_TARGET, MOTOR_STIFFNESS, MOTOR_DAMPING, CAST_SHAPE, CAST_PARAMS, CAST_ROTATION, RAY_ORIGIN, RAY_DIRECTION, RAY_MAX, RAY_INCLUDE_SENSORS, NO_EXCLUDE, RAY_EXCLUDE, RAY_HIT, HIT_COLLIDER, HIT_DISTANCE, HIT_POINT, HIT_NORMAL, OP_RESET_FORCES, OP_WAKE, RAY_SOLID, CONTROLLER_OFFSET, CONTROLLER_MAX_SLOPE_CLIMB, CONTROLLER_MIN_SLOPE_SLIDE, CONTROLLER_AUTOSTEP_HEIGHT, CONTROLLER_AUTOSTEP_WIDTH, CONTROLLER_SNAP, CONTROLLER_SLIDE_UNSET, CONTROLLER_SLIDE, CONTROLLER_HAS_UP, CONTROLLER_UP, GROUNDED_OUT, OP_SET_COLLIDER_CLASS, OP_SET_CONTACT_RULE, OP_SET_COLLIDER_GROUPS, OP_SET_SOLVER, OP_SET_BODY_SOFT_CCD, OP_SET_BODY_SLEEP, REGISTER_FRAME_ALPHA, REGISTER_FRAME_VERSION_LOW, REGISTER_FRAME_VERSION_HIGH, U32_RANGE, ENGINE_EXPORT_ARITY, ENGINE_EXPORT_PROTOTYPES, SHAPE_COMPOUND, SHAPE_ROUND_CONVEX_HULL, SHAPE_ROUND_CONE, SHAPE_ROUND_CYLINDER, SHAPE_ROUND_CUBOID, SHAPE_HEIGHTFIELD, SHAPE_CONVEX_HULL, SHAPE_TRIMESH, SHAPE_CONE, SHAPE_CYLINDER, SHAPE_CAPSULE, SHAPE_CUBOID, SHAPE_BALL, PART_FLOATS, PART_SHAPE, PART_OFFSET, PART_ROTATION, JOINT_FRAME_A, JOINT_FRAME_B, MOTION_FREE, JOINT_AXIS_LIMITS, JOINT_MOTIONS, JOINT_SWING_CONE, PART_BORDER, PART_PARAMS, MOTION_BITS, BODY_TRANSLATION_SHIFT, BODY_ROTATION_SHIFT, MOTION_LOCKED, MOTION_LIMITED } from './chunk-A33OORT7.mjs';
+import { registerFontTable, FontTable } from './chunk-XJA2NGTI.mjs';
+import { noteInspectorWorld } from './chunk-MOMOZEUM.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/gpu/engine.ts
+var WORD = 4, DEFAULT_WORKGROUP = 1, ENTRY_BYTES = 52 * (4), MAX_TARGETS = 4, PACK_SHIFT = 16, NUL = 0, DEPTH_UNSET = 0, USAGE = {
+  storage: 1,
+  uniform: 2,
+  vertex: 4,
+  index: 8,
+  indirect: 16,
+  copy_src: 32,
+  copy_dst: 64,
+  map_read: 128
+}, TEXTURE_USAGE = {
+  sampled: 1,
+  storage: 2,
+  target: 4
+}, FORMAT = {
+  rgba8: 0,
+  rgba16f: 2,
+  rgba32f: 1
+}, TEXEL_BYTES = {
+  rgba8: 4,
+  rgba16f: 8,
+  rgba32f: 16
+}, FACTOR = {
+  zero: BLEND_FACTORS.indexOf("zero"),
+  one: BLEND_FACTORS.indexOf("one"),
+  src: BLEND_FACTORS.indexOf("srcColor"),
+  "one-minus-src": BLEND_FACTORS.indexOf("oneMinusSrcColor"),
+  "src-alpha": BLEND_FACTORS.indexOf("srcAlpha"),
+  "one-minus-src-alpha": BLEND_FACTORS.indexOf("oneMinusSrcAlpha"),
+  dst: BLEND_FACTORS.indexOf("dstColor"),
+  "one-minus-dst": BLEND_FACTORS.indexOf("oneMinusDstColor"),
+  "dst-alpha": BLEND_FACTORS.indexOf("dstAlpha"),
+  "one-minus-dst-alpha": BLEND_FACTORS.indexOf("oneMinusDstAlpha"),
+  "src-alpha-saturated": BLEND_FACTORS.indexOf("srcAlphaSaturate")
+}, TOPOLOGY = {
+  "triangle-list": 0,
+  "triangle-strip": 1,
+  "line-list": 2,
+  "point-list": 3
+}, SCENE_COLOR_FORMAT = "rgba16f", HOOK_ORDER = ["beforeScene", "afterOpaque", "afterTransparent", "post", "afterPost"], SCENE = {
+  depth: 4294967280,
+  motion: 4294967281,
+  color: 4294967282,
+  instances: 4294967283,
+  particles: 4294967284
+}, SCENE_TEXTURE = {
+  depth: 4294967280,
+  motion: 4294967281,
+  color: 4294967282
+};
+function failure(code, what) {
+  switch (code) {
+    case ERROR_CAPACITY_EXCEEDED:
+      return new GameError("capacity_exceeded", `${what}: capacity exceeded`);
+    case ERROR_DEAD_ENTITY:
+    case ERROR_UNKNOWN_RESOURCE:
+      return new GameError("unknown_resource", `${what}: unknown resource`);
+    case ERROR_UNSUPPORTED:
+      return new GameError("unsupported_feature", `${what}: unsupported`);
+    default:
+      return new GameError("invalid_argument", `${what}: invalid argument`);
+  }
+}
+function packBlend(blend) {
+  return blend ? (FACTOR[blend.color.src] << 0 | FACTOR[blend.color.dst] << 5 | FACTOR[blend.alpha.src] << 10 | FACTOR[blend.alpha.dst] << 15) >>> 0 : 0;
+}
+function pack(pair2) {
+  return (pair2[0] | pair2[1] << (16)) >>> 0;
+}
+var EngineRaw = class {
+  constructor(host) {
+    this.api = "wgsl";
+    this.shaders = [null];
+    this.sizes = /* @__PURE__ */ new Map();
+    this.textures = /* @__PURE__ */ new Map();
+    this.targetFormats = /* @__PURE__ */ new Map();
+    this.encoder = new TextEncoder();
+    this.reads = [];
+    this.host = host;
+  }
+  createBuffer(desc) {
+    if (desc.size <= 0 || desc.size % (4) !== 0)
+      throw new GameError("invalid_argument", `gpu buffer size ${desc.size} must be a positive multiple of ${(4)}`);
+    let d = this.host.clearDesc();
+    d[0] = desc.size;
+    let usage = 0;
+    for (let u of desc.usage) usage |= USAGE[u];
+    d[1] = usage;
+    let id = this.check(this.host.call("engine_render_raw_buffer"), "create gpu buffer");
+    return this.sizes.set(id, desc.size), id;
+  }
+  writeBuffer(buffer, offset, data) {
+    let size = this.size(buffer);
+    if (offset < 0 || offset % (4) !== 0 || offset + data.byteLength > size)
+      throw new GameError("invalid_argument", `write of ${data.byteLength} bytes at ${offset} overflows gpu buffer ${buffer}`);
+    this.host.flush(), this.host.bytes(10, buffer, 0).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), offset), this.host.command(OP_RAW_MARK_BUFFER, buffer);
+  }
+  createTexture(desc) {
+    let d = this.host.clearDesc();
+    d[0] = desc.width, d[1] = desc.height, d[2] = FORMAT[desc.format];
+    let usage = 0;
+    for (let u of desc.usage) usage |= TEXTURE_USAGE[u];
+    d[3] = usage, d[4] = desc.mipLevels ?? 1;
+    let id = this.check(this.host.call("engine_render_raw_texture"), "create gpu texture");
+    return this.textures.set(id, { width: desc.width, height: desc.height, format: desc.format }), id;
+  }
+  writeTexture(texture, data) {
+    let info = this.texture(texture), bytes = info.width * info.height * TEXEL_BYTES[info.format];
+    if (data.byteLength !== bytes)
+      throw new GameError("invalid_argument", `texture ${texture} takes exactly ${bytes} bytes`);
+    this.host.flush(), this.host.bytes(11, texture, 0).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength)), this.host.command(OP_RAW_MARK_TEXTURE, texture);
+  }
+  readTexture(texture, rect, out) {
+    let info = this.texture(texture), bytes = rect.width * rect.height * TEXEL_BYTES[info.format];
+    if (out.byteLength < bytes) throw new GameError("invalid_argument", `readTexture needs ${bytes} bytes`);
+    this.host.flush();
+    let request = this.check(
+      this.host.call("engine_render_raw_read_texture", texture, rect.x, rect.y, rect.width, rect.height),
+      "read gpu texture"
+    );
+    return new Promise((resolve, reject) => {
+      this.reads.push({ request, buffer: null, texture, offset: 0, out: out.subarray(0, bytes), resolve, reject });
+    });
+  }
+  copyTexture(source, target, copy) {
+    let info = this.texture(source), a = this.host.command(OP_RAW_COPY_TEXTURE, source), w = this.host.commandWords;
+    w[a] = target, w[a + 1] = pack(copy?.from ?? [0, 0]), w[a + 2] = pack(copy?.to ?? [0, 0]), w[a + 3] = pack(copy?.size ?? [info.width, info.height]), w[a + 4] = HOOK_ORDER.indexOf(copy?.hook ?? "beforeScene");
+  }
+  destroyTexture(texture) {
+    this.host.command(OP_RAW_DESTROY_TEXTURE, texture), this.textures.delete(texture), this.reject((read) => read.texture === texture, `gpu texture ${texture} was destroyed`);
+  }
+  createSampler(desc) {
+    let d = this.host.clearDesc();
+    return d[0] = desc?.filter === "nearest" ? 1 : 0, d[1] = desc?.wrap === "clamp" ? 1 : desc?.wrap === "mirror" ? 2 : 0, this.check(this.host.call("engine_render_raw_sampler"), "create gpu sampler");
+  }
+  createShader(wgsl) {
+    return this.shaders.push(wgsl), this.shaders.length - 1;
+  }
+  createComputePipeline(desc) {
+    let size = desc.workgroupSize ?? [(1), (1), (1)];
+    return this.pipeline(desc.shader, this.encoder.encode(desc.entryPoint), (d) => {
+      d[4] = 0, d[1] = size[0], d[2] = size[1], d[3] = size[2];
+    });
+  }
+  createRenderPipeline(desc) {
+    if (desc.targets.length === 0 || desc.targets.length > (4))
+      throw new GameError("invalid_argument", `render pipelines take 1 to ${(4)} targets`);
+    let vertex = this.encoder.encode(desc.vertexEntry), fragment = this.encoder.encode(desc.fragmentEntry), entry = new Uint8Array(vertex.byteLength + 1 + fragment.byteLength);
+    entry.set(vertex), entry[vertex.byteLength] = (0), entry.set(fragment, vertex.byteLength + 1);
+    let id = this.pipeline(desc.shader, entry, (d) => {
+      d[4] = 1, desc.targets.forEach((format, t) => {
+        d[5 + t] = FORMAT[format] + 1;
+      }), d[9] = packBlend(desc.blend), d[10] = (0), d[11] = TOPOLOGY[desc.topology ?? "triangle-list"];
+    });
+    return this.targetFormats.set(id, desc.targets[0]), id;
+  }
+  createBindGroup(pipeline, group, bindings) {
+    if (bindings.length > 11)
+      throw new GameError("capacity_exceeded", `bind groups take at most ${11} bindings`);
+    this.host.flush();
+    let d = this.host.clearDesc();
+    return d[0] = pipeline, d[1] = group, d[2] = bindings.length, bindings.forEach((b, i) => {
+      let at = 3 + i * 5;
+      if (d[at + 0] = b.binding, "texture" in b) {
+        d[at + 4] = 1, d[at + 1] = typeof b.texture == "string" ? SCENE_TEXTURE[b.texture] : b.texture;
+        return;
+      }
+      if ("sampler" in b) {
+        d[at + 4] = 2, d[at + 1] = b.sampler;
+        return;
+      }
+      let scene = typeof b.buffer == "string";
+      d[at + 4] = 0, d[at + 1] = scene ? SCENE[b.buffer] : b.buffer, d[at + 2] = b.offset ?? 0, d[at + 3] = b.size ?? (scene ? 0 : this.size(b.buffer) - (b.offset ?? 0));
+    }), this.check(this.host.call("engine_render_raw_bindings"), "create bind group");
+  }
+  dispatch(pipeline, bindGroup, x, y = (1), z = (1), options) {
+    let a = this.host.command(OP_RAW_DISPATCH, pipeline), w = this.host.commandWords;
+    w[a + 0] = bindGroup, w[a + 1] = x, w[a + 1 + 1] = y, w[a + 1 + 2] = z, w[a + 4] = HOOK_ORDER.indexOf(options?.hook ?? "beforeScene"), w[a + 5] = options?.indirect ?? 0;
+  }
+  draw(pipeline, bindGroup, vertexCount, options) {
+    let target = options?.target ?? "color", hook = options?.hook ?? (target === "color" ? "post" : "afterTransparent");
+    if (target === "color") {
+      if (hook !== "post")
+        throw new GameError("invalid_argument", "draws into scene colour run on the post hook");
+      if (this.targetFormats.get(pipeline) !== SCENE_COLOR_FORMAT)
+        throw new GameError("invalid_argument", `scene colour draws need a ${SCENE_COLOR_FORMAT} target`);
+    }
+    let a = this.host.command(OP_RAW_DRAW, pipeline), w = this.host.commandWords;
+    w[a + 0] = bindGroup, w[a + 1] = vertexCount, w[a + 2] = options?.instances ?? 1, w[a + 3] = target === "color" ? 4294967282 : target, w[a + 4] = HOOK_ORDER.indexOf(hook), w[a + 5] = 0;
+  }
+  copyBuffer(source, sourceOffset, target, targetOffset, size) {
+    let a = this.host.command(OP_RAW_COPY, source), w = this.host.commandWords;
+    w[a] = sourceOffset, w[a + 1] = target, w[a + 2] = targetOffset, w[a + 3] = size;
+  }
+  submit() {
+    this.host.flush(), this.poll();
+  }
+  readBuffer(buffer, offset, out) {
+    this.host.flush();
+    let request = this.check(
+      this.host.call("engine_render_raw_read", buffer, offset, out.byteLength),
+      "read gpu buffer"
+    );
+    return new Promise((resolve, reject) => {
+      this.reads.push({ request, buffer, texture: null, offset, out, resolve, reject });
+    });
+  }
+  destroyBuffer(buffer) {
+    this.host.command(OP_RAW_DESTROY_BUFFER, buffer), this.sizes.delete(buffer), this.reject((read) => read.buffer === buffer, `gpu buffer ${buffer} was destroyed`);
+  }
+  dispose() {
+    for (let id of this.sizes.keys()) this.host.command(OP_RAW_DESTROY_BUFFER, id);
+    for (let id of this.textures.keys()) this.host.command(OP_RAW_DESTROY_TEXTURE, id);
+    this.host.flush(), this.sizes.clear(), this.textures.clear(), this.reject(() => true, "gpu was disposed");
+  }
+  pipeline(shader, entry, configure) {
+    let source = this.shaders[shader];
+    if (!source) throw new GameError("unknown_resource", `shader ${shader} does not exist`);
+    if (entry.byteLength === 0 || entry.byteLength > ENTRY_BYTES)
+      throw new GameError("invalid_argument", `entry point names must fit ${ENTRY_BYTES} bytes`);
+    this.host.flush();
+    let bytes = this.encoder.encode(source), pointer = this.host.stage(bytes), d = this.host.clearDesc();
+    return d[0] = entry.byteLength, configure(d), new Uint8Array(d.buffer, d.byteOffset + 12 * (4), entry.byteLength).set(entry), this.check(
+      this.host.call("engine_render_raw_pipeline", pointer, bytes.byteLength),
+      "create gpu pipeline"
+    );
+  }
+  reject(matches, message) {
+    let kept = [];
+    for (let read of this.reads)
+      matches(read) ? read.reject(new GameError("unknown_resource", message)) : kept.push(read);
+    this.reads = kept;
+  }
+  poll() {
+    if (this.reads.length === 0) return;
+    let waiting = [];
+    for (let read of this.reads) {
+      let pointer = this.host.call("engine_render_raw_poll", read.request);
+      if (pointer === 0) {
+        waiting.push(read);
+        continue;
+      }
+      if (read.buffer !== null) {
+        let source = this.host.bytes(10, read.buffer, 0);
+        read.out.set(source.subarray(read.offset, read.offset + read.out.byteLength));
+      } else
+        read.out.set(this.host.view(pointer, read.out.byteLength));
+      read.resolve();
+    }
+    this.reads = waiting;
+  }
+  size(buffer) {
+    let size = this.sizes.get(buffer);
+    if (size === void 0) throw new GameError("unknown_resource", `gpu buffer ${buffer} does not exist`);
+    return size;
+  }
+  texture(texture) {
+    let info = this.textures.get(texture);
+    if (!info) throw new GameError("unknown_resource", `gpu texture ${texture} does not exist`);
+    return info;
+  }
+  check(code, what) {
+    if (code < 0) throw failure(code, what);
+    return code;
+  }
+};
+function createEngineGpu(host) {
+  return (host.capabilities & 8192) === 0 ? null : new EngineRaw(host);
+}
+
+// src/game/backends/engine/clips.ts
+var NO_JOINT = 4294967295, IK_HEADER = 8, BLEND_MEMBER_WORDS = 3, CLIP_INFO_WORDS = 4, EXPLICIT_MAP = 1, RETARGET_HEADER = 2, BAKE_HEADER = 4, FULL_TURN = Math.PI * 2, ANIM_CREATE_PROPERTY_CLIP = 40, ANIM_PLAY_PROPERTY_CLIP = 41, ANIM_DESTROY_PROPERTY_CLIP = 42, ANIM_SET_PROPERTY_EVENTS = 43, BIND_COMMAND = 0, BIND_MATERIAL_UNIFORM = 1, PROPERTY_TEMPLATE = 8, PROPERTY_TEMPLATE_WORDS = 6, PROPERTY_TRACK_HEADER = (8) + (6), EngineClips = class {
+  constructor(host) {
+    this.host = host;
+    this.bits = new Float32Array(1);
+    this.bitWords = new Uint32Array(this.bits.buffer);
+  }
+  floatBits(value) {
+    return this.bits[0] = value, this.bitWords[0];
+  }
+  op(target, sub) {
+    let at = this.host.command(OP_ANIMATION, target);
+    return this.host.commandWords[at] = sub, at + 1;
+  }
+  joint(root, bone) {
+    let index = this.host.model(root).nodeNames.indexOf(bone);
+    if (index < 0) throw new GameError("unknown_resource", `model has no bone ${bone}`);
+    return index;
+  }
+  clipIndex(root, clip) {
+    let index = this.host.model(root).clipNames.indexOf(clip);
+    if (index < 0) throw new GameError("unknown_resource", `model has no clip ${clip}`);
+    return index;
+  }
+  createPropertyClip(desc) {
+    let sizes = desc.tracks.map(propertySize), words = 2;
+    desc.tracks.forEach((track, i) => {
+      words += PROPERTY_TRACK_HEADER + sizes[i] + track.times.length + track.values.length;
+    });
+    let out = new Uint32Array(words);
+    out[0] = this.floatBits(desc.duration), out[1] = desc.tracks.length;
+    let at = 2;
+    return desc.tracks.forEach((track, i) => {
+      let size = sizes[i], header = out.subarray(at, at + PROPERTY_TRACK_HEADER);
+      this.bindTarget(track.target, size, header), header[4] = size, header[5] = INTERPOLATION_CODES[track.interpolation ?? "linear"], header[6] = track.times.length, at += PROPERTY_TRACK_HEADER;
+      for (let k = 0; k < size; k++) out[at++] = this.floatBits(track.rest[k]);
+      for (let k = 0; k < track.times.length; k++) out[at++] = this.floatBits(track.times[k]);
+      for (let k = 0; k < track.values.length; k++) out[at++] = this.floatBits(track.values[k]);
+    }), this.host.animation((40), 0, out);
+  }
+  bindTarget(target, size, header) {
+    let template = header.subarray((8), (8) + (6));
+    switch (target.kind) {
+      case "uniform": {
+        let slot = this.host.uniformSlot(target.material, target.name);
+        if (size > slot.words) throw new GameError("invalid_argument", `uniform ${target.name} holds ${slot.words} values`);
+        header[0] = (1), header[1] = 0, header[2] = target.material, header[3] = slot.offset;
+        return;
+      }
+      case "light":
+        header[0] = (0), header[1] = 12, header[2] = target.node, header[3] = 1, template[0] = target.color >>> 0;
+        return;
+      case "post":
+        header[0] = (0), header[1] = 24, header[2] = target.chain, header[3] = 2, template[0] = target.effect, template[1] = this.host.postParam(target.chain, target.effect, target.name);
+        return;
+      case "emitterRate":
+        header[0] = (0), header[1] = OP_SET_EMITTER_RATE, header[2] = target.emitter, header[3] = 0;
+        return;
+    }
+  }
+  playPropertyClip(clip, loop, fadeSeconds, speed) {
+    let words = Uint32Array.of(clip, loop ? 1 : 0, this.floatBits(fadeSeconds), this.floatBits(speed));
+    return this.host.animation((41), 0, words);
+  }
+  setPropertyClipEvents(clip, events) {
+    let words = new Uint32Array(1 + events.length * 2);
+    words[0] = clip, events.forEach((event, i) => {
+      words[1 + i * 2] = this.floatBits(event.time), words[2 + i * 2] = event.id >>> 0;
+    }), this.host.animation((43), 0, words);
+  }
+  destroyPropertyClip(clip) {
+    this.host.animation((42), 0, Uint32Array.of(clip));
+  }
+  setClipTime(action, seconds) {
+    this.host.commandFloats[this.op(action, ANIM_SET_TIME)] = seconds;
+  }
+  setClipSpeed(action, speed) {
+    this.host.commandFloats[this.op(action, ANIM_SET_SPEED)] = speed;
+  }
+  setClipLoop(action, loop, repetitions, clampWhenFinished) {
+    let at = this.op(action, ANIM_SET_LOOP), w = this.host.commandWords;
+    w[at] = LOOP_CODES[loop], w[at + 1] = Number.isFinite(repetitions) ? Math.max(0, repetitions | 0) : 0, w[at + 2] = clampWhenFinished ? 1 : 0;
+  }
+  setClipPaused(action, paused) {
+    this.host.commandWords[this.op(action, ANIM_SET_PAUSED)] = paused ? 1 : 0;
+  }
+  setClipRange(action, start, end) {
+    let at = this.op(action, ANIM_SET_RANGE);
+    this.host.commandFloats[at] = start, this.host.commandFloats[at + 1] = end;
+  }
+  setClipSync(action, group) {
+    this.host.commandWords[this.op(action, ANIM_SET_SYNC)] = group === null ? 0 : (group & 2147483647) + 1;
+  }
+  setClipSyncMode(action, mode) {
+    this.host.commandWords[this.op(action, ANIM_SET_SYNC_MODE)] = SYNC_MODE_CODES[mode];
+  }
+  setClipSyncMarkers(root, clip, markers) {
+    checkSyncMarkers(markers, Number.POSITIVE_INFINITY);
+    let words = new Uint32Array(1 + markers.length * 2);
+    words[0] = this.clipIndex(root, clip), markers.forEach((marker, i) => {
+      words[1 + i * 2] = this.floatBits(marker.time), words[2 + i * 2] = marker.id >>> 0;
+    }), this.host.animation(ANIM_SET_SYNC_MARKERS, root, words);
+  }
+  inertialize(from, to, seconds) {
+    let at = this.op(from, ANIM_INERTIALIZE);
+    this.host.commandWords[at] = to, this.host.commandFloats[at + 1] = seconds;
+  }
+  bakeRetarget(target, source, clip, options) {
+    let maps = options?.maps, words = new Uint32Array((4) + (maps === void 0 ? 0 : HUMAN_BONES.length * 2)).fill((4294967295));
+    words[0] = source, words[1] = this.clipIndex(source, clip), words[2] = this.floatBits(bakeRate(options)), words[3] = maps === void 0 ? 0 : (1), maps !== void 0 && this.writeMaps(words, (4), target, source, maps);
+    let index = this.host.animation(ANIM_BAKE_RETARGET, target, words), name = this.host.refreshModel(target).clipNames[index];
+    if (name === void 0) throw new GameError("unknown_resource", `baked clip ${index} is missing on the target model`);
+    return name;
+  }
+  writeMaps(words, at, target, source, maps) {
+    HUMAN_BONES.forEach((bone, i) => {
+      let from = maps.source[bone], to = maps.target[bone];
+      from !== void 0 && (words[at + i] = this.joint(source, from)), to !== void 0 && (words[at + HUMAN_BONES.length + i] = this.joint(target, to));
+    });
+  }
+  setClipEventsEnabled(action, enabled) {
+    this.host.commandWords[this.op(action, ANIM_SET_EVENTS)] = enabled ? 1 : 0;
+  }
+  setClipAdditive(action, referenceTime) {
+    this.host.commandFloats[this.host.command(OP_SET_CLIP_ADDITIVE, action)] = referenceTime ?? Number.POSITIVE_INFINITY;
+  }
+  crossFade(from, to, seconds, warp) {
+    let at = this.op(from, ANIM_CROSSFADE);
+    this.host.commandWords[at] = to, this.host.commandFloats[at + 1] = seconds, this.host.commandWords[at + 2] = warp ? 1 : 0;
+  }
+  fadeClip(action, weight, seconds) {
+    let at = this.op(action, ANIM_FADE);
+    this.host.commandFloats[at] = weight, this.host.commandFloats[at + 1] = seconds;
+  }
+  fadeClipFrom(action, values, offset) {
+    let at = this.op(action, ANIM_FADE), f = this.host.commandFloats;
+    f[at] = values[offset], f[at + 1] = values[offset + 1];
+  }
+  createClipMask(root, weights) {
+    let names = this.host.model(root).nodeNames, words = new Uint32Array(names.length);
+    for (let [bone, weight] of Object.entries(weights)) words[this.joint(root, bone)] = this.floatBits(weight);
+    return this.host.animation(ANIM_CREATE_MASK, root, words);
+  }
+  setClipMask(action, mask) {
+    this.host.commandWords[this.host.command(OP_SET_CLIP_MASK, action)] = mask ?? 0;
+  }
+  destroyClipMask(root, mask) {
+    this.host.animation(ANIM_DESTROY, root, Uint32Array.of(ANIM_KIND_MASK, mask));
+  }
+  setClipEvents(root, clip, events) {
+    let words = new Uint32Array(1 + events.length * 2);
+    words[0] = this.clipIndex(root, clip), events.forEach((event, i) => {
+      words[1 + i * 2] = this.floatBits(event.time), words[2 + i * 2] = event.id >>> 0;
+    }), this.host.animation(ANIM_SET_CLIP_EVENTS, root, words);
+  }
+  clipInfo(root, clip) {
+    let words = new Uint32Array((4));
+    return words[0] = this.clipIndex(root, clip), this.host.animation(ANIM_CLIP_INFO, root, words), this.bitWords[0] = words[0], { duration: this.bits[0], tracks: words[1], morphWeights: words[2], events: words[3] };
+  }
+  createBlendSpace(root, desc) {
+    let words = new Uint32Array(2 + desc.members.length * (3));
+    return words[0] = BLEND_SPACE_CODES[desc.kind], words[1] = desc.members.length, desc.members.forEach((member, i) => {
+      let at = 2 + i * (3);
+      words[at] = member.action, words[at + 1] = this.floatBits(member.x), words[at + 2] = this.floatBits(member.y ?? 0);
+    }), this.host.animation(ANIM_CREATE_BLEND, root, words);
+  }
+  setBlendParameter(space, x, y, weight) {
+    let at = this.op(space, ANIM_SET_BLEND);
+    this.host.commandFloats[at] = x, this.host.commandFloats[at + 1] = y, this.host.commandFloats[at + 2] = weight;
+  }
+  setBlendParameterFrom(space, values, offset) {
+    let at = this.op(space, ANIM_SET_BLEND), f = this.host.commandFloats;
+    f[at] = values[offset], f[at + 1] = values[offset + 1], f[at + 2] = values[offset + 2];
+  }
+  destroyBlendSpace(root, space) {
+    this.host.animation(ANIM_DESTROY, root, Uint32Array.of(ANIM_KIND_BLEND, space));
+  }
+  createIk(root, desc) {
+    let words = new Uint32Array((8) + desc.bones.length), forward = desc.forward ?? [0, 0, 1];
+    return words[0] = IK_CODES[desc.solver], words[1] = desc.iterations ?? DEFAULT_IK_ITERATIONS, words[2] = this.floatBits(desc.tolerance ?? DEFAULT_IK_TOLERANCE), words[3] = this.floatBits(desc.maxAngle ?? FULL_TURN), words[4] = this.floatBits(forward[0]), words[5] = this.floatBits(forward[1]), words[6] = this.floatBits(forward[2]), words[7] = desc.bones.length, desc.bones.forEach((bone, i) => {
+      words[(8) + i] = this.joint(root, bone);
+    }), this.host.animation(ANIM_CREATE_IK, root, words);
+  }
+  setIkTarget(chain, x, y, z, weight) {
+    let at = this.op(chain, ANIM_SET_IK_TARGET), f = this.host.commandFloats;
+    f[at] = x, f[at + 1] = y, f[at + 2] = z, f[at + 3] = weight;
+  }
+  setIkTargetFrom(chain, values, offset) {
+    let at = this.op(chain, ANIM_SET_IK_TARGET), f = this.host.commandFloats;
+    f[at] = values[offset], f[at + 1] = values[offset + 1], f[at + 2] = values[offset + 2], f[at + 3] = values[offset + 3];
+  }
+  setIkPole(chain, x, y, z) {
+    let at = this.op(chain, ANIM_SET_IK_POLE), f = this.host.commandFloats;
+    f[at] = x, f[at + 1] = y, f[at + 2] = z;
+  }
+  destroyIk(root, chain) {
+    this.host.animation(ANIM_DESTROY, root, Uint32Array.of(ANIM_KIND_IK, chain));
+  }
+  humanoid(root) {
+    let words = new Uint32Array(HUMAN_BONES.length);
+    this.host.animation(ANIM_HUMANOID, root, words);
+    let names = this.host.model(root).nodeNames, map = {};
+    return HUMAN_BONES.forEach((bone, i) => {
+      words[i] !== (4294967295) && (map[bone] = names[words[i]]);
+    }), map;
+  }
+  retarget(target, source, maps) {
+    if (maps === void 0) {
+      this.host.animation(ANIM_RETARGET, target, Uint32Array.of(source, 0));
+      return;
+    }
+    let words = new Uint32Array((2) + HUMAN_BONES.length * 2).fill((4294967295));
+    words[0] = source, words[1] = (1), this.writeMaps(words, (2), target, source, maps), this.host.animation(ANIM_RETARGET, target, words);
+  }
+  stopRetarget(target) {
+    this.host.animation(ANIM_DESTROY, target, Uint32Array.of(ANIM_KIND_RETARGET, 0));
+  }
+  createBoneSet(root, bones) {
+    let nodes = new Uint32Array(bones.length);
+    return bones.forEach((bone, i) => {
+      let node = this.host.findNode(root, bone);
+      if (node === null) throw new GameError("unknown_resource", `model has no bone ${bone}`);
+      nodes[i] = node;
+    }), this.host.createPoseReader(nodes);
+  }
+  readBonePoses(set, out, offset) {
+    this.host.readPoses(set, out, offset);
+  }
+  destroyBoneSet(set) {
+    this.host.destroyPoseReader(set);
+  }
+  setAnimationLod(root, interval) {
+    this.host.animation(ANIM_SET_LOD, root, Uint32Array.of(animationLodInterval(interval)));
+  }
+  enableRootMotion(root, desc) {
+    let flags = (desc.horizontal ?? true ? ROOT_MOTION_XZ : 0) | (desc.vertical ? ROOT_MOTION_Y : 0) | (desc.yaw ? ROOT_MOTION_YAW : 0) | (desc.apply ? ROOT_MOTION_APPLY : 0);
+    if (flags === 0 || flags === ROOT_MOTION_APPLY)
+      throw new GameError("invalid_argument", "root motion needs at least one extracted axis");
+    return this.host.animation(ANIM_ROOT_MOTION, root, Uint32Array.of(flags, this.joint(root, desc.bone)));
+  }
+  disableRootMotion(root) {
+    this.host.animation(ANIM_DESTROY, root, Uint32Array.of(ANIM_KIND_ROOT_MOTION, 0));
+  }
+  readRootMotion(motion, out, offset) {
+    let words = this.host.floats(ANIMATION_BUFFER_ROOT_MOTION);
+    out.set(words.subarray(motion * ROOT_MOTION_WORDS, (motion + 1) * ROOT_MOTION_WORDS), offset);
+  }
+  readClipState(action, out) {
+    let floats = this.host.floats(ANIMATION_BUFFER_ACTIONS), at = action * ANIM_ACTION_WORDS;
+    this.bits[0] = floats[at + 3];
+    let flags = this.bitWords[0];
+    out.time = floats[at], out.weight = floats[at + 1], out.speed = floats[at + 2], out.running = (flags & ANIM_ACTION_RUNNING) !== 0, out.paused = (flags & ANIM_ACTION_PAUSED) !== 0, out.finished = (flags & ANIM_ACTION_FINISHED) !== 0;
+  }
+  readClipEvents(out) {
+    let words = this.host.words(ANIMATION_BUFFER_EVENTS), count = Math.min(words[0], ANIM_MAX_EVENTS);
+    for (let i = 0; i < count; i++) {
+      let at = 1 + i * ANIM_EVENT_WORDS, event = out[i] ?? emptyClipEvent();
+      event.action = words[at], event.kind = CLIP_EVENT_KINDS[words[at + 1]] ?? "event", event.id = words[at + 2], this.bitWords[0] = words[at + 3], event.time = this.bits[0], out[i] = event;
+    }
+    return count;
+  }
+};
+
+// src/game/backends/engine/emitters.ts
+var CURVE_CHANNELS = 4, DEFAULT_LIFETIME = 1, DEFAULT_SPEED = 1, DEFAULT_SIZE = 0.1, WHITE = 16777215;
+function pair(d, at, value, fallback) {
+  d[at] = value?.[0] ?? fallback, d[at + 1] = value?.[1] ?? fallback;
+}
+function writeEmitterDesc(d, f, desc) {
+  d[0] = desc.capacity, f[1] = desc.rate ?? 0, d[2] = desc.burst ?? 0, pair(f, 3, desc.lifetime, (1)), pair(f, 5, desc.speed, (1)), pair(f, 7, desc.size, (0.1)), d[9] = desc.color?.[0] ?? (16777215), d[10] = desc.color?.[1] ?? desc.color?.[0] ?? (16777215), f[11] = desc.alpha?.[0] ?? 1, f[12] = desc.alpha?.[1] ?? 1, f.set(desc.gravity ?? [0, 0, 0], 13), f[16] = desc.drag ?? 0, f[17] = desc.noise?.strength ?? 0, f[18] = desc.noise?.scale ?? 1;
+  let shape = desc.shape ?? { kind: "point" };
+  switch (d[19] = EMITTER_SHAPES.indexOf(shape.kind), shape.kind) {
+    case "sphere":
+    case "disc":
+      f[20] = shape.radius;
+      break;
+    case "cone":
+      f[20] = shape.angle, f[21] = shape.radius ?? 0;
+      break;
+    case "box":
+      f.set(shape.size, 20);
+      break;
+  }
+  let collision = desc.collision ?? { kind: "none" };
+  d[24] = EMITTER_COLLISIONS.indexOf(collision.kind), collision.kind === "plane" && f.set(collision.plane, 25), collision.kind !== "none" && (f[29] = collision.bounce ?? 0), d[30] = desc.material ?? 0, d[31] = (desc.soft ? 1 : 0) | (desc.sorted ? 2 : 0) | (desc.localSpace ? 4 : 0) | (desc.deterministic ? 8 : 0) | (desc.additive ? 16 : 0) | (desc.stretch ? 32 : 0) | (desc.oit ? 64 : 0) | (desc.velocityAligned ? 128 : 0), d[32] = desc.seed ?? 0, f[33] = desc.spread ?? 0, f[34] = desc.spin ?? 0, d[36] = desc.sizeCurve || desc.colorCurve ? 32 : 0;
+}
+function channel(point, c) {
+  return typeof point.value == "number" ? point.value : point.value[c];
+}
+function sampleCurve(points, out) {
+  if (points.length === 0) return;
+  let segment = 0;
+  for (let i = 0; i < 32; i++) {
+    let t = i / 31;
+    for (; segment < points.length - 1 && points[segment + 1].t < t; ) segment++;
+    let a = points[segment], b = points[Math.min(segment + 1, points.length - 1)], span = b.t - a.t, k = span > 0 ? Math.min(1, Math.max(0, (t - a.t) / span)) : 0;
+    for (let c = 0; c < (4); c++) {
+      let from = channel(a, c);
+      out[i * (4) + c] = from + (channel(b, c) - from) * k;
+    }
+  }
+}
+
+// src/game/render/environment.ts
+var channel2 = (hex, shift) => (hex >> shift & 255) / 255;
+function volumetricChunks(words) {
+  let chunks = [];
+  for (let at = 0; at < words.length; at += 5)
+    chunks.push([at, words.subarray(at, Math.min(at + 5, words.length))]);
+  return chunks;
+}
+function volumetricWords(desc) {
+  let words = new Float32Array(24).fill(Number.NaN), flags = desc.enabled === false ? 1 : 0, fog = desc.fog;
+  if (fog) {
+    flags |= 2;
+    let albedo = fog.albedo ?? 15132390;
+    words.set(
+      [
+        fog.density ?? UNSET,
+        fog.height ?? UNSET,
+        fog.falloff ?? UNSET,
+        fog.anisotropy ?? UNSET,
+        channel2(albedo, 16),
+        channel2(albedo, 8),
+        channel2(albedo, 0),
+        fog.noise ?? UNSET,
+        fog.range ?? UNSET,
+        fog.ambient ?? UNSET
+      ],
+      1
+    );
+  }
+  let clouds = desc.clouds;
+  clouds && (flags |= 4, words.set(
+    [
+      clouds.coverage ?? UNSET,
+      clouds.density ?? UNSET,
+      clouds.altitude ?? UNSET,
+      clouds.thickness ?? UNSET,
+      clouds.type ?? UNSET,
+      clouds.shadow ?? UNSET,
+      clouds.detail ?? UNSET
+    ],
+    11
+  ));
+  let atmosphere = desc.atmosphere;
+  return atmosphere && (flags |= 8, words.set(
+    [
+      atmosphere.rayleigh ?? UNSET,
+      atmosphere.mie ?? UNSET,
+      atmosphere.mieAnisotropy ?? UNSET,
+      atmosphere.ozone ?? UNSET,
+      atmosphere.groundAlbedo ?? UNSET,
+      atmosphere.sunDiscDegrees ?? UNSET
+    ],
+    18
+  )), words[0] = flags, words;
+}
+var UNSET_WETNESS = -1, UNSET = Number.NaN, unit = (value) => Math.min(Math.max(value ?? 0, 0), 1);
+function weatherWords(state) {
+  return {
+    cloudCover: unit(state.cloudCover),
+    haze: unit(state.haze),
+    precipitation: unit(state.precipitation),
+    snow: state.snow ?? false,
+    wetness: state.wetness === void 0 ? (-1) : unit(state.wetness),
+    windX: state.wind?.[0] ?? 0,
+    windZ: state.wind?.[1] ?? 0
+  };
+}
+
+// src/game/backends/engine/advertised.ts
+function engineAdvertises(runtime, feature) {
+  let count = runtime.symbols.engine_feature_count, name = runtime.symbols.engine_feature_name;
+  if (typeof count != "function" || typeof name != "function") return false;
+  let scratch = runtime.exports.engine_alloc(64, 1);
+  if (scratch === 0) return false;
+  let found = false;
+  for (let i = 0; i < count() && !found; i++) {
+    let length = name(i, scratch, 64);
+    if (length !== feature.length) continue;
+    let bytes = new Uint8Array(runtime.memory.buffer, scratch, length);
+    found = true;
+    for (let k = 0; k < length && found; k++) found = bytes[k] === feature.charCodeAt(k);
+  }
+  return runtime.exports.engine_free(scratch, 64, 1), found;
+}
+
+// src/game/backends/engine/graphics.ts
+var ENGINE_GRAPHICS_NAME = "cimplify-render", NO_HANDLE = 0, GOVERNOR_TIER_MASK = 255, AUTO_QUALITY_TIER = -1, QUALITY_TIER_FULL = 0, GOVERNOR_PRESSURE_SHIFT = 28, GOVERNOR_PRESSURE_MASK = 15, MIN_REFRESH_INTERVAL_MS = 1, MAX_REFRESH_INTERVAL_MS = 100, REFRESH_WINDOW_FRAMES = 64, MICROS_PER_MS = 1e3, BUDGET_TOLERANCE = 50, NO_PRESENT_YET = -1, REFRESH_PRESENTED = 0, REFRESH_SHORTEST = 1, NO_NODE = 0, SRGB_KNEE = 0.04045, SRGB_SLOPE = 12.92, SRGB_OFFSET = 0.055, SRGB_SCALE = 1.055, SRGB_GAMMA = 2.4, BYTE_MAX = 255, DEFAULT_GROUND = 4473924, DEFAULT_SPOT_ANGLE = Math.PI / 3, DEFAULT_DECAY = 2, DEFAULT_IOR = 1.5, DEFAULT_ROUGHNESS = 1, DEFAULT_POINT_SIZE = 1, POSE_STRIDE2 = 10, NODE_BUFFER_SLOTS = 4, UTF8 = new TextEncoder(), UTF8_BYTES_PER_UNIT = 3, DEFAULT_TEXT_CAPACITY = 128, DEFAULT_TEXT3D_SIZE = 1, DEFAULT_TEXT2D_SIZE = 16, DEFAULT_TEXT_COLOR = 16777215, LINEAR = 0, SRGB = 1, TEXT_ALIGNS = {
+  start: 0,
+  end: 1,
+  left: 2,
+  center: 3,
+  right: 4
+}, TEXT_DIRECTIONS = {
+  auto: 0,
+  ltr: 1,
+  rtl: 2
+}, PICK_HIT = 1, NAMES = new TextDecoder(), NAME_SEPARATOR = 0, SEMANTICS = {
+  position: 0,
+  normal: 1,
+  uv: 2,
+  uv1: 3,
+  uv2: 3,
+  color: 4,
+  tangent: 5,
+  skinIndex: 6,
+  skinWeight: 7
+}, EFFECT_PARAMETERS = {
+  bloom: ["strength", "radius", "threshold", "physical"],
+  fxaa: [],
+  vignette: ["offset", "darkness"],
+  color_grade: ["exposure", "contrast", "saturation"],
+  shader: [],
+  ao: ["radius", "intensity", "thickness", "quality"],
+  smaa: ["threshold", "temporal"],
+  taa: ["feedback", "sharpness"],
+  outline: ["thickness", "depthThreshold", "normalThreshold", "color"],
+  ssr: ["intensity", "maxDistance", "thickness", "fade"],
+  dof: ["focus", "aperture", "maxBlur"],
+  motion_blur: ["intensity", "samples"],
+  lut: ["texture", "intensity", "size"],
+  grain: ["intensity"],
+  god_rays: ["intensity", "decay", "density", "weight"],
+  lens_dirt: ["texture", "intensity"],
+  sharpen: ["sharpness"],
+  chromatic: ["amount"],
+  mask: ["texture", "outline", "bloom", "hidden"],
+  weather: ["rain", "snow", "wetness", "night"],
+  lens_flare: ["intensity", "ghosts", "halo", "dispersal"]
+}, TEXEL_FORMATS = {
+  rgba8: [0, 4],
+  rgba16f: [2, 8],
+  rgba32f: [1, 16],
+  r8: [TEXTURE_FORMAT_R8, 1],
+  rg8: [TEXTURE_FORMAT_RG8, 2],
+  r16f: [TEXTURE_FORMAT_R16F, 2],
+  rg16f: [TEXTURE_FORMAT_RG16F, 4],
+  r32f: [TEXTURE_FORMAT_R32F, 4],
+  rg32f: [TEXTURE_FORMAT_RG32F, 8],
+  r8ui: [TEXTURE_FORMAT_R8UI, 1],
+  r16ui: [TEXTURE_FORMAT_R16UI, 2],
+  r32ui: [TEXTURE_FORMAT_R32UI, 4],
+  rg32ui: [TEXTURE_FORMAT_RG32UI, 8],
+  rgba8ui: [TEXTURE_FORMAT_RGBA8UI, 4],
+  rgba16ui: [TEXTURE_FORMAT_RGBA16UI, 8],
+  rgba32ui: [TEXTURE_FORMAT_RGBA32UI, 16],
+  r32i: [TEXTURE_FORMAT_R32I, 4],
+  rgba32i: [TEXTURE_FORMAT_RGBA32I, 16]
+}, EFFECT_KINDS = {
+  bloom: 0,
+  fxaa: 1,
+  vignette: 2,
+  color_grade: 3,
+  shader: 4,
+  ao: 5,
+  smaa: 6,
+  taa: 7,
+  outline: 8,
+  ssr: 9,
+  dof: 10,
+  motion_blur: 11,
+  lut: 12,
+  grain: 13,
+  god_rays: 14,
+  lens_dirt: 15,
+  sharpen: 16,
+  chromatic: 17,
+  mask: 18,
+  weather: 19,
+  lens_flare: EFFECT_LENS_FLARE
+}, SCALAR_PARAMS = {
+  opacity: 3,
+  emissiveIntensity: 7,
+  metalness: 8,
+  roughness: 9,
+  alphaTest: 10,
+  size: 11,
+  clearcoat: 12,
+  clearcoatRoughness: 13,
+  transmission: 14,
+  ior: 15
+}, POST_PARAM_SLOTS = 4, LANE_NAMES = ["x", "y", "z", "w"], POST_UNIFORM_LANES = {
+  f32: 1,
+  vec2: 2,
+  vec3: 3,
+  vec4: 4
+}, UNIFORM_WORDS = {
+  f32: 1,
+  i32: 1,
+  vec2: 2,
+  vec3: 3,
+  vec4: 4,
+  mat4: 16,
+  texture: 1
+}, SHADOW_WORDS = {
+  cascades: 23,
+  split: 24,
+  maxFar: 25,
+  fade: 26,
+  bias: 27,
+  normalBias: 28,
+  radius: 29,
+  blurSamples: 30,
+  type: 50
+}, SHADOW_INTEGERS = /* @__PURE__ */ new Set(["cascades", "blurSamples"]);
+function shadowWord(key, value) {
+  return typeof value == "string" ? SHADOW_TYPES[value] : SHADOW_INTEGERS.has(key) ? value >>> 0 : floatBits(value);
+}
+function linear(channel3) {
+  return channel3 <= (0.04045) ? channel3 / (12.92) : ((channel3 + (0.055)) / (1.055)) ** (2.4);
+}
+function scalarOf(data) {
+  return data instanceof Float32Array ? 0 : data instanceof Uint32Array ? 1 : data instanceof Uint16Array ? 2 : data instanceof Uint8Array ? 3 : data instanceof Int16Array ? 4 : 5;
+}
+function failure2(code, what) {
+  switch (code) {
+    case ERROR_CAPACITY_EXCEEDED:
+      return new GameError("capacity_exceeded", `${what}: capacity exceeded`);
+    case ERROR_DEAD_ENTITY:
+    case ERROR_UNKNOWN_RESOURCE:
+      return new GameError("unknown_resource", `${what}: unknown resource`);
+    case ERROR_UNSUPPORTED:
+      return new GameError("unsupported_feature", `${what}: unsupported`);
+    default:
+      return new GameError("invalid_argument", `${what}: invalid argument`);
+  }
+}
+function bindRenderExports(symbols) {
+  let bound = {};
+  for (let name of RENDER_CORE_EXPORTS) {
+    let value = symbols[name];
+    if (typeof value != "function") throw new GameError("not_initialized", `engine module is missing ${name}`);
+    bound[name] = value;
+  }
+  for (let name of Object.keys(RENDER_FEATURE_EXPORTS)) {
+    let value = symbols[name];
+    typeof value == "function" && (bound[name] = value);
+  }
+  return bound;
+}
+function featureAvailable(exports, caps, name) {
+  return exports[name] !== void 0 && (caps & RENDER_FEATURE_EXPORTS[name]) !== 0;
+}
+function graphicsCapabilities(render, caps) {
+  return {
+    backend: ENGINE_GRAPHICS_NAME,
+    dimensions: "3d",
+    rendering: (caps & 1) !== 0,
+    webgpu: false,
+    compute: false,
+    shaderLanguages: ["wgsl"],
+    instancing: (caps & 4) !== 0,
+    skinning: (caps & 8) !== 0,
+    morphTargets: (caps & 16) !== 0,
+    renderTargets: (caps & 32) !== 0,
+    postProcessing: (caps & 64) !== 0,
+    models: (caps & 128) !== 0,
+    particles: featuresAvailable(render, caps, 1024),
+    orderIndependentTransparency: (caps & 2048) !== 0,
+    imageBasedLighting: (caps & 4096) !== 0,
+    cascadedShadows: (caps & 16384) !== 0,
+    renderState: (caps & 32768) !== 0,
+    rawRender: featuresAvailable(render, caps, 131072),
+    decals: (caps & 65536) !== 0,
+    lod: (caps & 262144) !== 0,
+    fatLines: (caps & 524288) !== 0,
+    text: featuresAvailable(render, caps, 1048576),
+    picking: featuresAvailable(render, caps, 2097152),
+    pointShadows: (caps & CAP_POINT_SHADOWS) !== 0,
+    sky: (caps & 4096) !== 0,
+    customProjection: (caps & CAP_CUSTOM_PROJECTION) !== 0,
+    gpuTiming: (caps & 8388608) !== 0,
+    globalIllumination: (caps & 33554432) !== 0,
+    rayTracing: (caps & 67108864) !== 0
+  };
+}
+function featuresAvailable(exports, caps, cap) {
+  return (caps & cap) === 0 ? false : Object.keys(RENDER_FEATURE_EXPORTS).filter((name) => RENDER_FEATURE_EXPORTS[name] === cap).every((name) => exports[name] !== void 0);
+}
+function concat(a, b) {
+  let out = new Uint8Array(a.byteLength + b.byteLength);
+  return out.set(a, 0), out.set(b, a.byteLength), out;
+}
+function postShader(effect) {
+  let params = [], values = [], accessors = "";
+  for (let [name, uniform] of Object.entries(effect.uniforms ?? {})) {
+    let lanes = POST_UNIFORM_LANES[uniform.type];
+    if (lanes === void 0) throw new GameError("invalid_argument", `post shader uniform ${name} must be f32, vec2, vec3 or vec4`);
+    if (params.length + lanes > (4))
+      throw new GameError("invalid_argument", `post shader uniforms hold ${(4)} floats`);
+    let first = params.length, reads = [];
+    for (let lane = 0; lane < lanes; lane++) {
+      params.push(lanes === 1 ? name : `${name}.${LANE_NAMES[lane]}`);
+      let value = uniform.value;
+      values.push(typeof value == "number" ? value : value instanceof Float32Array ? value[lane] ?? 0 : 0), reads.push(`pass_info.params[${first + lane}]`);
+    }
+    let type = lanes === 1 ? "f32" : `vec${lanes}f`, body = lanes === 1 ? reads[0] : `${type}(${reads.join(", ")})`;
+    accessors += `fn ${name}() -> ${type} { return ${body}; }
+`;
+  }
+  return { source: UTF8.encode(accessors + effect.shader.wgsl.fragment), params, values };
+}
+var EngineGraphics = class {
+  constructor(runtime, render = bindRenderExports(runtime.symbols), attacher = null, options = {}) {
+    this.attacher = attacher;
+    this.nativeSurface = null;
+    this.stopResize = null;
+    this.raw = null;
+    this.refresh = Float64Array.of((-1), (100));
+    this.observed = 0;
+    this.budgetMicros = 0;
+    this.pending = 0;
+    this.scratch = 0;
+    this.scratchBytes = 0;
+    this.attributes = /* @__PURE__ */ new Map();
+    this.textures = /* @__PURE__ */ new Map();
+    this.targetDepths = /* @__PURE__ */ new Map();
+    this.targetFormats = /* @__PURE__ */ new Map();
+    this.targetAttachments = /* @__PURE__ */ new Map();
+    this.targetReads = [];
+    this.uniforms = /* @__PURE__ */ new Map();
+    this.chains = /* @__PURE__ */ new Map();
+    this.models = /* @__PURE__ */ new Map();
+    this.roots = /* @__PURE__ */ new Map();
+    this.clipPort = null;
+    this.nodeViews = /* @__PURE__ */ new Map();
+    this.targetTextures = /* @__PURE__ */ new Map();
+    this.matrixScratch = null;
+    this.poseReaders = [];
+    this.fontFamilies = /* @__PURE__ */ new Map();
+    this.textNodes = /* @__PURE__ */ new Map();
+    this.defaultFont = null;
+    this.textPointer = 0;
+    this.textBytes = 0;
+    this.pickPointer = 0;
+    this.disposed = false;
+    this.feedSupport = null;
+    this.poseSupport = null;
+    this.mediaSupport = null;
+    this.mediaLive = new Array(17).fill(false);
+    this.mediaViews = new Array(17).fill(null);
+    this.mediumWords = new Float32Array(14);
+    this.passScratch = new Uint32Array(10);
+    this.batchViews = /* @__PURE__ */ new Map();
+    this.runtime = runtime, this.abi = render;
+    let budget = runtime.symbols.engine_render_set_frame_budget;
+    this.frameBudget = typeof budget == "function" ? budget : null;
+    let force = runtime.symbols.engine_render_force_tier;
+    this.forceTierCall = typeof force == "function" ? force : null;
+    let quality = runtime.symbols.engine_render_quality_tier;
+    if (this.qualityTierCall = typeof quality == "function" ? quality : null, this.handle = createWithDescriptor(runtime, options, (desc2) => render.engine_render_create(desc2 === 0 ? (0) : desc2)), this.handle === (0)) throw engineSessionFailure(runtime.symbols) ?? new GameError("capacity_exceeded", "engine renderer could not be created");
+    let buffer = this.buffer, desc = render.engine_render_desc(this.handle);
+    this.desc = new Uint32Array(buffer, desc, 64), this.descFloats = new Float32Array(buffer, desc, 64);
+    let registers = render.engine_render_registers(this.handle);
+    this.registers = new Uint32Array(buffer, registers, 34), this.registerFloats = new Float32Array(buffer, registers, 34);
+    let commands = render.engine_render_commands(this.handle);
+    this.commandWords = new Uint32Array(buffer, commands, 1024 * 8), this.commandFloats = new Float32Array(buffer, commands, 1024 * 8), this.sync = this.u32(5, 0, 0), this.params = this.f32(3, 0, 0);
+    let caps = render.engine_render_capabilities(this.handle), surfaces = engineVectorSurfaceExports(runtime.symbols);
+    this.vectorSurfaces = surfaces === null ? null : new EngineVectorSurfaces(surfaces, {
+      handle: this.handle,
+      buffer: () => this.buffer,
+      stage: (bytes) => this.stage(bytes),
+      flush: () => this.flush()
+    }), this.capabilities = { ...graphicsCapabilities(render, caps), vectorSurfaces: this.vectorSurfaces?.cap ?? 0 }, this.caps = caps, this.features = new EngineFeatures({
+      caps: () => this.caps,
+      command: (op, target) => this.command(op, target),
+      words: this.commandWords,
+      floats: this.commandFloats,
+      flush: () => this.flush(),
+      buffer: (owner, id, slot) => this.f32(owner, id, slot),
+      registers: this.registers
+    });
+  }
+  get gpu() {
+    return this.raw === null && (this.raw = createEngineGpu(this.rawHost())), this.raw;
+  }
+  rawCapabilities() {
+    let caps = this.caps, rawCompute = featuresAvailable(this.abi, caps, 8192), rawRender = featuresAvailable(this.abi, caps, 131072);
+    return caps & -139265 | (rawCompute ? 8192 : 0) | (rawRender ? 131072 : 0);
+  }
+  get clips() {
+    if (featureAvailable(this.abi, this.caps, "engine_render_animation"))
+      return this.clipPort ?? (this.clipPort = new EngineClips(this.clipHost())), this.clipPort;
+  }
+  clipHost() {
+    let views = { words: [], floats: [] }, fresh = (cached) => cached !== void 0 && cached.buffer === this.buffer;
+    return {
+      command: (op, target) => this.command(op, target),
+      commandWords: this.commandWords,
+      commandFloats: this.commandFloats,
+      animation: (op, target, words) => {
+        this.flush();
+        let pointer = words.length === 0 ? 0 : this.stage(new Uint8Array(words.buffer, words.byteOffset, words.byteLength)), result = this.check(this.feature("engine_render_animation")(this.handle, op, target, pointer, words.length), "animation");
+        return pointer !== 0 && words.set(new Uint32Array(this.buffer, pointer, words.length)), result;
+      },
+      words: (slot) => {
+        let cached = views.words[slot];
+        if (fresh(cached)) return cached;
+        let view = this.u32(14, 0, slot);
+        return views.words[slot] = view, view;
+      },
+      floats: (slot) => {
+        let cached = views.floats[slot];
+        if (fresh(cached)) return cached;
+        let view = this.f32(14, 0, slot);
+        return views.floats[slot] = view, view;
+      },
+      model: (root) => {
+        let model = this.roots.get(root), info = model === void 0 ? void 0 : this.models.get(model);
+        if (info === void 0) throw new GameError("invalid_argument", `node ${root} is not a model instance`);
+        return info;
+      },
+      refreshModel: (root) => this.refreshModel(root),
+      findNode: (root, name) => this.findNode(root, name),
+      createPoseReader: (nodes) => this.createPoseReader(nodes),
+      readPoses: (reader, out, offset) => this.readPoses(reader, out, offset),
+      destroyPoseReader: (reader) => this.destroyPoseReader(reader),
+      uniformSlot: (material, name) => {
+        let slot = this.uniform(material, name);
+        if (slot === null) throw new GameError("invalid_argument", `material ${material} has no shader uniform ${name}`);
+        return slot;
+      },
+      postParam: (chain, effect, name) => {
+        let param = this.chains.get(chain)?.params[effect]?.indexOf(name) ?? -1;
+        if (param < 0) throw new GameError("invalid_argument", `post chain ${chain} effect ${effect} has no parameter ${name}`);
+        return param;
+      }
+    };
+  }
+  rawHost() {
+    let graphics = this;
+    return {
+      get capabilities() {
+        return graphics.rawCapabilities();
+      },
+      clearDesc: () => this.clearDesc(),
+      command: (op, target) => this.command(op, target),
+      commandWords: this.commandWords,
+      stage: (bytes) => this.stage(bytes),
+      call: (name, ...args) => this.feature(name)(this.handle, ...args),
+      bytes: (owner, id, slot) => {
+        let [pointer, length] = this.view(owner, id, slot);
+        return new Uint8Array(this.buffer, pointer, length);
+      },
+      flush: () => this.flush(),
+      view: (pointer, length) => new Uint8Array(this.buffer, pointer, length)
+    };
+  }
+  get buffer() {
+    return this.runtime.memory.buffer;
+  }
+  feature(name) {
+    let found = this.abi[name];
+    if (found === void 0 || !featureAvailable(this.abi, this.caps, name))
+      throw new GameError("unsupported_feature", `this engine build does not provide ${name}; update the app to use this feature`);
+    return found;
+  }
+  check(code, what) {
+    if (code < 0) throw failure2(code, what);
+    return code;
+  }
+  owns(owner) {
+    let required = BUFFER_OWNER_CAPABILITIES[owner];
+    return required === void 0 || (this.caps & required) !== 0;
+  }
+  view(owner, id, slot) {
+    if (!this.owns(owner)) throw new GameError("unsupported_feature", `this engine build has no buffer owner ${owner}`);
+    let pointer = this.abi.engine_render_buffer(this.handle, owner, id, slot);
+    if (pointer === 0) throw new GameError("unknown_resource", `engine buffer ${owner}:${id}:${slot} does not exist`);
+    return [pointer, this.registers[31]];
+  }
+  f32(owner, id, slot) {
+    let [pointer, length] = this.view(owner, id, slot);
+    return new Float32Array(this.buffer, pointer, length);
+  }
+  u32(owner, id, slot) {
+    let [pointer, length] = this.view(owner, id, slot);
+    return new Uint32Array(this.buffer, pointer, length);
+  }
+  clearDesc() {
+    return this.desc.fill(0), this.desc;
+  }
+  stage(bytes) {
+    if (bytes.byteLength > this.scratchBytes && (this.scratch !== 0 && this.runtime.exports.engine_free(this.scratch, this.scratchBytes, COLUMN_ALIGN), this.scratchBytes = Math.max(bytes.byteLength, COLUMN_ALIGN), this.scratch = this.runtime.exports.engine_alloc(this.scratchBytes, COLUMN_ALIGN), this.scratch === 0))
+      throw new GameError("capacity_exceeded", "engine memory cannot stage asset bytes");
+    return new Uint8Array(this.buffer, this.scratch, bytes.byteLength).set(bytes), this.scratch;
+  }
+  command(op, target) {
+    this.pending === 1024 && this.flush();
+    let o = this.pending * 8;
+    return this.commandWords[o + 0] = op, this.commandWords[o + 1] = target, this.pending++, o + 2;
+  }
+  flush() {
+    if (this.pending === 0) return;
+    let count = this.pending;
+    this.pending = 0, this.check(this.abi.engine_render_flush(this.handle, count), "graphics command");
+  }
+  get renderHandle() {
+    return this.handle;
+  }
+  passTimings(out) {
+    if (!this.owns(13)) return false;
+    let pointer = this.abi.engine_render_buffer(this.handle, 13, 0, 0);
+    return pointer === 0 ? false : (out.set(new Uint32Array(this.buffer, pointer, Math.min(10, out.length))), true);
+  }
+  get native() {
+    return this.nativeSurface;
+  }
+  async attach(surface) {
+    if (surface !== null || this.attacher === null || this.nativeSurface !== null) return;
+    let native = await this.attacher(this.handle, {});
+    this.nativeSurface = native, this.caps = this.abi.engine_render_capabilities(this.handle), this.capabilities = { ...graphicsCapabilities(this.abi, this.caps), vectorSurfaces: this.vectorSurfaces?.cap ?? 0 }, this.resize(native.width, native.height, native.pixel_ratio), this.stopResize = native.on_resize((width, height, pixelRatio) => this.resize(width, height, pixelRatio));
+  }
+  resize(width, height, pixelRatio) {
+    let a = this.command(30, 0);
+    this.commandWords[a] = Math.max(1, Math.round(width * pixelRatio)), this.commandWords[a + 1] = Math.max(1, Math.round(height * pixelRatio)), this.commandFloats[a + 2] = pixelRatio, this.features.resize(width, height);
+  }
+  createGeometry(desc) {
+    let names = Object.keys(desc.attributes);
+    if (names.length > 8) throw new GameError("invalid_argument", `geometry has more than ${8} attributes`);
+    let position = desc.attributes.position;
+    if (!position) throw new GameError("invalid_argument", "geometry needs a position attribute");
+    let vertices = position.data.length / position.itemSize, morphs = desc.morphTargets ?? [], d = this.clearDesc();
+    d[0] = names.length, d[1] = vertices, d[2] = desc.index?.length ?? 0, d[3] = desc.index instanceof Uint32Array ? 1 : 0, d[4] = morphs.length, d[5] = morphs.length > 0 && morphs.every((m) => m.normal !== void 0) ? 1 : 0, d[6] = desc.morphRelative === false ? 0 : 1, names.forEach((name, i) => {
+      let attribute = desc.attributes[name], at = 8 + i * 4;
+      d[at + 0] = SEMANTICS[name] ?? 8 + i, d[at + 1] = scalarOf(attribute.data), d[at + 2] = attribute.itemSize, d[at + 3] = (attribute.normalized ? 1 : 0) | (attribute.dynamic ? 2 : 0);
+    });
+    let id = this.check(this.abi.engine_render_create_geometry(this.handle), "create geometry"), mirrors = /* @__PURE__ */ new Map();
+    if (names.forEach((name, i) => {
+      let source = desc.attributes[name].data, [pointer] = this.view(0, id, i), Constructor = source.constructor, target = new Constructor(this.buffer, pointer, source.length);
+      target.set(source), mirrors.set(name, { source, target, slot: i });
+    }), this.attributes.set(id, mirrors), desc.index) {
+      let [pointer] = this.view(0, id, 65535);
+      (desc.index instanceof Uint32Array ? new Uint32Array(this.buffer, pointer, desc.index.length) : new Uint16Array(this.buffer, pointer, desc.index.length)).set(desc.index);
+    }
+    if (morphs.length > 0) {
+      let positions = this.f32(0, id, 65534), stride = vertices * 3;
+      if (morphs.forEach((m, t) => positions.set(m.position, t * stride)), d[5] === 1) {
+        let normals = this.f32(0, id, 65533);
+        morphs.forEach((m, t) => {
+          m.normal && normals.set(m.normal, t * stride);
+        });
+      }
+    }
+    return this.check(this.abi.engine_render_commit_geometry(this.handle, id), "commit geometry"), id;
+  }
+  geometryAttribute(geometry, name) {
+    let mirror = this.attributes.get(geometry)?.get(name);
+    if (!mirror) throw new GameError("unknown_resource", `geometry ${geometry} has no attribute ${name}`);
+    return mirror.source;
+  }
+  markGeometryDirty(geometry, name, start, count) {
+    let mirrors = this.attributes.get(geometry), mirror = mirrors?.get(name);
+    if (!mirrors || !mirror) throw new GameError("unknown_resource", `geometry ${geometry} has no attribute ${name}`);
+    let end = count < 0 ? mirror.source.length : Math.min(mirror.source.length, start + count);
+    for (let i = start; i < end; i++) mirror.target[i] = mirror.source[i];
+    this.commandWords[this.command(16, geometry)] = mirror.slot;
+  }
+  setDrawRange(geometry, start, count) {
+    let a = this.command(17, geometry);
+    this.commandWords[a] = start, this.commandWords[a + 1] = count;
+  }
+  destroyGeometry(geometry) {
+    this.command(18, geometry), this.attributes.delete(geometry);
+  }
+  createTexture(desc) {
+    if (desc.source.kind === "video") {
+      let d2 = this.clearDesc();
+      return d2[0] = desc.source.width, d2[1] = desc.source.height, d2[8] = TEXTURE_KIND_EXTERNAL, this.check(this.abi.engine_render_create_texture(this.handle), "create video texture");
+    }
+    if (desc.source.kind !== "pixels")
+      throw new GameError("unsupported_feature", "the Cimplify renderer takes pixel or encoded textures; decode images with loadTexture");
+    let { width, height, data } = desc.source, format = desc.source.format ?? (data instanceof Float32Array ? "rgba32f" : data instanceof Uint16Array ? "rgba16f" : "rgba8"), [formatWord, texelBytes] = TEXEL_FORMATS[format], layered = desc.kind === "2d-array" || desc.kind === "3d", depth = desc.kind === "cube" ? 6 : layered ? desc.source.depth ?? 1 : 1;
+    if (desc.kind === "cube" && (width !== height || data.byteLength !== width * height * 6 * texelBytes))
+      throw new GameError("invalid_argument", "cube textures take six square faces packed +X, -X, +Y, -Y, +Z, -Z");
+    if (data.byteLength !== width * height * depth * texelBytes)
+      throw new GameError("invalid_argument", `a ${format} texture of ${width}x${height}x${depth} takes ${width * height * depth * texelBytes} bytes`);
+    let d = this.clearDesc();
+    d[0] = width, d[1] = height, d[2] = formatWord, d[8] = desc.kind === "cube" ? 1 : desc.kind === "equirect" ? 2 : desc.kind === "2d-array" ? TEXTURE_KIND_2D_ARRAY : desc.kind === "3d" ? TEXTURE_KIND_3D : 0, d[9] = depth, d[3] = desc.colorSpace === "linear" ? 1 : 0, d[4] = desc.wrap === "clamp" ? 1 : desc.wrap === "mirror" ? 2 : 0, d[5] = desc.filter === "nearest" ? 1 : 0, d[6] = desc.mipmaps === false ? 0 : 1, d[7] = desc.flipY ? 1 : 0;
+    let id = this.check(this.abi.engine_render_create_texture(this.handle), "create texture");
+    return this.textures.set(id, { data, width, height, depth, texelBytes }), this.copyTexture(id, data), this.requestEncode(id, desc.encode), id;
+  }
+  requestEncode(id, encode) {
+    if (encode === void 0 || encode === "none" || !featureAvailable(this.abi, this.caps, "engine_render_encode_texture")) return;
+    let encodeTexture = this.abi.engine_render_encode_texture;
+    if (!encodeTexture) return;
+    let mode = encode === "astc" ? TEXTURE_ENCODE_ASTC_4X4 : encode === "bc7" ? TEXTURE_ENCODE_BC7 : TEXTURE_ENCODE_AUTO;
+    encodeTexture(this.handle, id, mode);
+  }
+  copyTexture(id, data) {
+    let [pointer] = this.view(1, id, 0);
+    new Uint8Array(this.buffer, pointer, data.byteLength).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  }
+  copyRegion(id, mirror, region) {
+    let [pointer] = this.view(1, id, 0), source = new Uint8Array(mirror.data.buffer, mirror.data.byteOffset, mirror.data.byteLength), target = new Uint8Array(this.buffer, pointer, mirror.data.byteLength), row = mirror.width * mirror.texelBytes, span = region.width * mirror.texelBytes, z0 = region.z ?? 0;
+    for (let z = z0; z < z0 + (region.depth ?? 1); z++)
+      for (let y = region.y; y < region.y + region.height; y++) {
+        let at = (z * mirror.height + y) * row + region.x * mirror.texelBytes;
+        target.set(source.subarray(at, at + span), at);
+      }
+  }
+  async loadTexture(source) {
+    let bytes = await this.bytes(source, "texture"), pointer = this.stage(bytes);
+    return this.check(this.abi.engine_render_decode_texture(this.handle, pointer, bytes.byteLength, (1)), "decode texture");
+  }
+  async upgradeTexture(texture, source) {
+    let bytes = await this.bytes(source, "texture"), reload = this.reloadExport("engine_render_reload_texture");
+    if (reload !== null) {
+      this.flush();
+      let code = reload(this.handle, texture, this.stage(bytes), bytes.byteLength, (1));
+      if (code >= 0) return { texture, inPlace: true };
+      if (code !== ERROR_INVALID_ARGUMENT) throw failure2(code, "reload texture");
+    }
+    let pointer = this.stage(bytes);
+    return { texture: this.check(this.abi.engine_render_decode_texture(this.handle, pointer, bytes.byteLength, (1)), "decode texture"), inPlace: false };
+  }
+  reloadExport(name) {
+    return featureAvailable(this.abi, this.caps, name) ? this.abi[name] ?? null : null;
+  }
+  markTextureDirty(texture, region) {
+    let mirror = this.textures.get(texture);
+    if (region === void 0) {
+      mirror && this.copyTexture(texture, mirror.data), this.command(19, texture);
+      return;
+    }
+    mirror && this.copyRegion(texture, mirror, region);
+    let a = this.command(OP_MARK_TEXTURE_REGION, texture), w = this.commandWords;
+    w[a] = region.x, w[a + 1] = region.y, w[a + 2] = region.z ?? 0, w[a + 3] = region.width, w[a + 4] = region.height, w[a + 5] = region.depth ?? 1;
+  }
+  destroyTexture(texture) {
+    this.command(20, texture), this.textures.delete(texture);
+  }
+  createMaterial(desc) {
+    refuseUndrawnPhysicalFields(desc);
+    let d = this.clearDesc(), f = this.descFloats;
+    d[0] = MATERIAL_KINDS[desc.kind];
+    let color = "color" in desc && desc.color !== void 0 ? desc.color : 16777215;
+    this.writeHex(f, 1, color), f[4] = desc.opacity ?? 1, f[11] = desc.alphaTest ?? 0, f[25] = (1.5), f[6] = (1), f[21] = (1);
+    let flags = 0;
+    desc.transparent && (flags |= 1), desc.depthTest !== false && (flags |= 2), (desc.depthWrite ?? !desc.transparent) && (flags |= 4), desc.vertexColors && (flags |= 8), desc.wireframe && (flags |= 16), d[13] = desc.side === "back" ? 1 : desc.side === "double" ? 2 : 0, d[14] = desc.blending === "additive" ? 1 : desc.blending === "multiply" ? 2 : desc.blending === "none" ? 3 : desc.blending === "custom" ? 4 : 0;
+    let write = (word, value) => {
+      d[word] = value;
+    };
+    writeMaterialExtension(desc, write);
+    let extras = extraTextures(desc);
+    for (let i = 0; i < 8; i++) d[51 + i] = extras[i] ?? 0;
+    writeMaterialFeatures(desc, d, f), flags |= materialFeatureFlags(desc), flags |= writeMaterialTint(desc, d);
+    let fragment = null, uniforms = null;
+    switch (desc.kind) {
+      case "standard":
+      case "physical": {
+        flags |= 64, desc.flatShading && (flags |= 32), f[5] = desc.metalness ?? 0, f[6] = desc.roughness ?? (1), this.writeHex(f, 7, desc.emissive ?? 0), f[10] = desc.emissiveIntensity ?? 1, [desc.map, desc.normalMap, desc.roughnessMap, desc.metalnessMap, desc.emissiveMap, desc.aoMap].forEach((texture, i) => {
+          d[15 + i] = texture ?? 0;
+        }), desc.kind === "physical" && (f[22] = desc.clearcoat ?? 0, f[23] = desc.clearcoatRoughness ?? 0, f[24] = desc.transmission ?? 0, f[25] = desc.ior ?? (1.5), f[26] = desc.sheen ?? 0);
+        break;
+      }
+      case "skin":
+      case "eye":
+      case "hair": {
+        flags |= 64, desc.flatShading && (flags |= 32), f[6] = desc.roughness ?? (1), this.writeHex(f, 7, desc.emissive ?? 0), f[10] = desc.emissiveIntensity ?? 1, [desc.map, desc.normalMap, desc.roughnessMap, void 0, desc.emissiveMap, desc.aoMap].forEach((texture, i) => {
+          d[15 + i] = texture ?? 0;
+        }), writeCharacterWords(desc, write);
+        break;
+      }
+      case "unlit":
+      case "sprite":
+        d[15] = desc.map ?? 0, desc.kind === "sprite" && desc.sizeAttenuation !== false && (flags |= 128);
+        break;
+      case "points":
+        d[15] = desc.map ?? 0, f[21] = desc.size ?? (1), desc.sizeAttenuation !== false && (flags |= 128);
+        break;
+      case "lines":
+        break;
+      case "shader": {
+        desc.lights && (flags |= 64), fragment = UTF8.encode(desc.shader.wgsl.fragment), uniforms = /* @__PURE__ */ new Map();
+        let offset = 0;
+        for (let [name, uniform] of Object.entries(desc.uniforms ?? {})) {
+          let words = UNIFORM_WORDS[uniform.type];
+          uniforms.set(name, { offset, words }), offset += words;
+        }
+        d[27] = offset;
+        break;
+      }
+    }
+    d[12] = flags;
+    let transforms = desc.textureTransforms ? new Float32Array(MATERIAL_SLOTS.length * 8) : null, transformed = transforms !== null && writeTextureTransforms(desc, transforms, write), vertex = desc.kind === "shader" && desc.shader.wgsl.vertex ? UTF8.encode(desc.shader.wgsl.vertex) : null, staged = fragment && vertex ? concat(fragment, vertex) : fragment, pointer = staged ? this.stage(staged) : 0, fragmentBytes = fragment?.byteLength ?? 0, id = this.check(
+      this.abi.engine_render_create_material(
+        this.handle,
+        pointer,
+        fragmentBytes,
+        vertex ? pointer + fragmentBytes : 0,
+        vertex?.byteLength ?? 0
+      ),
+      "create material"
+    ), clipped = (desc.clippingPlanes?.length ?? 0) > 0 && writePlanes(desc, this.f32(7, id, 0));
+    if (transforms && transformed && this.f32(8, id, 0).set(transforms), (clipped || transformed) && this.command(13, id), uniforms && desc.kind === "shader") {
+      this.uniforms.set(id, uniforms);
+      for (let [name, uniform] of Object.entries(desc.uniforms ?? {}))
+        typeof uniform.value == "number" ? this.setMaterialScalar(id, name, uniform.value) : uniform.value instanceof Float32Array && this.setMaterialVector(id, name, uniform.value);
+    }
+    return this.features.material(id, desc), id;
+  }
+  writeHex(target, at, hex) {
+    target[at] = linear((hex >> 16 & (255)) / (255)), target[at + 1] = linear((hex >> 8 & (255)) / (255)), target[at + 2] = linear((hex & (255)) / (255));
+  }
+  setMaterialColor(material, r, g, b) {
+    let at = material * 20 + 0;
+    this.params[at] = r, this.params[at + 1] = g, this.params[at + 2] = b, this.command(13, material);
+  }
+  setMaterialOpacity(material, opacity) {
+    this.params[material * 20 + 3] = opacity, this.command(13, material);
+  }
+  setMaterialTexture(material, slot, texture) {
+    let a = this.command(14, material);
+    this.commandWords[a] = materialSlotIndex(slot), this.commandWords[a + 1] = texture ?? 0;
+  }
+  uniform(material, name) {
+    let slots = this.uniforms.get(material);
+    if (!slots) return null;
+    let slot = slots.get(name);
+    if (!slot) throw new GameError("invalid_argument", `material ${material} has no uniform ${name}`);
+    return slot;
+  }
+  setMaterialScalar(material, uniform, value) {
+    let slot = this.uniform(material, uniform);
+    if (slot)
+      this.f32(2, material, 0)[slot.offset] = value;
+    else {
+      let param = SCALAR_PARAMS[uniform];
+      if (param === void 0) throw new GameError("invalid_argument", `material ${material} has no scalar ${uniform}`);
+      this.params[material * 20 + param] = value;
+    }
+    this.command(13, material);
+  }
+  setMaterialVector(material, uniform, value) {
+    let slot = this.uniform(material, uniform);
+    if (!slot) throw new GameError("invalid_argument", "vector uniforms belong to shader materials");
+    if (value.length > slot.words) throw new GameError("invalid_argument", `uniform ${uniform} holds ${slot.words} values`);
+    this.f32(2, material, 0).set(value, slot.offset), this.command(13, material);
+  }
+  setMaterialUniformTexture(material, uniform, texture) {
+    let slot = this.uniform(material, uniform);
+    if (!slot) throw new GameError("invalid_argument", "texture uniforms belong to shader materials");
+    this.u32(2, material, 0)[slot.offset] = texture, this.command(13, material);
+  }
+  setMaterialState(material, state) {
+    writeMaterialState(state, (word, value) => {
+      let a = this.command(OP_SET_MATERIAL_WORD, material);
+      this.commandWords[a] = word, this.commandWords[a + 1] = value;
+    }), (state.clippingPlanes?.length ?? 0) > 0 && writePlanes(state, this.f32(7, material, 0)) && this.command(13, material);
+  }
+  destroyMaterial(material) {
+    this.command(15, material), this.uniforms.delete(material), this.features.forgetMaterial(material);
+  }
+  createEmitter(desc) {
+    if (!this.capabilities.particles) throw new GameError("unsupported_feature", "this engine build has no particles");
+    this.flush(), writeEmitterDesc(this.clearDesc(), this.descFloats, desc);
+    let id = this.check(this.feature("engine_render_create_emitter")(this.handle), "create emitter");
+    return desc.sizeCurve && sampleCurve(desc.sizeCurve, this.f32(9, id, 0)), desc.colorCurve && sampleCurve(desc.colorCurve, this.f32(9, id, 1)), (desc.sizeCurve || desc.colorCurve) && this.command(OP_MARK_EMITTER, id), id;
+  }
+  emit(emitter, count) {
+    this.commandWords[this.command(OP_EMIT, emitter)] = count;
+  }
+  setEmitterRate(emitter, rate) {
+    this.commandFloats[this.command(OP_SET_EMITTER_RATE, emitter)] = rate;
+  }
+  clearEmitter(emitter) {
+    this.command(OP_CLEAR_EMITTER, emitter);
+  }
+  destroyEmitter(emitter) {
+    this.command(OP_DESTROY_EMITTER, emitter);
+  }
+  setRenderOrder(node, order) {
+    this.commandWords[this.command(OP_SET_RENDER_ORDER, node)] = order | 0;
+  }
+  setShadow(light, shadow) {
+    let room = 6, a = 0, used = room;
+    for (let key of Object.keys(shadow)) {
+      let value = shadow[key];
+      value !== void 0 && (used === room && (a = this.command(OP_SET_SHADOW, light), used = 0), this.commandWords[a + used] = SHADOW_WORDS[key], this.commandWords[a + used + 1] = shadowWord(key, value), used += 2);
+    }
+    used < room && (this.commandWords[a + used] = 0);
+  }
+  writeShadow(d, shadow) {
+    if (shadow)
+      for (let key of Object.keys(shadow)) {
+        let value = shadow[key];
+        value !== void 0 && (d[SHADOW_WORDS[key]] = shadowWord(key, value));
+      }
+  }
+  createNode(desc) {
+    let d = this.clearDesc(), f = this.descFloats;
+    switch (d[22] = desc.renderOrder ?? 0, desc.kind) {
+      case "mesh":
+        d[0] = 0, d[1] = desc.geometry, d[2] = Array.isArray(desc.material) ? desc.material[0] ?? 0 : desc.material, d[3] = this.shadowFlags(desc.castShadow, desc.receiveShadow, desc.giExclude);
+        break;
+      case "instanced":
+        d[0] = 1, d[1] = desc.geometry, d[2] = desc.material, d[4] = desc.capacity, d[3] = this.shadowFlags(desc.castShadow, desc.receiveShadow, desc.giExclude) | (desc.colors ? 4 : 0) | (desc.batchSlots ? 64 : 0), d[18] = desc.batchSlots ?? 0;
+        break;
+      case "skinned": {
+        d[0] = 2, d[1] = desc.geometry, d[2] = desc.material, d[3] = this.shadowFlags(desc.castShadow, desc.receiveShadow, desc.giExclude);
+        let { parents, bindPose, inverseBindMatrices } = desc.skeleton;
+        if (bindPose.length !== parents.length * (10)) throw new GameError("invalid_argument", "bind pose needs ten floats per bone");
+        let parentBytes = Math.ceil(parents.byteLength / COLUMN_ALIGN) * COLUMN_ALIGN, poseBytes = Math.ceil(bindPose.byteLength / COLUMN_ALIGN) * COLUMN_ALIGN, total = new Uint8Array(parentBytes + poseBytes + (inverseBindMatrices?.byteLength ?? 0));
+        total.set(new Uint8Array(parents.buffer, parents.byteOffset, parents.byteLength), 0), total.set(new Uint8Array(bindPose.buffer, bindPose.byteOffset, bindPose.byteLength), parentBytes), inverseBindMatrices && total.set(new Uint8Array(inverseBindMatrices.buffer, inverseBindMatrices.byteOffset, inverseBindMatrices.byteLength), parentBytes + poseBytes);
+        let base = this.stage(total);
+        d[18] = parents.length, d[19] = base, d[20] = base + parentBytes, d[21] = inverseBindMatrices ? base + parentBytes + poseBytes : 0;
+        break;
+      }
+      case "points":
+        d[0] = 3, d[1] = desc.geometry, d[2] = desc.material;
+        break;
+      case "lines":
+        d[0] = 4, d[1] = desc.geometry, d[2] = desc.material, d[3] = desc.segments ? 8 : 0;
+        break;
+      case "sprite":
+        d[0] = 5, d[2] = desc.material;
+        break;
+      case "camera":
+        d[0] = 6, d[14] = desc.projection === "orthographic" ? 1 : 0, f[15] = desc.projection === "orthographic" ? desc.height : desc.projection === "perspective" ? desc.fov ?? 60 : 60, f[16] = desc.near ?? 0.1, f[17] = desc.far ?? 1e3;
+        break;
+      case "decal":
+        break;
+      case "light": {
+        d[0] = 7, d[5] = LIGHT_KINDS[desc.light], d[6] = desc.color ?? 16777215, d[12] = desc.groundColor ?? (4473924), d[3] = desc.castShadow ? 1 : 0, d[13] = desc.shadowMapSize ?? 0, f[7] = desc.intensity ?? 1, f[8] = desc.distance ?? 0, f[9] = desc.decay ?? (2), f[10] = desc.angle ?? DEFAULT_SPOT_ANGLE, f[11] = desc.penumbra ?? 0, this.writeShadow(d, desc.shadow);
+        break;
+      }
+      case "particles":
+        d[0] = 9, d[31] = desc.emitter;
+        break;
+      case "group":
+        d[0] = 8;
+        break;
+      case "shape2d":
+        throw new GameError("unsupported_feature", "shape2d nodes need the 2D renderer");
+      case "text2d":
+      case "text3d": {
+        let mode = desc.kind === "text2d" ? 2 : desc.billboard ? 1 : 0, font = desc.kind === "text3d" ? desc.font : this.resolveFont(desc.font, desc.fontFamily);
+        this.writeText(d, f, font, desc, mode);
+        let node2 = this.check(this.abi.engine_render_create_node(this.handle), `create ${desc.kind} node`);
+        return this.textNodes.set(node2, { font, mode }), desc.text && this.setNodeText(node2, desc.text), node2;
+      }
+    }
+    writeNodeFeatures(desc, d, f, desc.kind === "sprite" ? this.features.spriteRotation(desc.material) : 0);
+    let node = this.check(this.abi.engine_render_create_node(this.handle), `create ${desc.kind} node`);
+    return this.features.node(node, desc), node;
+  }
+  setLod(node, near, far, hysteresis) {
+    this.features.setLod(node, near, far, hysteresis);
+  }
+  setSprite(node, rotation, centerX, centerY) {
+    this.features.setSprite(node, rotation, centerX, centerY);
+  }
+  setProbeCoefficients(light, sh) {
+    this.features.setProbeCoefficients(light, sh);
+  }
+  setProjectionMatrix(camera, matrix, near, far) {
+    this.features.setProjectionMatrix(camera, matrix, near, far);
+  }
+  setViewOffset(camera, offset) {
+    this.features.setViewOffset(camera, offset);
+  }
+  batchBuffers(node) {
+    let cached = this.batchViews.get(node);
+    if (cached) return cached;
+    this.flush();
+    let slots = this.abi.engine_render_buffer(this.handle, 4, node, 5);
+    if (slots === 0) return null;
+    let slotCount = this.registers[31], ranges = this.abi.engine_render_buffer(this.handle, 4, node, 6);
+    if (ranges === 0) return null;
+    let views = {
+      slots: new Uint32Array(this.buffer, slots, slotCount),
+      ranges: new Uint32Array(this.buffer, ranges, this.registers[31])
+    };
+    return this.batchViews.set(node, views), views;
+  }
+  markBatch(node) {
+    this.command(62, node);
+  }
+  gpuStats(out) {
+    this.flush(), this.check(this.abi.engine_render_stats(this.handle), "stats"), this.features.readGpuStats(out);
+    let timed = this.passTimings(this.passScratch);
+    for (let i = 0; i < out.passNs.length; i++) out.passNs[i] = timed ? this.passScratch[i] ?? 0 : 0;
+    return timed || out.gpuLastNs > 0;
+  }
+  resolveFont(font, family) {
+    let found = font ?? (family !== void 0 ? this.fontFamilies.get(family) : void 0) ?? this.defaultFont;
+    if (found == null) throw new GameError("asset_load_failed", "load a font with loadFont before creating text");
+    return found;
+  }
+  writeText(d, f, font, style, mode) {
+    d[0] = 11, d[4] = style.capacity ?? (128), d[6] = style.color ?? (16777215), d[37] = font, d[46] = mode, d[42] = TEXT_ALIGNS[style.align ?? "start"], d[43] = TEXT_DIRECTIONS[style.direction ?? "auto"], d[48] = style.outlineColor ?? 0, f[38] = style.size ?? (mode === 2 ? (16) : (1)), f[39] = style.lineHeight ?? 0, f[40] = style.letterSpacing ?? 0, f[41] = style.maxWidth ?? 0, f[44] = style.anchor?.[0] ?? 0, f[45] = style.anchor?.[1] ?? 0, f[47] = style.outlineWidth ?? 0, f[49] = style.opacity ?? 1;
+  }
+  async loadFont(source, family) {
+    let [atlas, table] = await Promise.all([this.bytes(source.atlas, "font atlas"), this.bytes(source.table, "font table")]), texture = this.check(
+      this.abi.engine_render_decode_texture(this.handle, this.stage(atlas), atlas.byteLength, (0)),
+      "decode font atlas"
+    ), material = this.createMaterial({ kind: "unlit", transparent: true, depthWrite: false });
+    this.setMaterialTexture(material, "map", texture);
+    let font = this.check(
+      this.feature("engine_render_load_font")(this.handle, this.stage(table), table.byteLength, material),
+      "load font"
+    );
+    return source.face !== void 0 && await this.loadFontFace(font, source.face), family !== void 0 && this.fontFamilies.set(family, font), this.defaultFont ?? (this.defaultFont = font), registerFontTable(font, new FontTable(table.slice().buffer)), font;
+  }
+  async loadFontFace(font, source) {
+    let attach = this.abi.engine_render_font_face;
+    if (attach === void 0) return;
+    let face = await this.bytes(source, "font face");
+    this.check(attach(this.handle, font, this.stage(face), face.byteLength), "load font face");
+  }
+  setTextStyle(node, style) {
+    let text = this.textNodes.get(node);
+    if (text === void 0) throw new GameError("unknown_resource", "setTextStyle needs a text node");
+    this.writeText(this.clearDesc(), this.descFloats, text.font, style, text.mode), this.check(this.feature("engine_render_set_text_style")(this.handle, node), "set text style");
+  }
+  textBounds(node, out) {
+    let pointer = this.pickScratch();
+    this.check(this.feature("engine_render_text_bounds")(this.handle, node, pointer), "text bounds"), out.set(new Float32Array(this.buffer, pointer, 4));
+  }
+  batchHandle() {
+    return this.handle;
+  }
+  forceQualityTier(tier) {
+    return this.forceTierCall === null ? false : (this.check(this.forceTierCall(this.handle, tier === null ? (-1) : tier), "force quality tier"), true);
+  }
+  qualityTier() {
+    return this.qualityTierCall === null ? (0) : this.check(this.qualityTierCall(this.handle), "quality tier");
+  }
+  governorPressure() {
+    this.check(this.abi.engine_render_stats(this.handle), "stats");
+    let word = this.registers[STAT_THERMAL_TIER];
+    return Math.max(word & (255), word >>> (28) & (15));
+  }
+  raycast(origin, direction, far, layers, out) {
+    let pointer = this.pickScratch(), ray = new Float32Array(this.buffer, pointer, 7);
+    ray[0] = origin[0], ray[1] = origin[1], ray[2] = origin[2], ray[3] = direction[0], ray[4] = direction[1], ray[5] = direction[2], ray[6] = far;
+    let result = pointer + 7 * WORD_BYTES;
+    if (this.check(this.feature("engine_render_raycast")(this.handle, pointer, layers >>> 0, result), "raycast") !== (1)) return false;
+    let words = new Uint32Array(this.buffer, result, 11), floats = new Float32Array(this.buffer, result, 11);
+    return out.node = words[0], out.instance = words[1], out.triangle = words[2], out.distance = floats[3], out.point.set(floats.subarray(4, 7)), out.barycentric.set(floats.subarray(7, 9)), out.uv.set(floats.subarray(9, 11)), true;
+  }
+  pickScratch() {
+    if (this.pickPointer === 0 && (this.pickPointer = this.runtime.exports.engine_alloc(18 * WORD_BYTES, COLUMN_ALIGN), this.pickPointer === 0))
+      throw new GameError("capacity_exceeded", "engine memory cannot hold the pick scratch");
+    return this.pickPointer;
+  }
+  shadowFlags(cast, receive, giExclude) {
+    return (cast ? 1 : 0) | (receive ? 2 : 0) | (giExclude ? 32 : 0);
+  }
+  destroyNode(node) {
+    this.command(1, node), this.roots.delete(node), this.nodeViews.delete(node), this.textNodes.delete(node), this.batchViews.delete(node), this.features.forgetNode(node);
+  }
+  setNodeVisible(node, visible) {
+    this.commandWords[this.command(2, node)] = visible ? 1 : 0;
+  }
+  setNodeLayers(node, mask) {
+    this.commandWords[this.command(3, node)] = mask >>> 0;
+  }
+  setNodeMaterial(node, material) {
+    this.commandWords[this.command(4, node)] = material;
+  }
+  setNodeText(node, text) {
+    let needed = Math.max(text.length * (3), COLUMN_ALIGN);
+    if (needed > this.textBytes && (this.textPointer !== 0 && this.runtime.exports.engine_free(this.textPointer, this.textBytes, COLUMN_ALIGN), this.textBytes = needed, this.textPointer = this.runtime.exports.engine_alloc(needed, COLUMN_ALIGN), this.textPointer === 0))
+      throw new GameError("capacity_exceeded", "engine memory cannot stage text");
+    let written = UTF8.encodeInto(text, new Uint8Array(this.buffer, this.textPointer, this.textBytes)).written;
+    this.check(this.feature("engine_render_set_text")(this.handle, node, this.textPointer, written), "set text");
+  }
+  writeNodeMatrices(nodes, matrices, rows, count) {
+    if (matrices.buffer !== this.buffer) throw new GameError("invalid_argument", "the Cimplify renderer reads render matrices from engine memory");
+    let sync = this.sync;
+    for (let i = 0; i < count; i++)
+      sync[2 * i] = nodes[i], sync[2 * i + 1] = rows[i];
+    this.flush(), this.check(this.abi.engine_render_sync(this.handle, count, matrices.byteOffset, matrices.length / 16), "sync matrices");
+  }
+  readNodeMatrix(node, out, offset) {
+    this.flush();
+    let scratch = this.nodeMatrixScratch();
+    this.check(this.abi.engine_render_node_matrix(this.handle, node, scratch.byteOffset), "read node matrix");
+    for (let i = 0; i < 16; i++) out[offset + i] = scratch[i];
+  }
+  createPoseReader(nodes) {
+    let count = nodes.length, bytes = count * WORD_BYTES * (1 + NODE_POSE_FLOATS), pointer = count === 0 ? 0 : this.runtime.exports.engine_alloc(bytes, COLUMN_ALIGN);
+    if (count > 0 && pointer === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold a bone set");
+    count > 0 && new Uint32Array(this.buffer, pointer, count).set(nodes);
+    let reader = { pointer, bytes, count, out: pointer + count * WORD_BYTES, view: null }, free = this.poseReaders.indexOf(null, 1);
+    return free > 0 ? (this.poseReaders[free] = reader, free) : (this.poseReaders.length === 0 && this.poseReaders.push(null), this.poseReaders.push(reader), this.poseReaders.length - 1);
+  }
+  poseReader(reader) {
+    let found = this.poseReaders[reader];
+    if (!found) throw new GameError("unknown_resource", `bone set ${reader} does not exist`);
+    return found;
+  }
+  readPoses(id, out, offset) {
+    let reader = this.poseReader(id);
+    if (reader.count === 0) return;
+    this.flush(), this.check(this.feature("engine_render_node_poses")(this.handle, reader.pointer, reader.count, reader.out), "read bone poses");
+    let view = reader.view;
+    (view === null || view.buffer !== this.buffer) && (view = new Float32Array(this.buffer, reader.out, reader.count * NODE_POSE_FLOATS), reader.view = view);
+    for (let i = 0; i < view.length; i++) out[offset + i] = view[i];
+  }
+  destroyPoseReader(id) {
+    let reader = this.poseReader(id);
+    reader.pointer !== 0 && this.runtime.exports.engine_free(reader.pointer, reader.bytes, COLUMN_ALIGN), this.poseReaders[id] = null;
+  }
+  nodeMatrixScratch() {
+    if (!this.matrixScratch) {
+      let pointer = this.runtime.exports.engine_alloc(16 * WORD_BYTES, COLUMN_ALIGN);
+      if (pointer === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold a matrix");
+      this.matrixScratch = new Float32Array(this.buffer, pointer, 16);
+    }
+    return this.matrixScratch;
+  }
+  nodeBuffer(node, slot) {
+    let key = node * (4) + slot, cached = this.nodeViews.get(key);
+    if (cached) return cached;
+    let view = this.f32(4, node, slot);
+    return this.nodeViews.set(key, view), view;
+  }
+  instanceMatrices(node) {
+    return this.nodeBuffer(node, 0);
+  }
+  instanceColors(node) {
+    try {
+      return this.nodeBuffer(node, 1);
+    } catch {
+      return null;
+    }
+  }
+  setInstanceCount(node, count) {
+    this.commandWords[this.command(5, node)] = count;
+  }
+  markInstancesDirty(node) {
+    this.command(6, node);
+  }
+  setInstanceFeed(node, table, columns, hostReads, pose) {
+    if (this.feedSupport === null && (this.feedSupport = engineAdvertises(this.runtime, RENDER_KERNEL_INSTANCES_FEATURE)), !this.feedSupport || columns.length !== 4 || pose !== void 0 && (pose.length !== 2 || !this.posesSupported())) return false;
+    let at = this.command(64, node);
+    this.commandWords[at] = table;
+    for (let k = 0; k < 4; k++) this.commandWords[at + 1 + k] = columns[k];
+    if (this.commandWords[at + 1 + 4] = hostReads ? 1 : 0, pose !== void 0) {
+      let words = this.command(66, node);
+      for (let k = 0; k < 2; k++) this.commandWords[words + k] = pose[k];
+    }
+    return true;
+  }
+  setInstancePalette(node, model, skin, firstClip, clips, frames) {
+    if (!this.posesSupported()) return false;
+    let at = this.command(67, node);
+    return this.commandWords[at] = model, this.commandWords[at + 1] = skin, this.commandWords[at + 2] = firstClip, this.commandWords[at + 3] = clips, this.commandWords[at + 4] = frames, true;
+  }
+  posesSupported() {
+    return this.poseSupport === null && (this.poseSupport = engineAdvertises(this.runtime, RENDER_FEED_POSE_FEATURE)), this.poseSupport;
+  }
+  requireMedia() {
+    if (this.mediaSupport === null && (this.mediaSupport = engineAdvertises(this.runtime, MEDIA_VOLUME_FEATURE)), !this.mediaSupport) throw new GameError("unsupported_feature", `this engine build has no media volumes (feature ${MEDIA_VOLUME_FEATURE}); update the app to use them`);
+  }
+  liveMedium(medium) {
+    let id = medium;
+    if (!(Number.isInteger(id) && id >= 1 && id <= 16 && this.mediaLive[id])) throw new GameError("unknown_resource", `media volume ${id} does not exist`);
+    return id;
+  }
+  sendMedium(op, id, desc) {
+    writeMediumDesc(this.mediumWords, desc), this.flush(), this.f32(OWNER_STAGING, 0, 0).set(this.mediumWords), this.command(op, id), this.flush(), this.mediaViews[id] = null;
+  }
+  createMedium(desc) {
+    this.requireMedia();
+    let id = this.mediaLive.indexOf(false, 1);
+    if (id < 0) throw new GameError("capacity_exceeded", `a scene holds at most ${16} media volumes`);
+    return this.sendMedium(68, id, desc), this.mediaLive[id] = true, id;
+  }
+  setMedium(medium, desc) {
+    this.sendMedium(69, this.liveMedium(medium), desc);
+  }
+  mediumTexels(medium) {
+    let id = this.liveMedium(medium), held = this.mediaViews[id];
+    if (held !== null && held.buffer === this.buffer) return held;
+    let view = this.u32(16, id, 0);
+    return this.mediaViews[id] = view, view;
+  }
+  markMedium(medium) {
+    this.command(71, this.liveMedium(medium));
+  }
+  destroyMedium(medium) {
+    let id = this.liveMedium(medium);
+    this.command(70, id), this.flush(), this.mediaLive[id] = false, this.mediaViews[id] = null;
+  }
+  clearInstanceFeed(node) {
+    this.feedSupport === true && this.command(65, node);
+  }
+  morphWeights(node) {
+    return this.nodeBuffer(node, 2);
+  }
+  markMorphWeightsDirty(node) {
+    this.command(7, node);
+  }
+  skeletonPose(node) {
+    return this.nodeBuffer(node, 3);
+  }
+  markSkeletonDirty(node) {
+    this.command(8, node);
+  }
+  setCameraPerspective(node, fovDegrees, near, far) {
+    let a = this.command(9, node);
+    this.commandFloats[a] = fovDegrees, this.commandFloats[a + 1] = near, this.commandFloats[a + 2] = far, this.features.perspective(node, fovDegrees, near, far);
+  }
+  setCameraPerspectiveFrom(node, values, offset) {
+    let a = this.command(9, node), f = this.commandFloats;
+    f[a] = values[offset], f[a + 1] = values[offset + 1], f[a + 2] = values[offset + 2], this.features.perspectiveFrom(node, values, offset);
+  }
+  setCameraOrthographic(node, height, near, far) {
+    let a = this.command(10, node);
+    this.commandFloats[a] = height, this.commandFloats[a + 1] = near, this.commandFloats[a + 2] = far, this.features.orthographic(node, height, near, far);
+  }
+  setActiveCamera(node) {
+    this.command(11, node);
+  }
+  setLight(node, color, intensity) {
+    let a = this.command(12, node);
+    this.commandWords[a] = color, this.commandFloats[a + 1] = intensity;
+  }
+  setEnvironment(desc) {
+    this.flush();
+    let d = this.clearDesc(), f = this.descFloats, background = desc.background;
+    d[2] = 0, background && "color" in background ? (d[0] = 1, d[1] = background.color) : background && "texture" in background ? (d[0] = 2, d[2] = background.texture) : background ? d[0] = 3 : d[0] = 1, d[3] = desc.environment ?? 0, f[15] = desc.environmentIntensity ?? 1, f[16] = desc.environmentRotation ?? 0, f[17] = desc.backgroundBlurriness ?? 0, f[18] = desc.backgroundIntensity ?? 1;
+    let fog = desc.fog;
+    fog && (d[4] = 1, d[5] = fog.color, d[11] = FOG_MODES.indexOf(fog.mode ?? "linear"), fog.mode === "exp2" || fog.mode === "height" ? f[12] = fog.density : (f[6] = fog.near, f[7] = fog.far), fog.mode === "height" && (f[13] = fog.height, f[14] = fog.falloff)), d[8] = Math.max(0, TONE_MAPPINGS.indexOf(desc.toneMapping ?? "aces")), d[ENV_TONE_CURVE] = desc.toneCurve ?? 0, f[9] = desc.exposure ?? 1, d[10] = desc.shadows === false ? 0 : 1;
+    let gi = desc.gi;
+    if (gi && (d[ENV_GI] = Math.max(0, GI_MODES.indexOf(gi.mode ?? "field")), f[ENV_GI_INTENSITY] = gi.intensity ?? 1, f[ENV_GI_SPACING] = gi.spacing ?? 1, f[ENV_GI_SUN_ANGLE] = gi.sunAngle ?? 0.53), writeSky(desc, d, f), this.check(this.abi.engine_render_set_environment(this.handle), "set environment"), desc.volumetrics)
+      for (let [at, chunk] of volumetricChunks(volumetricWords(desc.volumetrics))) {
+        let a = this.command(OP_SET_VOLUMETRICS, 0);
+        this.commandWords[a] = at, chunk.forEach((value, k) => {
+          this.commandFloats[a + 1 + k] = value;
+        });
+      }
+  }
+  createRenderTarget(desc) {
+    let d = this.clearDesc();
+    d[0] = desc.width, d[1] = desc.height, d[2] = desc.format === "rgba16f" ? 1 : desc.format === "rgba32f" ? 2 : 0, d[3] = desc.depth === false ? 0 : 1, d[4] = desc.samples ?? 1, d[TARGET_KIND] = desc.kind === "cube" ? TARGET_KIND_CUBE : desc.kind === "2d-array" ? TARGET_KIND_ARRAY : TARGET_KIND_2D, d[TARGET_LAYERS] = desc.layers ?? 1, d[TARGET_SAMPLED_DEPTH] = desc.sampleDepth ? 1 : 0, d[TARGET_COLORS] = desc.colors ?? 1;
+    let id = this.check(this.abi.engine_render_create_target(this.handle), "create render target");
+    this.targetTextures.set(id, this.registers[30]);
+    let depth = d[TARGET_TEXTURES + TARGET_MAX_COLORS - 1];
+    desc.sampleDepth && depth !== 0 && this.targetDepths.set(id, depth), this.targetFormats.set(id, desc.format ?? "rgba8");
+    let extras = [];
+    for (let k = 1; k < (desc.colors ?? 1); k++) extras.push(d[TARGET_TEXTURES + k - 1]);
+    return this.targetAttachments.set(id, extras), id;
+  }
+  renderTargetAttachment(target, attachment) {
+    if (attachment === 0) return this.renderTargetTexture(target);
+    let texture = this.targetAttachments.get(target)?.[attachment - 1];
+    if (texture === void 0 || texture === 0)
+      throw new GameError("invalid_argument", `render target ${target} has no colour attachment ${attachment}`);
+    return texture;
+  }
+  renderTargetTexture(target) {
+    let texture = this.targetTextures.get(target);
+    if (texture === void 0) throw new GameError("unknown_resource", `render target ${target} does not exist`);
+    return texture;
+  }
+  renderTargetDepthTexture(target) {
+    let texture = this.targetDepths.get(target);
+    if (texture === void 0) throw new GameError("unsupported_feature", `render target ${target} was not created with sampleDepth`);
+    return texture;
+  }
+  resizeRenderTarget(target, width, height) {
+    let a = this.command(26, target);
+    this.commandWords[a] = width, this.commandWords[a + 1] = height;
+  }
+  destroyRenderTarget(target) {
+    this.command(27, target), this.targetTextures.delete(target), this.targetDepths.delete(target), this.targetFormats.delete(target), this.targetAttachments.delete(target);
+  }
+  createPostChain(desc) {
+    if (desc.effects.length > MAX_CHAIN_EFFECTS) throw new GameError("invalid_argument", `post chains hold ${MAX_CHAIN_EFFECTS} effects`);
+    let shaders = desc.effects.map((effect) => effect.kind === "shader" ? postShader(effect) : null), params = desc.effects.map((effect, e) => {
+      let shader = shaders[e];
+      if (shader) return shader.values;
+      let record = effect;
+      return EFFECT_PARAMETERS[effect.kind].map((name) => Number(record[name] ?? 0));
+    }), inline = Math.min(desc.effects.length, 12), d = this.clearDesc(), f = this.descFloats;
+    d[0] = inline;
+    for (let e = 0; e < inline; e++) {
+      let at = 1 + e * 5;
+      d[at + 0] = EFFECT_KINDS[desc.effects[e].kind], params[e].forEach((value, p) => {
+        f[at + 1 + p] = value;
+      });
+    }
+    let setShader = shaders.some((shader) => shader !== null) ? this.feature("engine_render_set_chain_shader") : null, id = this.check(this.abi.engine_render_create_chain(this.handle), "create post chain");
+    for (let e = inline; e < desc.effects.length; e++) {
+      let a = this.command(OP_SET_EFFECT, id);
+      this.commandWords[a] = e, this.commandWords[a + 1] = EFFECT_KINDS[desc.effects[e].kind], params[e].forEach((value, p) => {
+        this.commandFloats[a + 2 + p] = value;
+      });
+    }
+    return inline < desc.effects.length && this.flush(), shaders.forEach((shader, e) => {
+      if (!shader || !setShader) return;
+      let pointer = this.stage(shader.source);
+      this.check(setShader(this.handle, id, e, pointer, shader.source.byteLength), "set post shader");
+    }), desc.effects.forEach((effect, e) => {
+      if (!(effect.kind !== "shader" || effect.textures === void 0)) {
+        if (effect.textures.length > POST_EFFECT_TEXTURES)
+          throw new GameError("invalid_argument", `post shaders take ${POST_EFFECT_TEXTURES} textures`);
+        effect.textures.forEach((texture, slot) => {
+          let a = this.command(OP_SET_EFFECT_TEXTURE, id);
+          this.commandWords[a] = e, this.commandWords[a + 1] = slot, this.commandWords[a + 2] = texture;
+        });
+      }
+    }), this.chains.set(id, {
+      kinds: desc.effects.map((e) => e.kind),
+      params: desc.effects.map((effect, e) => shaders[e]?.params ?? EFFECT_PARAMETERS[effect.kind])
+    }), id;
+  }
+  setPostScalar(chain, effect, uniform, value) {
+    let mirror = this.chains.get(chain), kind = mirror?.kinds[effect];
+    if (mirror === void 0 || kind === void 0) throw new GameError("unknown_resource", `post chain ${chain} has no effect ${effect}`);
+    let param = mirror.params[effect].indexOf(uniform);
+    if (param < 0) throw new GameError("invalid_argument", `${kind} has no parameter ${uniform}`);
+    let a = this.command(24, chain);
+    this.commandWords[a] = effect, this.commandWords[a + 1] = param, this.commandFloats[a + 2] = value;
+  }
+  setPostChain(chain) {
+    this.command(23, chain ?? 0);
+  }
+  setWeather(state) {
+    let w = weatherWords(state), a = this.command(OP_SET_WEATHER, w.snow ? 1 : 0), f = this.commandFloats;
+    f[a] = w.cloudCover, f[a + 1] = w.haze, f[a + 2] = w.precipitation, f[a + 3] = w.wetness, f[a + 4] = w.windX, f[a + 5] = w.windZ;
+  }
+  setTimeOfDay(hours, latitude, dayOfYear) {
+    let a = this.command(OP_SET_TIME_OF_DAY, 0), f = this.commandFloats;
+    f[a] = hours, f[a + 1] = latitude ?? UNSET, f[a + 2] = dayOfYear ?? UNSET;
+  }
+  destroyPostChain(chain) {
+    this.command(25, chain), this.chains.delete(chain);
+  }
+  createRenderPass(desc) {
+    this.flush();
+    let d = this.clearDesc(), f = this.descFloats;
+    return d[0] = desc.camera, d[1] = desc.target ?? 0, d[2] = (desc.layers ?? 4294967295) >>> 0, d[3] = desc.clearColor ?? 0, f[4] = desc.clearAlpha ?? 1, d[5] = (desc.order ?? 0) >>> 0, d[PASS_SLICE] = desc.slice ?? 0, d[PASS_FLAGS] = (desc.cubeFace ? PASS_FLAG_CUBE_FACE : 0) | (desc.reflect ? PASS_FLAG_REFLECT : 0) | (desc.once ? PASS_FLAG_ONCE : 0), desc.reflect?.forEach((v, i) => {
+      f[PASS_PLANE + i] = v;
+    }), desc.viewport && (d[6] = 1, desc.viewport.forEach((v, i) => {
+      f[7 + i] = v;
+    })), this.check(this.abi.engine_render_create_pass(this.handle), "create render pass");
+  }
+  setRenderPassEnabled(pass, enabled) {
+    this.commandWords[this.command(21, pass)] = enabled ? 1 : 0;
+  }
+  destroyRenderPass(pass) {
+    this.command(22, pass);
+  }
+  async bytes(source, what) {
+    if ("bytes" in source) return new Uint8Array(source.bytes);
+    if ("text" in source) return UTF8.encode(source.text);
+    let response = await fetch(source.url);
+    if (!response.ok) throw new GameError("asset_load_failed", `${what} ${source.url} failed with ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  installShaders(bytes) {
+    let pointer = this.stage(bytes);
+    return this.check(
+      this.abi.engine_render_install_shaders(this.handle, pointer, bytes.byteLength),
+      "install shaders"
+    );
+  }
+  async loadModel(source) {
+    let bytes = await this.bytes(source, "model"), pointer = this.stage(bytes), id = this.check(this.abi.engine_render_load_model(this.handle, pointer, bytes.byteLength), "load model");
+    return this.readModel(id, null);
+  }
+  async upgradeModel(model, source) {
+    let previous = this.models.get(model);
+    if (previous === void 0) throw new GameError("unknown_resource", `model ${model} is not loaded`);
+    let bytes = await this.bytes(source, "model"), reload = this.reloadExport("engine_render_reload_model");
+    if (reload !== null) {
+      this.flush();
+      let code = reload(this.handle, model, this.stage(bytes), bytes.byteLength);
+      if (code >= 0) return { model: this.readModel(model, previous), inPlace: true };
+      if (code !== ERROR_INVALID_ARGUMENT) throw failure2(code, "reload model");
+    }
+    let id = this.check(this.abi.engine_render_load_model(this.handle, this.stage(bytes), bytes.byteLength), "load model");
+    return { model: this.readModel(id, null), inPlace: false };
+  }
+  readModel(id, previous) {
+    let nodes = this.registers[12], clips = nodes + this.registers[13], [names, length] = this.view(6, id, 0), all = NAMES.decode(new Uint8Array(this.buffer, names, length).slice()).split(String.fromCharCode((0))), clipNames = all.slice(nodes, clips);
+    if (previous !== null) {
+      let info2 = { ...previous, nodeNames: all.slice(0, nodes), clipNames };
+      return this.models.set(id, info2), info2;
+    }
+    let named = this.owns(12), materialNames = named ? all.slice(clips, all.length - 1) : [], materials = named ? this.modelMaterials(id, materialNames.length) : [], info = { id, nodeNames: all.slice(0, nodes), clipNames, materialNames, materials };
+    return this.models.set(id, info), info;
+  }
+  refreshModel(root) {
+    let model = this.roots.get(root), previous = model === void 0 ? void 0 : this.models.get(model);
+    if (model === void 0 || previous === void 0) throw new GameError("invalid_argument", `node ${root} is not a model instance`);
+    return this.readModel(model, previous);
+  }
+  async loadClips(root, source, options) {
+    let rate = bakeRate(options), load = this.feature("engine_render_load_clips");
+    if (!this.roots.has(root)) throw new GameError("invalid_argument", `node ${root} is not a model instance`);
+    let bytes = await this.bytes(source, "clips");
+    this.flush();
+    let pointer = this.stage(bytes), first = this.check(load(this.handle, root, pointer, bytes.byteLength, rate), "load clips");
+    return this.refreshModel(root).clipNames.slice(first);
+  }
+  setTint(node, tint) {
+    let at = this.command(63, node);
+    writeTintWords(tint, this.commandWords, at);
+  }
+  modelMaterials(model, count) {
+    let [ids] = this.view(12, model, 0);
+    return Array.from(new Uint32Array(this.buffer, ids, count), (material) => material);
+  }
+  instantiateModel(model) {
+    if (!this.models.get(model)) throw new GameError("unknown_resource", `model ${model} is not loaded`);
+    let root = this.check(this.abi.engine_render_instantiate(this.handle, model), "instantiate model");
+    return this.roots.set(root, model), root;
+  }
+  findNode(root, name) {
+    let bytes = UTF8.encode(name), node = this.check(this.abi.engine_render_find_node(this.handle, root, this.stage(bytes), bytes.byteLength), "find node");
+    return node === (0) ? null : node;
+  }
+  playClip(root, clip, loop, fadeSeconds, speed) {
+    let index = this.clipIndex(root, clip);
+    if (index < 0) throw new GameError("unknown_resource", `node ${root} has no clip ${clip}`);
+    return this.playClipIndex(root, index, loop, fadeSeconds, speed);
+  }
+  clipIndex(root, clip) {
+    let model = this.roots.get(root);
+    return model === void 0 ? -1 : this.models.get(model)?.clipNames.indexOf(clip) ?? -1;
+  }
+  playClipIndex(root, clip, loop, fadeSeconds, speed) {
+    return this.flush(), this.check(this.abi.engine_render_play_clip(this.handle, root, clip, loop ? 1 : 0, fadeSeconds, speed), "play clip");
+  }
+  setClipWeight(action, weight) {
+    this.commandFloats[this.command(28, action)] = weight;
+  }
+  stopClip(action, fadeSeconds) {
+    this.commandFloats[this.command(29, action)] = fadeSeconds;
+  }
+  advanceAnimations(time) {
+    this.flush(), this.registerFloats[16] = time.values[FRAME_SECONDS_SLOT], this.check(this.abi.engine_render_animate(this.handle), "advance animations");
+  }
+  render(time) {
+    this.frameBudget !== null && this.followRefresh(time.values), this.flush();
+    let native = this.nativeSurface;
+    native !== null && native.before_render !== void 0 && native.before_render(), this.vectorSurfaces?.frame(time.values[FRAME_SECONDS_SLOT]), this.check(this.abi.engine_render_frame(this.handle), "render frame"), this.targetReads.length > 0 && this.pollTargetReads();
+  }
+  followRefresh(clock) {
+    let refresh = this.refresh, interval = clock[FRAME_NOW_MS_SLOT] - refresh[(0)];
+    if (refresh[(0)] = clock[FRAME_NOW_MS_SLOT], interval >= (1) && interval < (100) && (interval < refresh[(1)] && (refresh[(1)] = interval), this.observed++), this.observed < (64) || this.frameBudget === null) return;
+    let micros = Math.round(refresh[(1)] * (1e3));
+    refresh[(1)] = (100), this.observed = 0, !(Math.abs(micros - this.budgetMicros) * (50) <= this.budgetMicros) && (this.budgetMicros = micros, this.frameBudget(this.handle, micros));
+  }
+  pushVideoFrame(texture, frame, width, height) {
+    let gpu = this.runtime.gpu;
+    if (gpu === null || this.abi.engine_render_texture_object === void 0) return false;
+    this.flush();
+    let object = this.abi.engine_render_texture_object(this.handle, texture);
+    return object <= 0 ? false : gpu.copyExternalImage(object, frame, width, height);
+  }
+  readRenderTarget(target, rect, slice = 0) {
+    let read = this.feature("engine_render_read_target");
+    if (this.abi.engine_render_raw_poll === void 0)
+      throw new GameError("unsupported_feature", "this engine build cannot poll readbacks");
+    this.flush();
+    let [x, y, width, height] = rect, request = this.check(read(this.handle, target, slice, x, y, width, height), "read render target"), bytes = width * height * (this.targetFormats.get(target) === "rgba8" ? 4 : 8);
+    return new Promise((resolve, reject) => {
+      this.targetReads.push({ request, bytes, resolve, reject });
+    });
+  }
+  pollTargetReads() {
+    let poll = this.abi.engine_render_raw_poll;
+    if (poll === void 0) return;
+    let waiting = [];
+    for (let read of this.targetReads) {
+      let pointer = poll(this.handle, read.request);
+      if (pointer === 0) {
+        waiting.push(read);
+        continue;
+      }
+      if (pointer < 0) {
+        read.reject(failure2(pointer, "read render target"));
+        continue;
+      }
+      read.resolve(new Uint8Array(this.buffer, pointer, read.bytes).slice());
+    }
+    this.targetReads = waiting;
+  }
+  stats(out) {
+    this.flush(), this.check(this.abi.engine_render_stats(this.handle), "stats");
+    let r = this.registers;
+    out.nodes = r[0], out.geometries = r[1], out.materials = r[2], out.textures = r[3], out.renderTargets = r[4], out.postChains = r[5], out.renderPasses = r[6], out.frames = r[7];
+  }
+  dispose() {
+    this.disposed || (this.disposed = true, this.stopResize?.(), this.nativeSurface?.release(), this.nativeSurface = null, this.abi.engine_render_destroy(this.handle), this.scratch !== 0 && this.runtime.exports.engine_free(this.scratch, this.scratchBytes, COLUMN_ALIGN), this.matrixScratch && this.runtime.exports.engine_free(this.matrixScratch.byteOffset, 16 * WORD_BYTES, COLUMN_ALIGN), this.textPointer !== 0 && this.runtime.exports.engine_free(this.textPointer, this.textBytes, COLUMN_ALIGN), this.pickPointer !== 0 && this.runtime.exports.engine_free(this.pickPointer, 18 * WORD_BYTES, COLUMN_ALIGN), this.textPointer = 0, this.pickPointer = 0, this.scratch = 0, this.matrixScratch = null);
+  }
+};
+
+// src/game/backends/engine/ai.ts
+var NO_WORLD = 0;
+function engineAiExports(symbols) {
+  for (let name of ENGINE_AI_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+var EngineAiPort = class {
+  constructor(runtime, exports, physicsWorld) {
+    this.name = "cimplify-engine-ai";
+    this.runtime = runtime, this.exports = exports, this.physicsWorld = physicsWorld;
+    let stepWorld = runtime.symbols[ENGINE_AI_WORLD_STEP];
+    this.stepWorld = typeof stepWorld == "function" ? stepWorld : null;
+  }
+  buffer() {
+    return this.runtime.memory.buffer;
+  }
+  alloc(bytes, align) {
+    return this.runtime.exports.engine_alloc(bytes, align);
+  }
+  free(pointer, bytes, align) {
+    this.runtime.exports.engine_free(pointer, bytes, align);
+  }
+  step(ai) {
+    let world = this.physicsWorld();
+    return this.stepWorld !== null && world !== (0) ? this.stepWorld(ai, world) : this.exports.engine_ai_step(ai);
+  }
+};
+function engineAi(runtime, physicsWorld = () => (0)) {
+  let exports = engineAiExports(runtime.symbols);
+  return exports ? new EngineAiPort(runtime, exports, physicsWorld) : null;
+}
+
+// src/game/backends/engine/nav.ts
+var ENGINE_NAV_EXPORT_NAMES = [
+  "engine_nav_create",
+  "engine_nav_destroy",
+  "engine_nav_registers",
+  "engine_nav_costs",
+  "engine_nav_include",
+  "engine_nav_add_tile",
+  "engine_nav_remove_tile",
+  "engine_nav_nearest",
+  "engine_nav_find_path",
+  "engine_nav_agents",
+  "engine_nav_agent_add",
+  "engine_nav_agent_remove",
+  "engine_nav_agent_target",
+  "engine_nav_agent_stop",
+  "engine_nav_step",
+  "engine_nav_roads",
+  "engine_nav_vehicles",
+  "engine_nav_vehicle_add",
+  "engine_nav_vehicle_remove",
+  "engine_nav_vehicle_external",
+  "engine_nav_signal",
+  "engine_nav_add_link",
+  "engine_nav_remove_link"
+], NO_POINTER = 0, EMPTY = new Float32Array(0), ERROR_MESSAGES = ["", "capacity exceeded", "dead entity", "unknown resource", "invalid argument", "unsupported"], DRIVER_WORDS = 6;
+function engineNavExports(symbols) {
+  for (let name of ENGINE_NAV_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+var EngineNav = class {
+  constructor(runtime, exports) {
+    this.name = "cimplify-engine-nav";
+    this.handle = (0);
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.costs = new Float32Array(0);
+    this.agentView = EMPTY;
+    this.vehicleView = EMPTY;
+    this.maxAgents = 0;
+    this.maxVehicles = 0;
+    this.scratch = (0);
+    this.scratchBytes = 0;
+    this.complete = false;
+    this.runtime = runtime, this.exports = exports;
+  }
+  get pathComplete() {
+    return this.complete;
+  }
+  batchHandle() {
+    return this.handle;
+  }
+  check(code, what) {
+    if (code < 0) {
+      let kind = -code === 1 ? "capacity_exceeded" : -code === 3 ? "unknown_resource" : -code === 5 ? "unsupported_feature" : "invalid_argument";
+      throw new GameError(kind, `${what}: ${ERROR_MESSAGES[-code] ?? "failed"}`);
+    }
+    return code;
+  }
+  require() {
+    if (this.handle === (0)) throw new GameError("not_initialized", "navigation is not initialised");
+    return this.handle;
+  }
+  alloc(bytes) {
+    if (bytes <= this.scratchBytes) return this.scratch;
+    if (this.scratch !== (0) && this.runtime.exports.engine_free(this.scratch, this.scratchBytes, WORD_BYTES), this.scratch = this.runtime.exports.engine_alloc(bytes, WORD_BYTES), this.scratch === (0)) throw new GameError("capacity_exceeded", "engine memory is full");
+    return this.scratchBytes = bytes, this.scratch;
+  }
+  init(desc) {
+    let pointer = this.alloc(16 * WORD_BYTES), buffer = this.runtime.memory.buffer, words = new Uint32Array(buffer, pointer, 16), floats = new Float32Array(buffer, pointer, 16);
+    words.fill(0);
+    let origin = desc.origin ?? [0, 0], extents = desc.extents ?? DEFAULT_EXTENTS;
+    floats[0] = origin[0], floats[1] = origin[1], floats[2] = desc.tileWorld, words[3] = desc.maxTiles ?? 256, words[4] = desc.queryNodes ?? 2048, this.maxAgents = desc.maxAgents ?? 512, words[5] = this.maxAgents, floats[6] = desc.neighbourDistance ?? 4, floats[7] = desc.timeHorizon ?? 2, words[8] = desc.pathBudget ?? 16, words[9] = desc.maxPathPolys ?? 256;
+    for (let k = 0; k < 3; k++) floats[10 + k] = extents[k];
+    if (this.handle = this.exports.engine_nav_create(pointer), this.handle === (0)) throw new GameError("invalid_argument", "navigation could not be created");
+    let registers = this.exports.engine_nav_registers(this.handle);
+    this.words = new Uint32Array(buffer, registers, 32), this.floats = new Float32Array(buffer, registers, 32);
+    for (let k = 0; k < 3; k++) this.floats[6 + k] = extents[k];
+    this.costs = new Float32Array(buffer, this.exports.engine_nav_costs(this.handle), 64), this.agentView = new Float32Array(buffer, this.exports.engine_nav_agents(this.handle), this.maxAgents * 8);
+  }
+  addTile(bytes) {
+    let handle = this.require(), pointer = this.alloc(bytes.byteLength);
+    return new Uint8Array(this.runtime.memory.buffer, pointer, bytes.byteLength).set(bytes), this.check(this.exports.engine_nav_add_tile(handle, pointer, bytes.byteLength), "add tile");
+  }
+  removeTile(x, z) {
+    this.check(this.exports.engine_nav_remove_tile(this.require(), x, z), "remove tile");
+  }
+  addLink(start, end, radius, bidirectional, area, user) {
+    let handle = this.require(), f = this.floats;
+    for (let k = 0; k < 3; k++)
+      f[0 + k] = start[k], f[3 + k] = end[k];
+    return f[29] = radius, this.words[30] = (bidirectional ? 1 : 0) | area << 8, this.words[31] = user >>> 0, this.check(this.exports.engine_nav_add_link(handle), "add link");
+  }
+  removeLink(link) {
+    this.check(this.exports.engine_nav_remove_link(this.require(), link), "remove link");
+  }
+  setAreaCost(area, cost) {
+    this.require(), this.costs[area] = cost;
+  }
+  setIncludeMask(low, high) {
+    let handle = this.require();
+    this.words[27] = low, this.words[28] = high, this.check(this.exports.engine_nav_include(handle), "include mask");
+  }
+  nearest(x, y, z, out) {
+    let handle = this.require(), f = this.floats;
+    return f[0] = x, f[1] = y, f[2] = z, this.check(this.exports.engine_nav_nearest(handle), "nearest") === 0 ? false : (out[0] = f[10], out[1] = f[11], out[2] = f[12], true);
+  }
+  findPath(sx, sy, sz, ex, ey, ez, out) {
+    let handle = this.require(), f = this.floats;
+    f[0] = sx, f[1] = sy, f[2] = sz, f[3] = ex, f[4] = ey, f[5] = ez;
+    let maxPoints = Math.max(Math.floor(out.length / 3), 1), pointer = this.alloc(maxPoints * 3 * WORD_BYTES), code = this.exports.engine_nav_find_path(handle, pointer, maxPoints);
+    return code < 0 ? (this.complete = false, 0) : (out.set(new Float32Array(this.runtime.memory.buffer, pointer, code * 3)), this.complete = this.words[13] === 1, code);
+  }
+  addAgent(x, y, z, radius, speed, accel) {
+    let handle = this.require(), f = this.floats;
+    return f[0] = x, f[1] = y, f[2] = z, f[15] = radius, f[16] = speed, f[17] = accel, this.check(this.exports.engine_nav_agent_add(handle), "add agent");
+  }
+  removeAgent(agent) {
+    this.check(this.exports.engine_nav_agent_remove(this.require(), agent), "remove agent");
+  }
+  setAgentTarget(agent, x, y, z) {
+    let handle = this.require(), f = this.floats;
+    f[3] = x, f[4] = y, f[5] = z, this.check(this.exports.engine_nav_agent_target(handle, agent), "agent target");
+  }
+  stopAgent(agent) {
+    this.check(this.exports.engine_nav_agent_stop(this.require(), agent), "stop agent");
+  }
+  agents() {
+    return this.agentView;
+  }
+  loadRoads(words) {
+    let handle = this.require(), pointer = this.alloc(words.byteLength);
+    new Uint32Array(this.runtime.memory.buffer, pointer, words.length).set(words), this.check(this.exports.engine_nav_roads(handle, pointer, words.length), "load roads"), this.maxVehicles = words[5];
+    let padded = Math.ceil(this.maxVehicles / 4) * 4;
+    this.vehicleView = new Float32Array(this.runtime.memory.buffer, this.exports.engine_nav_vehicles(handle), padded * 8);
+  }
+  addVehicle(lane, position, speed, driver) {
+    let handle = this.require(), f = this.floats;
+    f[18] = position, f[19] = speed;
+    for (let k = 0; k < (6); k++) f[20 + k] = driver[k];
+    return this.check(this.exports.engine_nav_vehicle_add(handle, lane), "add vehicle");
+  }
+  removeVehicle(vehicle) {
+    this.check(this.exports.engine_nav_vehicle_remove(this.require(), vehicle), "remove vehicle");
+  }
+  setExternalVehicle(vehicle, lane, position, speed) {
+    let handle = this.require();
+    this.floats[18] = position, this.floats[19] = speed, this.check(this.exports.engine_nav_vehicle_external(handle, vehicle, lane), "external vehicle");
+  }
+  vehicles() {
+    return this.vehicleView;
+  }
+  signal(lane) {
+    return this.check(this.exports.engine_nav_signal(this.require(), lane), "signal");
+  }
+  step(dt) {
+    let handle = this.require();
+    this.floats[14] = dt, this.check(this.exports.engine_nav_step(handle), "nav step");
+  }
+  dispose() {
+    this.handle !== (0) && this.exports.engine_nav_destroy(this.handle), this.scratch !== (0) && this.runtime.exports.engine_free(this.scratch, this.scratchBytes, WORD_BYTES), this.handle = (0), this.scratch = (0), this.scratchBytes = 0;
+  }
+};
+
+// src/game/backends/engine/craft.ts
+var ENGINE_CRAFT_NAME = "engine-craft", CRAFT_EXPORTS = [
+  "engine_craft_create",
+  "engine_craft_destroy",
+  "engine_craft_registers",
+  "engine_craft_controls",
+  "engine_craft_telemetry",
+  "engine_craft_set_water",
+  "engine_craft_set_flow",
+  "engine_craft_sea",
+  "engine_craft_custom",
+  "engine_craft_spin_up",
+  "engine_craft_remove",
+  "engine_craft_step",
+  "engine_water_sample",
+  "engine_alloc",
+  "engine_free"
+], MILLIMETRES = 1e3, OCEAN_SIZE = 113, OCEAN_PATCH = 114, OCEAN_WIND = 115, OCEAN_AMPLITUDE = 117, OCEAN_CHOPPINESS = 118, OCEAN_SMALL_WAVE = 119, OCEAN_SEED = 120, OCEAN_EVERY = 121, POINT_X = 122, POINT_Z = 123, POINT_AMOUNT = 124, DEFAULT_OCEAN_SIZE = 64, DEFAULT_OCEAN_PATCH = 64, DEFAULT_OCEAN_AMPLITUDE = 2e-4, DEFAULT_OCEAN_CHOPPINESS = 1.2, DEFAULT_OCEAN_SMALL_WAVE = 0.05, NO_RENDER = 0, DEFAULT_RIPPLE_SIZE = 128, DEFAULT_RIPPLE_CELL = 0.25, DEFAULT_RIPPLE_SPEED = 1.5, NO_RIPPLES = 0, NO_PUDDLES = 0, DEFAULT_PUDDLE_DEPTH = 0.5, REGISTER_WORDS2 = 128, WATER_LEVEL = 0, WATER_DEPTH = 1, WATER_GRAVITY = 2, WATER_DENSITY = 3, WATER_CURRENT = 4, WATER_WIND = 6, WATER_GUST = 8, WATER_GUST_PERIOD = 9, WATER_ITERATIONS = 10, WATER_WAVE_COUNT = 11, WATER_WAVES = 12, WAVE_WORDS = 6, DEFAULT_GRAVITY = 9.81, DEFAULT_DENSITY = 1025, DEFAULT_ITERATIONS = 2, NO_HANDLE2 = 0, FLOAT_BYTES = 4, SAMPLE_CAPACITY = 1024, CASCADE_DESC_FLOATS = 21, CASCADE_SEED_LOW = 19, CASCADE_SEED_HIGH = 20, SEED_HIGH = 2 ** 32, DEFAULT_PHYSICS_SIZE = 64, DEFAULT_CASCADES = {
+  size: 256,
+  count: 4,
+  patches: [256, 64, 16, 4],
+  windSpeed: 10,
+  windDirection: 0,
+  fetch: 1e5,
+  peakEnhancement: 3.3,
+  swell: 0,
+  depth: Number.POSITIVE_INFINITY,
+  shortWaves: 0.01,
+  scale: 1,
+  choppiness: 1,
+  gravity: 9.81,
+  seed: 1
+}, DEFAULT_FOAM = { threshold: 0.7, gain: 4, decaySeconds: 2.5 };
+function packCascades(desc) {
+  let out = new Float32Array((21)), bits = new Uint32Array(out.buffer);
+  if (desc === null) return out;
+  let d = { ...DEFAULT_CASCADES, ...desc }, foam = { ...DEFAULT_FOAM, ...desc.foam };
+  out.set([d.size, d.count, ...d.patches, d.windSpeed, d.windDirection, d.fetch, d.peakEnhancement, d.swell, d.depth, d.shortWaves, d.scale, d.choppiness, foam.threshold, foam.gain, foam.decaySeconds, d.gravity]);
+  let seed = Math.max(0, Math.floor(d.seed));
+  return bits[(19)] = seed % SEED_HIGH, bits[(20)] = Math.floor(seed / SEED_HIGH), out;
+}
+function hasCraft(symbols) {
+  return CRAFT_EXPORTS.every((name) => typeof symbols[name] == "function");
+}
+function engineCraft(session) {
+  return hasCraft(session.symbols) ? new EngineCraft(session, session.symbols) : null;
+}
+var EngineCraft = class {
+  constructor(session, symbols, capacity = 64) {
+    this.name = ENGINE_CRAFT_NAME;
+    this.handle = (0);
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.controlTable = new Float32Array(0);
+    this.telemetryTable = new Float32Array(0);
+    this.points = 0;
+    this.samples = 0;
+    this.render = () => (0);
+    this.pointView = new Float32Array(0);
+    this.sampleView = new Float32Array(0);
+    if (!hasCraft(symbols)) throw new GameError("unsupported_feature", "this engine build has no craft simulation");
+    this.session = session, this.exports = symbols, this.capacity = capacity;
+  }
+  configureWater(desc) {
+    this.open();
+    let w = this.words, f = this.floats, waves = desc.waves ?? [];
+    if (waves.length > MAX_WAVES) throw new GameError("invalid_argument", "too many waves");
+    f[(0)] = desc.level ?? 0, f[(1)] = desc.depth ?? Number.POSITIVE_INFINITY, f[(2)] = desc.gravity ?? (9.81), f[(3)] = desc.density ?? (1025), f[(4)] = desc.current?.[0] ?? 0, f[(4) + 1] = desc.current?.[1] ?? 0, f[(6)] = desc.wind?.[0] ?? 0, f[(6) + 1] = desc.wind?.[1] ?? 0, f[(8)] = desc.gust ?? 0, f[(9)] = desc.gustPeriod ?? 0, w[(10)] = desc.iterations ?? (2), w[(11)] = waves.length, waves.forEach((wave, i) => {
+      let o = (12) + i * (6);
+      f[o] = wave.direction[0], f[o + 1] = wave.direction[1], f[o + 2] = wave.wavelength, f[o + 3] = wave.amplitude, f[o + 4] = wave.steepness, f[o + 5] = wave.phase;
+    }), this.session.check(this.exports.engine_craft_set_water(this.handle), "configure water");
+  }
+  sea(state, windRadians, seed) {
+    this.open(), this.session.check(this.exports.engine_craft_sea(this.handle, SEA_STATES.indexOf(state), windRadians, seed >>> 0), "sea state");
+  }
+  setFlow(flow) {
+    this.open();
+    let f = this.floats;
+    f[(0)] = flow.level, f[(4)] = flow.current[0], f[(4) + 1] = flow.current[1], f[(6)] = flow.wind[0], f[(6) + 1] = flow.wind[1], f[(8)] = flow.gust, f[(9)] = flow.gustPeriod, this.session.check(this.exports.engine_craft_set_flow(this.handle), "water flow");
+  }
+  createCraft(_entity, body, collider, words, running) {
+    this.open();
+    let bytes = words.length * (4), pointer = this.exports.engine_alloc(bytes, (4));
+    if (pointer === 0) throw new GameError("capacity_exceeded", "craft description could not be staged");
+    try {
+      new Float32Array(this.session.buffer, pointer, words.length).set(words);
+      let id = this.session.check(
+        this.exports.engine_craft_custom(this.handle, body, collider >>> 0, pointer, words.length),
+        "create craft"
+      );
+      return running && this.session.check(this.exports.engine_craft_spin_up(this.handle, id), "spin up craft"), id;
+    } finally {
+      this.exports.engine_free(pointer, bytes, (4));
+    }
+  }
+  removeCraft(craft) {
+    this.open(), this.session.check(this.exports.engine_craft_remove(this.handle, craft), "remove craft");
+  }
+  controls() {
+    return this.open(), this.controlTable;
+  }
+  telemetry() {
+    return this.open(), this.telemetryTable;
+  }
+  setOcean(desc) {
+    let ocean = this.exports.engine_craft_ocean;
+    if (!ocean) throw new GameError("unsupported_feature", "this engine build has no ocean simulation");
+    this.open();
+    let w = this.words, f = this.floats;
+    w[(113)] = desc ? desc.size ?? (64) : 0, f[(114)] = desc?.patch ?? (64), f[(115)] = desc?.wind?.[0] ?? f[(6)], f[(115) + 1] = desc?.wind?.[1] ?? f[(6) + 1], f[(117)] = desc?.amplitude ?? (2e-4), f[(118)] = desc?.choppiness ?? (1.2), f[(119)] = desc?.smallWave ?? (0.05), w[(120)] = (desc?.seed ?? 1) >>> 0, w[(121)] = Math.max(1, desc?.updateEvery ?? 1), this.session.check(ocean(this.handle), "configure ocean");
+  }
+  setRipples(desc) {
+    let ripples = this.exports.engine_craft_ripples;
+    if (!ripples) throw new GameError("unsupported_feature", "this engine build has no ripples");
+    this.open();
+    let size = desc ? desc.size ?? (128) : (0), cell = desc?.cell ?? (0.25), speed = desc?.speed ?? (1.5);
+    this.session.check(ripples(this.handle, size, cell, speed), "configure ripples");
+  }
+  setCascades(desc) {
+    let cascades = this.exports.engine_craft_cascades;
+    if (!cascades) throw new GameError("unsupported_feature", "this engine build has no FFT ocean");
+    let render = this.render();
+    if (render === (0)) throw new GameError("invalid_argument", "the FFT ocean needs a render world to draw it");
+    this.open();
+    let words = packCascades(desc), pointer = this.exports.engine_alloc(words.byteLength, (4));
+    if (pointer === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold the ocean desc");
+    try {
+      new Float32Array(this.session.buffer, pointer, (21)).set(words);
+      let size = desc?.physicsSize ?? (64);
+      this.session.check(cascades(this.handle, render, pointer, size), "FFT ocean");
+    } finally {
+      this.exports.engine_free(pointer, words.byteLength, (4));
+    }
+  }
+  setPuddles(desc) {
+    let puddles = this.exports.engine_craft_puddles;
+    if (!puddles) throw new GameError("unsupported_feature", "this engine build has no puddles");
+    this.open();
+    let width = desc ? desc.width : (0);
+    this.session.check(
+      puddles(this.handle, desc?.origin[0] ?? 0, desc?.origin[1] ?? 0, desc?.cell ?? 0, width, desc?.height ?? 0, desc?.maxDepth ?? (0.5)),
+      "configure puddles"
+    );
+  }
+  setPuddleBed(heights) {
+    let bed = this.exports.engine_craft_puddles_bed;
+    if (!bed || this.handle === (0)) return;
+    let bytes = Math.max(heights.byteLength, (4)), pointer = this.exports.engine_alloc(bytes, (4));
+    if (pointer === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold the puddle bed");
+    try {
+      new Float32Array(this.session.buffer, pointer, heights.length).set(heights), this.session.check(bed(this.handle, pointer, heights.length), "puddle bed");
+    } finally {
+      this.exports.engine_free(pointer, bytes, (4));
+    }
+  }
+  pourPuddles(x, z, volume) {
+    let pour = this.exports.engine_craft_puddles_pour;
+    pour && this.handle !== (0) && (this.point(x, z, volume), this.session.check(pour(this.handle), "pour"));
+  }
+  /** Per-frame water calls pass integers only: the point goes through the registers. */
+  point(x, z, amount) {
+    let f = this.floats;
+    f[(122)] = x, f[(123)] = z, f[(124)] = amount;
+  }
+  puddleWeather(rain, evaporation) {
+    let weather = this.exports.engine_craft_puddles_weather;
+    weather && this.handle !== (0) && this.session.check(weather(this.handle, rain, evaporation), "puddle weather");
+  }
+  followRipples(x, z) {
+    let follow = this.exports.engine_craft_ripples_follow;
+    follow && this.handle !== (0) && (this.point(x, z, 0), this.session.check(follow(this.handle), "follow ripples"));
+  }
+  pushRipples(x, z, amount) {
+    let push = this.exports.engine_craft_ripples_push;
+    push && this.handle !== (0) && (this.point(x, z, amount), this.session.check(push(this.handle), "push ripples"));
+  }
+  bindRender(source) {
+    this.render = source;
+  }
+  step() {
+    if (this.handle === (0) || this.session.world === 0) return;
+    this.session.check(this.exports.engine_craft_step(this.handle, this.session.world), "craft step");
+    let handoff = this.exports.engine_craft_render_water, render = this.render();
+    handoff && render !== (0) && this.session.check(handoff(this.handle, render), "render water");
+  }
+  sampleWater(points, count, out) {
+    this.open();
+    let buffer = this.session.buffer;
+    this.pointView.buffer !== buffer && (this.pointView = new Float32Array(buffer, this.points, (1024) * 2), this.sampleView = new Float32Array(buffer, this.samples, (1024) * WATER_SAMPLE_WORDS));
+    for (let start = 0; start < count; start += (1024)) {
+      let n = Math.min((1024), count - start);
+      for (let i = 0; i < n * 2; i++) this.pointView[i] = points[start * 2 + i];
+      this.session.check(this.exports.engine_water_sample(this.handle, this.points, n, this.samples), "water sample");
+      let base = start * WATER_SAMPLE_WORDS;
+      for (let i = 0; i < n * WATER_SAMPLE_WORDS; i++) out[base + i] = this.sampleView[i];
+    }
+  }
+  floatsIn(values) {
+    let pointer = this.exports.engine_alloc(Math.max(values.byteLength, (4)), (4));
+    if (pointer === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold the crumple data");
+    return new Float32Array(this.session.buffer, pointer, values.length).set(values), pointer;
+  }
+  crumpleExport(name) {
+    let found = this.exports[name];
+    if (!found) throw new GameError("unsupported_feature", `this engine build has no vehicle crumple (feature ${SOFT_BODY_FEATURE})`);
+    return found;
+  }
+  crumple(craft, vertices, desc) {
+    let create = this.crumpleExport("engine_craft_crumple");
+    this.open();
+    let points = this.floatsIn(vertices), words = desc === null ? 0 : this.floatsIn(desc);
+    try {
+      this.session.check(create(this.handle, craft, words, points, vertices.length / 3), "crumple cage");
+    } finally {
+      this.exports.engine_free(points, Math.max(vertices.byteLength, (4)), (4)), desc !== null && this.exports.engine_free(words, Math.max(desc.byteLength, (4)), (4));
+    }
+  }
+  impact(craft, point, severity) {
+    let impact = this.crumpleExport("engine_craft_impact");
+    this.open();
+    let words = this.floatsIn(new Float32Array([...point, ...severity]));
+    try {
+      return this.session.check(impact(this.handle, craft, words), "impact") === 1;
+    } finally {
+      this.exports.engine_free(words, CRUMPLE_IMPACT_FLOATS * (4), (4));
+    }
+  }
+  damage(craft) {
+    if (this.handle === (0)) return 0;
+    let mm = this.crumpleExport("engine_craft_damage")(this.handle, craft);
+    return mm >= 0 ? mm / (1e3) : 0;
+  }
+  presentCrumple(craft, geometry) {
+    let render = this.render();
+    if (this.handle === (0) || render === (0)) return 0;
+    let written = this.crumpleExport("engine_craft_crumple_present")(this.handle, craft, render, geometry);
+    return written >= 0 ? written : 0;
+  }
+  dispose() {
+    this.handle !== (0) && (this.exports.engine_craft_destroy(this.handle), this.exports.engine_free(this.points, (1024) * 2 * (4), (4)), this.exports.engine_free(this.samples, (1024) * WATER_SAMPLE_WORDS * (4), (4)), this.handle = (0));
+  }
+  open() {
+    if (this.handle !== (0)) return;
+    let handle = this.exports.engine_craft_create(this.capacity);
+    if (handle === (0)) throw new GameError("capacity_exceeded", "craft world could not be created");
+    this.handle = handle;
+    let buffer = this.session.buffer, registers = this.exports.engine_craft_registers(handle);
+    if (this.words = new Uint32Array(buffer, registers, (128)), this.floats = new Float32Array(buffer, registers, (128)), this.controlTable = new Float32Array(buffer, this.exports.engine_craft_controls(handle), this.capacity * 16), this.telemetryTable = new Float32Array(buffer, this.exports.engine_craft_telemetry(handle), this.capacity * 16), this.points = this.exports.engine_alloc((1024) * 2 * (4), (4)), this.samples = this.exports.engine_alloc((1024) * WATER_SAMPLE_WORDS * (4), (4)), this.points === 0 || this.samples === 0) throw new GameError("capacity_exceeded", "water sample buffers could not be allocated");
+  }
+};
+
+// src/game/backends/engine/vehicles.ts
+var ENGINE_VEHICLE_EXPORT_NAMES = [
+  "engine_vehicle_reserve",
+  "engine_vehicle_create",
+  "engine_vehicle_destroy",
+  "engine_vehicle_capacity",
+  "engine_vehicle_inputs",
+  "engine_vehicle_states"
+], NO_POINTER2 = 0, EMPTY2 = new Float32Array(0);
+function engineVehicleExports(symbols) {
+  for (let name of ENGINE_VEHICLE_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+var EngineVehicles = class {
+  constructor(session, exports) {
+    this.desc = (0);
+    this.inputs = EMPTY2;
+    this.states = EMPTY2;
+    this.session = session, this.exports = exports;
+  }
+  createVehicle(body, desc) {
+    let s = this.session;
+    s.flush();
+    let world = s.require();
+    if (this.desc === (0) && (this.desc = s.exports.engine_alloc(VEHICLE_DESC_WORDS * WORD_BYTES, WORD_BYTES), this.desc === (0)))
+      throw new GameError("capacity_exceeded", "engine memory cannot hold a vehicle descriptor");
+    new Float32Array(s.buffer, this.desc, VEHICLE_DESC_WORDS).set(desc.subarray(0, VEHICLE_DESC_WORDS));
+    let id = s.check(this.exports.engine_vehicle_create(world, body, this.desc, VEHICLE_DESC_WORDS), "create vehicle");
+    return this.bindViews(world), id;
+  }
+  destroyVehicle(vehicle) {
+    let s = this.session;
+    s.flush(), s.check(this.exports.engine_vehicle_destroy(s.require(), vehicle), "destroy vehicle");
+  }
+  vehicleInputs() {
+    return this.inputs;
+  }
+  vehicleStates() {
+    return this.states;
+  }
+  bindViews(world) {
+    let capacity = this.exports.engine_vehicle_capacity(world), inputs = this.exports.engine_vehicle_inputs(world), states = this.exports.engine_vehicle_states(world);
+    if (inputs === (0) || states === (0)) throw new GameError("not_initialized", "engine vehicles are not reserved");
+    let buffer = this.session.buffer;
+    (this.inputs.byteOffset !== inputs || this.inputs.buffer !== buffer) && (this.inputs = new Float32Array(buffer, inputs, capacity * INPUT_STRIDE), this.states = new Float32Array(buffer, states, capacity * STATE_STRIDE));
+  }
+};
+
+// src/game/backends/engine/physics.ts
+var ENGINE_PHYSICS_NAME = "cimplify-engine", COLLISION_GROUP_BITS = 65535, DEGREES_TO_RADIANS = Math.PI / 180, DEFAULT_CONTROLLER_OFFSET = 0.01, ORIGIN = [0, 0, 0], IDENTITY_ROTATION = [0, 0, 0, 1], ALL_AXES = [true, true, true], NO_AXES = [false, false, false], PLANAR_TRANSLATIONS = [true, true, false], PLANAR_ROTATIONS = [false, false, true], NO_POINTER3 = 0, NO_VALUE = Number.NaN;
+function axisBits(axes, shift) {
+  return ((axes[0] ? 1 : 0) | (axes[1] ? 2 : 0) | (axes[2] ? 4 : 0)) << shift;
+}
+function shapeCode(shape) {
+  switch (shape.kind) {
+    case "ball":
+      return SHAPE_BALL;
+    case "cuboid":
+      return SHAPE_CUBOID;
+    case "capsule":
+      return SHAPE_CAPSULE;
+    case "cylinder":
+      return SHAPE_CYLINDER;
+    case "cone":
+      return SHAPE_CONE;
+    case "trimesh":
+      return SHAPE_TRIMESH;
+    case "convex_hull":
+      return SHAPE_CONVEX_HULL;
+    case "heightfield":
+      return SHAPE_HEIGHTFIELD;
+    case "round_cuboid":
+      return SHAPE_ROUND_CUBOID;
+    case "round_cylinder":
+      return SHAPE_ROUND_CYLINDER;
+    case "round_cone":
+      return SHAPE_ROUND_CONE;
+    case "round_convex_hull":
+      return SHAPE_ROUND_CONVEX_HULL;
+    case "compound":
+      return SHAPE_COMPOUND;
+  }
+}
+function writePrimitive(shape, floats, params, border) {
+  switch (shape.kind) {
+    case "ball":
+      floats[params] = shape.radius;
+      break;
+    case "cuboid":
+    case "round_cuboid":
+      floats[params] = shape.halfExtents[0], floats[params + 1] = shape.halfExtents[1], floats[params + 2] = shape.halfExtents[2];
+      break;
+    case "capsule":
+    case "cylinder":
+    case "cone":
+    case "round_cylinder":
+    case "round_cone":
+      floats[params] = shape.halfHeight, floats[params + 1] = shape.radius;
+      break;
+  }
+  (shape.kind === "round_cuboid" || shape.kind === "round_cylinder" || shape.kind === "round_cone") && (floats[border] = shape.border);
+}
+function compoundFloats(parts) {
+  let out = new Float32Array(parts.length * PART_FLOATS);
+  for (let i = 0; i < parts.length; i++) {
+    let part = parts[i], at = i * PART_FLOATS;
+    out[at + PART_SHAPE] = shapeCode(part.shape), writePrimitive(part.shape, out, at + PART_PARAMS, at + PART_BORDER);
+    let offset = part.offset ?? ORIGIN, rotation = part.rotation ?? IDENTITY_ROTATION;
+    for (let k = 0; k < 3; k++) out[at + PART_OFFSET + k] = offset[k];
+    for (let k = 0; k < 4; k++) out[at + PART_ROTATION + k] = rotation[k];
+  }
+  return out;
+}
+var LOCKED_AXES = ["locked", "locked", "locked"], LIMIT_PAIR = 2, SIX_DOF_AXES = 6, QUATERNION = 4;
+function encodeSixDof(desc, words, floats) {
+  let frameA = desc.frameA ?? IDENTITY_ROTATION, frameB = desc.frameB ?? IDENTITY_ROTATION;
+  for (let k = 0; k < (4); k++)
+    floats[JOINT_FRAME_A + k] = frameA[k], floats[JOINT_FRAME_B + k] = frameB[k];
+  let axes = [...desc.linear ?? LOCKED_AXES, ...desc.angular ?? LOCKED_AXES];
+  if (axes.length !== (6)) throw new GameError("invalid_argument", "a six_dof joint has three linear and three angular axes");
+  let motions = 0;
+  for (let axis = 0; axis < (6); axis++) {
+    let motion = axes[axis], code = MOTION_LOCKED;
+    motion === "free" ? code = MOTION_FREE : motion !== "locked" && (code = MOTION_LIMITED, floats[JOINT_AXIS_LIMITS + axis * (2)] = motion[0], floats[JOINT_AXIS_LIMITS + axis * (2) + 1] = motion[1]), motions |= code << axis * MOTION_BITS;
+  }
+  words[JOINT_MOTIONS] = motions >>> 0, floats[JOINT_SWING_CONE] = desc.swingCone ?? NO_VALUE;
+}
+var EnginePhysics = class {
+  constructor(session) {
+    this.name = ENGINE_PHYSICS_NAME;
+    this.session = session;
+    let exports = engineVehicleExports(session.symbols);
+    this.vehicles = exports ? new EngineVehicles(session, exports) : null, this.craft = engineCraft(session), this.jointPort = engineJoints(session);
+  }
+  bindTransforms(columns) {
+    this.session.bind(columns);
+  }
+  init(desc) {
+    return this.session.open(desc), Promise.resolve();
+  }
+  get rollback() {
+    return this.session.snapshots;
+  }
+  setGravity(gravity) {
+    this.vectorCommand(OP_SET_GRAVITY, 0, gravity);
+  }
+  createBody(entity, desc) {
+    let s = this.session;
+    s.flush();
+    let words = s.descWords, floats = s.descFloats;
+    words[BODY_KIND] = desc.kind === "dynamic" ? BODY_KIND_DYNAMIC : desc.kind === "kinematic" ? BODY_KIND_KINEMATIC : BODY_KIND_FIXED, floats[BODY_LINEAR_DAMPING] = desc.linearDamping ?? 0, floats[BODY_ANGULAR_DAMPING] = desc.angularDamping ?? 0, floats[BODY_GRAVITY_SCALE] = desc.gravityScale ?? 1;
+    let translations = desc.planar ? PLANAR_TRANSLATIONS : desc.lockTranslations ? NO_AXES : desc.enabledTranslations ?? ALL_AXES, rotations = desc.planar ? PLANAR_ROTATIONS : desc.lockRotations ? NO_AXES : desc.enabledRotations ?? ALL_AXES;
+    return words[BODY_FLAGS] = (desc.ccd ? BODY_FLAG_CCD : 0) | (desc.canSleep === false ? 0 : BODY_FLAG_CAN_SLEEP) | axisBits(translations, BODY_TRANSLATION_SHIFT) | axisBits(rotations, BODY_ROTATION_SHIFT), words[BODY_DOMINANCE] = desc.dominance ?? 0, s.check(s.exports.engine_body_create(s.require(), entity), "create body");
+  }
+  destroyBody(body) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_body_destroy(s.require(), body), "destroy body");
+  }
+  createCollider(body, desc) {
+    let s = this.session;
+    s.flush();
+    let words = s.descWords, floats = s.descFloats;
+    words.fill(0);
+    let shape = desc.shape;
+    words[COLLIDER_SHAPE] = shapeCode(shape);
+    let staged = [];
+    switch (shape.kind) {
+      case "ball":
+      case "cuboid":
+      case "capsule":
+      case "cylinder":
+      case "cone":
+      case "round_cuboid":
+      case "round_cylinder":
+      case "round_cone":
+        writePrimitive(shape, floats, COLLIDER_PARAMS, COLLIDER_BORDER);
+        break;
+      case "round_convex_hull":
+        this.stage(staged, shape.points, COLLIDER_DATA_A, COLLIDER_DATA_A_LEN), floats[COLLIDER_BORDER] = shape.border;
+        break;
+      case "compound":
+        this.stage(staged, compoundFloats(shape.parts), COLLIDER_DATA_A, COLLIDER_DATA_A_LEN);
+        break;
+      case "trimesh":
+        this.stage(staged, shape.vertices, COLLIDER_DATA_A, COLLIDER_DATA_A_LEN), this.stage(staged, shape.indices, COLLIDER_DATA_B, COLLIDER_DATA_B_LEN);
+        break;
+      case "convex_hull":
+        this.stage(staged, shape.points, COLLIDER_DATA_A, COLLIDER_DATA_A_LEN);
+        break;
+      case "heightfield":
+        this.stage(staged, shape.heights, COLLIDER_DATA_A, COLLIDER_DATA_A_LEN), words[COLLIDER_ROWS] = shape.rows, words[COLLIDER_COLUMNS] = shape.columns, floats[COLLIDER_PARAMS] = shape.scale[0], floats[COLLIDER_PARAMS + 1] = shape.scale[1], floats[COLLIDER_PARAMS + 2] = shape.scale[2];
+        break;
+    }
+    let offset = desc.offset ?? ORIGIN, rotation = desc.rotation ?? IDENTITY_ROTATION;
+    for (let k = 0; k < 3; k++) floats[COLLIDER_OFFSET + k] = offset[k];
+    for (let k = 0; k < 4; k++) floats[COLLIDER_ROTATION + k] = rotation[k];
+    floats[COLLIDER_DENSITY] = desc.density ?? NO_VALUE, floats[COLLIDER_MASS] = desc.mass ?? NO_VALUE, floats[COLLIDER_FRICTION] = desc.friction ?? NO_VALUE, floats[COLLIDER_RESTITUTION] = desc.restitution ?? NO_VALUE;
+    let grouped = desc.membership !== void 0 || desc.filter !== void 0;
+    words[COLLIDER_FLAGS] = (desc.sensor ? COLLIDER_FLAG_SENSOR : 0) | (desc.events ? COLLIDER_FLAG_EVENTS : 0) | (grouped ? COLLIDER_FLAG_GROUPS : 0), words[COLLIDER_MEMBERSHIP] = desc.membership ?? COLLISION_GROUP_ALL, words[COLLIDER_FILTER] = desc.filter ?? COLLISION_GROUP_ALL;
+    try {
+      return s.check(s.exports.engine_collider_create(s.require(), body), "create collider");
+    } finally {
+      for (let block of staged) s.exports.engine_free(block.pointer, block.bytes, WORD_BYTES);
+    }
+  }
+  destroyCollider(collider) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_collider_destroy(s.require(), collider), "destroy collider");
+  }
+  setColliderEnabled(collider, enabled) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_collider_enable(s.require(), collider, enabled ? 1 : 0), "enable collider");
+  }
+  createJoint(bodyA, bodyB, desc) {
+    let s = this.session;
+    s.flush();
+    let words = s.descWords, floats = s.descFloats;
+    words.fill(0);
+    for (let k = 0; k < 3; k++)
+      floats[JOINT_ANCHOR_A + k] = desc.anchorA[k], floats[JOINT_ANCHOR_B + k] = desc.anchorB[k];
+    switch (desc.kind) {
+      case "fixed":
+        words[JOINT_KIND] = JOINT_FIXED;
+        break;
+      case "spherical":
+        words[JOINT_KIND] = JOINT_SPHERICAL;
+        break;
+      case "revolute":
+      case "prismatic":
+        words[JOINT_KIND] = desc.kind === "revolute" ? JOINT_REVOLUTE : JOINT_PRISMATIC;
+        for (let k = 0; k < 3; k++) floats[JOINT_AXIS + k] = desc.axis[k];
+        desc.limits && (words[JOINT_HAS_LIMITS] = 1, floats[JOINT_LIMITS] = desc.limits[0], floats[JOINT_LIMITS + 1] = desc.limits[1]);
+        break;
+      case "rope":
+        words[JOINT_KIND] = JOINT_ROPE, floats[JOINT_LENGTH] = desc.length;
+        break;
+      case "spring":
+        words[JOINT_KIND] = JOINT_SPRING, floats[JOINT_LENGTH] = desc.restLength, floats[JOINT_STIFFNESS] = desc.stiffness, floats[JOINT_DAMPING] = desc.damping;
+        break;
+      case "cone":
+        words[JOINT_KIND] = JOINT_CONE;
+        for (let k = 0; k < 3; k++) floats[JOINT_AXIS + k] = desc.axis[k];
+        floats[JOINT_SWING] = desc.swing, floats[JOINT_LIMITS] = desc.twist[0], floats[JOINT_LIMITS + 1] = desc.twist[1];
+        break;
+      case "six_dof":
+        words[JOINT_KIND] = JOINT_SIX_DOF, encodeSixDof(desc, words, floats);
+        break;
+    }
+    return s.check(s.exports.engine_joint_create(s.require(), bodyA, bodyB), "create joint");
+  }
+  setJointMotor(joint, targetVelocity, maxForce) {
+    let s = this.session;
+    s.flush();
+    let world = s.require();
+    s.registerFloats[REGISTER_MOTOR_VELOCITY] = targetVelocity, s.registerFloats[REGISTER_MOTOR_MAX_FORCE] = maxForce, s.check(s.exports.engine_joint_motor(world, joint), "joint motor");
+  }
+  destroyJoint(joint) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_joint_destroy(s.require(), joint), "destroy joint");
+  }
+  step() {
+    this.session.step();
+  }
+  setBodyPose(body, positions, po, rotations, ro) {
+    let s = this.session, o = s.command(OP_SET_BODY_POSE, body), f = s.commandPayload;
+    f[o] = positions[po], f[o + 1] = positions[po + 1], f[o + 2] = positions[po + 2], f[o + 3] = rotations[ro], f[o + 4] = rotations[ro + 1], f[o + 5] = rotations[ro + 2], f[o + 6] = rotations[ro + 3];
+  }
+  linearVelocity(body, out) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_body_linear_velocity(s.require(), body), "linear velocity"), this.readVector(out);
+  }
+  angularVelocity(body, out) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_body_angular_velocity(s.require(), body), "angular velocity"), this.readVector(out);
+  }
+  setLinearVelocity(body, velocity) {
+    this.vectorCommand(OP_SET_LINEAR_VELOCITY, body, velocity);
+  }
+  setAngularVelocity(body, velocity) {
+    this.vectorCommand(OP_SET_ANGULAR_VELOCITY, body, velocity);
+  }
+  applyImpulse(body, impulse) {
+    this.vectorCommand(OP_APPLY_IMPULSE, body, impulse);
+  }
+  applyTorqueImpulse(body, impulse) {
+    this.vectorCommand(OP_APPLY_TORQUE_IMPULSE, body, impulse);
+  }
+  addForce(body, force) {
+    this.vectorCommand(OP_ADD_FORCE, body, force);
+  }
+  applyImpulseAtPoint(body, impulse, point) {
+    this.pointCommand(OP_APPLY_IMPULSE_AT_POINT, body, impulse, point);
+  }
+  addForceAtPoint(body, force, point) {
+    this.pointCommand(OP_ADD_FORCE_AT_POINT, body, force, point);
+  }
+  addTorque(body, torque) {
+    this.vectorCommand(OP_ADD_TORQUE, body, torque);
+  }
+  extra(name) {
+    let fn = this.session.symbols[name];
+    if (typeof fn != "function") throw new GameError("unsupported_feature", `${name} is not in this engine build`);
+    return fn;
+  }
+  velocityAtPoint(body, point, out) {
+    let s = this.session;
+    s.flush();
+    let floats = s.registerFloats;
+    floats[VECTOR_OUT] = point.x, floats[VECTOR_OUT + 1] = point.y, floats[VECTOR_OUT + 2] = point.z, s.check(this.extra("engine_body_velocity_at_point")(s.require(), body), "velocity at point"), this.readVector(out);
+  }
+  setJointMotorPosition(joint, target, stiffness, damping) {
+    let s = this.session;
+    s.flush();
+    let floats = s.registerFloats;
+    floats[MOTOR_TARGET] = target, floats[MOTOR_STIFFNESS] = stiffness, floats[MOTOR_DAMPING] = damping, s.check(this.extra("engine_joint_motor_position")(s.require(), joint), "joint motor position");
+  }
+  castShape(query, out) {
+    let s = this.session;
+    s.flush();
+    let words = s.registerWords, floats = s.registerFloats;
+    words[CAST_SHAPE] = castShapeCode(query.kind), floats[CAST_PARAMS] = query.params.x, floats[CAST_PARAMS + 1] = query.params.y, floats[CAST_PARAMS + 2] = query.params.z;
+    for (let k = 0; k < 4; k++) floats[CAST_ROTATION + k] = query.rotation[k];
+    floats[RAY_ORIGIN] = query.origin.x, floats[RAY_ORIGIN + 1] = query.origin.y, floats[RAY_ORIGIN + 2] = query.origin.z, floats[RAY_DIRECTION] = query.direction.x, floats[RAY_DIRECTION + 1] = query.direction.y, floats[RAY_DIRECTION + 2] = query.direction.z, floats[RAY_MAX] = query.maxDistance, words[RAY_INCLUDE_SENSORS] = query.includeSensors ? 1 : 0, words[RAY_EXCLUDE] = query.excludeBody < 0 ? NO_EXCLUDE : query.excludeBody;
+    let hit = s.check(this.extra("engine_shape_cast")(s.require()), "shape cast") === RAY_HIT;
+    return out.hit = hit, hit ? (out.collider = words[HIT_COLLIDER], out.distance = floats[HIT_DISTANCE], out.pointX = floats[HIT_POINT], out.pointY = floats[HIT_POINT + 1], out.pointZ = floats[HIT_POINT + 2], out.normalX = floats[HIT_NORMAL], out.normalY = floats[HIT_NORMAL + 1], out.normalZ = floats[HIT_NORMAL + 2], true) : (out.collider = -1, false);
+  }
+  overlapSphere(x, y, z, radius, includeSensors, out) {
+    let s = this.session;
+    s.flush();
+    let words = s.registerWords, floats = s.registerFloats;
+    floats[RAY_ORIGIN] = x, floats[RAY_ORIGIN + 1] = y, floats[RAY_ORIGIN + 2] = z, floats[RAY_MAX] = radius, words[RAY_INCLUDE_SENSORS] = includeSensors ? 1 : 0, out.count = s.check(this.extra("engine_overlap_sphere")(s.require()), "sphere overlap"), out.collider = out.count > 0 ? words[HIT_COLLIDER] : -1;
+  }
+  pointCommand(op, body, v, p) {
+    let s = this.session, o = s.command(op, body), f = s.commandPayload;
+    f[o] = v.x, f[o + 1] = v.y, f[o + 2] = v.z, f[o + 3] = p.x, f[o + 4] = p.y, f[o + 5] = p.z;
+  }
+  resetForces(body) {
+    this.session.command(OP_RESET_FORCES, body);
+  }
+  isSleeping(body) {
+    let s = this.session;
+    return s.flush(), s.check(s.exports.engine_body_sleeping(s.require(), body), "sleeping") === 1;
+  }
+  wake(body) {
+    this.session.command(OP_WAKE, body);
+  }
+  batchHandle() {
+    let s = this.session;
+    return s.flush(), s.require();
+  }
+  raycast(ray, out) {
+    let s = this.session;
+    s.flush();
+    let words = s.registerWords, floats = s.registerFloats;
+    floats[RAY_ORIGIN] = ray.origin.x, floats[RAY_ORIGIN + 1] = ray.origin.y, floats[RAY_ORIGIN + 2] = ray.origin.z, floats[RAY_DIRECTION] = ray.direction.x, floats[RAY_DIRECTION + 1] = ray.direction.y, floats[RAY_DIRECTION + 2] = ray.direction.z, floats[RAY_MAX] = ray.maxDistance, words[RAY_SOLID] = ray.solid ? 1 : 0, words[RAY_INCLUDE_SENSORS] = ray.includeSensors ? 1 : 0, words[RAY_EXCLUDE] = ray.excludeCollider < 0 ? NO_EXCLUDE : ray.excludeCollider;
+    let hit = s.check(s.exports.engine_raycast(s.require()), "raycast") === RAY_HIT;
+    return out.hit = hit, hit ? (out.collider = words[HIT_COLLIDER], out.distance = floats[HIT_DISTANCE], out.pointX = floats[HIT_POINT], out.pointY = floats[HIT_POINT + 1], out.pointZ = floats[HIT_POINT + 2], out.normalX = floats[HIT_NORMAL], out.normalY = floats[HIT_NORMAL + 1], out.normalZ = floats[HIT_NORMAL + 2], true) : (out.collider = -1, false);
+  }
+  contactCount() {
+    return this.session.contacts;
+  }
+  contactColliderA(index) {
+    return this.session.contactA[index];
+  }
+  contactColliderB(index) {
+    return this.session.contactB[index];
+  }
+  contactStarted(index) {
+    return this.session.contactBegan[index] === 1;
+  }
+  createCharacterController(desc) {
+    let s = this.session;
+    s.flush();
+    let words = s.descWords, floats = s.descFloats;
+    if (words.fill(0), floats[CONTROLLER_OFFSET] = desc.offset ?? (0.01), floats[CONTROLLER_MAX_SLOPE_CLIMB] = desc.maxSlopeClimbDegrees === void 0 ? NO_VALUE : desc.maxSlopeClimbDegrees * DEGREES_TO_RADIANS, floats[CONTROLLER_MIN_SLOPE_SLIDE] = desc.minSlopeSlideDegrees === void 0 ? NO_VALUE : desc.minSlopeSlideDegrees * DEGREES_TO_RADIANS, floats[CONTROLLER_AUTOSTEP_HEIGHT] = desc.autostepMaxHeight ?? NO_VALUE, floats[CONTROLLER_AUTOSTEP_WIDTH] = desc.autostepMinWidth ?? NO_VALUE, floats[CONTROLLER_SNAP] = desc.snapToGround ?? NO_VALUE, words[CONTROLLER_SLIDE] = desc.slide === void 0 ? CONTROLLER_SLIDE_UNSET : desc.slide ? 1 : 0, desc.up) {
+      words[CONTROLLER_HAS_UP] = 1;
+      for (let k = 0; k < 3; k++) floats[CONTROLLER_UP + k] = desc.up[k];
+    }
+    return s.check(s.exports.engine_controller_create(s.require()), "create controller");
+  }
+  moveCharacter(controller, collider, desired, out) {
+    let s = this.session;
+    s.flush();
+    let floats = s.registerFloats;
+    floats[VECTOR_OUT] = desired.x, floats[VECTOR_OUT + 1] = desired.y, floats[VECTOR_OUT + 2] = desired.z, s.check(s.exports.engine_character_move(s.require(), controller, collider), "move character"), out.x = floats[VECTOR_OUT], out.y = floats[VECTOR_OUT + 1], out.z = floats[VECTOR_OUT + 2], out.grounded = s.registerWords[GROUNDED_OUT] === 1;
+  }
+  destroyCharacterController(controller) {
+    let s = this.session;
+    s.flush(), s.check(s.exports.engine_controller_destroy(s.require(), controller), "destroy controller");
+  }
+  dispose() {
+    this.craft?.dispose(), this.session.close();
+  }
+  setColliderClass(collider, colliderClass) {
+    let s = this.session, o = s.command(OP_SET_COLLIDER_CLASS, collider);
+    s.commandPayloadWords[o] = checkColliderClass(colliderClass);
+  }
+  setContactRule(platform, other, rule) {
+    let s = this.session, o = s.command(OP_SET_CONTACT_RULE, packContactRuleHeader(platform, other, rule));
+    writeContactRulePayload(rule, s.commandPayload, o);
+  }
+  setCollisionGroups(collider, membership, filter) {
+    let s = this.session, o = s.command(OP_SET_COLLIDER_GROUPS, collider);
+    s.commandPayloadWords[o] = membership & (65535), s.commandPayloadWords[o + 1] = filter & (65535);
+  }
+  setSolver(iterations, pgsIterations, ccdSubsteps) {
+    let s = this.session, o = s.command(OP_SET_SOLVER, 0);
+    s.commandPayloadWords[o] = iterations, s.commandPayloadWords[o + 1] = pgsIterations, s.commandPayloadWords[o + 2] = ccdSubsteps;
+  }
+  setSoftCcd(body, distance) {
+    let s = this.session, o = s.command(OP_SET_BODY_SOFT_CCD, body);
+    s.commandPayload[o] = distance;
+  }
+  setSleepThresholds(body, linear2, angular, seconds) {
+    let s = this.session, o = s.command(OP_SET_BODY_SLEEP, body), f = s.commandPayload;
+    f[o] = linear2, f[o + 1] = angular, f[o + 2] = seconds;
+  }
+  vectorCommand(op, body, v) {
+    let s = this.session, o = s.command(op, body), f = s.commandPayload;
+    f[o] = v.x, f[o + 1] = v.y, f[o + 2] = v.z;
+  }
+  readVector(out) {
+    let floats = this.session.registerFloats;
+    out.x = floats[VECTOR_OUT], out.y = floats[VECTOR_OUT + 1], out.z = floats[VECTOR_OUT + 2];
+  }
+  stage(staged, data, pointerSlot, lengthSlot) {
+    let s = this.session, bytes = data.length * WORD_BYTES, pointer = s.exports.engine_alloc(bytes, WORD_BYTES);
+    if (pointer === (0)) throw new GameError("capacity_exceeded", "engine memory cannot hold collider data");
+    staged.push({ pointer, bytes }), new Uint8Array(s.buffer, pointer, bytes).set(new Uint8Array(data.buffer, data.byteOffset, bytes)), s.descWords[pointerSlot] = pointer, s.descWords[lengthSlot] = data.length;
+  }
+};
+
+// src/game/backends/engine/session.ts
+var NO_WORLD2 = 0, EMPTY_WORDS = new Uint32Array(0), EMPTY_FLOATS = new Float32Array(0), EMPTY_BYTES = new Uint8Array(0);
+function failure3(code, what) {
+  switch (code) {
+    case ERROR_CAPACITY_EXCEEDED:
+      return new GameError("capacity_exceeded", `${what}: capacity exceeded`);
+    case ERROR_DEAD_ENTITY:
+      return new GameError("dead_entity", `${what}: entity has no transform`);
+    case ERROR_UNKNOWN_RESOURCE:
+      return new GameError("unknown_resource", `${what}: unknown resource`);
+    case ERROR_UNSUPPORTED:
+      return new GameError("unsupported_feature", `${what}: unsupported`);
+    case ERROR_INVALID_ARGUMENT:
+    default:
+      return new GameError("invalid_argument", `${what}: invalid argument`);
+  }
+}
+var EngineSession = class {
+  constructor(runtime, memory) {
+    this.world = (0);
+    this.registerWords = EMPTY_WORDS;
+    this.registerFloats = EMPTY_FLOATS;
+    this.descWords = EMPTY_WORDS;
+    this.descFloats = EMPTY_FLOATS;
+    this.contactA = EMPTY_WORDS;
+    this.contactB = EMPTY_WORDS;
+    this.contactBegan = EMPTY_BYTES;
+    this.contacts = 0;
+    this.snapshots = null;
+    this.commandWords = EMPTY_WORDS;
+    this.commandFloats = EMPTY_FLOATS;
+    this.commandCapacity = 0;
+    this.pending = 0;
+    this.columns = null;
+    this.runtime = runtime, this.exports = runtime.exports, this.memory = memory;
+  }
+  bind(columns) {
+    for (let array of [columns.position, columns.rotation, columns.render, columns.parent, columns.entities, columns.sparse])
+      if (!this.memory.owns(array)) throw new GameError("invalid_argument", "engine transforms must live in engine memory");
+    this.columns = columns, this.world !== (0) && this.bindLayout(columns);
+  }
+  open(desc) {
+    if (this.world !== (0)) throw new GameError("invalid_argument", "engine world is already open");
+    let scratch = this.memory.allocate("u32", DESC_WORDS), floats = new Float32Array(scratch.buffer, scratch.byteOffset, DESC_WORDS), g = desc.gravity ?? [0, -9.81, 0];
+    floats[WORLD_GRAVITY] = g[0], floats[WORLD_GRAVITY + 1] = g[1], floats[WORLD_GRAVITY + 2] = g[2], floats[WORLD_STEP_SECONDS] = desc.stepSeconds, scratch[WORLD_MAX_BODIES] = desc.maxBodies ?? 2048, scratch[WORLD_MAX_COLLIDERS] = desc.maxColliders ?? 4096, scratch[WORLD_MAX_JOINTS] = desc.maxJoints ?? 1024, scratch[WORLD_MAX_CONTACTS] = desc.maxContactEvents ?? 1024, scratch[WORLD_MAX_CONTROLLERS] = desc.maxCharacterControllers ?? 64, scratch[WORLD_MAX_COMMANDS] = DEFAULT_MAX_COMMANDS;
+    let world = desc.rollback === void 0 ? this.exports.engine_world_create(scratch.byteOffset) : this.createRollback(scratch, desc.rollback);
+    if (world === (0)) throw engineSessionFailure(this.runtime.symbols) ?? new GameError("capacity_exceeded", "engine world could not be created");
+    this.world = world, this.snapshots = desc.rollback === void 0 ? null : WorldSnapshots.bind(this.runtime.symbols, this.runtime.memory, world, () => this.discard(), desc.rollback.frames ?? DEFAULT_ROLLBACK_FRAMES), noteInspectorWorld(world);
+    let buffer = this.runtime.memory.buffer, registers = this.exports.engine_world_registers(world);
+    this.registerWords = new Uint32Array(buffer, registers, REGISTER_WORDS), this.registerFloats = new Float32Array(buffer, registers, REGISTER_WORDS);
+    let descPointer = this.exports.engine_world_desc(world);
+    this.descWords = new Uint32Array(buffer, descPointer, DESC_WORDS), this.descFloats = new Float32Array(buffer, descPointer, DESC_WORDS), this.commandCapacity = DEFAULT_MAX_COMMANDS;
+    let commandBuffer = hasPhysics(this.runtime.symbols) ? buffer : new ArrayBuffer(DEFAULT_MAX_COMMANDS * COMMAND_WORDS * WORD_BYTES), commands = commandBuffer === buffer ? this.exports.engine_world_commands(world) : 0;
+    this.commandWords = new Uint32Array(commandBuffer, commands, DEFAULT_MAX_COMMANDS * COMMAND_WORDS), this.commandFloats = new Float32Array(commandBuffer, commands, DEFAULT_MAX_COMMANDS * COMMAND_WORDS);
+    let maxContacts = scratch[WORLD_MAX_CONTACTS];
+    this.contactA = new Uint32Array(buffer, this.exports.engine_contacts_a(world), maxContacts), this.contactB = new Uint32Array(buffer, this.exports.engine_contacts_b(world), maxContacts), this.contactBegan = new Uint8Array(buffer, this.exports.engine_contacts_started(world), maxContacts), this.columns && this.bindLayout(this.columns);
+  }
+  createRollback(desc, rollback) {
+    let symbols = this.runtime.symbols;
+    if (!hasRollback(symbols)) throw new GameError("unsupported_feature", "this engine has no client rollback (feature rollback_1)");
+    let config = this.memory.allocate("u32", ROLLBACK_CONFIG_WORDS);
+    writeRollbackConfig(config, rollback);
+    let create = symbols.engine_world_rollback_create;
+    return create(desc.byteOffset, config.byteOffset);
+  }
+  require() {
+    if (this.world === (0)) throw new GameError("not_initialized", "engine physics is not initialised");
+    return this.world;
+  }
+  check(code, what) {
+    if (!(code >= 0)) throw failure3(code, what);
+    return code;
+  }
+  command(op, body) {
+    this.pending === this.commandCapacity && this.flush();
+    let o = this.pending * COMMAND_WORDS;
+    return this.commandWords[o + COMMAND_OP] = op, this.commandWords[o + COMMAND_BODY] = body, this.pending++, o + COMMAND_PAYLOAD;
+  }
+  get commandPayload() {
+    return this.commandFloats;
+  }
+  get commandPayloadWords() {
+    return this.commandWords;
+  }
+  get symbols() {
+    return this.runtime.symbols;
+  }
+  get buffer() {
+    return this.runtime.memory.buffer;
+  }
+  discard() {
+    this.pending = 0;
+  }
+  flush() {
+    if (this.pending === 0) return;
+    let count = this.pending;
+    this.pending = 0, this.check(this.exports.engine_apply_commands(this.require(), count), "command");
+  }
+  step() {
+    requireEngineMemoryHeld(this.runtime.memory);
+    let count = this.pending;
+    this.pending = 0, this.check(this.exports.engine_step(this.require(), count), "step"), this.contacts = this.exports.engine_contact_count(this.world);
+  }
+  close() {
+    this.world !== (0) && (noteInspectorWorld((0)), this.exports.engine_world_destroy(this.world)), this.world = (0), this.snapshots = null, this.pending = 0, this.columns = null, this.memory.release(), releaseEngineArena(this.runtime.symbols);
+  }
+  bindLayout(columns) {
+    let words = this.descWords;
+    words[LAYOUT_POSITION] = columns.position.byteOffset, words[LAYOUT_ROTATION] = columns.rotation.byteOffset, words[LAYOUT_SCALE] = columns.scale.byteOffset, words[LAYOUT_PREVIOUS_POSITION] = columns.previousPosition.byteOffset, words[LAYOUT_PREVIOUS_ROTATION] = columns.previousRotation.byteOffset, words[LAYOUT_PREVIOUS_SCALE] = columns.previousScale.byteOffset, words[LAYOUT_PARENT] = columns.parent.byteOffset, words[LAYOUT_RENDER] = columns.render.byteOffset, words[LAYOUT_ENTITIES] = columns.entities.byteOffset, words[LAYOUT_SPARSE] = columns.sparse.byteOffset, words[LAYOUT_CAPACITY] = columns.capacity, words[LAYOUT_SPARSE_LEN] = columns.sparse.byteLength / WORD_BYTES, this.check(this.exports.engine_bind_transforms(this.world), "bind transforms");
+  }
+};
+
+// src/game/backends/engine/transforms.ts
+var EngineTransforms = class {
+  constructor(session) {
+    this.session = session;
+  }
+  bind(columns) {
+    this.session.bind(columns);
+  }
+  snapshot(count) {
+    let s = this.session;
+    s.check(s.exports.engine_snapshot(s.require(), count), "snapshot");
+  }
+  computeRender(count, time, version) {
+    let s = this.session, world = s.require();
+    s.registerFloats[REGISTER_FRAME_ALPHA] = time.values[FRAME_ALPHA_SLOT], s.registerWords[REGISTER_FRAME_VERSION_LOW] = version >>> 0, s.registerWords[REGISTER_FRAME_VERSION_HIGH] = Math.floor(version / U32_RANGE), s.check(s.exports.engine_compute_render(world, count), "compute render");
+  }
+};
+
+// src/game/backends/engine/signatures.ts
+var ARITY_EXPORT = "engine_export_arity", PROTOTYPE_EXPORT = "engine_export_prototype_of", NAME_ALIGN = 8, NAME_CAPACITY = 64, NULL = 0, NO_PROTOTYPE = 0;
+function nativeByName(runtime, query) {
+  let scratch = runtime.exports.engine_alloc((64), (8));
+  if (scratch === (0)) throw new GameError("capacity_exceeded", "engine memory cannot hold an export name");
+  return (name) => {
+    let bytes = new Uint8Array(runtime.memory.buffer, scratch, (64));
+    for (let i = 0; i < name.length; i++) bytes[i] = name.charCodeAt(i);
+    return query(scratch, name.length);
+  };
+}
+function engineArity(runtime) {
+  let symbols = runtime.symbols, native = symbols[ARITY_EXPORT];
+  return typeof native == "function" ? nativeByName(runtime, native) : (name) => {
+    let fn = symbols[name];
+    return typeof fn == "function" ? fn.length : -1;
+  };
+}
+function enginePrototype(runtime) {
+  let native = runtime.symbols[PROTOTYPE_EXPORT];
+  return typeof native == "function" ? nativeByName(runtime, native) : null;
+}
+function engineSignatureMismatches(symbols, arity, prototype = null) {
+  let mismatches = [];
+  for (let name in ENGINE_EXPORT_ARITY) {
+    if (typeof symbols[name] != "function") continue;
+    let expected = ENGINE_EXPORT_ARITY[name], actual = arity(name);
+    if (actual !== expected) {
+      mismatches.push(`${name} takes ${actual < 0 ? "an unknown number of" : actual} arguments, this package expects ${expected}`);
+      continue;
+    }
+    let advertised = prototype?.(name) ?? (0);
+    advertised !== (0) && advertised !== ENGINE_EXPORT_PROTOTYPES[name] && mismatches.push(`${name} has another prototype than this package expects`);
+  }
+  return mismatches;
+}
+function verifyEngineSignatures(runtime) {
+  let mismatches = engineSignatureMismatches(runtime.symbols, engineArity(runtime), enginePrototype(runtime));
+  if (mismatches.length > 0)
+    throw new GameError(
+      "engine_mismatch",
+      `this package was built for a different engine; rebuild it or update the app (${mismatches.length} exports differ: ${mismatches.slice(0, 3).join("; ")})`
+    );
+}
+
+// src/game/backends/engine/native.ts
+var ENGINE_BACKEND_NAME = "cimplify-engine", ENGINE_BACKEND_VERSION = "engine_core@0.1.0+rapier3d@0.36.0+three@0.186.1";
+function engineAudio(options, runtime) {
+  let native = runtime ? nativeAudio(runtime, options.assets ?? null) : null;
+  if (native) return native;
+  let assets = options.assets ?? null, explicit = runtime && options.audioWorklet ? workletAudio(runtime, options.audioWorklet, assets) : null;
+  if (explicit) return explicit;
+  if (options.audio) return options.audio;
+  let context = options.audioContext ?? runtime?.audioContext?.() ?? null, chosen = options.audioWorklet === null ? null : defaultWorklet(runtime, context), worklet = runtime && chosen ? workletAudio(runtime, chosen, assets) : null;
+  return worklet || (context ? new WebAudioPort(context) : new HeadlessAudio());
+}
+function defaultWorklet(runtime, context) {
+  let module = runtime?.audioWorklet ?? null, worklets = context?.audioWorklet;
+  return context === null || module === null || typeof worklets?.addModule != "function" ? null : { context, module };
+}
+function engineHost(runtime) {
+  return {
+    exports: runtime.symbols,
+    memory: runtime.memory,
+    allocate: (bytes) => runtime.exports.engine_alloc(bytes, COLUMN_ALIGN),
+    release: (pointer, bytes) => runtime.exports.engine_free(pointer, bytes, COLUMN_ALIGN)
+  };
+}
+function workletAudio(runtime, options, assets) {
+  let symbols = runtime.symbols;
+  if ([...ENGINE_AUDIO_EXPORT_NAMES.filter((name) => name !== "engine_audio_bound"), ...ENGINE_AUDIO_WORKLET_EXPORTS].some((name) => typeof symbols[name] != "function")) return null;
+  let host = engineHost(runtime), relay = WorkletAudio.create(host, options);
+  return new EngineAudioPort({ ...host, decode: runtime.decodeAudio ?? null, assets, handle: relay.handle, relay });
+}
+function nativeAudio(runtime, assets) {
+  let symbols = runtime.symbols;
+  if (ENGINE_AUDIO_EXPORT_NAMES.some((name) => typeof symbols[name] != "function")) return null;
+  let exports = symbols;
+  return exports.engine_audio_bound() === 0 ? null : new EngineAudioPort({
+    exports,
+    memory: runtime.memory,
+    allocate: (bytes) => runtime.exports.engine_alloc(bytes, COLUMN_ALIGN),
+    release: (pointer, bytes) => runtime.exports.engine_free(pointer, bytes, COLUMN_ALIGN),
+    decode: runtime.decodeAudio ?? null,
+    assets
+  });
+}
+function assembleEngineBackend(runtime, graphics, audio) {
+  verifyEngineSignatures(runtime);
+  let memory = new EngineMemory(runtime), session = new EngineSession(runtime, memory), port = graphics(runtime), physics = new EnginePhysics(session);
+  return port instanceof EngineGraphics && physics.craft?.bindRender?.(() => port.renderHandle), audio instanceof EngineAudioPort && audio.bindOcclusionWorld(() => session.world), useTransformEngine(bindTransformEngine(runtime.symbols, runtime.memory)), {
+    name: ENGINE_BACKEND_NAME,
+    version: ENGINE_BACKEND_VERSION,
+    memory,
+    transforms: new EngineTransforms(session),
+    physics,
+    graphics: port,
+    audio,
+    nav: engineNav(runtime),
+    ai: engineAi(runtime, () => session.world),
+    streaming: engineStreaming(runtime, port),
+    scenery: engineScenery(runtime, port),
+    terrain: engineTerrain(runtime, port, () => session.world),
+    soa: bindSoaEngine(runtime.symbols, runtime.memory),
+    kernels: bindKernelEngine(runtime.symbols, runtime.memory),
+    chemistry: bindChemistryEngine(runtime.symbols, runtime.memory),
+    fluids: engineFluids(runtime, port),
+    destruction: engineDestruction(runtime, () => session.world),
+    softBodies: engineSoftBodies(runtime, port, () => session.world),
+    reactive: engineReactive(runtime, port),
+    cloths: engineCloths(runtime, port, () => session.world),
+    smoke: engineSmoke(runtime, port),
+    story: engineStory(runtime)
+  };
+}
+function engineStory(runtime) {
+  let exports = engineStoryExports(runtime);
+  return exports !== null ? new EngineStory(runtime, exports) : null;
+}
+function engineSmoke(runtime, port) {
+  let exports = engineSmokeExports(runtime);
+  return exports !== null && port instanceof EngineGraphics ? new EngineSmoke(runtime, exports, () => port.renderHandle) : null;
+}
+function engineCloths(runtime, port, world) {
+  let exports = engineClothExports(runtime);
+  if (exports === null) return null;
+  let render = port instanceof EngineGraphics ? () => port.renderHandle : () => 0;
+  return new EngineCloths(runtime, exports, render, world);
+}
+function engineReactive(runtime, port) {
+  let exports = engineReactiveExports(runtime);
+  if (exports === null) return null;
+  let render = port instanceof EngineGraphics ? () => port.renderHandle : () => 0;
+  return new EngineReactive(runtime, exports, render);
+}
+function engineSoftBodies(runtime, port, world) {
+  let exports = engineSoftBodyExports(runtime);
+  if (exports === null) return null;
+  let render = port instanceof EngineGraphics ? () => port.renderHandle : () => 0;
+  return new EngineSoftBodies(runtime, exports, render, world);
+}
+function engineFluids(runtime, port) {
+  let exports = engineFluidExports(runtime);
+  return exports !== null && port instanceof EngineGraphics ? new EngineFluids(runtime, exports, () => port.renderHandle) : null;
+}
+function engineDestruction(runtime, world) {
+  let exports = engineDestructionExports(runtime);
+  return exports !== null ? new EngineDestruction(runtime, exports, world) : null;
+}
+function engineTerrain(runtime, port, world) {
+  let exports = engineTerrainExports(runtime);
+  return exports !== null && port instanceof EngineGraphics ? new EngineTerrain(runtime, exports, () => port.renderHandle, world) : null;
+}
+function engineStreaming(runtime, port) {
+  let exports = engineStreamExports(runtime);
+  return exports !== null && port instanceof EngineGraphics ? new EngineWorldStreaming(runtime, exports, () => port.renderHandle) : null;
+}
+function engineScenery(runtime, port) {
+  let exports = engineSplatExports(runtime);
+  return exports !== null && port instanceof EngineGraphics ? new EngineScenery(runtime, exports, () => port.renderHandle) : null;
+}
+function engineNav(runtime) {
+  let exports = engineNavExports(runtime.symbols);
+  return exports ? new EngineNav(runtime, exports) : null;
+}
+function createNativeEngineBackend(runtime, options = {}) {
+  let attach = options.attach ?? null;
+  return assembleEngineBackend(runtime, (r) => new EngineGraphics(r, void 0, attach, options.graphics), engineAudio(options, runtime));
+}
+
+export { ENGINE_BACKEND_NAME, ENGINE_BACKEND_VERSION, EngineGraphics, assembleEngineBackend, createNativeEngineBackend, engineAudio };