@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-7BHW5GTC.mjs

@@ -0,0 +1,1234 @@
+import { mat4Frustum, mat4Orthographic } from './chunk-KIZOA5LX.mjs';
+import { materialTint } from './chunk-TL2SVO4P.mjs';
+import { CORE_MATERIAL_SLOTS, MATERIAL_SLOTS, OP_SET_LOD, STAT_GPU_LAST_NS, STAT_GPU_P50_NS, STAT_GPU_P95_NS, STAT_GPU_BYTES_LOW, STAT_GPU_BYTES_HIGH, STAT_THERMAL_TIER, STAT_PARTICLES_ALIVE, STAT_RAW_DISPATCHES, STAT_RAW_GPU_NS, STAT_RAW_DISABLED, STAT_TRANSPARENT_SORTED, STAT_TEXT_GLYPHS, STAT_DRAW_CALLS, STAT_TRIANGLES, FftAnalyser, BLEND_EQUATIONS, BLEND_FACTORS, STENCIL_OPERATIONS, COMPARE_FUNCTIONS } from './chunk-E65WCTIG.mjs';
+import { FULL_AUDIO_CAPABILITIES, SPATIAL_WORDS, FILTER_OFF, METER_PEAK, METER_RMS, ANALYSER_FREQUENCY, STREAM_STOPPED, STREAM_PLAYING, STREAM_PAUSED, FILTER_KINDS, DISTANCE_MODELS, SPATIAL_MODEL, SPATIAL_REF_DISTANCE, SPATIAL_MAX_DISTANCE, SPATIAL_ROLLOFF, SPATIAL_CONE_INNER, SPATIAL_CONE_OUTER, SPATIAL_CONE_OUTER_GAIN } from './chunk-5YFBGGCK.mjs';
+import { COLUMN_ALIGN } from './chunk-A33OORT7.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/render/character.ts
+var HUMAN_SCATTER_MM = [3.67, 1.37, 0.68], DEFAULT_THICKNESS_MM = 1.5, DEFAULT_IRIS_RADIUS = 0.18, DEFAULT_IRIS_DEPTH = 0.04, DEFAULT_LIMBUS = 0.02, DEFAULT_PUPIL = 0.35, DEFAULT_MELANIN = 0.5, DEFAULT_REDNESS = 0.2, DEFAULT_AZIMUTHAL = 0.3, DEFAULT_DENSITY = 1, MAX_SCATTER_MM = 50, MAX_IRIS = 0.5, MAX_DENSITY = 8, MATERIAL_SKIN_SHEEN = 60, MATERIAL_SKIN_SHEEN_ROUGHNESS = 61, MATERIAL_SKIN_WARMTH = 62, MATERIAL_SKIN_RIM = 49, CHARACTER_KINDS = {
+  skin: 12,
+  eye: 13,
+  hair: 14
+};
+function clamp(value, low, high) {
+  return Math.min(Math.max(value, low), high);
+}
+function characterParams(desc) {
+  switch (desc.kind) {
+    case "skin": {
+      let s = desc.scatter ?? HUMAN_SCATTER_MM;
+      return [
+        clamp(s[0], 0, (50)),
+        clamp(s[1], 0, (50)),
+        clamp(s[2], 0, (50)),
+        Math.max(desc.thickness ?? (1.5), 0)
+      ];
+    }
+    case "eye":
+      return [
+        clamp(desc.irisRadius ?? (0.18), 0, (0.5)),
+        clamp(desc.irisDepth ?? (0.04), 0, (0.5)),
+        clamp(desc.limbus ?? (0.02), 0, (0.5)),
+        clamp(desc.pupil ?? (0.35), 0, 1)
+      ];
+    case "hair":
+      return [
+        clamp(desc.melanin ?? (0.5), 0, 1),
+        clamp(desc.redness ?? (0.2), 0, 1),
+        clamp(desc.azimuthalRoughness ?? (0.3), 0, 1),
+        clamp(desc.density ?? (1), 0, (8))
+      ];
+  }
+}
+var FLOAT = new Float32Array(1), WORD = new Uint32Array(FLOAT.buffer);
+function bits(value) {
+  return FLOAT[0] = value === 0 ? -0 : value, WORD[0];
+}
+function writeCharacterWords(desc, write) {
+  if (characterParams(desc).forEach((value, i) => write(40 + i, bits(value))), desc.kind !== "skin") return;
+  let tuned = [
+    [(60), desc.sheen],
+    [(61), desc.sheenRoughness],
+    [(62), desc.warmth],
+    [(49), desc.rim]
+  ];
+  for (let [at, value] of tuned) value !== void 0 && write(at, bits(clamp(value, 0, 1)));
+}
+
+// src/game/backends/engine/material-state.ts
+var FLOAT2 = new Float32Array(1), WORD2 = new Uint32Array(FLOAT2.buffer), STENCIL_FULL_MASK = 255, RGB = 3, BYTE_BITS = 8, BYTE_MAX = 255, SRGB_KNEE = 0.04045, SRGB_SLOPE = 12.92, SRGB_OFFSET = 0.055, SRGB_GAMMA = 2.4;
+function floatBits(value) {
+  return FLOAT2[0] = value, WORD2[0];
+}
+function compare(func) {
+  return func === void 0 ? 0 : 1 + COMPARE_FUNCTIONS.indexOf(func);
+}
+function renderState(state) {
+  let equation = state.blend?.equation ?? "add", word = compare(state.depthFunc) << 0;
+  return word |= BLEND_EQUATIONS.indexOf(equation) << 4, word |= BLEND_EQUATIONS.indexOf(state.blend?.alphaEquation ?? equation) << 7, state.alphaToCoverage && (word |= 1024), state.transparency === "oit" && (word |= 2048), state.stencil && (word |= 8192), word >>> 0;
+}
+function blendFactors(blend) {
+  if (!blend) return 0;
+  let src = blend.src ?? "srcAlpha", dst = blend.dst ?? "oneMinusSrcAlpha";
+  return (BLEND_FACTORS.indexOf(src) << 0 | BLEND_FACTORS.indexOf(dst) << 5 | BLEND_FACTORS.indexOf(blend.srcAlpha ?? src) << 10 | BLEND_FACTORS.indexOf(blend.dstAlpha ?? dst) << 15) >>> 0;
+}
+function stencil(desc) {
+  return desc ? (compare(desc.func ?? "always") << 0 | ((desc.ref ?? 0) & 255) << 4 | ((desc.readMask ?? (255)) & 255) << 12 | ((desc.writeMask ?? (255)) & 255) << 20) >>> 0 : 0;
+}
+function stencilOps(desc) {
+  return desc ? STENCIL_OPERATIONS.indexOf(desc.fail ?? "keep") << 0 | STENCIL_OPERATIONS.indexOf(desc.depthFail ?? "keep") << 3 | STENCIL_OPERATIONS.indexOf(desc.pass ?? "keep") << 6 : 0;
+}
+function writeMaterialState(state, write) {
+  let planes = state.clippingPlanes?.length ?? 0;
+  if (planes > 4) throw new RangeError(`materials clip against at most ${4} planes`);
+  write(32, renderState(state)), write(33, blendFactors(state.blend)), write(34, stencil(state.stencil)), write(35, stencilOps(state.stencil)), write(36, floatBits(state.polygonOffset?.factor ?? 0)), write(37, floatBits(state.polygonOffset?.units ?? 0)), write(38, planes), write(39, explicit(state.envMapIntensity));
+}
+function explicit(value) {
+  return value === void 0 ? 0 : floatBits(value === 0 ? -0 : value);
+}
+function linear(channel) {
+  return channel <= (0.04045) ? channel / (12.92) : ((channel + (0.055)) / (1 + (0.055))) ** (2.4);
+}
+function writeColor(write, at, hex, scale) {
+  if (hex !== void 0)
+    for (let i = 0; i < (3); i++) {
+      let channel = (hex >> ((3) - 1 - i) * (8) & (255)) / (255);
+      write(at + i, explicit(linear(channel) * scale));
+    }
+}
+function writeMaterialExtension(desc, write) {
+  if (writeMaterialState(desc, write), desc.kind !== "physical") return;
+  writeColor(write, 40, desc.sheenColor, desc.sheen ?? 0), write(43, explicit(desc.sheenRoughness)), writeColor(write, 44, desc.specularColor, 1), write(47, explicit(desc.specularIntensity)), write(48, explicit(desc.thickness)), write(49, explicit(desc.iridescence)), write(59, explicit(desc.clearcoatNormalScale)), writeColor(write, 28, desc.attenuationColor, 1), write(31, explicit(desc.attenuationDistance)), write(60, explicit(desc.iridescenceIOR));
+  let thickness = desc.iridescenceThicknessRange;
+  thickness !== void 0 && (write(61, explicit(thickness[0])), write(62, explicit(thickness[1])));
+}
+var UNDRAWN_PHYSICAL_MAPS = ["iridescenceMap", "iridescenceThicknessMap", "anisotropyMap"];
+function refuseUndrawnPhysicalFields(desc) {
+  if (desc.kind === "physical") {
+    for (let field of UNDRAWN_PHYSICAL_MAPS)
+      if (desc[field] !== void 0)
+        throw new GameError(
+          "unsupported_feature",
+          `the engine renderer does not draw ${field} on physical materials; remove it, or bake it into the base maps`
+        );
+    if ((desc.dispersion ?? 0) > 0)
+      throw new GameError(
+        "unsupported_feature",
+        "the engine renderer does not draw dispersion on physical materials; remove it or set it to 0"
+      );
+  }
+}
+function extraTextures(desc) {
+  return desc.kind !== "physical" ? [] : [
+    desc.clearcoatMap,
+    desc.clearcoatRoughnessMap,
+    desc.clearcoatNormalMap,
+    desc.sheenColorMap,
+    desc.sheenRoughnessMap,
+    desc.specularIntensityMap,
+    desc.specularColorMap,
+    desc.transmissionMap
+  ];
+}
+function writePlanes(state, out) {
+  let planes = state.clippingPlanes;
+  return !planes || planes.length === 0 ? false : (planes.forEach((plane, i) => out.set(plane, i * 4)), true);
+}
+function writeTextureTransforms(desc, out, write) {
+  if (!desc.textureTransforms) return false;
+  let mask = 0;
+  for (let [slot, transform] of Object.entries(desc.textureTransforms)) {
+    if (!transform) continue;
+    let index = materialSlotIndex(slot), at = index * 8;
+    out[at + 0] = transform.offset?.[0] ?? 0, out[at + 0 + 1] = transform.offset?.[1] ?? 0, out[at + 2] = transform.repeat?.[0] ?? 1, out[at + 2 + 1] = transform.repeat?.[1] ?? 1, out[at + 4] = transform.rotation ?? 0, out[at + 5] = transform.center?.[0] ?? 0, out[at + 5 + 1] = transform.center?.[1] ?? 0, out[at + 7] = transform.channel ?? 0, mask |= 1 << index;
+  }
+  return write(50, mask), mask !== 0;
+}
+
+// src/game/backends/engine/features.ts
+var MATERIAL_TOON = 7, MATERIAL_MATCAP = 8, SLOT_AUX = 13, NODE_BUFFER_PROBE_SH = 4, NODE_FLAG_PROBE_ENVIRONMENT = 16, SHADOW_PCF = 0, SHADOW_PCSS = 1, OP_MARK_PROBE = 49, OP_SET_SPRITE = 58, OP_SET_PROJECTION = 59, CREATE_POINT_SHADOWS = 22, PROBE_SH_FLOATS = 27, NODE_SPRITE_CENTER = 61, NODE_SPRITE_ROTATION = 63, OWNER_STAGING = 15;
+var CAP_SPRITE_TRANSFORM = 1 << 27, CAP_CUSTOM_PROJECTION = 1 << 28, CAP_POINT_SHADOWS = 1 << 30, MAT4 = 16, UNORM16 = 65535, TAU = Math.PI * 2, DEGREES_TO_RADIANS = Math.PI / 180, DEFAULT_SPRITE_CENTER = 0.5, DEFAULT_LINE_WIDTH = 1, DEFAULT_PROBE_INTENSITY = 1, SKY_DEFAULTS = { turbidity: 10, rayleigh: 2, mie: 5e-3, mieDirectionalG: 0.8 }, CLOUD_DEFAULTS = { coverage: 0.4, density: 0.6, scale: 1, speed: 1, elevation: 0.5 }, WORD_BYTES = 4, CREATE_ALIGN = 16, LIGHT_KINDS = {
+  directional: 0,
+  point: 1,
+  spot: 2,
+  ambient: 3,
+  hemisphere: 4,
+  probe: 5,
+  rectArea: 6,
+  reflectionProbe: 7
+}, MATERIAL_KINDS = {
+  standard: 0,
+  physical: 1,
+  toon: (7),
+  matcap: (8),
+  unlit: 2,
+  sprite: 3,
+  points: 4,
+  lines: 5,
+  shader: 6,
+  ...CHARACTER_KINDS
+}, RGB_MASK = 16777215;
+function tintChannel(words, at, color, bit) {
+  return words[at] = color === void 0 ? 0 : (color & (16777215)) >>> 0, color === void 0 ? 0 : bit;
+}
+function writeTintWords(tint, words, at) {
+  let enabled = tintChannel(words, at, tint?.primary, 1) | tintChannel(words, at + 1, tint?.secondary, 2) | tintChannel(words, at + 2, tint?.tertiary, 4);
+  words[at + 3] = enabled;
+}
+function writeMaterialTint(desc, d) {
+  let tint = materialTint(desc);
+  return tint.tintable ? (tint.mask !== void 0 && (d[51 + (13 - CORE_MATERIAL_SLOTS)] = tint.mask), 512) : 0;
+}
+var SHADOW_TYPES = { pcf: (0), pcss: (1) };
+function materialSlotIndex(slot) {
+  return slot === "gradientMap" || slot === "matcap" ? (13) : MATERIAL_SLOTS.indexOf(slot);
+}
+function explicitFloat(value) {
+  return floatBits(value === 0 ? -0 : value);
+}
+function anisotropyWord(strength, rotation) {
+  let s = Math.round(Math.min(Math.max(strength, 0), 1) * (65535)), turns = (rotation % TAU + TAU) % TAU;
+  return ((Math.round(turns / TAU * (65535)) & (65535)) << 16 | s) >>> 0;
+}
+function materialFeatureFlags(desc) {
+  switch (desc.kind) {
+    case "toon":
+      return 64;
+    case "matcap":
+      return desc.flatShading ? 32 : 0;
+    case "lines":
+      return desc.worldUnits ? 256 : 0;
+    case "sprite":
+      return desc.sizeAttenuation === false ? 0 : 128;
+    default:
+      return 0;
+  }
+}
+function linearChannel(channel) {
+  return channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+}
+function writeLinearHex(f, at, hex) {
+  f[at] = linearChannel((hex >> 16 & 255) / 255), f[at + 1] = linearChannel((hex >> 8 & 255) / 255), f[at + 2] = linearChannel((hex & 255) / 255);
+}
+function writeMaterialFeatures(desc, d, f) {
+  let aux = 51 + ((13) - CORE_MATERIAL_SLOTS);
+  switch (desc.kind) {
+    case "toon":
+      d[15] = desc.map ?? 0, d[16] = desc.normalMap ?? 0, d[19] = desc.emissiveMap ?? 0, d[20] = desc.aoMap ?? 0, writeLinearHex(f, 7, desc.emissive ?? 0), f[10] = desc.emissiveIntensity ?? 1, d[aux] = desc.gradientMap ?? 0;
+      break;
+    case "matcap":
+      d[15] = desc.map ?? 0, d[16] = desc.normalMap ?? 0, d[aux] = desc.matcap ?? 0;
+      break;
+    case "lines":
+      f[21] = desc.width ?? (1), desc.dashSize !== void 0 && (d[60] = explicitFloat(desc.dashSize)), desc.gapSize !== void 0 && (d[61] = explicitFloat(desc.gapSize)), desc.dashScale !== void 0 && (d[62] = explicitFloat(desc.dashScale));
+      break;
+    case "physical":
+      desc.anisotropy !== void 0 && desc.anisotropy > 0 && (d[63] = anisotropyWord(desc.anisotropy, desc.anisotropyRotation ?? 0));
+      break;
+  }
+}
+function writeSky(desc, d, f) {
+  let sky = desc.sky;
+  if (desc.background !== void 0 && "sky" in desc.background && (d[0] = 3), !sky) {
+    d[19] = 0;
+    return;
+  }
+  d[19] = 1, f[20] = sky.turbidity ?? SKY_DEFAULTS.turbidity, f[21] = sky.rayleigh ?? SKY_DEFAULTS.rayleigh, f[22] = sky.mie ?? SKY_DEFAULTS.mie, f[23] = sky.mieDirectionalG ?? SKY_DEFAULTS.mieDirectionalG;
+  let clouds = sky.clouds;
+  if (!clouds) {
+    f[24] = 0;
+    return;
+  }
+  f[24] = clouds.coverage ?? CLOUD_DEFAULTS.coverage, f[25] = clouds.density ?? CLOUD_DEFAULTS.density, f[26] = clouds.scale ?? CLOUD_DEFAULTS.scale, f[27] = clouds.speed ?? CLOUD_DEFAULTS.speed, f[28] = clouds.elevation ?? CLOUD_DEFAULTS.elevation;
+}
+function writeNodeFeatures(desc, d, f, spriteRotation) {
+  let lod = desc.lod;
+  switch (lod && (f[34] = lod.near ?? 0, f[35] = lod.far ?? 0, f[36] = lod.hysteresis ?? 0), desc.kind) {
+    case "sprite":
+      d[(61)] = explicitFloat(desc.center?.[0] ?? (0.5)), d[(61) + 1] = explicitFloat(desc.center?.[1] ?? (0.5)), d[(63)] = explicitFloat(spriteRotation);
+      break;
+    case "decal":
+      d[0] = 10, d[2] = desc.material, desc.angleFade !== void 0 && (f[32] = desc.angleFade), desc.fade !== void 0 && (f[33] = desc.fade);
+      break;
+    case "light":
+      if (d[5] = LIGHT_KINDS[desc.light], desc.shadow?.type !== void 0 && (d[50] = SHADOW_TYPES[desc.shadow.type]), desc.light === "rectArea")
+        f[51] = desc.width ?? 1, f[52] = desc.height ?? 1;
+      else if (desc.light === "probe")
+        desc.fromEnvironment && (d[3] |= (16));
+      else if (desc.light === "reflectionProbe") {
+        if (desc.texture === void 0) throw new GameError("invalid_argument", "reflection probes need a cube or equirect texture");
+        d[53] = desc.texture;
+        let min = desc.boxMin ?? [-1, -1, -1], max = desc.boxMax ?? [1, 1, 1];
+        for (let i = 0; i < 3; i++)
+          f[54 + i] = min[i], f[57 + i] = max[i];
+        d[60] = explicitFloat(desc.intensity ?? (1));
+      }
+      break;
+  }
+}
+function glToEngineProjection(gl, out, offset = 0) {
+  for (let c = 0; c < 4; c++) {
+    let o = c * 4;
+    out[offset + o] = gl[o], out[offset + o + 1] = gl[o + 1], out[offset + o + 2] = 0.5 * gl[o + 3] - 0.5 * gl[o + 2], out[offset + o + 3] = gl[o + 3];
+  }
+}
+function viewOffsetProjection(camera, aspect, view, out) {
+  if (camera.perspective) {
+    let top2 = camera.near * Math.tan(DEGREES_TO_RADIANS * 0.5 * camera.fov), height = 2 * top2, width = aspect * height, left2 = -0.5 * width;
+    left2 += view.x * width / view.fullWidth, top2 -= view.y * height / view.fullHeight, width *= view.width / view.fullWidth, height *= view.height / view.fullHeight, mat4Frustum(out, 0, left2, left2 + width, top2 - height, top2, camera.near, camera.far);
+    return;
+  }
+  let halfHeight = camera.height / 2, halfWidth = halfHeight * aspect, scaleW = 2 * halfWidth / view.fullWidth, scaleH = 2 * halfHeight / view.fullHeight, left = -halfWidth + scaleW * view.x, right = left + scaleW * view.width, top = halfHeight - scaleH * view.y, bottom = top - scaleH * view.height;
+  mat4Orthographic(out, 0, left, right, bottom, top, camera.near, camera.far);
+}
+var EngineFeatures = class {
+  constructor(host) {
+    this.spriteRotations = /* @__PURE__ */ new Map();
+    this.cameras = /* @__PURE__ */ new Map();
+    this.glScratch = new Float64Array((16));
+    this.staging = null;
+    this.aspect = 1;
+    this.host = host;
+  }
+  has(cap) {
+    return (this.host.caps() & cap) !== 0;
+  }
+  require(cap, feature) {
+    if (!this.has(cap)) throw new GameError("unsupported_feature", `this engine build has no ${feature}; update the app to use it`);
+  }
+  material(id, desc) {
+    desc.kind === "sprite" && this.spriteRotations.set(id, desc.rotation ?? 0);
+  }
+  spriteRotation(material) {
+    return this.spriteRotations.get(material) ?? 0;
+  }
+  forgetMaterial(id) {
+    this.spriteRotations.delete(id);
+  }
+  node(id, desc) {
+    if (desc.kind === "camera") {
+      let perspective = desc.projection !== "orthographic";
+      this.cameras.set(id, {
+        perspective,
+        fov: desc.projection === "perspective" ? desc.fov ?? 0 : 0,
+        height: desc.projection === "orthographic" ? desc.height : 0,
+        near: desc.near ?? 0,
+        far: desc.far ?? 0,
+        offset: null,
+        custom: false
+      }), desc.projection === "custom" && this.setProjectionMatrix(id, desc.matrix, desc.near, desc.far);
+      return;
+    }
+    desc.kind === "light" && desc.light === "probe" && desc.sh && this.setProbeCoefficients(id, desc.sh);
+  }
+  forgetNode(id) {
+    this.cameras.delete(id);
+  }
+  perspective(id, fov, near, far) {
+    let camera = this.cameras.get(id);
+    camera && (camera.perspective = true, camera.fov = fov, camera.near = near, camera.far = far, camera.custom = false, camera.offset && this.sendOffset(id, camera));
+  }
+  perspectiveFrom(id, values, offset) {
+    let camera = this.cameras.get(id);
+    camera && (camera.perspective = true, camera.fov = values[offset], camera.near = values[offset + 1], camera.far = values[offset + 2], camera.custom = false, camera.offset && this.sendOffset(id, camera));
+  }
+  orthographic(id, height, near, far) {
+    let camera = this.cameras.get(id);
+    camera && (camera.perspective = false, camera.height = height, camera.near = near, camera.far = far, camera.custom = false, camera.offset && this.sendOffset(id, camera));
+  }
+  resize(width, height) {
+    this.aspect = width / Math.max(1, height);
+    for (let [id, camera] of this.cameras) camera.offset && this.sendOffset(id, camera);
+  }
+  setLod(node, near, far, hysteresis) {
+    let a = this.host.command(OP_SET_LOD, node);
+    this.host.floats[a] = near, this.host.floats[a + 1] = far, this.host.floats[a + 2] = hysteresis;
+  }
+  setSprite(node, rotation, centerX, centerY) {
+    this.require(CAP_SPRITE_TRANSFORM, "sprite rotation and center");
+    let a = this.host.command((58), node);
+    this.host.floats[a] = rotation, this.host.floats[a + 1] = centerX, this.host.floats[a + 2] = centerY;
+  }
+  setProbeCoefficients(node, sh) {
+    if (sh.length < (27)) throw new GameError("invalid_argument", `light probes take ${(27)} coefficients (9 RGB)`);
+    this.host.buffer(4, node, (4)).set(sh.subarray(0, (27))), this.host.command((49), node);
+  }
+  setProjectionMatrix(camera, matrix, near, far) {
+    this.require(CAP_CUSTOM_PROJECTION, "custom camera projections");
+    let state = this.cameras.get(camera);
+    state && (state.custom = matrix !== null, matrix !== null && (state.offset = null)), this.sendProjection(camera, matrix, near, far);
+  }
+  setViewOffset(camera, offset) {
+    this.require(CAP_CUSTOM_PROJECTION, "camera view offsets");
+    let state = this.cameras.get(camera);
+    if (!state) throw new GameError("unknown_resource", `node ${camera} is not a camera`);
+    if (state.offset = offset, offset === null) {
+      this.sendProjection(camera, null, state.near, state.far);
+      return;
+    }
+    this.sendOffset(camera, state);
+  }
+  readGpuStats(out) {
+    let r = this.host.registers;
+    out.gpuLastNs = r[STAT_GPU_LAST_NS], out.gpuP50Ns = r[STAT_GPU_P50_NS], out.gpuP95Ns = r[STAT_GPU_P95_NS], out.gpuBytes = r[STAT_GPU_BYTES_LOW] + r[STAT_GPU_BYTES_HIGH] * 4294967296, out.thermalTier = r[STAT_THERMAL_TIER], out.particlesAlive = r[STAT_PARTICLES_ALIVE], out.rawDispatches = r[STAT_RAW_DISPATCHES], out.rawGpuNs = r[STAT_RAW_GPU_NS], out.rawDisabled = r[STAT_RAW_DISABLED], out.transparentSorted = r[STAT_TRANSPARENT_SORTED], out.textGlyphs = r[STAT_TEXT_GLYPHS], out.drawCalls = r[STAT_DRAW_CALLS], out.triangles = r[STAT_TRIANGLES];
+  }
+  sendOffset(camera, state) {
+    let offset = state.offset;
+    offset && (viewOffsetProjection(state, this.aspect, offset, this.glScratch), this.sendProjection(camera, this.glScratch, state.near, state.far));
+  }
+  sendProjection(camera, matrix, near, far) {
+    if (matrix === null) {
+      this.sendBase(camera);
+      return;
+    }
+    this.host.flush(), glToEngineProjection(matrix, this.stagingView());
+    let a = this.host.command((59), camera);
+    this.host.floats[a] = near, this.host.floats[a + 1] = far, this.host.flush();
+  }
+  sendBase(camera) {
+    let state = this.cameras.get(camera), perspective = state?.perspective ?? true, a = this.host.command(perspective ? 9 : 10, camera);
+    this.host.floats[a] = perspective ? state?.fov || 60 : state?.height ?? 1, this.host.floats[a + 1] = state?.near || 0.1, this.host.floats[a + 2] = state?.far || 1e3;
+  }
+  stagingView() {
+    return (this.staging === null || this.staging.length === 0) && (this.staging = this.host.buffer((15), 0, 0)), this.staging;
+  }
+};
+function createWithDescriptor(runtime, options, create) {
+  let bytes = 64 * (4);
+  if (typeof runtime.exports.engine_alloc != "function") return create(0);
+  let pointer = runtime.exports.engine_alloc(bytes, (16));
+  if (pointer === 0) return create(0);
+  try {
+    let words = new Uint32Array(runtime.memory.buffer, pointer, 64);
+    return words.fill(0), words[(22)] = options.pointShadows === !1 ? 0 : 1, create(pointer);
+  } finally {
+    runtime.exports.engine_free(pointer, bytes, (16));
+  }
+}
+
+// src/game/audio/worklet-processor.ts
+var WORKLET_PROCESSOR_NAME = "cimplify-audio";
+var WORKLET_PROCESSOR_SOURCE = `
+const RING_HEADER_WORDS = 2;
+const RING_WRITE = 0;
+const RING_READ = 1;
+
+class CimplifyAudioProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const o = options.processorOptions;
+    const instance = new WebAssembly.Instance(o.module, {});
+    this.x = instance.exports;
+    const sizes = new Uint32Array(this.x.memory.buffer, this.x.worklet_sizes(), o.sizes.length);
+    for (let k = 0; k < o.sizes.length; k++) sizes[k] = o.sizes[k];
+    this.host = this.x.worklet_create(sampleRate, o.voices, o.inputWords);
+    this.capacity = this.x.worklet_input_words(this.host);
+    this.pending = 0;
+    this.queue = [];
+    this.queued = 0;
+    this.reportQuanta = o.reportQuanta;
+    this.quanta = 0;
+    this.buffer = null;
+    this.inbound = o.inbound === null ? null : new Int32Array(o.inbound);
+    this.outbound = o.outbound === null ? null : new Int32Array(o.outbound);
+    if (this.inbound === null) {
+      this.port.onmessage = (event) => {
+        this.queue.push(event.data);
+      };
+    }
+  }
+
+  views() {
+    const buffer = this.x.memory.buffer;
+    if (this.buffer === buffer) return;
+    this.buffer = buffer;
+    this.input = new Uint32Array(buffer, this.x.worklet_input(this.host), this.capacity);
+    this.left = new Float32Array(buffer, this.x.worklet_output(this.host, 0), 4096);
+    this.right = new Float32Array(buffer, this.x.worklet_output(this.host, 1), 4096);
+  }
+
+  fromRing() {
+    const ring = this.inbound;
+    const capacity = ring.length - RING_HEADER_WORDS;
+    const write = Atomics.load(ring, RING_WRITE);
+    let read = Atomics.load(ring, RING_READ);
+    let available = (write - read) | 0;
+    const room = this.capacity - this.pending;
+    if (available > room) available = room;
+    for (let k = 0; k < available; k++) {
+      this.input[this.pending + k] = ring[RING_HEADER_WORDS + ((read + k) & (capacity - 1))];
+    }
+    this.pending += available;
+    Atomics.store(ring, RING_READ, (read + available) | 0);
+  }
+
+  fromQueue() {
+    while (this.queue.length > 0 && this.pending < this.capacity) {
+      const head = this.queue[0];
+      const take = Math.min(head.length - this.queued, this.capacity - this.pending);
+      this.input.set(head.subarray(this.queued, this.queued + take), this.pending);
+      this.pending += take;
+      this.queued += take;
+      if (this.queued === head.length) {
+        this.queue.shift();
+        this.queued = 0;
+      }
+    }
+  }
+
+  ingest() {
+    this.views();
+    if (this.inbound !== null) this.fromRing();
+    else this.fromQueue();
+    if (this.pending === 0) return;
+    const used = this.x.worklet_ingest(this.host, this.pending);
+    if (used > 0) {
+      this.input.copyWithin(0, used, this.pending);
+      this.pending -= used;
+    }
+  }
+
+  report() {
+    const words = this.x.worklet_report(this.host);
+    this.views();
+    const report = new Uint32Array(this.x.memory.buffer, this.x.worklet_report_buffer(this.host), words);
+    if (this.outbound === null) {
+      this.port.postMessage(report.slice());
+      return;
+    }
+    const ring = this.outbound;
+    const capacity = ring.length - RING_HEADER_WORDS;
+    const write = Atomics.load(ring, RING_WRITE);
+    const read = Atomics.load(ring, RING_READ);
+    if (capacity - ((write - read) | 0) < words) return;
+    for (let k = 0; k < words; k++) ring[RING_HEADER_WORDS + ((write + k) & (capacity - 1))] = report[k];
+    Atomics.store(ring, RING_WRITE, (write + words) | 0);
+  }
+
+  process(inputs, outputs) {
+    this.ingest();
+    const out = outputs[0];
+    const frames = out[0].length;
+    this.x.worklet_render(this.host, frames);
+    this.views();
+    out[0].set(this.left.subarray(0, frames));
+    if (out.length > 1) out[1].set(this.right.subarray(0, frames));
+    this.ingest();
+    this.quanta += 1;
+    if (this.quanta >= this.reportQuanta) {
+      this.quanta = 0;
+      this.report();
+    }
+    return true;
+  }
+}
+
+registerProcessor("${WORKLET_PROCESSOR_NAME}", CimplifyAudioProcessor);
+`;
+
+// src/game/audio/output.ts
+var outputs = /* @__PURE__ */ new WeakMap();
+function audioOutput(context) {
+  let output = outputs.get(context);
+  return output === void 0 ? context.destination : output;
+}
+
+// src/game/audio/worklet.ts
+var ENGINE_MIX_RATE = 48e3, DEFAULT_PUMP_WORDS = 65536, DEFAULT_RING_WORDS = 1 << 20, DEFAULT_IDLE_PUMPS = 120, WORD_BYTES2 = 4, OUTPUT_CHANNELS = 2, MASTER_BUS = 0, METER_FLOATS = 2, METER_PEAK2 = 0, RUNNING = "running", DEFAULT_WORKLET_SIZES = {
+  arenaFloats: 1 << 23,
+  streamFrames: 65536,
+  reverbs: 2,
+  reverbPartitions: 1024,
+  banks: 4,
+  emitters: 2048
+};
+function sizeWords(sizes) {
+  return [sizes.arenaFloats, sizes.streamFrames, sizes.reverbs, sizes.reverbPartitions, sizes.banks, sizes.emitters];
+}
+function ring(words) {
+  return new SharedArrayBuffer((2 + words) * (4));
+}
+function blobUrl(source) {
+  return URL.createObjectURL(new Blob([source], { type: "application/javascript" }));
+}
+function defaultNode(context, name, options) {
+  let Node = globalThis.AudioWorkletNode;
+  return new Node(context, name, {
+    numberOfInputs: 0,
+    numberOfOutputs: 1,
+    outputChannelCount: [(2)],
+    processorOptions: options
+  });
+}
+function sharedMemoryAvailable() {
+  return typeof SharedArrayBuffer == "function" && globalThis.crossOriginIsolated === true;
+}
+var WorkletAudio = class _WorkletAudio {
+  constructor(engine, handle, shared, pumpWords, ringWords, context, idlePumps) {
+    this.backlog = [];
+    this.reports = [];
+    this.node = null;
+    this.failed = null;
+    this.meterView = null;
+    this.quiet = 0;
+    this.idled = false;
+    this.hidden = false;
+    this.engine = engine, this.handle = handle, this.shared = shared, this.stagingWords = pumpWords, this.staging = engine.allocate(pumpWords * (4)), this.inbound = shared ? new Int32Array(ring(ringWords)) : null, this.outbound = shared ? new Int32Array(ring(ringWords)) : null, this.context = context, this.idlePumps = idlePumps;
+  }
+  static create(engine, options) {
+    let create = engine.exports.engine_audio_relay_create;
+    if (!create) throw new GameError("unsupported_feature", "this engine build has no web audio relay");
+    let sizes = options.sizes ?? DEFAULT_WORKLET_SIZES, words = sizeWords(sizes), pointer = engine.allocate(6 * (4));
+    new Uint32Array(engine.memory.buffer, pointer, 6).set(words);
+    let voices = options.voices ?? 64, handle = create((48e3), voices, pointer);
+    if (engine.release(pointer, 6 * (4)), handle === 0) throw new GameError("invalid_argument", "the engine refused the web audio relay sizes");
+    let shared = options.shared ?? sharedMemoryAvailable(), pumpWords = options.pumpWords ?? (65536), ringWords = options.ringWords ?? DEFAULT_RING_WORDS;
+    if (ringWords & ringWords - 1 || ringWords < pumpWords) throw new GameError("invalid_argument", "the ring holds a power of two words, at least one pump");
+    let idlePumps = options.idlePumps ?? (120), audio = new _WorkletAudio(engine, handle, shared, pumpWords, ringWords, options.context, idlePumps), url = (options.moduleUrl ?? blobUrl)(WORKLET_PROCESSOR_SOURCE);
+    return Promise.all([options.context.audioWorklet.addModule(url), options.module]).then(([, module]) => {
+      let processor = {
+        module,
+        voices,
+        sizes: words,
+        inputWords: pumpWords * 2,
+        reportQuanta: options.reportQuanta ?? 8,
+        inbound: audio.inbound === null ? null : audio.inbound.buffer,
+        outbound: audio.outbound === null ? null : audio.outbound.buffer
+      };
+      audio.attach((options.createNode ?? defaultNode)(options.context, WORKLET_PROCESSOR_NAME, processor), options.context);
+    }).catch((cause) => {
+      audio.failed = cause;
+    }), audio;
+  }
+  get idle() {
+    return this.idled;
+  }
+  suspend() {
+    this.hidden = true, this.context.suspend?.();
+  }
+  resume() {
+    this.hidden = false, this.idled = false, this.quiet = 0, this.context.resume?.();
+  }
+  silent() {
+    let buffer = this.engine.memory.buffer, view = this.meterView;
+    return (view === null || view.buffer !== buffer) && (view = new Float32Array(buffer, this.staging, (2)), this.meterView = view), this.engine.exports.engine_audio_meter(this.handle, (0), this.staging), view[(0)] === 0;
+  }
+  settle(sent) {
+    if (sent > 0 || !this.silent()) {
+      this.quiet = 0, this.idled && !this.hidden && (this.idled = false, this.context.resume?.());
+      return;
+    }
+    this.idled || this.hidden || this.node === null || this.context.state !== RUNNING || (this.quiet += 1, !(this.quiet < this.idlePumps) && (this.idled = true, this.context.suspend?.()));
+  }
+  get ready() {
+    return this.node !== null;
+  }
+  get error() {
+    return this.failed;
+  }
+  attach(node, context) {
+    this.node = node, this.shared || (node.port.onmessage = (event) => {
+      this.reports.push(event.data);
+    }), node.connect(audioOutput(context)), this.drainBacklog();
+  }
+  send(words) {
+    let node = this.node;
+    if (node === null) return false;
+    let ring2 = this.inbound;
+    if (ring2 === null)
+      return node.port.postMessage(words, [words.buffer]), true;
+    let capacity = ring2.length - 2, write = Atomics.load(ring2, 0), read = Atomics.load(ring2, 1);
+    if (capacity - (write - read | 0) < words.length) return false;
+    for (let k = 0; k < words.length; k++) ring2[2 + (write + k & capacity - 1)] = words[k];
+    return Atomics.store(ring2, 0, write + words.length | 0), true;
+  }
+  drainBacklog() {
+    for (; this.backlog.length > 0 && this.send(this.backlog[0]); ) this.backlog.shift();
+  }
+  receive(words) {
+    let receive = this.engine.exports.engine_audio_relay_receive;
+    if (!receive || words.length === 0) return;
+    let bytes = words.length * (4), pointer = words.length <= this.stagingWords ? this.staging : this.engine.allocate(bytes);
+    new Uint32Array(this.engine.memory.buffer, pointer, words.length).set(words), receive(this.handle, pointer, words.length), pointer !== this.staging && this.engine.release(pointer, bytes);
+  }
+  collect() {
+    if (this.outbound === null) {
+      for (let report of this.reports) this.receive(report);
+      this.reports.length = 0;
+      return;
+    }
+    let ring2 = this.outbound, capacity = ring2.length - 2, write = Atomics.load(ring2, 0), read = Atomics.load(ring2, 1), available = write - read | 0;
+    if (available <= 0) return;
+    let words = new Uint32Array(available);
+    for (let k = 0; k < available; k++) words[k] = ring2[2 + (read + k & capacity - 1)];
+    Atomics.store(ring2, 1, read + available | 0), this.receive(words);
+  }
+  pump() {
+    let pump = this.engine.exports.engine_audio_relay_pump;
+    if (!pump) return;
+    this.collect(), this.drainBacklog();
+    let sent = this.backlog.length;
+    for (; ; ) {
+      let words = pump(this.handle, this.staging, this.stagingWords);
+      if (words <= 0) break;
+      sent += words;
+      let batch = new Uint32Array(this.engine.memory.buffer, this.staging, words).slice();
+      (this.backlog.length > 0 || !this.send(batch)) && this.backlog.push(batch);
+    }
+    this.settle(sent);
+  }
+};
+
+// src/game/audio/headless.ts
+var NO_SOUND = -1, NO_BUS = -1, MATRIX_TRANSLATION = 12, FILTER_WORDS = 4, LOOP_WORDS = 3, RATE_WORDS = 2, HEADLESS_SAMPLE_RATE = 48e3, DEFAULT_STREAM_SECONDS = 180, SEND_KEY = 1024, HeadlessAudio = class {
+  constructor(maxVoices = 64) {
+    this.name = "headless";
+    this.capabilities = FULL_AUDIO_CAPABILITIES;
+    this.sampleRate = (48e3);
+    this.unlockedValue = false;
+    this.soundCount = 0;
+    this.busCount = 0;
+    this.busGains = [];
+    this.busFilters = [];
+    this.busMeters = [];
+    this.sends = /* @__PURE__ */ new Map();
+    this.reverbs = /* @__PURE__ */ new Map();
+    this.analysers = [];
+    this.analyserBus = [];
+    this.streams = [];
+    this.listener = new Float32Array(16);
+    this.nextVoice = 0;
+    this.voiceSound = new Int32Array(maxVoices).fill((-1)), this.voiceLoop = new Uint8Array(maxVoices), this.voicePosition = new Float32Array(maxVoices * 3), this.voiceGain = new Float32Array(maxVoices), this.voiceRate = new Float32Array(maxVoices * (2)), this.voiceLoopPoints = new Float32Array(maxVoices * (3)), this.voiceSpatial = new Float32Array(maxVoices * SPATIAL_WORDS);
+  }
+  get unlocked() {
+    return this.unlockedValue;
+  }
+  unlock() {
+    this.unlockedValue = true;
+  }
+  decode(_source) {
+    return Promise.resolve(this.soundCount++);
+  }
+  createSound(samples, channels, sampleRate) {
+    if (channels < 1 || sampleRate <= 0 || samples.length % channels !== 0) throw new GameError("invalid_argument", "sound PCM must be interleaved whole frames");
+    return this.soundCount++;
+  }
+  createBus(_name, _parent) {
+    this.busGains.push(1);
+    for (let i = 0; i < (4); i++) this.busFilters.push(i === 0 ? FILTER_OFF : 0);
+    return this.busMeters.push(0, 0), this.busCount++;
+  }
+  setBusGain(bus, gain, _rampSeconds) {
+    this.busGains[bus] = gain;
+  }
+  busGain(bus) {
+    return this.busGains[bus];
+  }
+  setBusFilter(bus, kind, frequency, q, gainDb) {
+    let o = bus * (4);
+    this.busFilters[o] = kind, this.busFilters[o + 1] = frequency, this.busFilters[o + 2] = q, this.busFilters[o + 3] = gainDb;
+  }
+  busFilter(bus, out) {
+    for (let i = 0; i < (4); i++) out[i] = this.busFilters[bus * (4) + i];
+  }
+  meter(bus, out) {
+    out[METER_PEAK] = this.busMeters[bus * 2] ?? 0, out[METER_RMS] = this.busMeters[bus * 2 + 1] ?? 0;
+  }
+  inject(bus, samples) {
+    let peak = 0, energy = 0;
+    for (let i = 0; i < samples.length; i++) {
+      let v = samples[i], a = v < 0 ? -v : v;
+      a > peak && (peak = a), energy += v * v;
+    }
+    this.busMeters[bus * 2] = peak, this.busMeters[bus * 2 + 1] = samples.length > 0 ? Math.sqrt(energy / samples.length) : 0;
+    for (let a = 0; a < this.analysers.length; a++)
+      this.analyserBus[a] === bus && this.analysers[a].push(samples, 0, samples.length);
+  }
+  createAnalyser(bus, settings) {
+    return this.analysers.push(new FftAnalyser(settings)), this.analyserBus.push(bus), this.analysers.length - 1;
+  }
+  readAnalyser(analyser, mode, out) {
+    let found = this.analysers[analyser];
+    if (!found) throw new GameError("unknown_resource", `analyser ${analyser} does not exist`);
+    mode === ANALYSER_FREQUENCY ? found.frequency(out) : found.timeDomain(out);
+  }
+  createReverb(parent, impulse) {
+    let bus = this.createBus("reverb", parent);
+    return this.reverbs.set(bus, impulse), bus;
+  }
+  reverbImpulse(bus) {
+    return this.reverbs.get(bus) ?? (-1);
+  }
+  setBusSend(bus, target, gain) {
+    this.sends.set(bus * (1024) + target, gain);
+  }
+  busSend(bus, target) {
+    return this.sends.get(bus * (1024) + target) ?? 0;
+  }
+  play(sound, _bus, gain, rate, loop, _spatial) {
+    let voice = this.nextVoice;
+    return this.nextVoice = (this.nextVoice + 1) % this.voiceSound.length, this.voiceSound[voice] = sound, this.voiceLoop[voice] = loop ? 1 : 0, this.voiceGain[voice] = gain, this.voiceRate[voice * (2)] = rate, this.voiceRate[voice * (2) + 1] = 0, this.voiceLoopPoints[voice * (3)] = loop ? 1 : 0, this.voiceLoopPoints[voice * (3) + 1] = 0, this.voiceLoopPoints[voice * (3) + 2] = 0, voice;
+  }
+  stop(voice, _fadeSeconds) {
+    this.voiceSound[voice] = (-1);
+  }
+  isPlaying(voice) {
+    return this.voiceSound[voice] !== (-1);
+  }
+  setVoiceGain(voice, gain, _rampSeconds) {
+    this.voiceGain[voice] = gain;
+  }
+  voiceGainOf(voice) {
+    return this.voiceGain[voice];
+  }
+  setVoiceRate(voice, rate, detuneCents) {
+    this.voiceRate[voice * (2)] = rate, this.voiceRate[voice * (2) + 1] = detuneCents;
+  }
+  voiceRateOf(voice, out) {
+    out[0] = this.voiceRate[voice * (2)], out[1] = this.voiceRate[voice * (2) + 1];
+  }
+  setVoiceSpatial(voice, params) {
+    this.voiceSpatial.set(params.subarray(0, SPATIAL_WORDS), voice * SPATIAL_WORDS);
+  }
+  voiceSpatialOf(voice, out) {
+    for (let i = 0; i < SPATIAL_WORDS; i++) out[i] = this.voiceSpatial[voice * SPATIAL_WORDS + i];
+  }
+  setVoiceLoop(voice, loop, startSeconds, endSeconds) {
+    let o = voice * (3);
+    this.voiceLoop[voice] = loop ? 1 : 0, this.voiceLoopPoints[o] = loop ? 1 : 0, this.voiceLoopPoints[o + 1] = startSeconds, this.voiceLoopPoints[o + 2] = endSeconds;
+  }
+  voiceLoopOf(voice, out) {
+    for (let i = 0; i < (3); i++) out[i] = this.voiceLoopPoints[voice * (3) + i];
+  }
+  setVoicePosition(voice, matrix, offset) {
+    let o = voice * 3;
+    this.voicePosition[o] = matrix[offset + (12)], this.voicePosition[o + 1] = matrix[offset + (12) + 1], this.voicePosition[o + 2] = matrix[offset + (12) + 2];
+  }
+  voiceX(voice) {
+    return this.voicePosition[voice * 3];
+  }
+  setListener(matrix, offset) {
+    for (let i = 0; i < 16; i++) this.listener[i] = matrix[offset + i];
+  }
+  async openStream(_source, bus) {
+    return this.streams.push({ bus, state: STREAM_STOPPED, loop: false, gain: 1, time: 0, duration: (180) }), this.streams.length - 1;
+  }
+  stream(stream) {
+    let found = this.streams[stream];
+    if (!found) throw new GameError("unknown_resource", `stream ${stream} is not open`);
+    return found;
+  }
+  playStream(stream, gain, loop) {
+    let s = this.stream(stream);
+    s.state = STREAM_PLAYING, s.gain = gain, s.loop = loop;
+  }
+  pauseStream(stream) {
+    this.stream(stream).state = STREAM_PAUSED;
+  }
+  seekStream(stream, seconds) {
+    let s = this.stream(stream);
+    s.time = Math.max(0, Math.min(s.duration, seconds));
+  }
+  streamTime(stream) {
+    return this.stream(stream).time;
+  }
+  streamDuration(stream) {
+    return this.stream(stream).duration;
+  }
+  streamState(stream) {
+    return this.stream(stream).state;
+  }
+  closeStream(stream) {
+    this.streams[stream] = null;
+  }
+  commit(frame, at) {
+    let seconds = frame[at];
+    for (let i = 0; i < this.streams.length; i++) {
+      let s = this.streams[i];
+      s === null || s.state !== STREAM_PLAYING || (s.time += seconds, s.time >= s.duration && (s.loop ? s.time -= s.duration : (s.time = s.duration, s.state = STREAM_STOPPED)));
+    }
+  }
+  suspend() {
+  }
+  resume() {
+  }
+  dispose() {
+    this.voiceSound.fill((-1)), this.streams.length = 0, this.analyserBus.fill((-1));
+  }
+};
+
+// src/game/audio/web-audio.ts
+var MASTER_PARENT = -1, MATRIX_TRANSLATION2 = 12, PANNER_REF_DISTANCE = 1, PANNER_MAX_DISTANCE = 100, RAMP_TIME_CONSTANT_DIVISOR = 3, METER_FFT_SIZE = 1024, SEND_KEY2 = 1024, WebAudioPort = class {
+  constructor(context, maxVoices = 64, options = {}) {
+    this.name = "web-audio";
+    this.buffers = [];
+    this.buses = [];
+    this.analysers = [];
+    this.sends = /* @__PURE__ */ new Map();
+    this.streams = [];
+    this.meterScratch = new Float32Array((1024));
+    this.nextVoice = 0;
+    this.context = context, this.voices = Array.from({ length: maxVoices }, () => ({ source: null, gain: null, panner: null })), this.onEnded = Array.from({ length: maxVoices }, (_, voice) => () => this.release(voice)), this.createMediaElement = options.createMediaElement ?? (typeof document > "u" ? null : () => document.createElement("audio"));
+    let streaming = this.createMediaElement !== null && typeof context.createMediaElementSource == "function";
+    this.capabilities = {
+      spatial: true,
+      filters: true,
+      meters: true,
+      analyser: true,
+      reverb: true,
+      sends: true,
+      loopPoints: true,
+      streaming,
+      detune: true,
+      procedural: true
+    };
+  }
+  get sampleRate() {
+    return this.context.sampleRate;
+  }
+  get unlocked() {
+    return this.context.state === "running";
+  }
+  unlock() {
+    this.context.state !== "running" && this.context.resume();
+  }
+  async decode(source) {
+    let bytes;
+    if ("bytes" in source) bytes = source.bytes.slice(0);
+    else if ("url" in source) bytes = await (await fetch(source.url)).arrayBuffer();
+    else throw new GameError("invalid_argument", "audio sources are bytes or a url");
+    return this.buffers.push(await this.context.decodeAudioData(bytes)), this.buffers.length - 1;
+  }
+  createSound(samples, channels, sampleRate) {
+    if (channels < 1 || sampleRate <= 0 || samples.length % channels !== 0) throw new GameError("invalid_argument", "sound PCM must be interleaved whole frames");
+    let frames = samples.length / channels, buffer = this.context.createBuffer(channels, frames, sampleRate);
+    for (let c = 0; c < channels; c++) {
+      let data = buffer.getChannelData(c);
+      for (let i = 0; i < frames; i++) data[i] = samples[i * channels + c];
+    }
+    return this.buffers.push(buffer), this.buffers.length - 1;
+  }
+  createBus(_name, parent) {
+    let input = this.context.createGain(), target = parent === (-1) ? audioOutput(this.context) : this.buses[parent].input;
+    return input.connect(target), this.buses.push({ input, parent: target, tail: input, body: input, filter: null, meter: null }), this.buses.length - 1;
+  }
+  createReverb(parent, impulse) {
+    let buffer = this.buffers[impulse];
+    if (!buffer) throw new GameError("unknown_resource", `impulse sound ${impulse} is not loaded`);
+    let input = this.context.createGain(), convolver = this.context.createConvolver();
+    convolver.normalize = true, convolver.buffer = buffer;
+    let target = parent === (-1) ? audioOutput(this.context) : this.buses[parent].input;
+    return input.connect(convolver), convolver.connect(target), this.buses.push({ input, parent: target, tail: convolver, body: convolver, filter: null, meter: null }), this.buses.length - 1;
+  }
+  setBusGain(bus, gain, rampSeconds) {
+    this.ramp(this.buses[bus].input.gain, gain, rampSeconds);
+  }
+  setBusFilter(bus, kind, frequency, q, gainDb) {
+    let b = this.buses[bus];
+    if (kind < 0) {
+      if (b.filter === null) return;
+      b.body.disconnect(b.filter), b.filter.disconnect(), b.body.connect(b.parent), b.meter && b.body.connect(b.meter), b.filter = null, b.tail = b.body;
+      return;
+    }
+    let type = FILTER_KINDS[kind];
+    if (type === void 0) throw new GameError("invalid_argument", `filter kind ${kind} is unknown`);
+    let filter = b.filter;
+    filter === null && (filter = this.context.createBiquadFilter(), b.body.disconnect(b.parent), b.meter && b.body.disconnect(b.meter), b.body.connect(filter), filter.connect(b.parent), b.meter && filter.connect(b.meter), b.filter = filter, b.tail = filter), filter.type = type, filter.frequency.setValueAtTime(frequency, this.context.currentTime), filter.Q.setValueAtTime(q, this.context.currentTime), filter.gain.setValueAtTime(gainDb, this.context.currentTime);
+  }
+  meter(bus, out) {
+    let b = this.buses[bus];
+    b.meter === null && (b.meter = this.context.createAnalyser(), b.meter.fftSize = (1024), b.tail.connect(b.meter));
+    let data = this.meterScratch;
+    b.meter.getFloatTimeDomainData(data);
+    let peak = 0, energy = 0;
+    for (let i = 0; i < data.length; i++) {
+      let v = data[i], a = v < 0 ? -v : v;
+      a > peak && (peak = a), energy += v * v;
+    }
+    out[METER_PEAK] = peak, out[METER_RMS] = Math.sqrt(energy / data.length);
+  }
+  createAnalyser(bus, settings) {
+    let node = this.context.createAnalyser();
+    return node.fftSize = settings.fftSize, node.smoothingTimeConstant = settings.smoothing, node.minDecibels = settings.minDecibels, node.maxDecibels = settings.maxDecibels, this.buses[bus].tail.connect(node), this.analysers.push(node), this.analysers.length - 1;
+  }
+  readAnalyser(analyser, mode, out) {
+    let node = this.analysers[analyser];
+    if (!node) throw new GameError("unknown_resource", `analyser ${analyser} does not exist`);
+    out instanceof Uint8Array ? mode === ANALYSER_FREQUENCY ? node.getByteFrequencyData(out) : node.getByteTimeDomainData(out) : mode === ANALYSER_FREQUENCY ? node.getFloatFrequencyData(out) : node.getFloatTimeDomainData(out);
+  }
+  setBusSend(bus, target, gain) {
+    let key = bus * (1024) + target, send = this.sends.get(key);
+    send === void 0 && (send = this.context.createGain(), this.buses[bus].input.connect(send), send.connect(this.buses[target].input), this.sends.set(key, send)), send.gain.setValueAtTime(gain, this.context.currentTime);
+  }
+  play(sound, bus, gain, rate, loop, spatial) {
+    let id = this.nextVoice;
+    this.nextVoice = (this.nextVoice + 1) % this.voices.length, this.release(id);
+    let voice = this.voices[id], source = this.context.createBufferSource();
+    source.buffer = this.buffers[sound], source.loop = loop, source.playbackRate.value = rate;
+    let gainNode = this.context.createGain();
+    if (gainNode.gain.value = gain, source.connect(gainNode), spatial) {
+      let panner = this.context.createPanner();
+      panner.panningModel = "HRTF", panner.refDistance = (1), panner.maxDistance = (100), gainNode.connect(panner), panner.connect(this.buses[bus].input), voice.panner = panner;
+    } else
+      gainNode.connect(this.buses[bus].input);
+    return source.addEventListener("ended", this.onEnded[id]), source.start(), voice.source = source, voice.gain = gainNode, id;
+  }
+  stop(voice, fadeSeconds) {
+    let v = this.voices[voice];
+    if (!v.source || !v.gain) return;
+    if (fadeSeconds <= 0) {
+      v.source.stop();
+      return;
+    }
+    let now = this.context.currentTime;
+    v.gain.gain.setTargetAtTime(0, now, fadeSeconds / (3)), v.source.stop(now + fadeSeconds);
+  }
+  isPlaying(voice) {
+    return this.voices[voice].source !== null;
+  }
+  setVoiceGain(voice, gain, rampSeconds) {
+    let node = this.voices[voice]?.gain;
+    node && this.ramp(node.gain, gain, rampSeconds);
+  }
+  setVoiceRate(voice, rate, detuneCents) {
+    let source = this.voices[voice]?.source;
+    if (!source) return;
+    let now = this.context.currentTime;
+    source.playbackRate.setValueAtTime(rate, now), source.detune.setValueAtTime(detuneCents, now);
+  }
+  setVoiceSpatial(voice, params) {
+    let panner = this.voices[voice]?.panner;
+    panner && (panner.distanceModel = DISTANCE_MODELS[params[SPATIAL_MODEL]] ?? "inverse", panner.refDistance = params[SPATIAL_REF_DISTANCE], panner.maxDistance = params[SPATIAL_MAX_DISTANCE], panner.rolloffFactor = params[SPATIAL_ROLLOFF], panner.coneInnerAngle = params[SPATIAL_CONE_INNER], panner.coneOuterAngle = params[SPATIAL_CONE_OUTER], panner.coneOuterGain = params[SPATIAL_CONE_OUTER_GAIN]);
+  }
+  setVoiceLoop(voice, loop, startSeconds, endSeconds) {
+    let source = this.voices[voice]?.source;
+    source && (source.loop = loop, source.loopStart = startSeconds, source.loopEnd = endSeconds);
+  }
+  setVoicePosition(voice, matrix, offset) {
+    let panner = this.voices[voice].panner;
+    panner && (panner.positionX.value = matrix[offset + (12)], panner.positionY.value = matrix[offset + (12) + 1], panner.positionZ.value = matrix[offset + (12) + 2], panner.orientationX.value = -matrix[offset + 8], panner.orientationY.value = -matrix[offset + 9], panner.orientationZ.value = -matrix[offset + 10]);
+  }
+  setListener(matrix, offset) {
+    let l = this.context.listener;
+    l.positionX.value = matrix[offset + 12], l.positionY.value = matrix[offset + 13], l.positionZ.value = matrix[offset + 14], l.forwardX.value = -matrix[offset + 8], l.forwardY.value = -matrix[offset + 9], l.forwardZ.value = -matrix[offset + 10], l.upX.value = matrix[offset + 4], l.upY.value = matrix[offset + 5], l.upZ.value = matrix[offset + 6];
+  }
+  async openStream(source, bus) {
+    let make = this.createMediaElement;
+    if (make === null || !this.capabilities.streaming) throw new GameError("unsupported_feature", "this audio context cannot stream media");
+    let element = make(), objectUrl = null;
+    if ("url" in source) element.src = source.url;
+    else if ("bytes" in source)
+      objectUrl = URL.createObjectURL(new Blob([source.bytes])), element.src = objectUrl;
+    else throw new GameError("invalid_argument", "streams play from bytes or a url");
+    element.crossOrigin = "anonymous", element.preload = "auto";
+    let node = this.context.createMediaElementSource(element), gain = this.context.createGain();
+    return node.connect(gain), gain.connect(this.buses[bus].input), this.streams.push({ element, source: node, gain, objectUrl }), this.streams.length - 1;
+  }
+  stream(stream) {
+    let found = this.streams[stream];
+    if (!found) throw new GameError("unknown_resource", `stream ${stream} is not open`);
+    return found;
+  }
+  playStream(stream, gain, loop) {
+    let s = this.stream(stream);
+    s.gain.gain.setValueAtTime(gain, this.context.currentTime), s.element.loop = loop;
+    let started = s.element.play();
+    started && started.catch(() => {
+    });
+  }
+  pauseStream(stream) {
+    this.stream(stream).element.pause();
+  }
+  seekStream(stream, seconds) {
+    this.stream(stream).element.currentTime = Math.max(0, seconds);
+  }
+  streamTime(stream) {
+    return this.stream(stream).element.currentTime;
+  }
+  streamDuration(stream) {
+    let duration = this.stream(stream).element.duration;
+    return Number.isFinite(duration) ? duration : 0;
+  }
+  closeStream(stream) {
+    let s = this.streams[stream];
+    s && (s.element.pause(), s.source.disconnect(), s.gain.disconnect(), s.objectUrl !== null && URL.revokeObjectURL(s.objectUrl), this.streams[stream] = null);
+  }
+  suspend() {
+    this.context.suspend();
+  }
+  resume() {
+    this.context.resume();
+  }
+  dispose() {
+    for (let i = 0; i < this.voices.length; i++) this.release(i);
+    for (let i = 0; i < this.streams.length; i++) this.closeStream(i);
+    this.context.close();
+  }
+  ramp(param, value, rampSeconds) {
+    rampSeconds <= 0 ? param.setValueAtTime(value, this.context.currentTime) : param.setTargetAtTime(value, this.context.currentTime, rampSeconds / (3));
+  }
+  release(id) {
+    let voice = this.voices[id], source = voice.source;
+    source && (source.removeEventListener("ended", this.onEnded[id]), source.stop(), source.disconnect()), voice.gain?.disconnect(), voice.panner?.disconnect(), voice.source = null, voice.gain = null, voice.panner = null;
+  }
+};
+
+// src/game/terrain/port.ts
+var TERRAIN_SOURCE = { recipe: 0, pack: 1, planet: 2 }, TERRAIN_REGISTER = {
+  requested: 0,
+  installed: 1,
+  inflight: 2,
+  resident: 3,
+  nodes: 4,
+  touched: 5,
+  deferred: 6,
+  totalInstalls: 7
+}, BRUSH = {
+  raise: 0,
+  lower: 1,
+  smooth: 2,
+  flatten: 3,
+  paint: 4,
+  hole: 5,
+  fill: 6
+}, NOISE = { perlin: 0, simplex2: 1, simplex3: 2, worley: 3 };
+
+// src/game/terrain/engine.ts
+var ENGINE_TERRAIN_EXPORT_NAMES = [
+  "engine_terrain_open",
+  "engine_terrain_close",
+  "engine_terrain_update",
+  "engine_terrain_registers",
+  "engine_terrain_height",
+  "engine_terrain_normal",
+  "engine_terrain_sculpt",
+  "engine_terrain_colliders",
+  "engine_physics_radial_gravity",
+  "engine_terrain_grass",
+  "engine_terrain_wind",
+  "engine_terrain_interactors",
+  "engine_terrain_look",
+  "engine_terrain_scatter",
+  "engine_noise",
+  "engine_noise_fbm"
+], NULL = 0, F32_BYTES = 4, NORMAL_FLOATS = 3, GRAVITY_SURFACE = 3, GRAVITY_RADIUS = 4, SCRATCH_FLOATS = Math.max(
+  8,
+  12,
+  7,
+  6,
+  14,
+  16,
+  32,
+  64
+) * 2;
+function engineTerrainExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_TERRAIN_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineTerrain = class {
+  constructor(runtime, exports, render, world) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.world = world;
+    this.scratch = { pointer: (0), bytes: 0 };
+    this.second = { pointer: (0), bytes: 0 };
+    this.columns = { pointer: (0), bytes: 0 };
+    this.buffer = null;
+    this.floats = new Float32Array(0);
+    this.words = new Uint32Array(0);
+    this.bytes = new Uint8Array(0);
+  }
+  views() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.floats = new Float32Array(buffer), this.words = new Uint32Array(buffer), this.bytes = new Uint8Array(buffer));
+  }
+  ensure(block, bytes) {
+    if (block.bytes >= bytes) return block.pointer;
+    if (block.pointer !== (0) && this.runtime.exports.engine_free(block.pointer, block.bytes, COLUMN_ALIGN), block.bytes = Math.max(bytes, COLUMN_ALIGN), block.pointer = this.runtime.exports.engine_alloc(block.bytes, COLUMN_ALIGN), block.pointer === (0))
+      throw block.bytes = 0, new GameError("capacity_exceeded", "engine memory cannot hold terrain buffers");
+    return block.pointer;
+  }
+  put(block, values, count = values.length) {
+    let pointer = this.ensure(block, Math.max(SCRATCH_FLOATS, count) * (4));
+    this.views();
+    let at = pointer >>> 2;
+    for (let i = 0; i < count; i++) this.floats[at + i] = values[i];
+    return pointer;
+  }
+  open(desc, source, recipe, pack) {
+    let descPointer = this.put(this.scratch, desc), recipePointer = this.put(this.second, recipe), packPointer = (0);
+    if (pack !== null) {
+      if (packPointer = this.runtime.exports.engine_alloc(Math.max(pack.byteLength, 1), COLUMN_ALIGN), packPointer === (0)) throw new GameError("capacity_exceeded", "engine memory cannot hold the terrain pack");
+      this.views(), this.bytes.set(pack, packPointer);
+    }
+    let handle = this.exports.engine_terrain_open(this.render(), descPointer, source, recipePointer, packPointer, pack?.byteLength ?? 0);
+    if (handle === (0)) throw new GameError("invalid_argument", "the engine refused the terrain description");
+    return handle;
+  }
+  close(terrain) {
+    this.exports.engine_terrain_close(terrain, this.render());
+  }
+  update(terrain, eye) {
+    return this.exports.engine_terrain_update(terrain, this.render(), this.put(this.scratch, eye, 6));
+  }
+  registers(terrain) {
+    let pointer = this.exports.engine_terrain_registers(terrain);
+    if (pointer === (0)) throw new GameError("unknown_resource", "terrain is closed");
+    return this.views(), this.words.subarray(pointer >>> 2, (pointer >>> 2) + 8);
+  }
+  height(x, z) {
+    return this.exports.engine_terrain_height(this.render(), x, z);
+  }
+  normal(x, z, out) {
+    let pointer = this.ensure(this.second, SCRATCH_FLOATS * (4));
+    if (this.exports.engine_terrain_normal(this.render(), x, z, pointer) < 0) return false;
+    this.views();
+    let at = pointer >>> 2;
+    for (let i = 0; i < (3); i++) out[i] = this.floats[at + i];
+    return true;
+  }
+  sculpt(terrain, brush) {
+    return this.exports.engine_terrain_sculpt(terrain, this.render(), this.put(this.scratch, brush, 7));
+  }
+  colliders(terrain, x, y, z) {
+    let pointer = this.ensure(this.second, SCRATCH_FLOATS * (4));
+    this.views();
+    let f = this.floats, at = pointer >>> 2;
+    return f[at] = x, f[at + 1] = y, f[at + 2] = z, this.exports.engine_terrain_colliders(terrain, this.render(), this.world(), pointer);
+  }
+  gravity(x, y, z, surface, radius) {
+    let pointer = this.ensure(this.second, SCRATCH_FLOATS * (4));
+    this.views();
+    let f = this.floats, at = pointer >>> 2;
+    return f[at] = x, f[at + 1] = y, f[at + 2] = z, f[at + (3)] = surface, f[at + (4)] = radius, this.exports.engine_physics_radial_gravity(this.world(), pointer);
+  }
+  grass(params) {
+    return this.exports.engine_terrain_grass(this.render(), this.put(this.scratch, params, 14));
+  }
+  wind(x, z, strength, gust) {
+    this.exports.engine_terrain_wind(this.render(), x, z, strength, gust);
+  }
+  interactors(data, count) {
+    let n = Math.min(count, 8);
+    this.exports.engine_terrain_interactors(this.render(), this.put(this.scratch, data, n * 4), n);
+  }
+  look(layers, count) {
+    let n = Math.min(count, 8);
+    this.exports.engine_terrain_look(this.render(), this.put(this.scratch, layers, n * 8), n);
+  }
+  scatter(rules, out, capacity) {
+    let rulesPointer = this.put(this.scratch, rules, 16), columns = this.ensure(this.columns, capacity * 6 * (4)), written = this.exports.engine_terrain_scatter(this.render(), rulesPointer, columns, capacity);
+    if (written < 0) throw new GameError("invalid_argument", `the engine refused the scatter rules (${written})`);
+    return this.views(), out.set(this.floats.subarray(columns >>> 2, (columns >>> 2) + capacity * 6)), written;
+  }
+  noise(kind, x, y, z, seed) {
+    return this.exports.engine_noise(kind, x, y, z, seed);
+  }
+  fbm(x, z, octaves, frequency, seed) {
+    return this.exports.engine_noise_fbm(x, z, octaves, frequency, seed);
+  }
+};
+
+export { BRUSH, CAP_CUSTOM_PROJECTION, CAP_POINT_SHADOWS, DEFAULT_WORKLET_SIZES, ENGINE_MIX_RATE, ENGINE_TERRAIN_EXPORT_NAMES, EngineFeatures, EngineTerrain, HeadlessAudio, LIGHT_KINDS, MATERIAL_KINDS, NOISE, OWNER_STAGING, SHADOW_TYPES, TERRAIN_REGISTER, TERRAIN_SOURCE, WORKLET_PROCESSOR_NAME, WORKLET_PROCESSOR_SOURCE, WebAudioPort, WorkletAudio, characterParams, createWithDescriptor, engineTerrainExports, extraTextures, floatBits, materialFeatureFlags, materialSlotIndex, refuseUndrawnPhysicalFields, sharedMemoryAvailable, writeCharacterWords, writeMaterialExtension, writeMaterialFeatures, writeMaterialState, writeMaterialTint, writeNodeFeatures, writePlanes, writeSky, writeTextureTransforms, writeTintWords };